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