?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add sys_writev
[Samba.git] / source / lib / system.c
blob5b06d3c7600e943ab5dd33f66a26f4d0f37bb1ae
1 /*
2 Unix SMB/CIFS implementation.
3 Samba system utilities
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 1998-2005
6 Copyright (C) Timur Bakeyev 2005
7 Copyright (C) Bjoern Jacke 2006-2007
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24
25 #ifdef HAVE_SYS_PRCTL_H
26 #include <sys/prctl.h>
27 #endif
28
29 /*
30 The idea is that this file will eventually have wrappers around all
31 important system calls in samba. The aims are:
32
33 - to enable easier porting by putting OS dependent stuff in here
34
35 - to allow for hooks into other "pseudo-filesystems"
36
37 - to allow easier integration of things like the japanese extensions
38
39 - to support the philosophy of Samba to expose the features of
40 the OS within the SMB model. In general whatever file/printer/variable
41 expansions/etc make sense to the OS should be acceptable to Samba.
42 */
43
44
45
46 /*******************************************************************
47 A wrapper for memalign
48 ********************************************************************/
49
50 void *sys_memalign( size_t align, size_t size )
51 {
52 #if defined(HAVE_POSIX_MEMALIGN)
53 void *p = NULL;
54 int ret = posix_memalign( &p, align, size );
55 if ( ret == 0 )
56 return p;
57
58 return NULL;
59 #elif defined(HAVE_MEMALIGN)
60 return memalign( align, size );
61 #else
62 /* On *BSD systems memaligns doesn't exist, but memory will
63 * be aligned on allocations of > pagesize. */
64 #if defined(SYSCONF_SC_PAGESIZE)
65 size_t pagesize = (size_t)sysconf(_SC_PAGESIZE);
66 #elif defined(HAVE_GETPAGESIZE)
67 size_t pagesize = (size_t)getpagesize();
68 #else
69 size_t pagesize = (size_t)-1;
70 #endif
71 if (pagesize == (size_t)-1) {
72 DEBUG(0,("memalign functionalaity not available on this platform!\n"));
73 return NULL;
74 }
75 if (size < pagesize) {
76 size = pagesize;
77 }
78 return SMB_MALLOC(size);
79 #endif
80 }
81
82 /*******************************************************************
83 A wrapper for usleep in case we don't have one.
84 ********************************************************************/
85
86 int sys_usleep(long usecs)
87 {
88 #ifndef HAVE_USLEEP
89 struct timeval tval;
90 #endif
91
92 /*
93 * We need this braindamage as the glibc usleep
94 * is not SPEC1170 complient... grumble... JRA.
95 */
96
97 if(usecs < 0 || usecs > 1000000) {
98 errno = EINVAL;
99 return -1;
100 }
101
102 #if HAVE_USLEEP
103 usleep(usecs);
104 return 0;
105 #else /* HAVE_USLEEP */
106 /*
107 * Fake it with select...
108 */
109 tval.tv_sec = 0;
110 tval.tv_usec = usecs/1000;
111 select(0,NULL,NULL,NULL,&tval);
112 return 0;
113 #endif /* HAVE_USLEEP */
114 }
115
116 /*******************************************************************
117 A read wrapper that will deal with EINTR.
118 ********************************************************************/
119
120 ssize_t sys_read(int fd, void *buf, size_t count)
121 {
122 ssize_t ret;
123
124 do {
125 ret = read(fd, buf, count);
126 } while (ret == -1 && errno == EINTR);
127 return ret;
128 }
129
130 /*******************************************************************
131 A write wrapper that will deal with EINTR.
132 ********************************************************************/
133
134 ssize_t sys_write(int fd, const void *buf, size_t count)
135 {
136 ssize_t ret;
137
138 do {
139 ret = write(fd, buf, count);
140 } while (ret == -1 && errno == EINTR);
141 return ret;
142 }
143
144 /*******************************************************************
145 A writev wrapper that will deal with EINTR.
146 ********************************************************************/
147
148 ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt)
149 {
150 ssize_t ret;
151
152 do {
153 ret = writev(fd, iov, iovcnt);
154 } while (ret == -1 && errno == EINTR);
155 return ret;
156 }
157
158 /*******************************************************************
159 A pread wrapper that will deal with EINTR and 64-bit file offsets.
160 ********************************************************************/
161
162 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
163 ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
164 {
165 ssize_t ret;
166
167 do {
168 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PREAD64)
169 ret = pread64(fd, buf, count, off);
170 #else
171 ret = pread(fd, buf, count, off);
172 #endif
173 } while (ret == -1 && errno == EINTR);
174 return ret;
175 }
176 #endif
177
178 /*******************************************************************
179 A write wrapper that will deal with EINTR and 64-bit file offsets.
180 ********************************************************************/
181
182 #if defined(HAVE_PWRITE) || defined(HAVE_PWRITE64)
183 ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off)
184 {
185 ssize_t ret;
186
187 do {
188 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64)
189 ret = pwrite64(fd, buf, count, off);
190 #else
191 ret = pwrite(fd, buf, count, off);
192 #endif
193 } while (ret == -1 && errno == EINTR);
194 return ret;
195 }
196 #endif
197
198 /*******************************************************************
199 A send wrapper that will deal with EINTR.
200 ********************************************************************/
201
202 ssize_t sys_send(int s, const void *msg, size_t len, int flags)
203 {
204 ssize_t ret;
205
206 do {
207 ret = send(s, msg, len, flags);
208 } while (ret == -1 && errno == EINTR);
209 return ret;
210 }
211
212 /*******************************************************************
213 A sendto wrapper that will deal with EINTR.
214 ********************************************************************/
215
216 ssize_t sys_sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
217 {
218 ssize_t ret;
219
220 do {
221 ret = sendto(s, msg, len, flags, to, tolen);
222 } while (ret == -1 && errno == EINTR);
223 return ret;
224 }
225
226 /*******************************************************************
227 A recv wrapper that will deal with EINTR.
228 ********************************************************************/
229
230 ssize_t sys_recv(int fd, void *buf, size_t count, int flags)
231 {
232 ssize_t ret;
233
234 do {
235 ret = recv(fd, buf, count, flags);
236 } while (ret == -1 && errno == EINTR);
237 return ret;
238 }
239
240 /*******************************************************************
241 A recvfrom wrapper that will deal with EINTR.
242 ********************************************************************/
243
244 ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
245 {
246 ssize_t ret;
247
248 do {
249 ret = recvfrom(s, buf, len, flags, from, fromlen);
250 } while (ret == -1 && errno == EINTR);
251 return ret;
252 }
253
254 /*******************************************************************
255 A fcntl wrapper that will deal with EINTR.
256 ********************************************************************/
257
258 int sys_fcntl_ptr(int fd, int cmd, void *arg)
259 {
260 int ret;
261
262 do {
263 ret = fcntl(fd, cmd, arg);
264 } while (ret == -1 && errno == EINTR);
265 return ret;
266 }
267
268 /*******************************************************************
269 A fcntl wrapper that will deal with EINTR.
270 ********************************************************************/
271
272 int sys_fcntl_long(int fd, int cmd, long arg)
273 {
274 int ret;
275
276 do {
277 ret = fcntl(fd, cmd, arg);
278 } while (ret == -1 && errno == EINTR);
279 return ret;
280 }
281
282 /*******************************************************************
283 A stat() wrapper that will deal with 64 bit filesizes.
284 ********************************************************************/
285
286 int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
287 {
288 int ret;
289 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
290 ret = stat64(fname, sbuf);
291 #else
292 ret = stat(fname, sbuf);
293 #endif
294 /* we always want directories to appear zero size */
295 if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
296 return ret;
297 }
298
299 /*******************************************************************
300 An fstat() wrapper that will deal with 64 bit filesizes.
301 ********************************************************************/
302
303 int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
304 {
305 int ret;
306 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
307 ret = fstat64(fd, sbuf);
308 #else
309 ret = fstat(fd, sbuf);
310 #endif
311 /* we always want directories to appear zero size */
312 if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
313 return ret;
314 }
315
316 /*******************************************************************
317 An lstat() wrapper that will deal with 64 bit filesizes.
318 ********************************************************************/
319
320 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
321 {
322 int ret;
323 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
324 ret = lstat64(fname, sbuf);
325 #else
326 ret = lstat(fname, sbuf);
327 #endif
328 /* we always want directories to appear zero size */
329 if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
330 return ret;
331 }
332
333 /*******************************************************************
334 An ftruncate() wrapper that will deal with 64 bit filesizes.
335 ********************************************************************/
336
337 int sys_ftruncate(int fd, SMB_OFF_T offset)
338 {
339 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
340 return ftruncate64(fd, offset);
341 #else
342 return ftruncate(fd, offset);
343 #endif
344 }
345
346 /*******************************************************************
347 An lseek() wrapper that will deal with 64 bit filesizes.
348 ********************************************************************/
349
350 SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
351 {
352 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
353 return lseek64(fd, offset, whence);
354 #else
355 return lseek(fd, offset, whence);
356 #endif
357 }
358
359 /*******************************************************************
360 An fseek() wrapper that will deal with 64 bit filesizes.
361 ********************************************************************/
362
363 int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
364 {
365 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
366 return fseek64(fp, offset, whence);
367 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
368 return fseeko64(fp, offset, whence);
369 #else
370 return fseek(fp, offset, whence);
371 #endif
372 }
373
374 /*******************************************************************
375 An ftell() wrapper that will deal with 64 bit filesizes.
376 ********************************************************************/
377
378 SMB_OFF_T sys_ftell(FILE *fp)
379 {
380 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
381 return (SMB_OFF_T)ftell64(fp);
382 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
383 return (SMB_OFF_T)ftello64(fp);
384 #else
385 return (SMB_OFF_T)ftell(fp);
386 #endif
387 }
388
389 /*******************************************************************
390 A creat() wrapper that will deal with 64 bit filesizes.
391 ********************************************************************/
392
393 int sys_creat(const char *path, mode_t mode)
394 {
395 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
396 return creat64(path, mode);
397 #else
398 /*
399 * If creat64 isn't defined then ensure we call a potential open64.
400 * JRA.
401 */
402 return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
403 #endif
404 }
405
406 /*******************************************************************
407 An open() wrapper that will deal with 64 bit filesizes.
408 ********************************************************************/
409
410 int sys_open(const char *path, int oflag, mode_t mode)
411 {
412 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
413 return open64(path, oflag, mode);
414 #else
415 return open(path, oflag, mode);
416 #endif
417 }
418
419 /*******************************************************************
420 An fopen() wrapper that will deal with 64 bit filesizes.
421 ********************************************************************/
422
423 FILE *sys_fopen(const char *path, const char *type)
424 {
425 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
426 return fopen64(path, type);
427 #else
428 return fopen(path, type);
429 #endif
430 }
431
432
433 /*******************************************************************
434 A flock() wrapper that will perform the kernel flock.
435 ********************************************************************/
436
437 void kernel_flock(int fd, uint32 share_mode)
438 {
439 #if HAVE_KERNEL_SHARE_MODES
440 int kernel_mode = 0;
441 if (share_mode == FILE_SHARE_WRITE) {
442 kernel_mode = LOCK_MAND|LOCK_WRITE;
443 } else if (share_mode == FILE_SHARE_READ) {
444 kernel_mode = LOCK_MAND|LOCK_READ;
445 } else if (share_mode == FILE_SHARE_NONE) {
446 kernel_mode = LOCK_MAND;
447 }
448 if (kernel_mode) {
449 flock(fd, kernel_mode);
450 }
451 #endif
452 ;
453 }
454
455
456
457 /*******************************************************************
458 An opendir wrapper that will deal with 64 bit filesizes.
459 ********************************************************************/
460
461 SMB_STRUCT_DIR *sys_opendir(const char *name)
462 {
463 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
464 return opendir64(name);
465 #else
466 return opendir(name);
467 #endif
468 }
469
470 /*******************************************************************
471 A readdir wrapper that will deal with 64 bit filesizes.
472 ********************************************************************/
473
474 SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
475 {
476 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
477 return readdir64(dirp);
478 #else
479 return readdir(dirp);
480 #endif
481 }
482
483 /*******************************************************************
484 A seekdir wrapper that will deal with 64 bit filesizes.
485 ********************************************************************/
486
487 void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset)
488 {
489 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_SEEKDIR64)
490 seekdir64(dirp, offset);
491 #else
492 seekdir(dirp, offset);
493 #endif
494 }
495
496 /*******************************************************************
497 A telldir wrapper that will deal with 64 bit filesizes.
498 ********************************************************************/
499
500 long sys_telldir(SMB_STRUCT_DIR *dirp)
501 {
502 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_TELLDIR64)
503 return (long)telldir64(dirp);
504 #else
505 return (long)telldir(dirp);
506 #endif
507 }
508
509 /*******************************************************************
510 A rewinddir wrapper that will deal with 64 bit filesizes.
511 ********************************************************************/
512
513 void sys_rewinddir(SMB_STRUCT_DIR *dirp)
514 {
515 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
516 rewinddir64(dirp);
517 #else
518 rewinddir(dirp);
519 #endif
520 }
521
522 /*******************************************************************
523 A close wrapper that will deal with 64 bit filesizes.
524 ********************************************************************/
525
526 int sys_closedir(SMB_STRUCT_DIR *dirp)
527 {
528 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
529 return closedir64(dirp);
530 #else
531 return closedir(dirp);
532 #endif
533 }
534
535 /*******************************************************************
536 An mknod() wrapper that will deal with 64 bit filesizes.
537 ********************************************************************/
538
539 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
540 {
541 #if defined(HAVE_MKNOD) || defined(HAVE_MKNOD64)
542 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_MKNOD64) && defined(HAVE_DEV64_T)
543 return mknod64(path, mode, dev);
544 #else
545 return mknod(path, mode, dev);
546 #endif
547 #else
548 /* No mknod system call. */
549 errno = ENOSYS;
550 return -1;
551 #endif
552 }
553
554 /*******************************************************************
555 Wrapper for realpath.
556 ********************************************************************/
557
558 char *sys_realpath(const char *path, char *resolved_path)
559 {
560 #if defined(HAVE_REALPATH)
561 return realpath(path, resolved_path);
562 #else
563 /* As realpath is not a system call we can't return ENOSYS. */
564 errno = EINVAL;
565 return NULL;
566 #endif
567 }
568
569 /*******************************************************************
570 The wait() calls vary between systems
571 ********************************************************************/
572
573 int sys_waitpid(pid_t pid,int *status,int options)
574 {
575 #ifdef HAVE_WAITPID
576 return waitpid(pid,status,options);
577 #else /* HAVE_WAITPID */
578 return wait4(pid, status, options, NULL);
579 #endif /* HAVE_WAITPID */
580 }
581
582 /*******************************************************************
583 System wrapper for getwd
584 ********************************************************************/
585
586 char *sys_getwd(char *s)
587 {
588 char *wd;
589 #ifdef HAVE_GETCWD
590 wd = (char *)getcwd(s, PATH_MAX);
591 #else
592 wd = (char *)getwd(s);
593 #endif
594 return wd;
595 }
596
597 /*******************************************************************
598 system wrapper for symlink
599 ********************************************************************/
600
601 int sys_symlink(const char *oldpath, const char *newpath)
602 {
603 #ifndef HAVE_SYMLINK
604 errno = ENOSYS;
605 return -1;
606 #else
607 return symlink(oldpath, newpath);
608 #endif
609 }
610
611 /*******************************************************************
612 system wrapper for readlink
613 ********************************************************************/
614
615 int sys_readlink(const char *path, char *buf, size_t bufsiz)
616 {
617 #ifndef HAVE_READLINK
618 errno = ENOSYS;
619 return -1;
620 #else
621 return readlink(path, buf, bufsiz);
622 #endif
623 }
624
625 /*******************************************************************
626 system wrapper for link
627 ********************************************************************/
628
629 int sys_link(const char *oldpath, const char *newpath)
630 {
631 #ifndef HAVE_LINK
632 errno = ENOSYS;
633 return -1;
634 #else
635 return link(oldpath, newpath);
636 #endif
637 }
638
639 /*******************************************************************
640 chown isn't used much but OS/2 doesn't have it
641 ********************************************************************/
642
643 int sys_chown(const char *fname,uid_t uid,gid_t gid)
644 {
645 #ifndef HAVE_CHOWN
646 static int done;
647 if (!done) {
648 DEBUG(1,("WARNING: no chown!\n"));
649 done=1;
650 }
651 errno = ENOSYS;
652 return -1;
653 #else
654 return(chown(fname,uid,gid));
655 #endif
656 }
657
658 /*******************************************************************
659 Wrapper for lchown.
660 ********************************************************************/
661
662 int sys_lchown(const char *fname,uid_t uid,gid_t gid)
663 {
664 #ifndef HAVE_LCHOWN
665 static int done;
666 if (!done) {
667 DEBUG(1,("WARNING: no lchown!\n"));
668 done=1;
669 }
670 errno = ENOSYS;
671 return -1;
672 #else
673 return(lchown(fname,uid,gid));
674 #endif
675 }
676
677 /*******************************************************************
678 os/2 also doesn't have chroot
679 ********************************************************************/
680 int sys_chroot(const char *dname)
681 {
682 #ifndef HAVE_CHROOT
683 static int done;
684 if (!done) {
685 DEBUG(1,("WARNING: no chroot!\n"));
686 done=1;
687 }
688 errno = ENOSYS;
689 return -1;
690 #else
691 return(chroot(dname));
692 #endif
693 }
694
695 #if defined(HAVE_POSIX_CAPABILITIES)
696
697 /**************************************************************************
698 Try and abstract process capabilities (for systems that have them).
699 ****************************************************************************/
700
701 /* Set the POSIX capabilities needed for the given purpose into the effective
702 * capability set of the current process. Make sure they are always removed
703 * from the inheritable set, because there is no circumstance in which our
704 * children should inherit our elevated privileges.
705 */
706 static bool set_process_capability(enum smbd_capability capability,
707 bool enable)
708 {
709 cap_value_t cap_vals[2] = {0};
710 int num_cap_vals = 0;
711
712 cap_t cap;
713
714 #if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
715 /* On Linux, make sure that any capabilities we grab are sticky
716 * across UID changes. We expect that this would allow us to keep both
717 * the effective and permitted capability sets, but as of circa 2.6.16,
718 * only the permitted set is kept. It is a bug (which we work around)
719 * that the effective set is lost, but we still require the effective
720 * set to be kept.
721 */
722 if (!prctl(PR_GET_KEEPCAPS)) {
723 prctl(PR_SET_KEEPCAPS, 1);
724 }
725 #endif
726
727 cap = cap_get_proc();
728 if (cap == NULL) {
729 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
730 strerror(errno)));
731 return False;
732 }
733
734 switch (capability) {
735 case KERNEL_OPLOCK_CAPABILITY:
736 #ifdef CAP_NETWORK_MGT
737 /* IRIX has CAP_NETWORK_MGT for oplocks. */
738 cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
739 #endif
740 break;
741 case DMAPI_ACCESS_CAPABILITY:
742 #ifdef CAP_DEVICE_MGT
743 /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
744 cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
745 #elif CAP_MKNOD
746 /* Linux has CAP_MKNOD for DMAPI access. */
747 cap_vals[num_cap_vals++] = CAP_MKNOD;
748 #endif
749 break;
750 case LEASE_CAPABILITY:
751 #ifdef CAP_LEASE
752 cap_vals[num_cap_vals++] = CAP_LEASE;
753 #endif
754 break;
755 }
756
757 SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
758
759 if (num_cap_vals == 0) {
760 cap_free(cap);
761 return True;
762 }
763
764 cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
765 enable ? CAP_SET : CAP_CLEAR);
766
767 /* We never want to pass capabilities down to our children, so make
768 * sure they are not inherited.
769 */
770 cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
771
772 if (cap_set_proc(cap) == -1) {
773 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
774 strerror(errno)));
775 cap_free(cap);
776 return False;
777 }
778
779 cap_free(cap);
780 return True;
781 }
782
783 #endif /* HAVE_POSIX_CAPABILITIES */
784
785 /****************************************************************************
786 Gain the oplock capability from the kernel if possible.
787 ****************************************************************************/
788
789 void set_effective_capability(enum smbd_capability capability)
790 {
791 #if defined(HAVE_POSIX_CAPABILITIES)
792 set_process_capability(capability, True);
793 #endif /* HAVE_POSIX_CAPABILITIES */
794 }
795
796 void drop_effective_capability(enum smbd_capability capability)
797 {
798 #if defined(HAVE_POSIX_CAPABILITIES)
799 set_process_capability(capability, False);
800 #endif /* HAVE_POSIX_CAPABILITIES */
801 }
802
803 /**************************************************************************
804 Wrapper for random().
805 ****************************************************************************/
806
807 long sys_random(void)
808 {
809 #if defined(HAVE_RANDOM)
810 return (long)random();
811 #elif defined(HAVE_RAND)
812 return (long)rand();
813 #else
814 DEBUG(0,("Error - no random function available !\n"));
815 exit(1);
816 #endif
817 }
818
819 /**************************************************************************
820 Wrapper for srandom().
821 ****************************************************************************/
822
823 void sys_srandom(unsigned int seed)
824 {
825 #if defined(HAVE_SRANDOM)
826 srandom(seed);
827 #elif defined(HAVE_SRAND)
828 srand(seed);
829 #else
830 DEBUG(0,("Error - no srandom function available !\n"));
831 exit(1);
832 #endif
833 }
834
835 /**************************************************************************
836 Returns equivalent to NGROUPS_MAX - using sysconf if needed.
837 ****************************************************************************/
838
839 int groups_max(void)
840 {
841 #if defined(SYSCONF_SC_NGROUPS_MAX)
842 int ret = sysconf(_SC_NGROUPS_MAX);
843 return (ret == -1) ? NGROUPS_MAX : ret;
844 #else
845 return NGROUPS_MAX;
846 #endif
847 }
848
849 /**************************************************************************
850 Wrap setgroups and getgroups for systems that declare getgroups() as
851 returning an array of gid_t, but actuall return an array of int.
852 ****************************************************************************/
853
854 #if defined(HAVE_BROKEN_GETGROUPS)
855 static int sys_broken_getgroups(int setlen, gid_t *gidset)
856 {
857 GID_T gid;
858 GID_T *group_list;
859 int i, ngroups;
860
861 if(setlen == 0) {
862 return getgroups(setlen, &gid);
863 }
864
865 /*
866 * Broken case. We need to allocate a
867 * GID_T array of size setlen.
868 */
869
870 if(setlen < 0) {
871 errno = EINVAL;
872 return -1;
873 }
874
875 if (setlen == 0)
876 setlen = groups_max();
877
878 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
879 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
880 return -1;
881 }
882
883 if((ngroups = getgroups(setlen, group_list)) < 0) {
884 int saved_errno = errno;
885 SAFE_FREE(group_list);
886 errno = saved_errno;
887 return -1;
888 }
889
890 for(i = 0; i < ngroups; i++)
891 gidset[i] = (gid_t)group_list[i];
892
893 SAFE_FREE(group_list);
894 return ngroups;
895 }
896
897 static int sys_broken_setgroups(int setlen, gid_t *gidset)
898 {
899 GID_T *group_list;
900 int i ;
901
902 if (setlen == 0)
903 return 0 ;
904
905 if (setlen < 0 || setlen > groups_max()) {
906 errno = EINVAL;
907 return -1;
908 }
909
910 /*
911 * Broken case. We need to allocate a
912 * GID_T array of size setlen.
913 */
914
915 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
916 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
917 return -1;
918 }
919
920 for(i = 0; i < setlen; i++)
921 group_list[i] = (GID_T) gidset[i];
922
923 if(setgroups(setlen, group_list) != 0) {
924 int saved_errno = errno;
925 SAFE_FREE(group_list);
926 errno = saved_errno;
927 return -1;
928 }
929
930 SAFE_FREE(group_list);
931 return 0 ;
932 }
933
934 #endif /* HAVE_BROKEN_GETGROUPS */
935
936 /* This is a list of systems that require the first GID passed to setgroups(2)
937 * to be the effective GID. If your system is one of these, add it here.
938 */
939 #if defined (FREEBSD) || defined (DARWINOS)
940 #define USE_BSD_SETGROUPS
941 #endif
942
943 #if defined(USE_BSD_SETGROUPS)
944 /* Depending on the particular BSD implementation, the first GID that is
945 * passed to setgroups(2) will either be ignored or will set the credential's
946 * effective GID. In either case, the right thing to do is to guarantee that
947 * gidset[0] is the effective GID.
948 */
949 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
950 {
951 gid_t *new_gidset = NULL;
952 int max;
953 int ret;
954
955 /* setgroups(2) will fail with EINVAL if we pass too many groups. */
956 max = groups_max();
957
958 /* No group list, just make sure we are setting the efective GID. */
959 if (setlen == 0) {
960 return setgroups(1, &primary_gid);
961 }
962
963 /* If the primary gid is not the first array element, grow the array
964 * and insert it at the front.
965 */
966 if (gidset[0] != primary_gid) {
967 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
968 if (new_gidset == NULL) {
969 return -1;
970 }
971
972 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
973 new_gidset[0] = primary_gid;
974 setlen++;
975 }
976
977 if (setlen > max) {
978 DEBUG(3, ("forced to truncate group list from %d to %d\n",
979 setlen, max));
980 setlen = max;
981 }
982
983 #if defined(HAVE_BROKEN_GETGROUPS)
984 ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
985 #else
986 ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
987 #endif
988
989 if (new_gidset) {
990 int errsav = errno;
991 SAFE_FREE(new_gidset);
992 errno = errsav;
993 }
994
995 return ret;
996 }
997
998 #endif /* USE_BSD_SETGROUPS */
999
1000 /**************************************************************************
1001 Wrapper for getgroups. Deals with broken (int) case.
1002 ****************************************************************************/
1003
1004 int sys_getgroups(int setlen, gid_t *gidset)
1005 {
1006 #if defined(HAVE_BROKEN_GETGROUPS)
1007 return sys_broken_getgroups(setlen, gidset);
1008 #else
1009 return getgroups(setlen, gidset);
1010 #endif
1011 }
1012
1013 /**************************************************************************
1014 Wrapper for setgroups. Deals with broken (int) case and BSD case.
1015 ****************************************************************************/
1016
1017 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
1018 {
1019 #if !defined(HAVE_SETGROUPS)
1020 errno = ENOSYS;
1021 return -1;
1022 #endif /* HAVE_SETGROUPS */
1023
1024 #if defined(USE_BSD_SETGROUPS)
1025 return sys_bsd_setgroups(primary_gid, setlen, gidset);
1026 #elif defined(HAVE_BROKEN_GETGROUPS)
1027 return sys_broken_setgroups(setlen, gidset);
1028 #else
1029 return setgroups(setlen, gidset);
1030 #endif
1031 }
1032
1033 /**************************************************************************
1034 Wrappers for setpwent(), getpwent() and endpwent()
1035 ****************************************************************************/
1036
1037 void sys_setpwent(void)
1038 {
1039 setpwent();
1040 }
1041
1042 struct passwd *sys_getpwent(void)
1043 {
1044 return getpwent();
1045 }
1046
1047 void sys_endpwent(void)
1048 {
1049 endpwent();
1050 }
1051
1052 /**************************************************************************
1053 Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
1054 ****************************************************************************/
1055
1056
1057 struct passwd *sys_getpwnam(const char *name)
1058 {
1059 return getpwnam(name);
1060 }
1061
1062 struct passwd *sys_getpwuid(uid_t uid)
1063 {
1064 return getpwuid(uid);
1065 }
1066
1067 struct group *sys_getgrnam(const char *name)
1068 {
1069 return getgrnam(name);
1070 }
1071
1072 struct group *sys_getgrgid(gid_t gid)
1073 {
1074 return getgrgid(gid);
1075 }
1076
1077 /**************************************************************************
1078 Extract a command into an arg list.
1079 ****************************************************************************/
1080
1081 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
1082 {
1083 char *trunc_cmd;
1084 char *saveptr;
1085 char *ptr;
1086 int argcl;
1087 char **argl = NULL;
1088 int i;
1089
1090 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1091 DEBUG(0, ("talloc failed\n"));
1092 goto nomem;
1093 }
1094
1095 if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1096 TALLOC_FREE(trunc_cmd);
1097 errno = EINVAL;
1098 return NULL;
1099 }
1100
1101 /*
1102 * Count the args.
1103 */
1104
1105 for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1106 argcl++;
1107
1108 TALLOC_FREE(trunc_cmd);
1109
1110 if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
1111 goto nomem;
1112 }
1113
1114 /*
1115 * Now do the extraction.
1116 */
1117
1118 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1119 goto nomem;
1120 }
1121
1122 ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1123 i = 0;
1124
1125 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1126 goto nomem;
1127 }
1128
1129 while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1130
1131 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1132 goto nomem;
1133 }
1134 }
1135
1136 argl[i++] = NULL;
1137 return argl;
1138
1139 nomem:
1140 DEBUG(0, ("talloc failed\n"));
1141 TALLOC_FREE(trunc_cmd);
1142 TALLOC_FREE(argl);
1143 errno = ENOMEM;
1144 return NULL;
1145 }
1146
1147 /**************************************************************************
1148 Wrapper for fork. Ensures that mypid is reset. Used so we can write
1149 a sys_getpid() that only does a system call *once*.
1150 ****************************************************************************/
1151
1152 static pid_t mypid = (pid_t)-1;
1153
1154 pid_t sys_fork(void)
1155 {
1156 pid_t forkret = fork();
1157
1158 if (forkret == (pid_t)0) /* Child - reset mypid so sys_getpid does a system call. */
1159 mypid = (pid_t) -1;
1160
1161 return forkret;
1162 }
1163
1164 /**************************************************************************
1165 Wrapper for getpid. Ensures we only do a system call *once*.
1166 ****************************************************************************/
1167
1168 pid_t sys_getpid(void)
1169 {
1170 if (mypid == (pid_t)-1)
1171 mypid = getpid();
1172
1173 return mypid;
1174 }
1175
1176 /**************************************************************************
1177 Wrapper for popen. Safer as it doesn't search a path.
1178 Modified from the glibc sources.
1179 modified by tridge to return a file descriptor. We must kick our FILE* habit
1180 ****************************************************************************/
1181
1182 typedef struct _popen_list
1183 {
1184 int fd;
1185 pid_t child_pid;
1186 struct _popen_list *next;
1187 } popen_list;
1188
1189 static popen_list *popen_chain;
1190
1191 int sys_popen(const char *command)
1192 {
1193 int parent_end, child_end;
1194 int pipe_fds[2];
1195 popen_list *entry = NULL;
1196 char **argl = NULL;
1197
1198 if (pipe(pipe_fds) < 0)
1199 return -1;
1200
1201 parent_end = pipe_fds[0];
1202 child_end = pipe_fds[1];
1203
1204 if (!*command) {
1205 errno = EINVAL;
1206 goto err_exit;
1207 }
1208
1209 if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1210 goto err_exit;
1211
1212 ZERO_STRUCTP(entry);
1213
1214 /*
1215 * Extract the command and args into a NULL terminated array.
1216 */
1217
1218 if(!(argl = extract_args(NULL, command)))
1219 goto err_exit;
1220
1221 entry->child_pid = sys_fork();
1222
1223 if (entry->child_pid == -1) {
1224 goto err_exit;
1225 }
1226
1227 if (entry->child_pid == 0) {
1228
1229 /*
1230 * Child !
1231 */
1232
1233 int child_std_end = STDOUT_FILENO;
1234 popen_list *p;
1235
1236 close(parent_end);
1237 if (child_end != child_std_end) {
1238 dup2 (child_end, child_std_end);
1239 close (child_end);
1240 }
1241
1242 /*
1243 * POSIX.2: "popen() shall ensure that any streams from previous
1244 * popen() calls that remain open in the parent process are closed
1245 * in the new child process."
1246 */
1247
1248 for (p = popen_chain; p; p = p->next)
1249 close(p->fd);
1250
1251 execv(argl[0], argl);
1252 _exit (127);
1253 }
1254
1255 /*
1256 * Parent.
1257 */
1258
1259 close (child_end);
1260 TALLOC_FREE(argl);
1261
1262 /* Link into popen_chain. */
1263 entry->next = popen_chain;
1264 popen_chain = entry;
1265 entry->fd = parent_end;
1266
1267 return entry->fd;
1268
1269 err_exit:
1270
1271 SAFE_FREE(entry);
1272 SAFE_FREE(argl);
1273 close(pipe_fds[0]);
1274 close(pipe_fds[1]);
1275 return -1;
1276 }
1277
1278 /**************************************************************************
1279 Wrapper for pclose. Modified from the glibc sources.
1280 ****************************************************************************/
1281
1282 int sys_pclose(int fd)
1283 {
1284 int wstatus;
1285 popen_list **ptr = &popen_chain;
1286 popen_list *entry = NULL;
1287 pid_t wait_pid;
1288 int status = -1;
1289
1290 /* Unlink from popen_chain. */
1291 for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1292 if ((*ptr)->fd == fd) {
1293 entry = *ptr;
1294 *ptr = (*ptr)->next;
1295 status = 0;
1296 break;
1297 }
1298 }
1299
1300 if (status < 0 || close(entry->fd) < 0)
1301 return -1;
1302
1303 /*
1304 * As Samba is catching and eating child process
1305 * exits we don't really care about the child exit
1306 * code, a -1 with errno = ECHILD will do fine for us.
1307 */
1308
1309 do {
1310 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1311 } while (wait_pid == -1 && errno == EINTR);
1312
1313 SAFE_FREE(entry);
1314
1315 if (wait_pid == -1)
1316 return -1;
1317 return wstatus;
1318 }
1319
1320 /**************************************************************************
1321 Wrappers for dlopen, dlsym, dlclose.
1322 ****************************************************************************/
1323
1324 void *sys_dlopen(const char *name, int flags)
1325 {
1326 #if defined(HAVE_DLOPEN)
1327 return dlopen(name, flags);
1328 #else
1329 return NULL;
1330 #endif
1331 }
1332
1333 void *sys_dlsym(void *handle, const char *symbol)
1334 {
1335 #if defined(HAVE_DLSYM)
1336 return dlsym(handle, symbol);
1337 #else
1338 return NULL;
1339 #endif
1340 }
1341
1342 int sys_dlclose (void *handle)
1343 {
1344 #if defined(HAVE_DLCLOSE)
1345 return dlclose(handle);
1346 #else
1347 return 0;
1348 #endif
1349 }
1350
1351 const char *sys_dlerror(void)
1352 {
1353 #if defined(HAVE_DLERROR)
1354 return dlerror();
1355 #else
1356 return NULL;
1357 #endif
1358 }
1359
1360 int sys_dup2(int oldfd, int newfd)
1361 {
1362 #if defined(HAVE_DUP2)
1363 return dup2(oldfd, newfd);
1364 #else
1365 errno = ENOSYS;
1366 return -1;
1367 #endif
1368 }
1369
1370 /**************************************************************************
1371 Wrapper for Admin Logs.
1372 ****************************************************************************/
1373
1374 void sys_adminlog(int priority, const char *format_str, ...)
1375 {
1376 va_list ap;
1377 int ret;
1378 char *msgbuf = NULL;
1379
1380 va_start( ap, format_str );
1381 ret = vasprintf( &msgbuf, format_str, ap );
1382 va_end( ap );
1383
1384 if (ret == -1)
1385 return;
1386
1387 #if defined(HAVE_SYSLOG)
1388 syslog( priority, "%s", msgbuf );
1389 #else
1390 DEBUG(0,("%s", msgbuf ));
1391 #endif
1392 SAFE_FREE(msgbuf);
1393 }
1394
1395 /******** Solaris EA helper function prototypes ********/
1396 #ifdef HAVE_ATTROPEN
1397 #define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP
1398 static int solaris_write_xattr(int attrfd, const char *value, size_t size);
1399 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size);
1400 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size);
1401 static int solaris_unlinkat(int attrdirfd, const char *name);
1402 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode);
1403 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode);
1404 #endif
1405
1406 /**************************************************************************
1407 Wrappers for extented attribute calls. Based on the Linux package with
1408 support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
1409 ****************************************************************************/
1410
1411 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
1412 {
1413 #if defined(HAVE_GETXATTR)
1414 #ifndef XATTR_ADD_OPT
1415 return getxattr(path, name, value, size);
1416 #else
1417 int options = 0;
1418 return getxattr(path, name, value, size, 0, options);
1419 #endif
1420 #elif defined(HAVE_GETEA)
1421 return getea(path, name, value, size);
1422 #elif defined(HAVE_EXTATTR_GET_FILE)
1423 char *s;
1424 ssize_t retval;
1425 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1426 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1427 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1428 /*
1429 * The BSD implementation has a nasty habit of silently truncating
1430 * the returned value to the size of the buffer, so we have to check
1431 * that the buffer is large enough to fit the returned value.
1432 */
1433 if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1434 if(retval > size) {
1435 errno = ERANGE;
1436 return -1;
1437 }
1438 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
1439 return retval;
1440 }
1441
1442 DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
1443 return -1;
1444 #elif defined(HAVE_ATTR_GET)
1445 int retval, flags = 0;
1446 int valuelength = (int)size;
1447 char *attrname = strchr(name,'.') + 1;
1448
1449 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1450
1451 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1452
1453 return retval ? retval : valuelength;
1454 #elif defined(HAVE_ATTROPEN)
1455 ssize_t ret = -1;
1456 int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
1457 if (attrfd >= 0) {
1458 ret = solaris_read_xattr(attrfd, value, size);
1459 close(attrfd);
1460 }
1461 return ret;
1462 #else
1463 errno = ENOSYS;
1464 return -1;
1465 #endif
1466 }
1467
1468 ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
1469 {
1470 #if defined(HAVE_LGETXATTR)
1471 return lgetxattr(path, name, value, size);
1472 #elif defined(HAVE_GETXATTR) && defined(XATTR_ADD_OPT)
1473 int options = XATTR_NOFOLLOW;
1474 return getxattr(path, name, value, size, 0, options);
1475 #elif defined(HAVE_LGETEA)
1476 return lgetea(path, name, value, size);
1477 #elif defined(HAVE_EXTATTR_GET_LINK)
1478 char *s;
1479 ssize_t retval;
1480 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1481 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1482 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1483
1484 if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1485 if(retval > size) {
1486 errno = ERANGE;
1487 return -1;
1488 }
1489 if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
1490 return retval;
1491 }
1492
1493 DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
1494 return -1;
1495 #elif defined(HAVE_ATTR_GET)
1496 int retval, flags = ATTR_DONTFOLLOW;
1497 int valuelength = (int)size;
1498 char *attrname = strchr(name,'.') + 1;
1499
1500 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1501
1502 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1503
1504 return retval ? retval : valuelength;
1505 #elif defined(HAVE_ATTROPEN)
1506 ssize_t ret = -1;
1507 int attrfd = solaris_attropen(path, name, O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1508 if (attrfd >= 0) {
1509 ret = solaris_read_xattr(attrfd, value, size);
1510 close(attrfd);
1511 }
1512 return ret;
1513 #else
1514 errno = ENOSYS;
1515 return -1;
1516 #endif
1517 }
1518
1519 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
1520 {
1521 #if defined(HAVE_FGETXATTR)
1522 #ifndef XATTR_ADD_OPT
1523 return fgetxattr(filedes, name, value, size);
1524 #else
1525 int options = 0;
1526 return fgetxattr(filedes, name, value, size, 0, options);
1527 #endif
1528 #elif defined(HAVE_FGETEA)
1529 return fgetea(filedes, name, value, size);
1530 #elif defined(HAVE_EXTATTR_GET_FD)
1531 char *s;
1532 ssize_t retval;
1533 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1534 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1535 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1536
1537 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
1538 if(retval > size) {
1539 errno = ERANGE;
1540 return -1;
1541 }
1542 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
1543 return retval;
1544 }
1545
1546 DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
1547 return -1;
1548 #elif defined(HAVE_ATTR_GETF)
1549 int retval, flags = 0;
1550 int valuelength = (int)size;
1551 char *attrname = strchr(name,'.') + 1;
1552
1553 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1554
1555 retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
1556
1557 return retval ? retval : valuelength;
1558 #elif defined(HAVE_ATTROPEN)
1559 ssize_t ret = -1;
1560 int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
1561 if (attrfd >= 0) {
1562 ret = solaris_read_xattr(attrfd, value, size);
1563 close(attrfd);
1564 }
1565 return ret;
1566 #else
1567 errno = ENOSYS;
1568 return -1;
1569 #endif
1570 }
1571
1572 #if defined(HAVE_EXTATTR_LIST_FILE)
1573
1574 #define EXTATTR_PREFIX(s) (s), (sizeof((s))-1)
1575
1576 static struct {
1577 int space;
1578 const char *name;
1579 size_t len;
1580 }
1581 extattr[] = {
1582 { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
1583 { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
1584 };
1585
1586 typedef union {
1587 const char *path;
1588 int filedes;
1589 } extattr_arg;
1590
1591 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
1592 {
1593 ssize_t list_size, total_size = 0;
1594 int i, t, len;
1595 char *buf;
1596 /* Iterate through extattr(2) namespaces */
1597 for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
1598 switch(type) {
1599 #if defined(HAVE_EXTATTR_LIST_FILE)
1600 case 0:
1601 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
1602 break;
1603 #endif
1604 #if defined(HAVE_EXTATTR_LIST_LINK)
1605 case 1:
1606 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
1607 break;
1608 #endif
1609 #if defined(HAVE_EXTATTR_LIST_FD)
1610 case 2:
1611 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
1612 break;
1613 #endif
1614 default:
1615 errno = ENOSYS;
1616 return -1;
1617 }
1618 /* Some error happend. Errno should be set by the previous call */
1619 if(list_size < 0)
1620 return -1;
1621 /* No attributes */
1622 if(list_size == 0)
1623 continue;
1624 /* XXX: Call with an empty buffer may be used to calculate
1625 necessary buffer size. Unfortunately, we can't say, how
1626 many attributes were returned, so here is the potential
1627 problem with the emulation.
1628 */
1629 if(list == NULL) {
1630 /* Take the worse case of one char attribute names -
1631 two bytes per name plus one more for sanity.
1632 */
1633 total_size += list_size + (list_size/2 + 1)*extattr[t].len;
1634 continue;
1635 }
1636 /* Count necessary offset to fit namespace prefixes */
1637 len = 0;
1638 for(i = 0; i < list_size; i += list[i] + 1)
1639 len += extattr[t].len;
1640
1641 total_size += list_size + len;
1642 /* Buffer is too small to fit the results */
1643 if(total_size > size) {
1644 errno = ERANGE;
1645 return -1;
1646 }
1647 /* Shift results back, so we can prepend prefixes */
1648 buf = memmove(list + len, list, list_size);
1649
1650 for(i = 0; i < list_size; i += len + 1) {
1651 len = buf[i];
1652 strncpy(list, extattr[t].name, extattr[t].len + 1);
1653 list += extattr[t].len;
1654 strncpy(list, buf + i + 1, len);
1655 list[len] = '\0';
1656 list += len + 1;
1657 }
1658 size -= total_size;
1659 }
1660 return total_size;
1661 }
1662
1663 #endif
1664
1665 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1666 static char attr_buffer[ATTR_MAX_VALUELEN];
1667
1668 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
1669 {
1670 int retval = 0, index;
1671 attrlist_cursor_t *cursor = 0;
1672 int total_size = 0;
1673 attrlist_t * al = (attrlist_t *)attr_buffer;
1674 attrlist_ent_t *ae;
1675 size_t ent_size, left = size;
1676 char *bp = list;
1677
1678 while (True) {
1679 if (filedes)
1680 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1681 else
1682 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1683 if (retval) break;
1684 for (index = 0; index < al->al_count; index++) {
1685 ae = ATTR_ENTRY(attr_buffer, index);
1686 ent_size = strlen(ae->a_name) + sizeof("user.");
1687 if (left >= ent_size) {
1688 strncpy(bp, "user.", sizeof("user."));
1689 strncat(bp, ae->a_name, ent_size - sizeof("user."));
1690 bp += ent_size;
1691 left -= ent_size;
1692 } else if (size) {
1693 errno = ERANGE;
1694 retval = -1;
1695 break;
1696 }
1697 total_size += ent_size;
1698 }
1699 if (al->al_more == 0) break;
1700 }
1701 if (retval == 0) {
1702 flags |= ATTR_ROOT;
1703 cursor = 0;
1704 while (True) {
1705 if (filedes)
1706 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1707 else
1708 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1709 if (retval) break;
1710 for (index = 0; index < al->al_count; index++) {
1711 ae = ATTR_ENTRY(attr_buffer, index);
1712 ent_size = strlen(ae->a_name) + sizeof("system.");
1713 if (left >= ent_size) {
1714 strncpy(bp, "system.", sizeof("system."));
1715 strncat(bp, ae->a_name, ent_size - sizeof("system."));
1716 bp += ent_size;
1717 left -= ent_size;
1718 } else if (size) {
1719 errno = ERANGE;
1720 retval = -1;
1721 break;
1722 }
1723 total_size += ent_size;
1724 }
1725 if (al->al_more == 0) break;
1726 }
1727 }
1728 return (ssize_t)(retval ? retval : total_size);
1729 }
1730
1731 #endif
1732
1733 ssize_t sys_listxattr (const char *path, char *list, size_t size)
1734 {
1735 #if defined(HAVE_LISTXATTR)
1736 #ifndef XATTR_ADD_OPT
1737 return listxattr(path, list, size);
1738 #else
1739 int options = 0;
1740 return listxattr(path, list, size, options);
1741 #endif
1742 #elif defined(HAVE_LISTEA)
1743 return listea(path, list, size);
1744 #elif defined(HAVE_EXTATTR_LIST_FILE)
1745 extattr_arg arg;
1746 arg.path = path;
1747 return bsd_attr_list(0, arg, list, size);
1748 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1749 return irix_attr_list(path, 0, list, size, 0);
1750 #elif defined(HAVE_ATTROPEN)
1751 ssize_t ret = -1;
1752 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1753 if (attrdirfd >= 0) {
1754 ret = solaris_list_xattr(attrdirfd, list, size);
1755 close(attrdirfd);
1756 }
1757 return ret;
1758 #else
1759 errno = ENOSYS;
1760 return -1;
1761 #endif
1762 }
1763
1764 ssize_t sys_llistxattr (const char *path, char *list, size_t size)
1765 {
1766 #if defined(HAVE_LLISTXATTR)
1767 return llistxattr(path, list, size);
1768 #elif defined(HAVE_LISTXATTR) && defined(XATTR_ADD_OPT)
1769 int options = XATTR_NOFOLLOW;
1770 return listxattr(path, list, size, options);
1771 #elif defined(HAVE_LLISTEA)
1772 return llistea(path, list, size);
1773 #elif defined(HAVE_EXTATTR_LIST_LINK)
1774 extattr_arg arg;
1775 arg.path = path;
1776 return bsd_attr_list(1, arg, list, size);
1777 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1778 return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW);
1779 #elif defined(HAVE_ATTROPEN)
1780 ssize_t ret = -1;
1781 int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1782 if (attrdirfd >= 0) {
1783 ret = solaris_list_xattr(attrdirfd, list, size);
1784 close(attrdirfd);
1785 }
1786 return ret;
1787 #else
1788 errno = ENOSYS;
1789 return -1;
1790 #endif
1791 }
1792
1793 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
1794 {
1795 #if defined(HAVE_FLISTXATTR)
1796 #ifndef XATTR_ADD_OPT
1797 return flistxattr(filedes, list, size);
1798 #else
1799 int options = 0;
1800 return flistxattr(filedes, list, size, options);
1801 #endif
1802 #elif defined(HAVE_FLISTEA)
1803 return flistea(filedes, list, size);
1804 #elif defined(HAVE_EXTATTR_LIST_FD)
1805 extattr_arg arg;
1806 arg.filedes = filedes;
1807 return bsd_attr_list(2, arg, list, size);
1808 #elif defined(HAVE_ATTR_LISTF)
1809 return irix_attr_list(NULL, filedes, list, size, 0);
1810 #elif defined(HAVE_ATTROPEN)
1811 ssize_t ret = -1;
1812 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1813 if (attrdirfd >= 0) {
1814 ret = solaris_list_xattr(attrdirfd, list, size);
1815 close(attrdirfd);
1816 }
1817 return ret;
1818 #else
1819 errno = ENOSYS;
1820 return -1;
1821 #endif
1822 }
1823
1824 int sys_removexattr (const char *path, const char *name)
1825 {
1826 #if defined(HAVE_REMOVEXATTR)
1827 #ifndef XATTR_ADD_OPT
1828 return removexattr(path, name);
1829 #else
1830 int options = 0;
1831 return removexattr(path, name, options);
1832 #endif
1833 #elif defined(HAVE_REMOVEEA)
1834 return removeea(path, name);
1835 #elif defined(HAVE_EXTATTR_DELETE_FILE)
1836 char *s;
1837 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1838 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1839 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1840
1841 return extattr_delete_file(path, attrnamespace, attrname);
1842 #elif defined(HAVE_ATTR_REMOVE)
1843 int flags = 0;
1844 char *attrname = strchr(name,'.') + 1;
1845
1846 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1847
1848 return attr_remove(path, attrname, flags);
1849 #elif defined(HAVE_ATTROPEN)
1850 int ret = -1;
1851 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1852 if (attrdirfd >= 0) {
1853 ret = solaris_unlinkat(attrdirfd, name);
1854 close(attrdirfd);
1855 }
1856 return ret;
1857 #else
1858 errno = ENOSYS;
1859 return -1;
1860 #endif
1861 }
1862
1863 int sys_lremovexattr (const char *path, const char *name)
1864 {
1865 #if defined(HAVE_LREMOVEXATTR)
1866 return lremovexattr(path, name);
1867 #elif defined(HAVE_REMOVEXATTR) && defined(XATTR_ADD_OPT)
1868 int options = XATTR_NOFOLLOW;
1869 return removexattr(path, name, options);
1870 #elif defined(HAVE_LREMOVEEA)
1871 return lremoveea(path, name);
1872 #elif defined(HAVE_EXTATTR_DELETE_LINK)
1873 char *s;
1874 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1875 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1876 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1877
1878 return extattr_delete_link(path, attrnamespace, attrname);
1879 #elif defined(HAVE_ATTR_REMOVE)
1880 int flags = ATTR_DONTFOLLOW;
1881 char *attrname = strchr(name,'.') + 1;
1882
1883 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1884
1885 return attr_remove(path, attrname, flags);
1886 #elif defined(HAVE_ATTROPEN)
1887 int ret = -1;
1888 int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1889 if (attrdirfd >= 0) {
1890 ret = solaris_unlinkat(attrdirfd, name);
1891 close(attrdirfd);
1892 }
1893 return ret;
1894 #else
1895 errno = ENOSYS;
1896 return -1;
1897 #endif
1898 }
1899
1900 int sys_fremovexattr (int filedes, const char *name)
1901 {
1902 #if defined(HAVE_FREMOVEXATTR)
1903 #ifndef XATTR_ADD_OPT
1904 return fremovexattr(filedes, name);
1905 #else
1906 int options = 0;
1907 return fremovexattr(filedes, name, options);
1908 #endif
1909 #elif defined(HAVE_FREMOVEEA)
1910 return fremoveea(filedes, name);
1911 #elif defined(HAVE_EXTATTR_DELETE_FD)
1912 char *s;
1913 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1914 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1915 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1916
1917 return extattr_delete_fd(filedes, attrnamespace, attrname);
1918 #elif defined(HAVE_ATTR_REMOVEF)
1919 int flags = 0;
1920 char *attrname = strchr(name,'.') + 1;
1921
1922 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1923
1924 return attr_removef(filedes, attrname, flags);
1925 #elif defined(HAVE_ATTROPEN)
1926 int ret = -1;
1927 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1928 if (attrdirfd >= 0) {
1929 ret = solaris_unlinkat(attrdirfd, name);
1930 close(attrdirfd);
1931 }
1932 return ret;
1933 #else
1934 errno = ENOSYS;
1935 return -1;
1936 #endif
1937 }
1938
1939 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1940 {
1941 #if defined(HAVE_SETXATTR)
1942 #ifndef XATTR_ADD_OPT
1943 return setxattr(path, name, value, size, flags);
1944 #else
1945 int options = 0;
1946 return setxattr(path, name, value, size, 0, options);
1947 #endif
1948 #elif defined(HAVE_SETEA)
1949 return setea(path, name, value, size, flags);
1950 #elif defined(HAVE_EXTATTR_SET_FILE)
1951 char *s;
1952 int retval = 0;
1953 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1954 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1955 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1956 if (flags) {
1957 /* Check attribute existence */
1958 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
1959 if (retval < 0) {
1960 /* REPLACE attribute, that doesn't exist */
1961 if (flags & XATTR_REPLACE && errno == ENOATTR) {
1962 errno = ENOATTR;
1963 return -1;
1964 }
1965 /* Ignore other errors */
1966 }
1967 else {
1968 /* CREATE attribute, that already exists */
1969 if (flags & XATTR_CREATE) {
1970 errno = EEXIST;
1971 return -1;
1972 }
1973 }
1974 }
1975 retval = extattr_set_file(path, attrnamespace, attrname, value, size);
1976 return (retval < 0) ? -1 : 0;
1977 #elif defined(HAVE_ATTR_SET)
1978 int myflags = 0;
1979 char *attrname = strchr(name,'.') + 1;
1980
1981 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1982 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1983 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1984
1985 return attr_set(path, attrname, (const char *)value, size, myflags);
1986 #elif defined(HAVE_ATTROPEN)
1987 int ret = -1;
1988 int myflags = O_RDWR;
1989 int attrfd;
1990 if (flags & XATTR_CREATE) myflags |= O_EXCL;
1991 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
1992 attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
1993 if (attrfd >= 0) {
1994 ret = solaris_write_xattr(attrfd, value, size);
1995 close(attrfd);
1996 }
1997 return ret;
1998 #else
1999 errno = ENOSYS;
2000 return -1;
2001 #endif
2002 }
2003
2004 int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags)
2005 {
2006 #if defined(HAVE_LSETXATTR)
2007 return lsetxattr(path, name, value, size, flags);
2008 #elif defined(HAVE_SETXATTR) && defined(XATTR_ADD_OPT)
2009 int options = XATTR_NOFOLLOW;
2010 return setxattr(path, name, value, size, 0, options);
2011 #elif defined(LSETEA)
2012 return lsetea(path, name, value, size, flags);
2013 #elif defined(HAVE_EXTATTR_SET_LINK)
2014 char *s;
2015 int retval = 0;
2016 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2017 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2018 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2019 if (flags) {
2020 /* Check attribute existence */
2021 retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
2022 if (retval < 0) {
2023 /* REPLACE attribute, that doesn't exist */
2024 if (flags & XATTR_REPLACE && errno == ENOATTR) {
2025 errno = ENOATTR;
2026 return -1;
2027 }
2028 /* Ignore other errors */
2029 }
2030 else {
2031 /* CREATE attribute, that already exists */
2032 if (flags & XATTR_CREATE) {
2033 errno = EEXIST;
2034 return -1;
2035 }
2036 }
2037 }
2038
2039 retval = extattr_set_link(path, attrnamespace, attrname, value, size);
2040 return (retval < 0) ? -1 : 0;
2041 #elif defined(HAVE_ATTR_SET)
2042 int myflags = ATTR_DONTFOLLOW;
2043 char *attrname = strchr(name,'.') + 1;
2044
2045 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2046 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2047 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2048
2049 return attr_set(path, attrname, (const char *)value, size, myflags);
2050 #elif defined(HAVE_ATTROPEN)
2051 int ret = -1;
2052 int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW;
2053 int attrfd;
2054 if (flags & XATTR_CREATE) myflags |= O_EXCL;
2055 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2056 attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2057 if (attrfd >= 0) {
2058 ret = solaris_write_xattr(attrfd, value, size);
2059 close(attrfd);
2060 }
2061 return ret;
2062 #else
2063 errno = ENOSYS;
2064 return -1;
2065 #endif
2066 }
2067
2068 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
2069 {
2070 #if defined(HAVE_FSETXATTR)
2071 #ifndef XATTR_ADD_OPT
2072 return fsetxattr(filedes, name, value, size, flags);
2073 #else
2074 int options = 0;
2075 return fsetxattr(filedes, name, value, size, 0, options);
2076 #endif
2077 #elif defined(HAVE_FSETEA)
2078 return fsetea(filedes, name, value, size, flags);
2079 #elif defined(HAVE_EXTATTR_SET_FD)
2080 char *s;
2081 int retval = 0;
2082 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2083 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2084 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2085 if (flags) {
2086 /* Check attribute existence */
2087 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
2088 if (retval < 0) {
2089 /* REPLACE attribute, that doesn't exist */
2090 if (flags & XATTR_REPLACE && errno == ENOATTR) {
2091 errno = ENOATTR;
2092 return -1;
2093 }
2094 /* Ignore other errors */
2095 }
2096 else {
2097 /* CREATE attribute, that already exists */
2098 if (flags & XATTR_CREATE) {
2099 errno = EEXIST;
2100 return -1;
2101 }
2102 }
2103 }
2104 retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
2105 return (retval < 0) ? -1 : 0;
2106 #elif defined(HAVE_ATTR_SETF)
2107 int myflags = 0;
2108 char *attrname = strchr(name,'.') + 1;
2109
2110 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2111 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2112 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2113
2114 return attr_setf(filedes, attrname, (const char *)value, size, myflags);
2115 #elif defined(HAVE_ATTROPEN)
2116 int ret = -1;
2117 int myflags = O_RDWR | O_XATTR;
2118 int attrfd;
2119 if (flags & XATTR_CREATE) myflags |= O_EXCL;
2120 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2121 attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2122 if (attrfd >= 0) {
2123 ret = solaris_write_xattr(attrfd, value, size);
2124 close(attrfd);
2125 }
2126 return ret;
2127 #else
2128 errno = ENOSYS;
2129 return -1;
2130 #endif
2131 }
2132
2133 /**************************************************************************
2134 helper functions for Solaris' EA support
2135 ****************************************************************************/
2136 #ifdef HAVE_ATTROPEN
2137 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
2138 {
2139 struct stat sbuf;
2140
2141 if (fstat(attrfd, &sbuf) == -1) {
2142 errno = ENOATTR;
2143 return -1;
2144 }
2145
2146 /* This is to return the current size of the named extended attribute */
2147 if (size == 0) {
2148 return sbuf.st_size;
2149 }
2150
2151 /* check size and read xattr */
2152 if (sbuf.st_size > size) {
2153 errno = ERANGE;
2154 return -1;
2155 }
2156
2157 return read(attrfd, value, sbuf.st_size);
2158 }
2159
2160 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
2161 {
2162 ssize_t len = 0;
2163 int stop = 0;
2164 DIR *dirp;
2165 struct dirent *de;
2166 int newfd = dup(attrdirfd);
2167 /* CAUTION: The originating file descriptor should not be
2168 used again following the call to fdopendir().
2169 For that reason we dup() the file descriptor
2170 here to make things more clear. */
2171 dirp = fdopendir(newfd);
2172
2173 while ((de = readdir(dirp))) {
2174 size_t listlen = strlen(de->d_name);
2175 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
2176 /* we don't want "." and ".." here: */
2177 DEBUG(10,("skipped EA %s\n",de->d_name));
2178 continue;
2179 }
2180
2181 if (size == 0) {
2182 /* return the current size of the list of extended attribute names*/
2183 len += listlen + 1;
2184 } else {
2185 /* check size and copy entrieѕ + nul into list. */
2186 if ((len + listlen + 1) > size) {
2187 errno = ERANGE;
2188 len = -1;
2189 break;
2190 } else {
2191 safe_strcpy(list + len, de->d_name, listlen);
2192 len += listlen;
2193 list[len] = '\0';
2194 ++len;
2195 }
2196 }
2197 }
2198
2199 if (closedir(dirp) == -1) {
2200 DEBUG(0,("closedir dirp failed: %s\n",strerror(errno)));
2201 return -1;
2202 }
2203 return len;
2204 }
2205
2206 static int solaris_unlinkat(int attrdirfd, const char *name)
2207 {
2208 if (unlinkat(attrdirfd, name, 0) == -1) {
2209 if (errno == ENOENT) {
2210 errno = ENOATTR;
2211 }
2212 return -1;
2213 }
2214 return 0;
2215 }
2216
2217 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
2218 {
2219 int filedes = attropen(path, attrpath, oflag, mode);
2220 if (filedes == -1) {
2221 DEBUG(10,("attropen FAILED: path: %s, name: %s, errno: %s\n",path,attrpath,strerror(errno)));
2222 if (errno == EINVAL) {
2223 errno = ENOTSUP;
2224 } else {
2225 errno = ENOATTR;
2226 }
2227 }
2228 return filedes;
2229 }
2230
2231 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
2232 {
2233 int filedes = openat(fildes, path, oflag, mode);
2234 if (filedes == -1) {
2235 DEBUG(10,("openat FAILED: fd: %s, path: %s, errno: %s\n",filedes,path,strerror(errno)));
2236 if (errno == EINVAL) {
2237 errno = ENOTSUP;
2238 } else {
2239 errno = ENOATTR;
2240 }
2241 }
2242 return filedes;
2243 }
2244
2245 static int solaris_write_xattr(int attrfd, const char *value, size_t size)
2246 {
2247 if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
2248 return 0;
2249 } else {
2250 DEBUG(10,("solaris_write_xattr FAILED!\n"));
2251 return -1;
2252 }
2253 }
2254 #endif /*HAVE_ATTROPEN*/
2255
2256
2257 /****************************************************************************
2258 Return the major devicenumber for UNIX extensions.
2259 ****************************************************************************/
2260
2261 uint32 unix_dev_major(SMB_DEV_T dev)
2262 {
2263 #if defined(HAVE_DEVICE_MAJOR_FN)
2264 return (uint32)major(dev);
2265 #else
2266 return (uint32)(dev >> 8);
2267 #endif
2268 }
2269
2270 /****************************************************************************
2271 Return the minor devicenumber for UNIX extensions.
2272 ****************************************************************************/
2273
2274 uint32 unix_dev_minor(SMB_DEV_T dev)
2275 {
2276 #if defined(HAVE_DEVICE_MINOR_FN)
2277 return (uint32)minor(dev);
2278 #else
2279 return (uint32)(dev & 0xff);
2280 #endif
2281 }
2282
2283 #if defined(WITH_AIO)
2284
2285 /*******************************************************************
2286 An aio_read wrapper that will deal with 64-bit sizes.
2287 ********************************************************************/
2288
2289 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2290 {
2291 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
2292 return aio_read64(aiocb);
2293 #elif defined(HAVE_AIO_READ)
2294 return aio_read(aiocb);
2295 #else
2296 errno = ENOSYS;
2297 return -1;
2298 #endif
2299 }
2300
2301 /*******************************************************************
2302 An aio_write wrapper that will deal with 64-bit sizes.
2303 ********************************************************************/
2304
2305 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2306 {
2307 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
2308 return aio_write64(aiocb);
2309 #elif defined(HAVE_AIO_WRITE)
2310 return aio_write(aiocb);
2311 #else
2312 errno = ENOSYS;
2313 return -1;
2314 #endif
2315 }
2316
2317 /*******************************************************************
2318 An aio_return wrapper that will deal with 64-bit sizes.
2319 ********************************************************************/
2320
2321 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2322 {
2323 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
2324 return aio_return64(aiocb);
2325 #elif defined(HAVE_AIO_RETURN)
2326 return aio_return(aiocb);
2327 #else
2328 errno = ENOSYS;
2329 return -1;
2330 #endif
2331 }
2332
2333 /*******************************************************************
2334 An aio_cancel wrapper that will deal with 64-bit sizes.
2335 ********************************************************************/
2336
2337 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2338 {
2339 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
2340 return aio_cancel64(fd, aiocb);
2341 #elif defined(HAVE_AIO_CANCEL)
2342 return aio_cancel(fd, aiocb);
2343 #else
2344 errno = ENOSYS;
2345 return -1;
2346 #endif
2347 }
2348
2349 /*******************************************************************
2350 An aio_error wrapper that will deal with 64-bit sizes.
2351 ********************************************************************/
2352
2353 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2354 {
2355 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
2356 return aio_error64(aiocb);
2357 #elif defined(HAVE_AIO_ERROR)
2358 return aio_error(aiocb);
2359 #else
2360 errno = ENOSYS;
2361 return -1;
2362 #endif
2363 }
2364
2365 /*******************************************************************
2366 An aio_fsync wrapper that will deal with 64-bit sizes.
2367 ********************************************************************/
2368
2369 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2370 {
2371 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64)
2372 return aio_fsync64(op, aiocb);
2373 #elif defined(HAVE_AIO_FSYNC)
2374 return aio_fsync(op, aiocb);
2375 #else
2376 errno = ENOSYS;
2377 return -1;
2378 #endif
2379 }
2380
2381 /*******************************************************************
2382 An aio_fsync wrapper that will deal with 64-bit sizes.
2383 ********************************************************************/
2384
2385 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2386 {
2387 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64)
2388 return aio_suspend64(cblist, n, timeout);
2389 #elif defined(HAVE_AIO_FSYNC)
2390 return aio_suspend(cblist, n, timeout);
2391 #else
2392 errno = ENOSYS;
2393 return -1;
2394 #endif
2395 }
2396 #else /* !WITH_AIO */
2397
2398 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2399 {
2400 errno = ENOSYS;
2401 return -1;
2402 }
2403
2404 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2405 {
2406 errno = ENOSYS;
2407 return -1;
2408 }
2409
2410 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2411 {
2412 errno = ENOSYS;
2413 return -1;
2414 }
2415
2416 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2417 {
2418 errno = ENOSYS;
2419 return -1;
2420 }
2421
2422 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2423 {
2424 errno = ENOSYS;
2425 return -1;
2426 }
2427
2428 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2429 {
2430 errno = ENOSYS;
2431 return -1;
2432 }
2433
2434 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2435 {
2436 errno = ENOSYS;
2437 return -1;
2438 }
2439 #endif /* WITH_AIO */
2440
2441 int sys_getpeereid( int s, uid_t *uid)
2442 {
2443 #if defined(HAVE_PEERCRED)
2444 struct ucred cred;
2445 socklen_t cred_len = sizeof(struct ucred);
2446 int ret;
2447
2448 ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
2449 if (ret != 0) {
2450 return -1;
2451 }
2452
2453 if (cred_len != sizeof(struct ucred)) {
2454 errno = EINVAL;
2455 return -1;
2456 }
2457
2458 *uid = cred.uid;
2459 return 0;
2460 #else
2461 errno = ENOSYS;
2462 return -1;
2463 #endif
2464 }
2465
2466 int sys_getnameinfo(const struct sockaddr *psa,
2467 socklen_t salen,
2468 char *host,
2469 size_t hostlen,
2470 char *service,
2471 size_t servlen,
2472 int flags)
2473 {
2474 /*
2475 * For Solaris we must make sure salen is the
2476 * correct length for the incoming sa_family.
2477 */
2478
2479 if (salen == sizeof(struct sockaddr_storage)) {
2480 salen = sizeof(struct sockaddr_in);
2481 #if defined(HAVE_IPV6)
2482 if (psa->sa_family == AF_INET6) {
2483 salen = sizeof(struct sockaddr_in6);
2484 }
2485 #endif
2486 }
2487 return getnameinfo(psa, salen, host, hostlen, service, servlen, flags);
2488 }
2489
2490 int sys_connect(int fd, const struct sockaddr * addr)
2491 {
2492 socklen_t salen = -1;
2493
2494 if (addr->sa_family == AF_INET) {
2495 salen = sizeof(struct sockaddr_in);
2496 } else if (addr->sa_family == AF_UNIX) {
2497 salen = sizeof(struct sockaddr_un);
2498 }
2499 #if defined(HAVE_IPV6)
2500 else if (addr->sa_family == AF_INET6) {
2501 salen = sizeof(struct sockaddr_in6);
2502 }
2503 #endif
2504
2505 return connect(fd, addr, salen);
2506 }
Samba GIT mirror