lib/replace: xattr wrappers in lib/replace rather than source3/lib/system.c
[kai/samba.git] / source3 / lib / system.c
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, 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, 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, off_t offset, 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         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, off_t offset, 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 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  An mknod() wrapper.
638 ********************************************************************/
639
640 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
641 {
642 #if defined(HAVE_MKNOD)
643         return mknod(path, mode, dev);
644 #else
645         /* No mknod system call. */
646         errno = ENOSYS;
647         return -1;
648 #endif
649 }
650
651 /*******************************************************************
652 The wait() calls vary between systems
653 ********************************************************************/
654
655 int sys_waitpid(pid_t pid,int *status,int options)
656 {
657 #ifdef HAVE_WAITPID
658         return waitpid(pid,status,options);
659 #else /* HAVE_WAITPID */
660         return wait4(pid, status, options, NULL);
661 #endif /* HAVE_WAITPID */
662 }
663
664 /*******************************************************************
665  System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
666  on error (malloc fail usually).
667 ********************************************************************/
668
669 char *sys_getwd(void)
670 {
671 #ifdef GETCWD_TAKES_NULL
672         return getcwd(NULL, 0);
673 #elif HAVE_GETCWD
674         char *wd = NULL, *s = NULL;
675         size_t allocated = PATH_MAX;
676
677         while (1) {
678                 s = SMB_REALLOC_ARRAY(s, char, allocated);
679                 if (s == NULL) {
680                         return NULL;
681                 }
682                 wd = getcwd(s, allocated);
683                 if (wd) {
684                         break;
685                 }
686                 if (errno != ERANGE) {
687                         SAFE_FREE(s);
688                         break;
689                 }
690                 allocated *= 2;
691                 if (allocated < PATH_MAX) {
692                         SAFE_FREE(s);
693                         break;
694                 }
695         }
696         return wd;
697 #else
698         char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
699         if (s == NULL) {
700                 return NULL;
701         }
702         return getwd(s);
703 #endif
704 }
705
706 #if defined(HAVE_POSIX_CAPABILITIES)
707
708 /**************************************************************************
709  Try and abstract process capabilities (for systems that have them).
710 ****************************************************************************/
711
712 /* Set the POSIX capabilities needed for the given purpose into the effective
713  * capability set of the current process. Make sure they are always removed
714  * from the inheritable set, because there is no circumstance in which our
715  * children should inherit our elevated privileges.
716  */
717 static bool set_process_capability(enum smbd_capability capability,
718                                    bool enable)
719 {
720         cap_value_t cap_vals[2] = {0};
721         int num_cap_vals = 0;
722
723         cap_t cap;
724
725 #if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
726         /* On Linux, make sure that any capabilities we grab are sticky
727          * across UID changes. We expect that this would allow us to keep both
728          * the effective and permitted capability sets, but as of circa 2.6.16,
729          * only the permitted set is kept. It is a bug (which we work around)
730          * that the effective set is lost, but we still require the effective
731          * set to be kept.
732          */
733         if (!prctl(PR_GET_KEEPCAPS)) {
734                 prctl(PR_SET_KEEPCAPS, 1);
735         }
736 #endif
737
738         cap = cap_get_proc();
739         if (cap == NULL) {
740                 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
741                         strerror(errno)));
742                 return False;
743         }
744
745         switch (capability) {
746                 case KERNEL_OPLOCK_CAPABILITY:
747 #ifdef CAP_NETWORK_MGT
748                         /* IRIX has CAP_NETWORK_MGT for oplocks. */
749                         cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
750 #endif
751                         break;
752                 case DMAPI_ACCESS_CAPABILITY:
753 #ifdef CAP_DEVICE_MGT
754                         /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
755                         cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
756 #elif CAP_MKNOD
757                         /* Linux has CAP_MKNOD for DMAPI access. */
758                         cap_vals[num_cap_vals++] = CAP_MKNOD;
759 #endif
760                         break;
761                 case LEASE_CAPABILITY:
762 #ifdef CAP_LEASE
763                         cap_vals[num_cap_vals++] = CAP_LEASE;
764 #endif
765                         break;
766         }
767
768         SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
769
770         if (num_cap_vals == 0) {
771                 cap_free(cap);
772                 return True;
773         }
774
775         cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
776                 enable ? CAP_SET : CAP_CLEAR);
777
778         /* We never want to pass capabilities down to our children, so make
779          * sure they are not inherited.
780          */
781         cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
782
783         if (cap_set_proc(cap) == -1) {
784                 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
785                         strerror(errno)));
786                 cap_free(cap);
787                 return False;
788         }
789
790         cap_free(cap);
791         return True;
792 }
793
794 #endif /* HAVE_POSIX_CAPABILITIES */
795
796 /****************************************************************************
797  Gain the oplock capability from the kernel if possible.
798 ****************************************************************************/
799
800 void set_effective_capability(enum smbd_capability capability)
801 {
802 #if defined(HAVE_POSIX_CAPABILITIES)
803         set_process_capability(capability, True);
804 #endif /* HAVE_POSIX_CAPABILITIES */
805 }
806
807 void drop_effective_capability(enum smbd_capability capability)
808 {
809 #if defined(HAVE_POSIX_CAPABILITIES)
810         set_process_capability(capability, False);
811 #endif /* HAVE_POSIX_CAPABILITIES */
812 }
813
814 /**************************************************************************
815  Wrapper for random().
816 ****************************************************************************/
817
818 long sys_random(void)
819 {
820 #if defined(HAVE_RANDOM)
821         return (long)random();
822 #elif defined(HAVE_RAND)
823         return (long)rand();
824 #else
825         DEBUG(0,("Error - no random function available !\n"));
826         exit(1);
827 #endif
828 }
829
830 /**************************************************************************
831  Wrapper for srandom().
832 ****************************************************************************/
833
834 void sys_srandom(unsigned int seed)
835 {
836 #if defined(HAVE_SRANDOM)
837         srandom(seed);
838 #elif defined(HAVE_SRAND)
839         srand(seed);
840 #else
841         DEBUG(0,("Error - no srandom function available !\n"));
842         exit(1);
843 #endif
844 }
845
846 #ifndef NGROUPS_MAX
847 #define NGROUPS_MAX 32 /* Guess... */
848 #endif
849
850 /**************************************************************************
851  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
852 ****************************************************************************/
853
854 int groups_max(void)
855 {
856 #if defined(SYSCONF_SC_NGROUPS_MAX)
857         int ret = sysconf(_SC_NGROUPS_MAX);
858         return (ret == -1) ? NGROUPS_MAX : ret;
859 #else
860         return NGROUPS_MAX;
861 #endif
862 }
863
864 /**************************************************************************
865  Wrap setgroups and getgroups for systems that declare getgroups() as
866  returning an array of gid_t, but actuall return an array of int.
867 ****************************************************************************/
868
869 #if defined(HAVE_BROKEN_GETGROUPS)
870
871 #ifdef HAVE_BROKEN_GETGROUPS
872 #define GID_T int
873 #else
874 #define GID_T gid_t
875 #endif
876
877 static int sys_broken_getgroups(int setlen, gid_t *gidset)
878 {
879         GID_T gid;
880         GID_T *group_list;
881         int i, ngroups;
882
883         if(setlen == 0) {
884                 return getgroups(setlen, &gid);
885         }
886
887         /*
888          * Broken case. We need to allocate a
889          * GID_T array of size setlen.
890          */
891
892         if(setlen < 0) {
893                 errno = EINVAL; 
894                 return -1;
895         } 
896
897         if (setlen == 0)
898                 setlen = groups_max();
899
900         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
901                 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
902                 return -1;
903         }
904
905         if((ngroups = getgroups(setlen, group_list)) < 0) {
906                 int saved_errno = errno;
907                 SAFE_FREE(group_list);
908                 errno = saved_errno;
909                 return -1;
910         }
911
912         for(i = 0; i < ngroups; i++)
913                 gidset[i] = (gid_t)group_list[i];
914
915         SAFE_FREE(group_list);
916         return ngroups;
917 }
918
919 static int sys_broken_setgroups(int setlen, gid_t *gidset)
920 {
921         GID_T *group_list;
922         int i ; 
923
924         if (setlen == 0)
925                 return 0 ;
926
927         if (setlen < 0 || setlen > groups_max()) {
928                 errno = EINVAL; 
929                 return -1;   
930         }
931
932         /*
933          * Broken case. We need to allocate a
934          * GID_T array of size setlen.
935          */
936
937         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
938                 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
939                 return -1;    
940         }
941
942         for(i = 0; i < setlen; i++) 
943                 group_list[i] = (GID_T) gidset[i]; 
944
945         if(setgroups(setlen, group_list) != 0) {
946                 int saved_errno = errno;
947                 SAFE_FREE(group_list);
948                 errno = saved_errno;
949                 return -1;
950         }
951
952         SAFE_FREE(group_list);
953         return 0 ;
954 }
955
956 #endif /* HAVE_BROKEN_GETGROUPS */
957
958 /* This is a list of systems that require the first GID passed to setgroups(2)
959  * to be the effective GID. If your system is one of these, add it here.
960  */
961 #if defined (FREEBSD) || defined (DARWINOS)
962 #define USE_BSD_SETGROUPS
963 #endif
964
965 #if defined(USE_BSD_SETGROUPS)
966 /* Depending on the particular BSD implementation, the first GID that is
967  * passed to setgroups(2) will either be ignored or will set the credential's
968  * effective GID. In either case, the right thing to do is to guarantee that
969  * gidset[0] is the effective GID.
970  */
971 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
972 {
973         gid_t *new_gidset = NULL;
974         int max;
975         int ret;
976
977         /* setgroups(2) will fail with EINVAL if we pass too many groups. */
978         max = groups_max();
979
980         /* No group list, just make sure we are setting the efective GID. */
981         if (setlen == 0) {
982                 return setgroups(1, &primary_gid);
983         }
984
985         /* If the primary gid is not the first array element, grow the array
986          * and insert it at the front.
987          */
988         if (gidset[0] != primary_gid) {
989                 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
990                 if (new_gidset == NULL) {
991                         return -1;
992                 }
993
994                 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
995                 new_gidset[0] = primary_gid;
996                 setlen++;
997         }
998
999         if (setlen > max) {
1000                 DEBUG(3, ("forced to truncate group list from %d to %d\n",
1001                         setlen, max));
1002                 setlen = max;
1003         }
1004
1005 #if defined(HAVE_BROKEN_GETGROUPS)
1006         ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
1007 #else
1008         ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
1009 #endif
1010
1011         if (new_gidset) {
1012                 int errsav = errno;
1013                 SAFE_FREE(new_gidset);
1014                 errno = errsav;
1015         }
1016
1017         return ret;
1018 }
1019
1020 #endif /* USE_BSD_SETGROUPS */
1021
1022 /**************************************************************************
1023  Wrapper for getgroups. Deals with broken (int) case.
1024 ****************************************************************************/
1025
1026 int sys_getgroups(int setlen, gid_t *gidset)
1027 {
1028 #if defined(HAVE_BROKEN_GETGROUPS)
1029         return sys_broken_getgroups(setlen, gidset);
1030 #else
1031         return getgroups(setlen, gidset);
1032 #endif
1033 }
1034
1035 /**************************************************************************
1036  Wrapper for setgroups. Deals with broken (int) case and BSD case.
1037 ****************************************************************************/
1038
1039 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
1040 {
1041 #if !defined(HAVE_SETGROUPS)
1042         errno = ENOSYS;
1043         return -1;
1044 #endif /* HAVE_SETGROUPS */
1045
1046 #if defined(USE_BSD_SETGROUPS)
1047         return sys_bsd_setgroups(primary_gid, setlen, gidset);
1048 #elif defined(HAVE_BROKEN_GETGROUPS)
1049         return sys_broken_setgroups(setlen, gidset);
1050 #else
1051         return setgroups(setlen, gidset);
1052 #endif
1053 }
1054
1055 /**************************************************************************
1056  Extract a command into an arg list.
1057 ****************************************************************************/
1058
1059 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
1060 {
1061         char *trunc_cmd;
1062         char *saveptr;
1063         char *ptr;
1064         int argcl;
1065         char **argl = NULL;
1066         int i;
1067
1068         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1069                 DEBUG(0, ("talloc failed\n"));
1070                 goto nomem;
1071         }
1072
1073         if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1074                 TALLOC_FREE(trunc_cmd);
1075                 errno = EINVAL;
1076                 return NULL;
1077         }
1078
1079         /*
1080          * Count the args.
1081          */
1082
1083         for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1084                 argcl++;
1085
1086         TALLOC_FREE(trunc_cmd);
1087
1088         if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
1089                 goto nomem;
1090         }
1091
1092         /*
1093          * Now do the extraction.
1094          */
1095
1096         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1097                 goto nomem;
1098         }
1099
1100         ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1101         i = 0;
1102
1103         if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1104                 goto nomem;
1105         }
1106
1107         while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1108
1109                 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1110                         goto nomem;
1111                 }
1112         }
1113
1114         argl[i++] = NULL;
1115         TALLOC_FREE(trunc_cmd);
1116         return argl;
1117
1118  nomem:
1119         DEBUG(0, ("talloc failed\n"));
1120         TALLOC_FREE(trunc_cmd);
1121         TALLOC_FREE(argl);
1122         errno = ENOMEM;
1123         return NULL;
1124 }
1125
1126 /**************************************************************************
1127  Wrapper for popen. Safer as it doesn't search a path.
1128  Modified from the glibc sources.
1129  modified by tridge to return a file descriptor. We must kick our FILE* habit
1130 ****************************************************************************/
1131
1132 typedef struct _popen_list
1133 {
1134         int fd;
1135         pid_t child_pid;
1136         struct _popen_list *next;
1137 } popen_list;
1138
1139 static popen_list *popen_chain;
1140
1141 int sys_popen(const char *command)
1142 {
1143         int parent_end, child_end;
1144         int pipe_fds[2];
1145         popen_list *entry = NULL;
1146         char **argl = NULL;
1147
1148         if (pipe(pipe_fds) < 0)
1149                 return -1;
1150
1151         parent_end = pipe_fds[0];
1152         child_end = pipe_fds[1];
1153
1154         if (!*command) {
1155                 errno = EINVAL;
1156                 goto err_exit;
1157         }
1158
1159         if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1160                 goto err_exit;
1161
1162         ZERO_STRUCTP(entry);
1163
1164         /*
1165          * Extract the command and args into a NULL terminated array.
1166          */
1167
1168         if(!(argl = extract_args(NULL, command)))
1169                 goto err_exit;
1170
1171         entry->child_pid = fork();
1172
1173         if (entry->child_pid == -1) {
1174                 goto err_exit;
1175         }
1176
1177         if (entry->child_pid == 0) {
1178
1179                 /*
1180                  * Child !
1181                  */
1182
1183                 int child_std_end = STDOUT_FILENO;
1184                 popen_list *p;
1185
1186                 close(parent_end);
1187                 if (child_end != child_std_end) {
1188                         dup2 (child_end, child_std_end);
1189                         close (child_end);
1190                 }
1191
1192                 /*
1193                  * POSIX.2:  "popen() shall ensure that any streams from previous
1194                  * popen() calls that remain open in the parent process are closed
1195                  * in the new child process."
1196                  */
1197
1198                 for (p = popen_chain; p; p = p->next)
1199                         close(p->fd);
1200
1201                 execv(argl[0], argl);
1202                 _exit (127);
1203         }
1204
1205         /*
1206          * Parent.
1207          */
1208
1209         close (child_end);
1210         TALLOC_FREE(argl);
1211
1212         /* Link into popen_chain. */
1213         entry->next = popen_chain;
1214         popen_chain = entry;
1215         entry->fd = parent_end;
1216
1217         return entry->fd;
1218
1219 err_exit:
1220
1221         SAFE_FREE(entry);
1222         TALLOC_FREE(argl);
1223         close(pipe_fds[0]);
1224         close(pipe_fds[1]);
1225         return -1;
1226 }
1227
1228 /**************************************************************************
1229  Wrapper for pclose. Modified from the glibc sources.
1230 ****************************************************************************/
1231
1232 int sys_pclose(int fd)
1233 {
1234         int wstatus;
1235         popen_list **ptr = &popen_chain;
1236         popen_list *entry = NULL;
1237         pid_t wait_pid;
1238         int status = -1;
1239
1240         /* Unlink from popen_chain. */
1241         for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1242                 if ((*ptr)->fd == fd) {
1243                         entry = *ptr;
1244                         *ptr = (*ptr)->next;
1245                         status = 0;
1246                         break;
1247                 }
1248         }
1249
1250         if (status < 0 || close(entry->fd) < 0)
1251                 return -1;
1252
1253         /*
1254          * As Samba is catching and eating child process
1255          * exits we don't really care about the child exit
1256          * code, a -1 with errno = ECHILD will do fine for us.
1257          */
1258
1259         do {
1260                 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1261         } while (wait_pid == -1 && errno == EINTR);
1262
1263         SAFE_FREE(entry);
1264
1265         if (wait_pid == -1)
1266                 return -1;
1267         return wstatus;
1268 }
1269
1270 /**************************************************************************
1271  Wrapper for Admin Logs.
1272 ****************************************************************************/
1273
1274  void sys_adminlog(int priority, const char *format_str, ...) 
1275 {
1276         va_list ap;
1277         int ret;
1278         char *msgbuf = NULL;
1279
1280         va_start( ap, format_str );
1281         ret = vasprintf( &msgbuf, format_str, ap );
1282         va_end( ap );
1283
1284         if (ret == -1)
1285                 return;
1286
1287 #if defined(HAVE_SYSLOG)
1288         syslog( priority, "%s", msgbuf );
1289 #else
1290         DEBUG(0,("%s", msgbuf ));
1291 #endif
1292         SAFE_FREE(msgbuf);
1293 }
1294
1295 /****************************************************************************
1296  Return the major devicenumber for UNIX extensions.
1297 ****************************************************************************/
1298
1299 uint32 unix_dev_major(SMB_DEV_T dev)
1300 {
1301 #if defined(HAVE_DEVICE_MAJOR_FN)
1302         return (uint32)major(dev);
1303 #else
1304         return (uint32)(dev >> 8);
1305 #endif
1306 }
1307
1308 /****************************************************************************
1309  Return the minor devicenumber for UNIX extensions.
1310 ****************************************************************************/
1311
1312 uint32 unix_dev_minor(SMB_DEV_T dev)
1313 {
1314 #if defined(HAVE_DEVICE_MINOR_FN)
1315         return (uint32)minor(dev);
1316 #else
1317         return (uint32)(dev & 0xff);
1318 #endif
1319 }
1320
1321 #if 0
1322 /*******************************************************************
1323  Return the number of CPUs.
1324 ********************************************************************/
1325
1326 int sys_get_number_of_cores(void)
1327 {
1328         int ret = -1;
1329
1330 #if defined(HAVE_SYSCONF)
1331 #if defined(_SC_NPROCESSORS_ONLN)
1332         ret = (int)sysconf(_SC_NPROCESSORS_ONLN);
1333 #endif
1334 #if defined(_SC_NPROCESSORS_CONF)
1335         if (ret < 1) {
1336                 ret = (int)sysconf(_SC_NPROCESSORS_CONF);
1337         }
1338 #endif
1339 #elif defined(HAVE_SYSCTL) && defined(CTL_HW)
1340         int name[2];
1341         unsigned int len = sizeof(ret);
1342
1343         name[0] = CTL_HW;
1344 #if defined(HW_AVAILCPU)
1345         name[1] = HW_AVAILCPU;
1346
1347         if (sysctl(name, 2, &ret, &len, NULL, 0) == -1) {
1348                 ret = -1;
1349         }
1350 #endif
1351 #if defined(HW_NCPU)
1352         if(ret < 1) {
1353                 name[0] = CTL_HW;
1354                 name[1] = HW_NCPU;
1355                 if (sysctl(nm, 2, &count, &len, NULL, 0) == -1) {
1356                         ret = -1;
1357                 }
1358         }
1359 #endif
1360 #endif
1361         if (ret < 1) {
1362                 ret = 1;
1363         }
1364         return ret;
1365 }
1366 #endif
1367
1368 #if defined(WITH_AIO)
1369
1370 /*******************************************************************
1371  An aio_read wrapper.
1372 ********************************************************************/
1373
1374 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
1375 {
1376 #if defined(HAVE_AIO_READ)
1377         return aio_read(aiocb);
1378 #else
1379         errno = ENOSYS;
1380         return -1;
1381 #endif
1382 }
1383
1384 /*******************************************************************
1385  An aio_write wrapper.
1386 ********************************************************************/
1387
1388 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
1389 {
1390 #if defined(HAVE_AIO_WRITE)
1391         return aio_write(aiocb);
1392 #else
1393         errno = ENOSYS;
1394         return -1;
1395 #endif
1396 }
1397
1398 /*******************************************************************
1399  An aio_return wrapper.
1400 ********************************************************************/
1401
1402 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
1403 {
1404 #if defined(HAVE_AIO_RETURN)
1405         return aio_return(aiocb);
1406 #else
1407         errno = ENOSYS;
1408         return -1;
1409 #endif
1410 }
1411
1412 /*******************************************************************
1413  An aio_cancel wrapper.
1414 ********************************************************************/
1415
1416 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
1417 {
1418 #if defined(HAVE_AIO_CANCEL)
1419         return aio_cancel(fd, aiocb);
1420 #else
1421         errno = ENOSYS;
1422         return -1;
1423 #endif
1424 }
1425
1426 /*******************************************************************
1427  An aio_error wrapper.
1428 ********************************************************************/
1429
1430 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
1431 {
1432 #if defined(HAVE_AIO_ERROR)
1433         return aio_error(aiocb);
1434 #else
1435         errno = ENOSYS;
1436         return -1;
1437 #endif
1438 }
1439
1440 /*******************************************************************
1441  An aio_fsync wrapper.
1442 ********************************************************************/
1443
1444 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
1445 {
1446 #if defined(HAVE_AIO_FSYNC)
1447         return aio_fsync(op, aiocb);
1448 #else
1449         errno = ENOSYS;
1450         return -1;
1451 #endif
1452 }
1453
1454 /*******************************************************************
1455  An aio_fsync wrapper.
1456 ********************************************************************/
1457
1458 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
1459 {
1460 #if defined(HAVE_AIO_FSYNC)
1461         return aio_suspend(cblist, n, timeout);
1462 #else
1463         errno = ENOSYS;
1464         return -1;
1465 #endif
1466 }
1467 #else /* !WITH_AIO */
1468
1469 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
1470 {
1471         errno = ENOSYS;
1472         return -1;
1473 }
1474
1475 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
1476 {
1477         errno = ENOSYS;
1478         return -1;
1479 }
1480
1481 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
1482 {
1483         errno = ENOSYS;
1484         return -1;
1485 }
1486
1487 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
1488 {
1489         errno = ENOSYS;
1490         return -1;
1491 }
1492
1493 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
1494 {
1495         errno = ENOSYS;
1496         return -1;
1497 }
1498
1499 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
1500 {
1501         errno = ENOSYS;
1502         return -1;
1503 }
1504
1505 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
1506 {
1507         errno = ENOSYS;
1508         return -1;
1509 }
1510 #endif /* WITH_AIO */