?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-rpcclient: Fix bug #7880: cmd_spoolss_deletedriver() returned without checking...
[Samba.git] / source3 / lib / system.c
blobe8157662bfd4d99eb3177bc7eca85983cb698517
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 /**************************************************************************
596 Try and abstract process capabilities (for systems that have them).
597 ****************************************************************************/
598
599 /* Set the POSIX capabilities needed for the given purpose into the effective
600 * capability set of the current process. Make sure they are always removed
601 * from the inheritable set, because there is no circumstance in which our
602 * children should inherit our elevated privileges.
603 */
604 static bool set_process_capability(enum smbd_capability capability,
605 bool enable)
606 {
607 cap_value_t cap_vals[2] = {0};
608 int num_cap_vals = 0;
609
610 cap_t cap;
611
612 #if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
613 /* On Linux, make sure that any capabilities we grab are sticky
614 * across UID changes. We expect that this would allow us to keep both
615 * the effective and permitted capability sets, but as of circa 2.6.16,
616 * only the permitted set is kept. It is a bug (which we work around)
617 * that the effective set is lost, but we still require the effective
618 * set to be kept.
619 */
620 if (!prctl(PR_GET_KEEPCAPS)) {
621 prctl(PR_SET_KEEPCAPS, 1);
622 }
623 #endif
624
625 cap = cap_get_proc();
626 if (cap == NULL) {
627 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
628 strerror(errno)));
629 return False;
630 }
631
632 switch (capability) {
633 case KERNEL_OPLOCK_CAPABILITY:
634 #ifdef CAP_NETWORK_MGT
635 /* IRIX has CAP_NETWORK_MGT for oplocks. */
636 cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
637 #endif
638 break;
639 case DMAPI_ACCESS_CAPABILITY:
640 #ifdef CAP_DEVICE_MGT
641 /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
642 cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
643 #elif CAP_MKNOD
644 /* Linux has CAP_MKNOD for DMAPI access. */
645 cap_vals[num_cap_vals++] = CAP_MKNOD;
646 #endif
647 break;
648 case LEASE_CAPABILITY:
649 #ifdef CAP_LEASE
650 cap_vals[num_cap_vals++] = CAP_LEASE;
651 #endif
652 break;
653 }
654
655 SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
656
657 if (num_cap_vals == 0) {
658 cap_free(cap);
659 return True;
660 }
661
662 cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
663 enable ? CAP_SET : CAP_CLEAR);
664
665 /* We never want to pass capabilities down to our children, so make
666 * sure they are not inherited.
667 */
668 cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
669
670 if (cap_set_proc(cap) == -1) {
671 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
672 strerror(errno)));
673 cap_free(cap);
674 return False;
675 }
676
677 cap_free(cap);
678 return True;
679 }
680
681 #endif /* HAVE_POSIX_CAPABILITIES */
682
683 /****************************************************************************
684 Gain the oplock capability from the kernel if possible.
685 ****************************************************************************/
686
687 void set_effective_capability(enum smbd_capability capability)
688 {
689 #if defined(HAVE_POSIX_CAPABILITIES)
690 set_process_capability(capability, True);
691 #endif /* HAVE_POSIX_CAPABILITIES */
692 }
693
694 void drop_effective_capability(enum smbd_capability capability)
695 {
696 #if defined(HAVE_POSIX_CAPABILITIES)
697 set_process_capability(capability, False);
698 #endif /* HAVE_POSIX_CAPABILITIES */
699 }
700
701 /**************************************************************************
702 Wrapper for random().
703 ****************************************************************************/
704
705 long sys_random(void)
706 {
707 #if defined(HAVE_RANDOM)
708 return (long)random();
709 #elif defined(HAVE_RAND)
710 return (long)rand();
711 #else
712 DEBUG(0,("Error - no random function available !\n"));
713 exit(1);
714 #endif
715 }
716
717 /**************************************************************************
718 Wrapper for srandom().
719 ****************************************************************************/
720
721 void sys_srandom(unsigned int seed)
722 {
723 #if defined(HAVE_SRANDOM)
724 srandom(seed);
725 #elif defined(HAVE_SRAND)
726 srand(seed);
727 #else
728 DEBUG(0,("Error - no srandom function available !\n"));
729 exit(1);
730 #endif
731 }
732
733 /**************************************************************************
734 Returns equivalent to NGROUPS_MAX - using sysconf if needed.
735 ****************************************************************************/
736
737 int groups_max(void)
738 {
739 #if defined(SYSCONF_SC_NGROUPS_MAX)
740 int ret = sysconf(_SC_NGROUPS_MAX);
741 return (ret == -1) ? NGROUPS_MAX : ret;
742 #else
743 return NGROUPS_MAX;
744 #endif
745 }
746
747 /**************************************************************************
748 Wrap setgroups and getgroups for systems that declare getgroups() as
749 returning an array of gid_t, but actuall return an array of int.
750 ****************************************************************************/
751
752 #if defined(HAVE_BROKEN_GETGROUPS)
753 static int sys_broken_getgroups(int setlen, gid_t *gidset)
754 {
755 GID_T gid;
756 GID_T *group_list;
757 int i, ngroups;
758
759 if(setlen == 0) {
760 return getgroups(setlen, &gid);
761 }
762
763 /*
764 * Broken case. We need to allocate a
765 * GID_T array of size setlen.
766 */
767
768 if(setlen < 0) {
769 errno = EINVAL;
770 return -1;
771 }
772
773 if (setlen == 0)
774 setlen = groups_max();
775
776 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
777 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
778 return -1;
779 }
780
781 if((ngroups = getgroups(setlen, group_list)) < 0) {
782 int saved_errno = errno;
783 SAFE_FREE(group_list);
784 errno = saved_errno;
785 return -1;
786 }
787
788 for(i = 0; i < ngroups; i++)
789 gidset[i] = (gid_t)group_list[i];
790
791 SAFE_FREE(group_list);
792 return ngroups;
793 }
794
795 static int sys_broken_setgroups(int setlen, gid_t *gidset)
796 {
797 GID_T *group_list;
798 int i ;
799
800 if (setlen == 0)
801 return 0 ;
802
803 if (setlen < 0 || setlen > groups_max()) {
804 errno = EINVAL;
805 return -1;
806 }
807
808 /*
809 * Broken case. We need to allocate a
810 * GID_T array of size setlen.
811 */
812
813 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
814 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
815 return -1;
816 }
817
818 for(i = 0; i < setlen; i++)
819 group_list[i] = (GID_T) gidset[i];
820
821 if(setgroups(setlen, group_list) != 0) {
822 int saved_errno = errno;
823 SAFE_FREE(group_list);
824 errno = saved_errno;
825 return -1;
826 }
827
828 SAFE_FREE(group_list);
829 return 0 ;
830 }
831
832 #endif /* HAVE_BROKEN_GETGROUPS */
833
834 /* This is a list of systems that require the first GID passed to setgroups(2)
835 * to be the effective GID. If your system is one of these, add it here.
836 */
837 #if defined (FREEBSD) || defined (DARWINOS)
838 #define USE_BSD_SETGROUPS
839 #endif
840
841 #if defined(USE_BSD_SETGROUPS)
842 /* Depending on the particular BSD implementation, the first GID that is
843 * passed to setgroups(2) will either be ignored or will set the credential's
844 * effective GID. In either case, the right thing to do is to guarantee that
845 * gidset[0] is the effective GID.
846 */
847 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
848 {
849 gid_t *new_gidset = NULL;
850 int max;
851 int ret;
852
853 /* setgroups(2) will fail with EINVAL if we pass too many groups. */
854 max = groups_max();
855
856 /* No group list, just make sure we are setting the efective GID. */
857 if (setlen == 0) {
858 return setgroups(1, &primary_gid);
859 }
860
861 /* If the primary gid is not the first array element, grow the array
862 * and insert it at the front.
863 */
864 if (gidset[0] != primary_gid) {
865 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
866 if (new_gidset == NULL) {
867 return -1;
868 }
869
870 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
871 new_gidset[0] = primary_gid;
872 setlen++;
873 }
874
875 if (setlen > max) {
876 DEBUG(3, ("forced to truncate group list from %d to %d\n",
877 setlen, max));
878 setlen = max;
879 }
880
881 #if defined(HAVE_BROKEN_GETGROUPS)
882 ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
883 #else
884 ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
885 #endif
886
887 if (new_gidset) {
888 int errsav = errno;
889 SAFE_FREE(new_gidset);
890 errno = errsav;
891 }
892
893 return ret;
894 }
895
896 #endif /* USE_BSD_SETGROUPS */
897
898 /**************************************************************************
899 Wrapper for getgroups. Deals with broken (int) case.
900 ****************************************************************************/
901
902 int sys_getgroups(int setlen, gid_t *gidset)
903 {
904 #if defined(HAVE_BROKEN_GETGROUPS)
905 return sys_broken_getgroups(setlen, gidset);
906 #else
907 return getgroups(setlen, gidset);
908 #endif
909 }
910
911 /**************************************************************************
912 Wrapper for setgroups. Deals with broken (int) case and BSD case.
913 ****************************************************************************/
914
915 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
916 {
917 #if !defined(HAVE_SETGROUPS)
918 errno = ENOSYS;
919 return -1;
920 #endif /* HAVE_SETGROUPS */
921
922 #if defined(USE_BSD_SETGROUPS)
923 return sys_bsd_setgroups(primary_gid, setlen, gidset);
924 #elif defined(HAVE_BROKEN_GETGROUPS)
925 return sys_broken_setgroups(setlen, gidset);
926 #else
927 return setgroups(setlen, gidset);
928 #endif
929 }
930
931 /**************************************************************************
932 Wrappers for setpwent(), getpwent() and endpwent()
933 ****************************************************************************/
934
935 void sys_setpwent(void)
936 {
937 setpwent();
938 }
939
940 struct passwd *sys_getpwent(void)
941 {
942 return getpwent();
943 }
944
945 void sys_endpwent(void)
946 {
947 endpwent();
948 }
949
950 /**************************************************************************
951 Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
952 ****************************************************************************/
953
954
955 struct passwd *sys_getpwnam(const char *name)
956 {
957 return getpwnam(name);
958 }
959
960 struct passwd *sys_getpwuid(uid_t uid)
961 {
962 return getpwuid(uid);
963 }
964
965 struct group *sys_getgrnam(const char *name)
966 {
967 return getgrnam(name);
968 }
969
970 struct group *sys_getgrgid(gid_t gid)
971 {
972 return getgrgid(gid);
973 }
974
975 /**************************************************************************
976 Extract a command into an arg list.
977 ****************************************************************************/
978
979 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
980 {
981 char *trunc_cmd;
982 char *saveptr;
983 char *ptr;
984 int argcl;
985 char **argl = NULL;
986 int i;
987
988 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
989 DEBUG(0, ("talloc failed\n"));
990 goto nomem;
991 }
992
993 if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
994 TALLOC_FREE(trunc_cmd);
995 errno = EINVAL;
996 return NULL;
997 }
998
999 /*
1000 * Count the args.
1001 */
1002
1003 for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1004 argcl++;
1005
1006 TALLOC_FREE(trunc_cmd);
1007
1008 if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
1009 goto nomem;
1010 }
1011
1012 /*
1013 * Now do the extraction.
1014 */
1015
1016 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1017 goto nomem;
1018 }
1019
1020 ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1021 i = 0;
1022
1023 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1024 goto nomem;
1025 }
1026
1027 while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1028
1029 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1030 goto nomem;
1031 }
1032 }
1033
1034 argl[i++] = NULL;
1035 return argl;
1036
1037 nomem:
1038 DEBUG(0, ("talloc failed\n"));
1039 TALLOC_FREE(trunc_cmd);
1040 TALLOC_FREE(argl);
1041 errno = ENOMEM;
1042 return NULL;
1043 }
1044
1045 /**************************************************************************
1046 Wrapper for popen. Safer as it doesn't search a path.
1047 Modified from the glibc sources.
1048 modified by tridge to return a file descriptor. We must kick our FILE* habit
1049 ****************************************************************************/
1050
1051 typedef struct _popen_list
1052 {
1053 int fd;
1054 pid_t child_pid;
1055 struct _popen_list *next;
1056 } popen_list;
1057
1058 static popen_list *popen_chain;
1059
1060 int sys_popen(const char *command)
1061 {
1062 int parent_end, child_end;
1063 int pipe_fds[2];
1064 popen_list *entry = NULL;
1065 char **argl = NULL;
1066
1067 if (pipe(pipe_fds) < 0)
1068 return -1;
1069
1070 parent_end = pipe_fds[0];
1071 child_end = pipe_fds[1];
1072
1073 if (!*command) {
1074 errno = EINVAL;
1075 goto err_exit;
1076 }
1077
1078 if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1079 goto err_exit;
1080
1081 ZERO_STRUCTP(entry);
1082
1083 /*
1084 * Extract the command and args into a NULL terminated array.
1085 */
1086
1087 if(!(argl = extract_args(NULL, command)))
1088 goto err_exit;
1089
1090 entry->child_pid = sys_fork();
1091
1092 if (entry->child_pid == -1) {
1093 goto err_exit;
1094 }
1095
1096 if (entry->child_pid == 0) {
1097
1098 /*
1099 * Child !
1100 */
1101
1102 int child_std_end = STDOUT_FILENO;
1103 popen_list *p;
1104
1105 close(parent_end);
1106 if (child_end != child_std_end) {
1107 dup2 (child_end, child_std_end);
1108 close (child_end);
1109 }
1110
1111 /*
1112 * POSIX.2: "popen() shall ensure that any streams from previous
1113 * popen() calls that remain open in the parent process are closed
1114 * in the new child process."
1115 */
1116
1117 for (p = popen_chain; p; p = p->next)
1118 close(p->fd);
1119
1120 execv(argl[0], argl);
1121 _exit (127);
1122 }
1123
1124 /*
1125 * Parent.
1126 */
1127
1128 close (child_end);
1129 TALLOC_FREE(argl);
1130
1131 /* Link into popen_chain. */
1132 entry->next = popen_chain;
1133 popen_chain = entry;
1134 entry->fd = parent_end;
1135
1136 return entry->fd;
1137
1138 err_exit:
1139
1140 SAFE_FREE(entry);
1141 SAFE_FREE(argl);
1142 close(pipe_fds[0]);
1143 close(pipe_fds[1]);
1144 return -1;
1145 }
1146
1147 /**************************************************************************
1148 Wrapper for pclose. Modified from the glibc sources.
1149 ****************************************************************************/
1150
1151 int sys_pclose(int fd)
1152 {
1153 int wstatus;
1154 popen_list **ptr = &popen_chain;
1155 popen_list *entry = NULL;
1156 pid_t wait_pid;
1157 int status = -1;
1158
1159 /* Unlink from popen_chain. */
1160 for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1161 if ((*ptr)->fd == fd) {
1162 entry = *ptr;
1163 *ptr = (*ptr)->next;
1164 status = 0;
1165 break;
1166 }
1167 }
1168
1169 if (status < 0 || close(entry->fd) < 0)
1170 return -1;
1171
1172 /*
1173 * As Samba is catching and eating child process
1174 * exits we don't really care about the child exit
1175 * code, a -1 with errno = ECHILD will do fine for us.
1176 */
1177
1178 do {
1179 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1180 } while (wait_pid == -1 && errno == EINTR);
1181
1182 SAFE_FREE(entry);
1183
1184 if (wait_pid == -1)
1185 return -1;
1186 return wstatus;
1187 }
1188
1189 /**************************************************************************
1190 Wrapper for Admin Logs.
1191 ****************************************************************************/
1192
1193 void sys_adminlog(int priority, const char *format_str, ...)
1194 {
1195 va_list ap;
1196 int ret;
1197 char *msgbuf = NULL;
1198
1199 va_start( ap, format_str );
1200 ret = vasprintf( &msgbuf, format_str, ap );
1201 va_end( ap );
1202
1203 if (ret == -1)
1204 return;
1205
1206 #if defined(HAVE_SYSLOG)
1207 syslog( priority, "%s", msgbuf );
1208 #else
1209 DEBUG(0,("%s", msgbuf ));
1210 #endif
1211 SAFE_FREE(msgbuf);
1212 }
1213
1214 /******** Solaris EA helper function prototypes ********/
1215 #ifdef HAVE_ATTROPEN
1216 #define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP
1217 static int solaris_write_xattr(int attrfd, const char *value, size_t size);
1218 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size);
1219 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size);
1220 static int solaris_unlinkat(int attrdirfd, const char *name);
1221 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode);
1222 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode);
1223 #endif
1224
1225 /**************************************************************************
1226 Wrappers for extented attribute calls. Based on the Linux package with
1227 support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
1228 ****************************************************************************/
1229
1230 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
1231 {
1232 #if defined(HAVE_GETXATTR)
1233 #ifndef XATTR_ADD_OPT
1234 return getxattr(path, name, value, size);
1235 #else
1236 int options = 0;
1237 return getxattr(path, name, value, size, 0, options);
1238 #endif
1239 #elif defined(HAVE_GETEA)
1240 return getea(path, name, value, size);
1241 #elif defined(HAVE_EXTATTR_GET_FILE)
1242 char *s;
1243 ssize_t retval;
1244 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1245 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1246 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1247 /*
1248 * The BSD implementation has a nasty habit of silently truncating
1249 * the returned value to the size of the buffer, so we have to check
1250 * that the buffer is large enough to fit the returned value.
1251 */
1252 if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1253 if(retval > size) {
1254 errno = ERANGE;
1255 return -1;
1256 }
1257 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
1258 return retval;
1259 }
1260
1261 DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
1262 return -1;
1263 #elif defined(HAVE_ATTR_GET)
1264 int retval, flags = 0;
1265 int valuelength = (int)size;
1266 char *attrname = strchr(name,'.') + 1;
1267
1268 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1269
1270 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1271
1272 return retval ? retval : valuelength;
1273 #elif defined(HAVE_ATTROPEN)
1274 ssize_t ret = -1;
1275 int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
1276 if (attrfd >= 0) {
1277 ret = solaris_read_xattr(attrfd, value, size);
1278 close(attrfd);
1279 }
1280 return ret;
1281 #else
1282 errno = ENOSYS;
1283 return -1;
1284 #endif
1285 }
1286
1287 ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
1288 {
1289 #if defined(HAVE_LGETXATTR)
1290 return lgetxattr(path, name, value, size);
1291 #elif defined(HAVE_GETXATTR) && defined(XATTR_ADD_OPT)
1292 int options = XATTR_NOFOLLOW;
1293 return getxattr(path, name, value, size, 0, options);
1294 #elif defined(HAVE_LGETEA)
1295 return lgetea(path, name, value, size);
1296 #elif defined(HAVE_EXTATTR_GET_LINK)
1297 char *s;
1298 ssize_t retval;
1299 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1300 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1301 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1302
1303 if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1304 if(retval > size) {
1305 errno = ERANGE;
1306 return -1;
1307 }
1308 if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
1309 return retval;
1310 }
1311
1312 DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
1313 return -1;
1314 #elif defined(HAVE_ATTR_GET)
1315 int retval, flags = ATTR_DONTFOLLOW;
1316 int valuelength = (int)size;
1317 char *attrname = strchr(name,'.') + 1;
1318
1319 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1320
1321 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1322
1323 return retval ? retval : valuelength;
1324 #elif defined(HAVE_ATTROPEN)
1325 ssize_t ret = -1;
1326 int attrfd = solaris_attropen(path, name, O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1327 if (attrfd >= 0) {
1328 ret = solaris_read_xattr(attrfd, value, size);
1329 close(attrfd);
1330 }
1331 return ret;
1332 #else
1333 errno = ENOSYS;
1334 return -1;
1335 #endif
1336 }
1337
1338 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
1339 {
1340 #if defined(HAVE_FGETXATTR)
1341 #ifndef XATTR_ADD_OPT
1342 return fgetxattr(filedes, name, value, size);
1343 #else
1344 int options = 0;
1345 return fgetxattr(filedes, name, value, size, 0, options);
1346 #endif
1347 #elif defined(HAVE_FGETEA)
1348 return fgetea(filedes, name, value, size);
1349 #elif defined(HAVE_EXTATTR_GET_FD)
1350 char *s;
1351 ssize_t retval;
1352 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1353 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1354 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1355
1356 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
1357 if(retval > size) {
1358 errno = ERANGE;
1359 return -1;
1360 }
1361 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
1362 return retval;
1363 }
1364
1365 DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
1366 return -1;
1367 #elif defined(HAVE_ATTR_GETF)
1368 int retval, flags = 0;
1369 int valuelength = (int)size;
1370 char *attrname = strchr(name,'.') + 1;
1371
1372 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1373
1374 retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
1375
1376 return retval ? retval : valuelength;
1377 #elif defined(HAVE_ATTROPEN)
1378 ssize_t ret = -1;
1379 int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
1380 if (attrfd >= 0) {
1381 ret = solaris_read_xattr(attrfd, value, size);
1382 close(attrfd);
1383 }
1384 return ret;
1385 #else
1386 errno = ENOSYS;
1387 return -1;
1388 #endif
1389 }
1390
1391 #if defined(HAVE_EXTATTR_LIST_FILE)
1392
1393 #define EXTATTR_PREFIX(s) (s), (sizeof((s))-1)
1394
1395 static struct {
1396 int space;
1397 const char *name;
1398 size_t len;
1399 }
1400 extattr[] = {
1401 { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
1402 { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
1403 };
1404
1405 typedef union {
1406 const char *path;
1407 int filedes;
1408 } extattr_arg;
1409
1410 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
1411 {
1412 ssize_t list_size, total_size = 0;
1413 int i, t, len;
1414 char *buf;
1415 /* Iterate through extattr(2) namespaces */
1416 for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
1417 switch(type) {
1418 #if defined(HAVE_EXTATTR_LIST_FILE)
1419 case 0:
1420 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
1421 break;
1422 #endif
1423 #if defined(HAVE_EXTATTR_LIST_LINK)
1424 case 1:
1425 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
1426 break;
1427 #endif
1428 #if defined(HAVE_EXTATTR_LIST_FD)
1429 case 2:
1430 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
1431 break;
1432 #endif
1433 default:
1434 errno = ENOSYS;
1435 return -1;
1436 }
1437 /* Some error happend. Errno should be set by the previous call */
1438 if(list_size < 0)
1439 return -1;
1440 /* No attributes */
1441 if(list_size == 0)
1442 continue;
1443 /* XXX: Call with an empty buffer may be used to calculate
1444 necessary buffer size. Unfortunately, we can't say, how
1445 many attributes were returned, so here is the potential
1446 problem with the emulation.
1447 */
1448 if(list == NULL) {
1449 /* Take the worse case of one char attribute names -
1450 two bytes per name plus one more for sanity.
1451 */
1452 total_size += list_size + (list_size/2 + 1)*extattr[t].len;
1453 continue;
1454 }
1455 /* Count necessary offset to fit namespace prefixes */
1456 len = 0;
1457 for(i = 0; i < list_size; i += list[i] + 1)
1458 len += extattr[t].len;
1459
1460 total_size += list_size + len;
1461 /* Buffer is too small to fit the results */
1462 if(total_size > size) {
1463 errno = ERANGE;
1464 return -1;
1465 }
1466 /* Shift results back, so we can prepend prefixes */
1467 buf = memmove(list + len, list, list_size);
1468
1469 for(i = 0; i < list_size; i += len + 1) {
1470 len = buf[i];
1471 strncpy(list, extattr[t].name, extattr[t].len + 1);
1472 list += extattr[t].len;
1473 strncpy(list, buf + i + 1, len);
1474 list[len] = '\0';
1475 list += len + 1;
1476 }
1477 size -= total_size;
1478 }
1479 return total_size;
1480 }
1481
1482 #endif
1483
1484 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1485 static char attr_buffer[ATTR_MAX_VALUELEN];
1486
1487 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
1488 {
1489 int retval = 0, index;
1490 attrlist_cursor_t *cursor = 0;
1491 int total_size = 0;
1492 attrlist_t * al = (attrlist_t *)attr_buffer;
1493 attrlist_ent_t *ae;
1494 size_t ent_size, left = size;
1495 char *bp = list;
1496
1497 while (True) {
1498 if (filedes)
1499 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1500 else
1501 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1502 if (retval) break;
1503 for (index = 0; index < al->al_count; index++) {
1504 ae = ATTR_ENTRY(attr_buffer, index);
1505 ent_size = strlen(ae->a_name) + sizeof("user.");
1506 if (left >= ent_size) {
1507 strncpy(bp, "user.", sizeof("user."));
1508 strncat(bp, ae->a_name, ent_size - sizeof("user."));
1509 bp += ent_size;
1510 left -= ent_size;
1511 } else if (size) {
1512 errno = ERANGE;
1513 retval = -1;
1514 break;
1515 }
1516 total_size += ent_size;
1517 }
1518 if (al->al_more == 0) break;
1519 }
1520 if (retval == 0) {
1521 flags |= ATTR_ROOT;
1522 cursor = 0;
1523 while (True) {
1524 if (filedes)
1525 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1526 else
1527 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1528 if (retval) break;
1529 for (index = 0; index < al->al_count; index++) {
1530 ae = ATTR_ENTRY(attr_buffer, index);
1531 ent_size = strlen(ae->a_name) + sizeof("system.");
1532 if (left >= ent_size) {
1533 strncpy(bp, "system.", sizeof("system."));
1534 strncat(bp, ae->a_name, ent_size - sizeof("system."));
1535 bp += ent_size;
1536 left -= ent_size;
1537 } else if (size) {
1538 errno = ERANGE;
1539 retval = -1;
1540 break;
1541 }
1542 total_size += ent_size;
1543 }
1544 if (al->al_more == 0) break;
1545 }
1546 }
1547 return (ssize_t)(retval ? retval : total_size);
1548 }
1549
1550 #endif
1551
1552 ssize_t sys_listxattr (const char *path, char *list, size_t size)
1553 {
1554 #if defined(HAVE_LISTXATTR)
1555 #ifndef XATTR_ADD_OPT
1556 return listxattr(path, list, size);
1557 #else
1558 int options = 0;
1559 return listxattr(path, list, size, options);
1560 #endif
1561 #elif defined(HAVE_LISTEA)
1562 return listea(path, list, size);
1563 #elif defined(HAVE_EXTATTR_LIST_FILE)
1564 extattr_arg arg;
1565 arg.path = path;
1566 return bsd_attr_list(0, arg, list, size);
1567 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1568 return irix_attr_list(path, 0, list, size, 0);
1569 #elif defined(HAVE_ATTROPEN)
1570 ssize_t ret = -1;
1571 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1572 if (attrdirfd >= 0) {
1573 ret = solaris_list_xattr(attrdirfd, list, size);
1574 close(attrdirfd);
1575 }
1576 return ret;
1577 #else
1578 errno = ENOSYS;
1579 return -1;
1580 #endif
1581 }
1582
1583 ssize_t sys_llistxattr (const char *path, char *list, size_t size)
1584 {
1585 #if defined(HAVE_LLISTXATTR)
1586 return llistxattr(path, list, size);
1587 #elif defined(HAVE_LISTXATTR) && defined(XATTR_ADD_OPT)
1588 int options = XATTR_NOFOLLOW;
1589 return listxattr(path, list, size, options);
1590 #elif defined(HAVE_LLISTEA)
1591 return llistea(path, list, size);
1592 #elif defined(HAVE_EXTATTR_LIST_LINK)
1593 extattr_arg arg;
1594 arg.path = path;
1595 return bsd_attr_list(1, arg, list, size);
1596 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1597 return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW);
1598 #elif defined(HAVE_ATTROPEN)
1599 ssize_t ret = -1;
1600 int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1601 if (attrdirfd >= 0) {
1602 ret = solaris_list_xattr(attrdirfd, list, size);
1603 close(attrdirfd);
1604 }
1605 return ret;
1606 #else
1607 errno = ENOSYS;
1608 return -1;
1609 #endif
1610 }
1611
1612 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
1613 {
1614 #if defined(HAVE_FLISTXATTR)
1615 #ifndef XATTR_ADD_OPT
1616 return flistxattr(filedes, list, size);
1617 #else
1618 int options = 0;
1619 return flistxattr(filedes, list, size, options);
1620 #endif
1621 #elif defined(HAVE_FLISTEA)
1622 return flistea(filedes, list, size);
1623 #elif defined(HAVE_EXTATTR_LIST_FD)
1624 extattr_arg arg;
1625 arg.filedes = filedes;
1626 return bsd_attr_list(2, arg, list, size);
1627 #elif defined(HAVE_ATTR_LISTF)
1628 return irix_attr_list(NULL, filedes, list, size, 0);
1629 #elif defined(HAVE_ATTROPEN)
1630 ssize_t ret = -1;
1631 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1632 if (attrdirfd >= 0) {
1633 ret = solaris_list_xattr(attrdirfd, list, size);
1634 close(attrdirfd);
1635 }
1636 return ret;
1637 #else
1638 errno = ENOSYS;
1639 return -1;
1640 #endif
1641 }
1642
1643 int sys_removexattr (const char *path, const char *name)
1644 {
1645 #if defined(HAVE_REMOVEXATTR)
1646 #ifndef XATTR_ADD_OPT
1647 return removexattr(path, name);
1648 #else
1649 int options = 0;
1650 return removexattr(path, name, options);
1651 #endif
1652 #elif defined(HAVE_REMOVEEA)
1653 return removeea(path, name);
1654 #elif defined(HAVE_EXTATTR_DELETE_FILE)
1655 char *s;
1656 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1657 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1658 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1659
1660 return extattr_delete_file(path, attrnamespace, attrname);
1661 #elif defined(HAVE_ATTR_REMOVE)
1662 int flags = 0;
1663 char *attrname = strchr(name,'.') + 1;
1664
1665 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1666
1667 return attr_remove(path, attrname, flags);
1668 #elif defined(HAVE_ATTROPEN)
1669 int ret = -1;
1670 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1671 if (attrdirfd >= 0) {
1672 ret = solaris_unlinkat(attrdirfd, name);
1673 close(attrdirfd);
1674 }
1675 return ret;
1676 #else
1677 errno = ENOSYS;
1678 return -1;
1679 #endif
1680 }
1681
1682 int sys_lremovexattr (const char *path, const char *name)
1683 {
1684 #if defined(HAVE_LREMOVEXATTR)
1685 return lremovexattr(path, name);
1686 #elif defined(HAVE_REMOVEXATTR) && defined(XATTR_ADD_OPT)
1687 int options = XATTR_NOFOLLOW;
1688 return removexattr(path, name, options);
1689 #elif defined(HAVE_LREMOVEEA)
1690 return lremoveea(path, name);
1691 #elif defined(HAVE_EXTATTR_DELETE_LINK)
1692 char *s;
1693 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1694 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1695 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1696
1697 return extattr_delete_link(path, attrnamespace, attrname);
1698 #elif defined(HAVE_ATTR_REMOVE)
1699 int flags = ATTR_DONTFOLLOW;
1700 char *attrname = strchr(name,'.') + 1;
1701
1702 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1703
1704 return attr_remove(path, attrname, flags);
1705 #elif defined(HAVE_ATTROPEN)
1706 int ret = -1;
1707 int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1708 if (attrdirfd >= 0) {
1709 ret = solaris_unlinkat(attrdirfd, name);
1710 close(attrdirfd);
1711 }
1712 return ret;
1713 #else
1714 errno = ENOSYS;
1715 return -1;
1716 #endif
1717 }
1718
1719 int sys_fremovexattr (int filedes, const char *name)
1720 {
1721 #if defined(HAVE_FREMOVEXATTR)
1722 #ifndef XATTR_ADD_OPT
1723 return fremovexattr(filedes, name);
1724 #else
1725 int options = 0;
1726 return fremovexattr(filedes, name, options);
1727 #endif
1728 #elif defined(HAVE_FREMOVEEA)
1729 return fremoveea(filedes, name);
1730 #elif defined(HAVE_EXTATTR_DELETE_FD)
1731 char *s;
1732 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1733 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1734 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1735
1736 return extattr_delete_fd(filedes, attrnamespace, attrname);
1737 #elif defined(HAVE_ATTR_REMOVEF)
1738 int flags = 0;
1739 char *attrname = strchr(name,'.') + 1;
1740
1741 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1742
1743 return attr_removef(filedes, attrname, flags);
1744 #elif defined(HAVE_ATTROPEN)
1745 int ret = -1;
1746 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1747 if (attrdirfd >= 0) {
1748 ret = solaris_unlinkat(attrdirfd, name);
1749 close(attrdirfd);
1750 }
1751 return ret;
1752 #else
1753 errno = ENOSYS;
1754 return -1;
1755 #endif
1756 }
1757
1758 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1759 {
1760 #if defined(HAVE_SETXATTR)
1761 #ifndef XATTR_ADD_OPT
1762 return setxattr(path, name, value, size, flags);
1763 #else
1764 int options = 0;
1765 return setxattr(path, name, value, size, 0, options);
1766 #endif
1767 #elif defined(HAVE_SETEA)
1768 return setea(path, name, value, size, flags);
1769 #elif defined(HAVE_EXTATTR_SET_FILE)
1770 char *s;
1771 int retval = 0;
1772 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1773 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1774 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1775 if (flags) {
1776 /* Check attribute existence */
1777 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
1778 if (retval < 0) {
1779 /* REPLACE attribute, that doesn't exist */
1780 if (flags & XATTR_REPLACE && errno == ENOATTR) {
1781 errno = ENOATTR;
1782 return -1;
1783 }
1784 /* Ignore other errors */
1785 }
1786 else {
1787 /* CREATE attribute, that already exists */
1788 if (flags & XATTR_CREATE) {
1789 errno = EEXIST;
1790 return -1;
1791 }
1792 }
1793 }
1794 retval = extattr_set_file(path, attrnamespace, attrname, value, size);
1795 return (retval < 0) ? -1 : 0;
1796 #elif defined(HAVE_ATTR_SET)
1797 int myflags = 0;
1798 char *attrname = strchr(name,'.') + 1;
1799
1800 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1801 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1802 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1803
1804 return attr_set(path, attrname, (const char *)value, size, myflags);
1805 #elif defined(HAVE_ATTROPEN)
1806 int ret = -1;
1807 int myflags = O_RDWR;
1808 int attrfd;
1809 if (flags & XATTR_CREATE) myflags |= O_EXCL;
1810 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
1811 attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
1812 if (attrfd >= 0) {
1813 ret = solaris_write_xattr(attrfd, value, size);
1814 close(attrfd);
1815 }
1816 return ret;
1817 #else
1818 errno = ENOSYS;
1819 return -1;
1820 #endif
1821 }
1822
1823 int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1824 {
1825 #if defined(HAVE_LSETXATTR)
1826 return lsetxattr(path, name, value, size, flags);
1827 #elif defined(HAVE_SETXATTR) && defined(XATTR_ADD_OPT)
1828 int options = XATTR_NOFOLLOW;
1829 return setxattr(path, name, value, size, 0, options);
1830 #elif defined(LSETEA)
1831 return lsetea(path, name, value, size, flags);
1832 #elif defined(HAVE_EXTATTR_SET_LINK)
1833 char *s;
1834 int retval = 0;
1835 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1836 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1837 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1838 if (flags) {
1839 /* Check attribute existence */
1840 retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
1841 if (retval < 0) {
1842 /* REPLACE attribute, that doesn't exist */
1843 if (flags & XATTR_REPLACE && errno == ENOATTR) {
1844 errno = ENOATTR;
1845 return -1;
1846 }
1847 /* Ignore other errors */
1848 }
1849 else {
1850 /* CREATE attribute, that already exists */
1851 if (flags & XATTR_CREATE) {
1852 errno = EEXIST;
1853 return -1;
1854 }
1855 }
1856 }
1857
1858 retval = extattr_set_link(path, attrnamespace, attrname, value, size);
1859 return (retval < 0) ? -1 : 0;
1860 #elif defined(HAVE_ATTR_SET)
1861 int myflags = ATTR_DONTFOLLOW;
1862 char *attrname = strchr(name,'.') + 1;
1863
1864 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1865 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1866 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1867
1868 return attr_set(path, attrname, (const char *)value, size, myflags);
1869 #elif defined(HAVE_ATTROPEN)
1870 int ret = -1;
1871 int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW;
1872 int attrfd;
1873 if (flags & XATTR_CREATE) myflags |= O_EXCL;
1874 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
1875 attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
1876 if (attrfd >= 0) {
1877 ret = solaris_write_xattr(attrfd, value, size);
1878 close(attrfd);
1879 }
1880 return ret;
1881 #else
1882 errno = ENOSYS;
1883 return -1;
1884 #endif
1885 }
1886
1887 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
1888 {
1889 #if defined(HAVE_FSETXATTR)
1890 #ifndef XATTR_ADD_OPT
1891 return fsetxattr(filedes, name, value, size, flags);
1892 #else
1893 int options = 0;
1894 return fsetxattr(filedes, name, value, size, 0, options);
1895 #endif
1896 #elif defined(HAVE_FSETEA)
1897 return fsetea(filedes, name, value, size, flags);
1898 #elif defined(HAVE_EXTATTR_SET_FD)
1899 char *s;
1900 int retval = 0;
1901 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1902 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1903 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1904 if (flags) {
1905 /* Check attribute existence */
1906 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
1907 if (retval < 0) {
1908 /* REPLACE attribute, that doesn't exist */
1909 if (flags & XATTR_REPLACE && errno == ENOATTR) {
1910 errno = ENOATTR;
1911 return -1;
1912 }
1913 /* Ignore other errors */
1914 }
1915 else {
1916 /* CREATE attribute, that already exists */
1917 if (flags & XATTR_CREATE) {
1918 errno = EEXIST;
1919 return -1;
1920 }
1921 }
1922 }
1923 retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
1924 return (retval < 0) ? -1 : 0;
1925 #elif defined(HAVE_ATTR_SETF)
1926 int myflags = 0;
1927 char *attrname = strchr(name,'.') + 1;
1928
1929 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1930 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1931 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1932
1933 return attr_setf(filedes, attrname, (const char *)value, size, myflags);
1934 #elif defined(HAVE_ATTROPEN)
1935 int ret = -1;
1936 int myflags = O_RDWR | O_XATTR;
1937 int attrfd;
1938 if (flags & XATTR_CREATE) myflags |= O_EXCL;
1939 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
1940 attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
1941 if (attrfd >= 0) {
1942 ret = solaris_write_xattr(attrfd, value, size);
1943 close(attrfd);
1944 }
1945 return ret;
1946 #else
1947 errno = ENOSYS;
1948 return -1;
1949 #endif
1950 }
1951
1952 /**************************************************************************
1953 helper functions for Solaris' EA support
1954 ****************************************************************************/
1955 #ifdef HAVE_ATTROPEN
1956 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
1957 {
1958 struct stat sbuf;
1959
1960 if (fstat(attrfd, &sbuf) == -1) {
1961 errno = ENOATTR;
1962 return -1;
1963 }
1964
1965 /* This is to return the current size of the named extended attribute */
1966 if (size == 0) {
1967 return sbuf.st_size;
1968 }
1969
1970 /* check size and read xattr */
1971 if (sbuf.st_size > size) {
1972 errno = ERANGE;
1973 return -1;
1974 }
1975
1976 return read(attrfd, value, sbuf.st_size);
1977 }
1978
1979 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
1980 {
1981 ssize_t len = 0;
1982 DIR *dirp;
1983 struct dirent *de;
1984 int newfd = dup(attrdirfd);
1985 /* CAUTION: The originating file descriptor should not be
1986 used again following the call to fdopendir().
1987 For that reason we dup() the file descriptor
1988 here to make things more clear. */
1989 dirp = fdopendir(newfd);
1990
1991 while ((de = readdir(dirp))) {
1992 size_t listlen = strlen(de->d_name);
1993 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
1994 /* we don't want "." and ".." here: */
1995 DEBUG(10,("skipped EA %s\n",de->d_name));
1996 continue;
1997 }
1998
1999 if (size == 0) {
2000 /* return the current size of the list of extended attribute names*/
2001 len += listlen + 1;
2002 } else {
2003 /* check size and copy entrieѕ + nul into list. */
2004 if ((len + listlen + 1) > size) {
2005 errno = ERANGE;
2006 len = -1;
2007 break;
2008 } else {
2009 safe_strcpy(list + len, de->d_name, listlen);
2010 len += listlen;
2011 list[len] = '\0';
2012 ++len;
2013 }
2014 }
2015 }
2016
2017 if (closedir(dirp) == -1) {
2018 DEBUG(0,("closedir dirp failed: %s\n",strerror(errno)));
2019 return -1;
2020 }
2021 return len;
2022 }
2023
2024 static int solaris_unlinkat(int attrdirfd, const char *name)
2025 {
2026 if (unlinkat(attrdirfd, name, 0) == -1) {
2027 if (errno == ENOENT) {
2028 errno = ENOATTR;
2029 }
2030 return -1;
2031 }
2032 return 0;
2033 }
2034
2035 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
2036 {
2037 int filedes = attropen(path, attrpath, oflag, mode);
2038 if (filedes == -1) {
2039 DEBUG(10,("attropen FAILED: path: %s, name: %s, errno: %s\n",path,attrpath,strerror(errno)));
2040 if (errno == EINVAL) {
2041 errno = ENOTSUP;
2042 } else {
2043 errno = ENOATTR;
2044 }
2045 }
2046 return filedes;
2047 }
2048
2049 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
2050 {
2051 int filedes = openat(fildes, path, oflag, mode);
2052 if (filedes == -1) {
2053 DEBUG(10,("openat FAILED: fd: %d, path: %s, errno: %s\n",filedes,path,strerror(errno)));
2054 if (errno == EINVAL) {
2055 errno = ENOTSUP;
2056 } else {
2057 errno = ENOATTR;
2058 }
2059 }
2060 return filedes;
2061 }
2062
2063 static int solaris_write_xattr(int attrfd, const char *value, size_t size)
2064 {
2065 if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
2066 return 0;
2067 } else {
2068 DEBUG(10,("solaris_write_xattr FAILED!\n"));
2069 return -1;
2070 }
2071 }
2072 #endif /*HAVE_ATTROPEN*/
2073
2074
2075 /****************************************************************************
2076 Return the major devicenumber for UNIX extensions.
2077 ****************************************************************************/
2078
2079 uint32 unix_dev_major(SMB_DEV_T dev)
2080 {
2081 #if defined(HAVE_DEVICE_MAJOR_FN)
2082 return (uint32)major(dev);
2083 #else
2084 return (uint32)(dev >> 8);
2085 #endif
2086 }
2087
2088 /****************************************************************************
2089 Return the minor devicenumber for UNIX extensions.
2090 ****************************************************************************/
2091
2092 uint32 unix_dev_minor(SMB_DEV_T dev)
2093 {
2094 #if defined(HAVE_DEVICE_MINOR_FN)
2095 return (uint32)minor(dev);
2096 #else
2097 return (uint32)(dev & 0xff);
2098 #endif
2099 }
2100
2101 #if defined(WITH_AIO)
2102
2103 /*******************************************************************
2104 An aio_read wrapper that will deal with 64-bit sizes.
2105 ********************************************************************/
2106
2107 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2108 {
2109 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
2110 return aio_read64(aiocb);
2111 #elif defined(HAVE_AIO_READ)
2112 return aio_read(aiocb);
2113 #else
2114 errno = ENOSYS;
2115 return -1;
2116 #endif
2117 }
2118
2119 /*******************************************************************
2120 An aio_write wrapper that will deal with 64-bit sizes.
2121 ********************************************************************/
2122
2123 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2124 {
2125 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
2126 return aio_write64(aiocb);
2127 #elif defined(HAVE_AIO_WRITE)
2128 return aio_write(aiocb);
2129 #else
2130 errno = ENOSYS;
2131 return -1;
2132 #endif
2133 }
2134
2135 /*******************************************************************
2136 An aio_return wrapper that will deal with 64-bit sizes.
2137 ********************************************************************/
2138
2139 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2140 {
2141 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
2142 return aio_return64(aiocb);
2143 #elif defined(HAVE_AIO_RETURN)
2144 return aio_return(aiocb);
2145 #else
2146 errno = ENOSYS;
2147 return -1;
2148 #endif
2149 }
2150
2151 /*******************************************************************
2152 An aio_cancel wrapper that will deal with 64-bit sizes.
2153 ********************************************************************/
2154
2155 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2156 {
2157 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
2158 return aio_cancel64(fd, aiocb);
2159 #elif defined(HAVE_AIO_CANCEL)
2160 return aio_cancel(fd, aiocb);
2161 #else
2162 errno = ENOSYS;
2163 return -1;
2164 #endif
2165 }
2166
2167 /*******************************************************************
2168 An aio_error wrapper that will deal with 64-bit sizes.
2169 ********************************************************************/
2170
2171 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2172 {
2173 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
2174 return aio_error64(aiocb);
2175 #elif defined(HAVE_AIO_ERROR)
2176 return aio_error(aiocb);
2177 #else
2178 errno = ENOSYS;
2179 return -1;
2180 #endif
2181 }
2182
2183 /*******************************************************************
2184 An aio_fsync wrapper that will deal with 64-bit sizes.
2185 ********************************************************************/
2186
2187 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2188 {
2189 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64)
2190 return aio_fsync64(op, aiocb);
2191 #elif defined(HAVE_AIO_FSYNC)
2192 return aio_fsync(op, aiocb);
2193 #else
2194 errno = ENOSYS;
2195 return -1;
2196 #endif
2197 }
2198
2199 /*******************************************************************
2200 An aio_fsync wrapper that will deal with 64-bit sizes.
2201 ********************************************************************/
2202
2203 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2204 {
2205 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64)
2206 return aio_suspend64(cblist, n, timeout);
2207 #elif defined(HAVE_AIO_FSYNC)
2208 return aio_suspend(cblist, n, timeout);
2209 #else
2210 errno = ENOSYS;
2211 return -1;
2212 #endif
2213 }
2214 #else /* !WITH_AIO */
2215
2216 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2217 {
2218 errno = ENOSYS;
2219 return -1;
2220 }
2221
2222 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2223 {
2224 errno = ENOSYS;
2225 return -1;
2226 }
2227
2228 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2229 {
2230 errno = ENOSYS;
2231 return -1;
2232 }
2233
2234 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2235 {
2236 errno = ENOSYS;
2237 return -1;
2238 }
2239
2240 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2241 {
2242 errno = ENOSYS;
2243 return -1;
2244 }
2245
2246 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2247 {
2248 errno = ENOSYS;
2249 return -1;
2250 }
2251
2252 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2253 {
2254 errno = ENOSYS;
2255 return -1;
2256 }
2257 #endif /* WITH_AIO */
2258
2259 int sys_getpeereid( int s, uid_t *uid)
2260 {
2261 #if defined(HAVE_PEERCRED)
2262 struct ucred cred;
2263 socklen_t cred_len = sizeof(struct ucred);
2264 int ret;
2265
2266 ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
2267 if (ret != 0) {
2268 return -1;
2269 }
2270
2271 if (cred_len != sizeof(struct ucred)) {
2272 errno = EINVAL;
2273 return -1;
2274 }
2275
2276 *uid = cred.uid;
2277 return 0;
2278 #else
2279 errno = ENOSYS;
2280 return -1;
2281 #endif
2282 }
2283
2284 int sys_getnameinfo(const struct sockaddr *psa,
2285 socklen_t salen,
2286 char *host,
2287 size_t hostlen,
2288 char *service,
2289 size_t servlen,
2290 int flags)
2291 {
2292 /*
2293 * For Solaris we must make sure salen is the
2294 * correct length for the incoming sa_family.
2295 */
2296
2297 if (salen == sizeof(struct sockaddr_storage)) {
2298 salen = sizeof(struct sockaddr_in);
2299 #if defined(HAVE_IPV6)
2300 if (psa->sa_family == AF_INET6) {
2301 salen = sizeof(struct sockaddr_in6);
2302 }
2303 #endif
2304 }
2305 return getnameinfo(psa, salen, host, hostlen, service, servlen, flags);
2306 }
2307
2308 int sys_connect(int fd, const struct sockaddr * addr)
2309 {
2310 socklen_t salen = -1;
2311
2312 if (addr->sa_family == AF_INET) {
2313 salen = sizeof(struct sockaddr_in);
2314 } else if (addr->sa_family == AF_UNIX) {
2315 salen = sizeof(struct sockaddr_un);
2316 }
2317 #if defined(HAVE_IPV6)
2318 else if (addr->sa_family == AF_INET6) {
2319 salen = sizeof(struct sockaddr_in6);
2320 }
2321 #endif
2322
2323 return connect(fd, addr, salen);
2324 }
Samba GIT mirror