source: vendor/current/lib/replace/xattr.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 20.0 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 replacement routines for xattr implementations
4 Copyright (C) Jeremy Allison 1998-2005
5 Copyright (C) Timur Bakeyev 2005
6 Copyright (C) Bjoern Jacke 2006-2007
7 Copyright (C) Herb Lewis 2003
8 Copyright (C) Andrew Bartlett 2012
9
10 ** NOTE! The following LGPL license applies to the replace
11 ** library. This does NOT imply that all of Samba is released
12 ** under the LGPL
13
14 This library is free software; you can redistribute it and/or
15 modify it under the terms of the GNU Lesser General Public
16 License as published by the Free Software Foundation; either
17 version 3 of the License, or (at your option) any later version.
18
19 This library is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 Lesser General Public License for more details.
23
24 You should have received a copy of the GNU Lesser General Public
25 License along with this library; if not, see <http://www.gnu.org/licenses/>.
26*/
27
28#define UID_WRAPPER_NOT_REPLACE
29#include "replace.h"
30#include "system/filesys.h"
31#include "system/dir.h"
32
33/******** Solaris EA helper function prototypes ********/
34#ifdef HAVE_ATTROPEN
35#define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP
36static int solaris_write_xattr(int attrfd, const char *value, size_t size);
37static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size);
38static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size);
39static int solaris_unlinkat(int attrdirfd, const char *name);
40static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode);
41static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode);
42#endif
43
44/**************************************************************************
45 Wrappers for extented attribute calls. Based on the Linux package with
46 support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
47****************************************************************************/
48
49ssize_t rep_getxattr (const char *path, const char *name, void *value, size_t size)
50{
51#if defined(HAVE_GETXATTR)
52#ifndef XATTR_ADDITIONAL_OPTIONS
53 return getxattr(path, name, value, size);
54#else
55
56/* So that we do not recursivly call this function */
57#undef getxattr
58 int options = 0;
59 return getxattr(path, name, value, size, 0, options);
60#endif
61#elif defined(HAVE_GETEA)
62 return getea(path, name, value, size);
63#elif defined(HAVE_EXTATTR_GET_FILE)
64 char *s;
65 ssize_t retval;
66 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
67 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
68 const char *attrname = ((s=strchr(name, '.')) == NULL) ? name : s + 1;
69 /*
70 * The BSD implementation has a nasty habit of silently truncating
71 * the returned value to the size of the buffer, so we have to check
72 * that the buffer is large enough to fit the returned value.
73 */
74 if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
75 if (size == 0) {
76 return retval;
77 } else if (retval > size) {
78 errno = ERANGE;
79 return -1;
80 }
81 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
82 return retval;
83 }
84
85 return -1;
86#elif defined(HAVE_ATTR_GET)
87 int retval, flags = 0;
88 int valuelength = (int)size;
89 char *attrname = strchr(name,'.') + 1;
90
91 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
92
93 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
94 if (size == 0 && retval == -1 && errno == E2BIG) {
95 return valuelength;
96 }
97
98 return retval ? retval : valuelength;
99#elif defined(HAVE_ATTROPEN)
100 ssize_t ret = -1;
101 int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
102 if (attrfd >= 0) {
103 ret = solaris_read_xattr(attrfd, value, size);
104 close(attrfd);
105 }
106 return ret;
107#else
108 errno = ENOSYS;
109 return -1;
110#endif
111}
112
113ssize_t rep_fgetxattr (int filedes, const char *name, void *value, size_t size)
114{
115#if defined(HAVE_FGETXATTR)
116#ifndef XATTR_ADDITIONAL_OPTIONS
117 return fgetxattr(filedes, name, value, size);
118#else
119
120/* So that we do not recursivly call this function */
121#undef fgetxattr
122 int options = 0;
123 return fgetxattr(filedes, name, value, size, 0, options);
124#endif
125#elif defined(HAVE_FGETEA)
126 return fgetea(filedes, name, value, size);
127#elif defined(HAVE_EXTATTR_GET_FD)
128 char *s;
129 ssize_t retval;
130 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
131 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
132 const char *attrname = ((s=strchr(name, '.')) == NULL) ? name : s + 1;
133
134 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
135 if (size == 0) {
136 return retval;
137 } else if (retval > size) {
138 errno = ERANGE;
139 return -1;
140 }
141 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
142 return retval;
143 }
144
145 return -1;
146#elif defined(HAVE_ATTR_GETF)
147 int retval, flags = 0;
148 int valuelength = (int)size;
149 char *attrname = strchr(name,'.') + 1;
150
151 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
152
153 retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
154 if (size == 0 && retval == -1 && errno == E2BIG) {
155 return valuelength;
156 }
157 return retval ? retval : valuelength;
158#elif defined(HAVE_ATTROPEN)
159 ssize_t ret = -1;
160 int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
161 if (attrfd >= 0) {
162 ret = solaris_read_xattr(attrfd, value, size);
163 close(attrfd);
164 }
165 return ret;
166#else
167 errno = ENOSYS;
168 return -1;
169#endif
170}
171
172#if defined(HAVE_EXTATTR_LIST_FILE)
173
174#define EXTATTR_PREFIX(s) (s), (sizeof((s))-1)
175
176static struct {
177 int space;
178 const char *name;
179 size_t len;
180}
181extattr[] = {
182 { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
183 { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
184};
185
186typedef union {
187 const char *path;
188 int filedes;
189} extattr_arg;
190
191static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
192{
193 ssize_t list_size, total_size = 0;
194 int i, t, len;
195 char *buf;
196 /* Iterate through extattr(2) namespaces */
197 for(t = 0; t < ARRAY_SIZE(extattr); t++) {
198 if (t != EXTATTR_NAMESPACE_USER && geteuid() != 0) {
199 /* ignore all but user namespace when we are not root, see bug 10247 */
200 continue;
201 }
202 switch(type) {
203#if defined(HAVE_EXTATTR_LIST_FILE)
204 case 0:
205 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
206 break;
207#endif
208#if defined(HAVE_EXTATTR_LIST_LINK)
209 case 1:
210 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
211 break;
212#endif
213#if defined(HAVE_EXTATTR_LIST_FD)
214 case 2:
215 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
216 break;
217#endif
218 default:
219 errno = ENOSYS;
220 return -1;
221 }
222 /* Some error happend. Errno should be set by the previous call */
223 if(list_size < 0)
224 return -1;
225 /* No attributes */
226 if(list_size == 0)
227 continue;
228 /* XXX: Call with an empty buffer may be used to calculate
229 necessary buffer size. Unfortunately, we can't say, how
230 many attributes were returned, so here is the potential
231 problem with the emulation.
232 */
233 if(list == NULL) {
234 /* Take the worse case of one char attribute names -
235 two bytes per name plus one more for sanity.
236 */
237 total_size += list_size + (list_size/2 + 1)*extattr[t].len;
238 continue;
239 }
240 /* Count necessary offset to fit namespace prefixes */
241 len = 0;
242 for(i = 0; i < list_size; i += list[i] + 1)
243 len += extattr[t].len;
244
245 total_size += list_size + len;
246 /* Buffer is too small to fit the results */
247 if(total_size > size) {
248 errno = ERANGE;
249 return -1;
250 }
251 /* Shift results back, so we can prepend prefixes */
252 buf = (char *)memmove(list + len, list, list_size);
253
254 for(i = 0; i < list_size; i += len + 1) {
255 len = buf[i];
256 strncpy(list, extattr[t].name, extattr[t].len + 1);
257 list += extattr[t].len;
258 strncpy(list, buf + i + 1, len);
259 list[len] = '\0';
260 list += len + 1;
261 }
262 size -= total_size;
263 }
264 return total_size;
265}
266
267#endif
268
269#if defined(HAVE_ATTR_LIST) && (defined(HAVE_SYS_ATTRIBUTES_H) || defined(HAVE_ATTR_ATTRIBUTES_H))
270static char attr_buffer[ATTR_MAX_VALUELEN];
271
272static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
273{
274 int retval = 0, index;
275 attrlist_cursor_t *cursor = 0;
276 int total_size = 0;
277 attrlist_t * al = (attrlist_t *)attr_buffer;
278 attrlist_ent_t *ae;
279 size_t ent_size, left = size;
280 char *bp = list;
281
282 while (true) {
283 if (filedes)
284 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
285 else
286 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
287 if (retval) break;
288 for (index = 0; index < al->al_count; index++) {
289 ae = ATTR_ENTRY(attr_buffer, index);
290 ent_size = strlen(ae->a_name) + sizeof("user.");
291 if (left >= ent_size) {
292 strncpy(bp, "user.", sizeof("user."));
293 strncat(bp, ae->a_name, ent_size - sizeof("user."));
294 bp += ent_size;
295 left -= ent_size;
296 } else if (size) {
297 errno = ERANGE;
298 retval = -1;
299 break;
300 }
301 total_size += ent_size;
302 }
303 if (al->al_more == 0) break;
304 }
305 if (retval == 0) {
306 flags |= ATTR_ROOT;
307 cursor = 0;
308 while (true) {
309 if (filedes)
310 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
311 else
312 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
313 if (retval) break;
314 for (index = 0; index < al->al_count; index++) {
315 ae = ATTR_ENTRY(attr_buffer, index);
316 ent_size = strlen(ae->a_name) + sizeof("system.");
317 if (left >= ent_size) {
318 strncpy(bp, "system.", sizeof("system."));
319 strncat(bp, ae->a_name, ent_size - sizeof("system."));
320 bp += ent_size;
321 left -= ent_size;
322 } else if (size) {
323 errno = ERANGE;
324 retval = -1;
325 break;
326 }
327 total_size += ent_size;
328 }
329 if (al->al_more == 0) break;
330 }
331 }
332 return (ssize_t)(retval ? retval : total_size);
333}
334
335#endif
336
337ssize_t rep_listxattr (const char *path, char *list, size_t size)
338{
339#if defined(HAVE_LISTXATTR)
340#ifndef XATTR_ADDITIONAL_OPTIONS
341 return listxattr(path, list, size);
342#else
343/* So that we do not recursivly call this function */
344#undef listxattr
345 int options = 0;
346 return listxattr(path, list, size, options);
347#endif
348#elif defined(HAVE_LISTEA)
349 return listea(path, list, size);
350#elif defined(HAVE_EXTATTR_LIST_FILE)
351 extattr_arg arg;
352 arg.path = path;
353 return bsd_attr_list(0, arg, list, size);
354#elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
355 return irix_attr_list(path, 0, list, size, 0);
356#elif defined(HAVE_ATTROPEN)
357 ssize_t ret = -1;
358 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
359 if (attrdirfd >= 0) {
360 ret = solaris_list_xattr(attrdirfd, list, size);
361 close(attrdirfd);
362 }
363 return ret;
364#else
365 errno = ENOSYS;
366 return -1;
367#endif
368}
369
370ssize_t rep_flistxattr (int filedes, char *list, size_t size)
371{
372#if defined(HAVE_FLISTXATTR)
373#ifndef XATTR_ADDITIONAL_OPTIONS
374 return flistxattr(filedes, list, size);
375#else
376/* So that we do not recursivly call this function */
377#undef flistxattr
378 int options = 0;
379 return flistxattr(filedes, list, size, options);
380#endif
381#elif defined(HAVE_FLISTEA)
382 return flistea(filedes, list, size);
383#elif defined(HAVE_EXTATTR_LIST_FD)
384 extattr_arg arg;
385 arg.filedes = filedes;
386 return bsd_attr_list(2, arg, list, size);
387#elif defined(HAVE_ATTR_LISTF)
388 return irix_attr_list(NULL, filedes, list, size, 0);
389#elif defined(HAVE_ATTROPEN)
390 ssize_t ret = -1;
391 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
392 if (attrdirfd >= 0) {
393 ret = solaris_list_xattr(attrdirfd, list, size);
394 close(attrdirfd);
395 }
396 return ret;
397#else
398 errno = ENOSYS;
399 return -1;
400#endif
401}
402
403int rep_removexattr (const char *path, const char *name)
404{
405#if defined(HAVE_REMOVEXATTR)
406#ifndef XATTR_ADDITIONAL_OPTIONS
407 return removexattr(path, name);
408#else
409/* So that we do not recursivly call this function */
410#undef removexattr
411 int options = 0;
412 return removexattr(path, name, options);
413#endif
414#elif defined(HAVE_REMOVEEA)
415 return removeea(path, name);
416#elif defined(HAVE_EXTATTR_DELETE_FILE)
417 char *s;
418 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
419 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
420 const char *attrname = ((s=strchr(name, '.')) == NULL) ? name : s + 1;
421
422 return extattr_delete_file(path, attrnamespace, attrname);
423#elif defined(HAVE_ATTR_REMOVE)
424 int flags = 0;
425 char *attrname = strchr(name,'.') + 1;
426
427 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
428
429 return attr_remove(path, attrname, flags);
430#elif defined(HAVE_ATTROPEN)
431 int ret = -1;
432 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
433 if (attrdirfd >= 0) {
434 ret = solaris_unlinkat(attrdirfd, name);
435 close(attrdirfd);
436 }
437 return ret;
438#else
439 errno = ENOSYS;
440 return -1;
441#endif
442}
443
444int rep_fremovexattr (int filedes, const char *name)
445{
446#if defined(HAVE_FREMOVEXATTR)
447#ifndef XATTR_ADDITIONAL_OPTIONS
448 return fremovexattr(filedes, name);
449#else
450/* So that we do not recursivly call this function */
451#undef fremovexattr
452 int options = 0;
453 return fremovexattr(filedes, name, options);
454#endif
455#elif defined(HAVE_FREMOVEEA)
456 return fremoveea(filedes, name);
457#elif defined(HAVE_EXTATTR_DELETE_FD)
458 char *s;
459 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
460 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
461 const char *attrname = ((s=strchr(name, '.')) == NULL) ? name : s + 1;
462
463 return extattr_delete_fd(filedes, attrnamespace, attrname);
464#elif defined(HAVE_ATTR_REMOVEF)
465 int flags = 0;
466 char *attrname = strchr(name,'.') + 1;
467
468 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
469
470 return attr_removef(filedes, attrname, flags);
471#elif defined(HAVE_ATTROPEN)
472 int ret = -1;
473 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
474 if (attrdirfd >= 0) {
475 ret = solaris_unlinkat(attrdirfd, name);
476 close(attrdirfd);
477 }
478 return ret;
479#else
480 errno = ENOSYS;
481 return -1;
482#endif
483}
484
485int rep_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
486{
487#if defined(HAVE_SETXATTR)
488#ifndef XATTR_ADDITIONAL_OPTIONS
489 return setxattr(path, name, value, size, flags);
490#else
491/* So that we do not recursivly call this function */
492#undef setxattr
493 int options = 0;
494 return setxattr(path, name, value, size, 0, options);
495#endif
496#elif defined(HAVE_SETEA)
497 return setea(path, name, value, size, flags);
498#elif defined(HAVE_EXTATTR_SET_FILE)
499 char *s;
500 int retval = 0;
501 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
502 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
503 const char *attrname = ((s=strchr(name, '.')) == NULL) ? name : s + 1;
504 if (flags) {
505 /* Check attribute existence */
506 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
507 if (retval < 0) {
508 /* REPLACE attribute, that doesn't exist */
509 if (flags & XATTR_REPLACE && errno == ENOATTR) {
510 errno = ENOATTR;
511 return -1;
512 }
513 /* Ignore other errors */
514 }
515 else {
516 /* CREATE attribute, that already exists */
517 if (flags & XATTR_CREATE) {
518 errno = EEXIST;
519 return -1;
520 }
521 }
522 }
523 retval = extattr_set_file(path, attrnamespace, attrname, value, size);
524 return (retval < 0) ? -1 : 0;
525#elif defined(HAVE_ATTR_SET)
526 int myflags = 0;
527 char *attrname = strchr(name,'.') + 1;
528
529 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
530 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
531 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
532
533 return attr_set(path, attrname, (const char *)value, size, myflags);
534#elif defined(HAVE_ATTROPEN)
535 int ret = -1;
536 int myflags = O_RDWR;
537 int attrfd;
538 if (flags & XATTR_CREATE) myflags |= O_EXCL;
539 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
540 attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
541 if (attrfd >= 0) {
542 ret = solaris_write_xattr(attrfd, value, size);
543 close(attrfd);
544 }
545 return ret;
546#else
547 errno = ENOSYS;
548 return -1;
549#endif
550}
551
552int rep_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
553{
554#if defined(HAVE_FSETXATTR)
555#ifndef XATTR_ADDITIONAL_OPTIONS
556 return fsetxattr(filedes, name, value, size, flags);
557#else
558/* So that we do not recursivly call this function */
559#undef fsetxattr
560 int options = 0;
561 return fsetxattr(filedes, name, value, size, 0, options);
562#endif
563#elif defined(HAVE_FSETEA)
564 return fsetea(filedes, name, value, size, flags);
565#elif defined(HAVE_EXTATTR_SET_FD)
566 char *s;
567 int retval = 0;
568 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
569 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
570 const char *attrname = ((s=strchr(name, '.')) == NULL) ? name : s + 1;
571 if (flags) {
572 /* Check attribute existence */
573 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
574 if (retval < 0) {
575 /* REPLACE attribute, that doesn't exist */
576 if (flags & XATTR_REPLACE && errno == ENOATTR) {
577 errno = ENOATTR;
578 return -1;
579 }
580 /* Ignore other errors */
581 }
582 else {
583 /* CREATE attribute, that already exists */
584 if (flags & XATTR_CREATE) {
585 errno = EEXIST;
586 return -1;
587 }
588 }
589 }
590 retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
591 return (retval < 0) ? -1 : 0;
592#elif defined(HAVE_ATTR_SETF)
593 int myflags = 0;
594 char *attrname = strchr(name,'.') + 1;
595
596 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
597 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
598 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
599
600 return attr_setf(filedes, attrname, (const char *)value, size, myflags);
601#elif defined(HAVE_ATTROPEN)
602 int ret = -1;
603 int myflags = O_RDWR | O_XATTR;
604 int attrfd;
605 if (flags & XATTR_CREATE) myflags |= O_EXCL;
606 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
607 attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
608 if (attrfd >= 0) {
609 ret = solaris_write_xattr(attrfd, value, size);
610 close(attrfd);
611 }
612 return ret;
613#else
614 errno = ENOSYS;
615 return -1;
616#endif
617}
618
619/**************************************************************************
620 helper functions for Solaris' EA support
621****************************************************************************/
622#ifdef HAVE_ATTROPEN
623static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
624{
625 struct stat sbuf;
626
627 if (fstat(attrfd, &sbuf) == -1) {
628 errno = ENOATTR;
629 return -1;
630 }
631
632 /* This is to return the current size of the named extended attribute */
633 if (size == 0) {
634 return sbuf.st_size;
635 }
636
637 /* check size and read xattr */
638 if (sbuf.st_size > size) {
639 errno = ERANGE;
640 return -1;
641 }
642
643 return read(attrfd, value, sbuf.st_size);
644}
645
646static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
647{
648 ssize_t len = 0;
649 DIR *dirp;
650 struct dirent *de;
651 int newfd = dup(attrdirfd);
652 /* CAUTION: The originating file descriptor should not be
653 used again following the call to fdopendir().
654 For that reason we dup() the file descriptor
655 here to make things more clear. */
656 dirp = fdopendir(newfd);
657
658 while ((de = readdir(dirp))) {
659 size_t listlen = strlen(de->d_name) + 1;
660 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
661 /* we don't want "." and ".." here: */
662 continue;
663 }
664
665 if (size == 0) {
666 /* return the current size of the list of extended attribute names*/
667 len += listlen;
668 } else {
669 /* check size and copy entrieѕ + nul into list. */
670 if ((len + listlen) > size) {
671 errno = ERANGE;
672 len = -1;
673 break;
674 } else {
675 strlcpy(list + len, de->d_name, listlen);
676 len += listlen;
677 }
678 }
679 }
680
681 if (closedir(dirp) == -1) {
682 return -1;
683 }
684 return len;
685}
686
687static int solaris_unlinkat(int attrdirfd, const char *name)
688{
689 if (unlinkat(attrdirfd, name, 0) == -1) {
690 if (errno == ENOENT) {
691 errno = ENOATTR;
692 }
693 return -1;
694 }
695 return 0;
696}
697
698static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
699{
700 int filedes = attropen(path, attrpath, oflag, mode);
701 if (filedes == -1) {
702 if (errno == EINVAL) {
703 errno = ENOTSUP;
704 } else {
705 errno = ENOATTR;
706 }
707 }
708 return filedes;
709}
710
711static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
712{
713 int filedes = openat(fildes, path, oflag, mode);
714 if (filedes == -1) {
715 if (errno == EINVAL) {
716 errno = ENOTSUP;
717 } else {
718 errno = ENOATTR;
719 }
720 }
721 return filedes;
722}
723
724static int solaris_write_xattr(int attrfd, const char *value, size_t size)
725{
726 if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
727 return 0;
728 } else {
729 return -1;
730 }
731}
732#endif /*HAVE_ATTROPEN*/
733
734
Note: See TracBrowser for help on using the repository browser.