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