1#ifndef EXTATTR_PORTABLE_H 2#define EXTATTR_PORTABLE_H 3 4/* OS detection */ 5#include "extattr_os.h" 6 7struct hv; 8 9/* 10 * Portable extattr functions. When these fail, they should return 11 * -errno, i.e.: < 0 indicates failure. 12 */ 13 14static inline int 15portable_setxattr (const char *path, 16 const char *attrname, 17 const void *attrvalue, 18 const size_t slen, 19 struct hv *flags) 20{ 21#ifdef EXTATTR_MACOSX 22 return macosx_setxattr(path, attrname, attrvalue, slen, flags); 23#elif defined(EXTATTR_BSD) 24 return bsd_setxattr(path, attrname, attrvalue, slen, flags); 25#elif defined(EXTATTR_SOLARIS) 26 return solaris_setxattr(path, attrname, attrvalue, slen, flags); 27#else 28 return linux_setxattr(path, attrname, attrvalue, slen, flags); 29#endif 30} 31 32static inline int 33portable_fsetxattr (const int fd, 34 const char *attrname, 35 const void *attrvalue, 36 const size_t slen, 37 struct hv *flags) 38{ 39#ifdef EXTATTR_MACOSX 40 return macosx_fsetxattr(fd, attrname, attrvalue, slen, flags); 41#elif defined(EXTATTR_BSD) 42 return bsd_fsetxattr(fd, attrname, attrvalue, slen, flags); 43#elif defined(EXTATTR_SOLARIS) 44 return solaris_fsetxattr(fd, attrname, attrvalue, slen, flags); 45#else 46 return linux_fsetxattr(fd, attrname, attrvalue, slen, flags); 47#endif 48} 49 50static inline int 51portable_getxattr (const char *path, 52 const char *attrname, 53 void *attrvalue, 54 const size_t slen, 55 struct hv *flags) 56{ 57#ifdef EXTATTR_MACOSX 58 return macosx_getxattr(path, attrname, attrvalue, slen, flags); 59#elif defined(EXTATTR_BSD) 60 return bsd_getxattr(path, attrname, attrvalue, slen, flags); 61#elif defined(EXTATTR_SOLARIS) 62 return solaris_getxattr(path, attrname, attrvalue, slen, flags); 63#else 64 return linux_getxattr(path, attrname, attrvalue, slen, flags); 65#endif 66} 67 68static inline int 69portable_fgetxattr (const int fd, 70 const char *attrname, 71 void *attrvalue, 72 const size_t slen, 73 struct hv *flags) 74{ 75#ifdef EXTATTR_MACOSX 76 return macosx_fgetxattr(fd, attrname, attrvalue, slen, flags); 77#elif defined(EXTATTR_BSD) 78 return bsd_fgetxattr(fd, attrname, attrvalue, slen, flags); 79#elif defined(EXTATTR_SOLARIS) 80 return solaris_fgetxattr(fd, attrname, attrvalue, slen, flags); 81#else 82 return linux_fgetxattr(fd, attrname, attrvalue, slen, flags); 83#endif 84} 85 86static inline ssize_t 87portable_lenxattr (const char *path, const char *attrname, struct hv *flags) 88{ 89#ifdef EXTATTR_BSD 90 /* XXX: flags? Namespace? */ 91 return extattr_get_file(path, EXTATTR_NAMESPACE_USER, attrname, NULL, 0); 92#else 93 /* XXX: Can BSD use this too? Maybe once namespacing sorted. */ 94 return portable_getxattr(path, attrname, NULL, 0, flags); 95#endif 96} 97 98static inline int 99portable_flenxattr (int fd, const char *attrname, struct hv *flags) 100{ 101#ifdef EXTATTR_BSD 102 /* XXX: flags? Namespace? */ 103 return extattr_get_fd(fd, EXTATTR_NAMESPACE_USER, attrname, NULL, 0); 104#else 105 /* XXX: Can BSD use this too? Maybe once namespacing sorted. */ 106 return portable_fgetxattr(fd, attrname, NULL, 0, flags); 107#endif 108} 109 110static inline int 111portable_removexattr (const char *path, const char *name, struct hv *flags) 112{ 113#ifdef EXTATTR_MACOSX 114 return macosx_removexattr(path, name, flags); 115#elif defined(EXTATTR_BSD) 116 return bsd_removexattr(path, name, flags); 117#elif defined(EXTATTR_SOLARIS) 118 return solaris_removexattr(path, name, flags); 119#else 120 return linux_removexattr(path, name, flags); 121#endif 122} 123 124static inline int 125portable_fremovexattr (const int fd, const char *name, struct hv *flags) 126{ 127#ifdef EXTATTR_MACOSX 128 return macosx_fremovexattr(fd, name, flags); 129#elif defined(EXTATTR_BSD) 130 return bsd_fremovexattr(fd, name, flags); 131#elif defined(EXTATTR_SOLARIS) 132 return solaris_fremovexattr(fd, name, flags); 133#else 134 return linux_fremovexattr(fd, name, flags); 135#endif 136} 137 138static inline int 139portable_listxattr(const char *path, 140 char *buf, 141 const size_t slen, 142 struct hv *flags) 143{ 144#ifdef EXTATTR_MACOSX 145 return macosx_listxattr(path, buf, slen, flags); 146#elif defined(EXTATTR_BSD) 147 return bsd_listxattr(path, buf, slen, flags); 148#elif defined(EXTATTR_SOLARIS) 149 return solaris_listxattr(path, buf, slen, flags); 150#else 151 return linux_listxattr(path, buf, slen, flags); 152#endif 153} 154 155static inline int 156portable_flistxattr(const int fd, 157 char *buf, 158 const size_t slen, 159 struct hv *flags) 160{ 161#ifdef EXTATTR_MACOSX 162 return macosx_flistxattr(fd, buf, slen, flags); 163#elif defined(EXTATTR_BSD) 164 return bsd_flistxattr(fd, buf, slen, flags); 165#elif defined(EXTATTR_SOLARIS) 166 return solaris_flistxattr(fd, buf, slen, flags); 167#else 168 return linux_flistxattr(fd, buf, slen, flags); 169#endif 170} 171 172static inline int 173portable_listxattrns(const char *path, 174 char *buf, 175 const size_t slen, 176 struct hv *flags) 177{ 178#ifdef EXTATTR_MACOSX 179 return macosx_listxattrns(path, buf, slen, flags); 180#elif defined(EXTATTR_BSD) 181 return bsd_listxattrns(path, buf, slen, flags); 182#elif defined(EXTATTR_SOLARIS) 183 return solaris_listxattrns(path, buf, slen, flags); 184#else 185 return linux_listxattrns(path, buf, slen, flags); 186#endif 187} 188 189static inline int 190portable_flistxattrns(const int fd, 191 char *buf, 192 const size_t slen, 193 struct hv *flags) 194{ 195#ifdef EXTATTR_MACOSX 196 return macosx_flistxattrns(fd, buf, slen, flags); 197#elif defined(EXTATTR_BSD) 198 return bsd_flistxattrns(fd, buf, slen, flags); 199#elif defined(EXTATTR_SOLARIS) 200 return solaris_flistxattrns(fd, buf, slen, flags); 201#else 202 return linux_flistxattrns(fd, buf, slen, flags); 203#endif 204} 205 206#endif /* EXTATTR_PORTABLE_H */ 207