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