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