lib: Remove sys_waitpid
[metze/samba/wip.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 #include "../lib/util/setid.h"
29
30 #ifdef HAVE_SYS_SYSCTL_H
31 #include <sys/sysctl.h>
32 #endif
33
34 #ifdef HAVE_SYS_PRCTL_H
35 #include <sys/prctl.h>
36 #endif
37
38 /*
39    The idea is that this file will eventually have wrappers around all
40    important system calls in samba. The aims are:
41
42    - to enable easier porting by putting OS dependent stuff in here
43
44    - to allow for hooks into other "pseudo-filesystems"
45
46    - to allow easier integration of things like the japanese extensions
47
48    - to support the philosophy of Samba to expose the features of
49      the OS within the SMB model. In general whatever file/printer/variable
50      expansions/etc make sense to the OS should be acceptable to Samba.
51 */
52
53 /*******************************************************************
54 A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
55 ********************************************************************/
56
57 ssize_t sys_send(int s, const void *msg, size_t len, int flags)
58 {
59         ssize_t ret;
60
61         do {
62                 ret = send(s, msg, len, flags);
63         } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
64
65         return ret;
66 }
67
68 /*******************************************************************
69 A recvfrom wrapper that will deal with EINTR.
70 NB. As used with non-blocking sockets, return on EAGAIN/EWOULDBLOCK
71 ********************************************************************/
72
73 ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
74 {
75         ssize_t ret;
76
77         do {
78                 ret = recvfrom(s, buf, len, flags, from, fromlen);
79         } while (ret == -1 && (errno == EINTR));
80         return ret;
81 }
82
83 /*******************************************************************
84 A fcntl wrapper that will deal with EINTR.
85 ********************************************************************/
86
87 int sys_fcntl_ptr(int fd, int cmd, void *arg)
88 {
89         int ret;
90
91         do {
92                 ret = fcntl(fd, cmd, arg);
93         } while (ret == -1 && errno == EINTR);
94         return ret;
95 }
96
97 /*******************************************************************
98 A fcntl wrapper that will deal with EINTR.
99 ********************************************************************/
100
101 int sys_fcntl_long(int fd, int cmd, long arg)
102 {
103         int ret;
104
105         do {
106                 ret = fcntl(fd, cmd, arg);
107         } while (ret == -1 && errno == EINTR);
108         return ret;
109 }
110
111 /****************************************************************************
112  Get/Set all the possible time fields from a stat struct as a timespec.
113 ****************************************************************************/
114
115 static struct timespec get_atimespec(const struct stat *pst)
116 {
117 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
118         struct timespec ret;
119
120         /* Old system - no ns timestamp. */
121         ret.tv_sec = pst->st_atime;
122         ret.tv_nsec = 0;
123         return ret;
124 #else
125 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
126         struct timespec ret;
127         ret.tv_sec = pst->st_atim.tv_sec;
128         ret.tv_nsec = pst->st_atim.tv_nsec;
129         return ret;
130 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
131         struct timespec ret;
132         ret.tv_sec = pst->st_atime;
133         ret.tv_nsec = pst->st_atimensec;
134         return ret;
135 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
136         struct timespec ret;
137         ret.tv_sec = pst->st_atime;
138         ret.tv_nsec = pst->st_atime_n;
139         return ret;
140 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
141         struct timespec ret;
142         ret.tv_sec = pst->st_atime;
143         ret.tv_nsec = pst->st_uatime * 1000;
144         return ret;
145 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
146         return pst->st_atimespec;
147 #else
148 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
149 #endif
150 #endif
151 }
152
153 static struct timespec get_mtimespec(const struct stat *pst)
154 {
155 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
156         struct timespec ret;
157
158         /* Old system - no ns timestamp. */
159         ret.tv_sec = pst->st_mtime;
160         ret.tv_nsec = 0;
161         return ret;
162 #else
163 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
164         struct timespec ret;
165         ret.tv_sec = pst->st_mtim.tv_sec;
166         ret.tv_nsec = pst->st_mtim.tv_nsec;
167         return ret;
168 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
169         struct timespec ret;
170         ret.tv_sec = pst->st_mtime;
171         ret.tv_nsec = pst->st_mtimensec;
172         return ret;
173 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
174         struct timespec ret;
175         ret.tv_sec = pst->st_mtime;
176         ret.tv_nsec = pst->st_mtime_n;
177         return ret;
178 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
179         struct timespec ret;
180         ret.tv_sec = pst->st_mtime;
181         ret.tv_nsec = pst->st_umtime * 1000;
182         return ret;
183 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
184         return pst->st_mtimespec;
185 #else
186 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
187 #endif
188 #endif
189 }
190
191 static struct timespec get_ctimespec(const struct stat *pst)
192 {
193 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
194         struct timespec ret;
195
196         /* Old system - no ns timestamp. */
197         ret.tv_sec = pst->st_ctime;
198         ret.tv_nsec = 0;
199         return ret;
200 #else
201 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
202         struct timespec ret;
203         ret.tv_sec = pst->st_ctim.tv_sec;
204         ret.tv_nsec = pst->st_ctim.tv_nsec;
205         return ret;
206 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
207         struct timespec ret;
208         ret.tv_sec = pst->st_ctime;
209         ret.tv_nsec = pst->st_ctimensec;
210         return ret;
211 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
212         struct timespec ret;
213         ret.tv_sec = pst->st_ctime;
214         ret.tv_nsec = pst->st_ctime_n;
215         return ret;
216 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
217         struct timespec ret;
218         ret.tv_sec = pst->st_ctime;
219         ret.tv_nsec = pst->st_uctime * 1000;
220         return ret;
221 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
222         return pst->st_ctimespec;
223 #else
224 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
225 #endif
226 #endif
227 }
228
229 /****************************************************************************
230  Return the best approximation to a 'create time' under UNIX from a stat
231  structure.
232 ****************************************************************************/
233
234 static struct timespec calc_create_time_stat(const struct stat *st)
235 {
236         struct timespec ret, ret1;
237         struct timespec c_time = get_ctimespec(st);
238         struct timespec m_time = get_mtimespec(st);
239         struct timespec a_time = get_atimespec(st);
240
241         ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
242         ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
243
244         if(!null_timespec(ret1)) {
245                 return ret1;
246         }
247
248         /*
249          * One of ctime, mtime or atime was zero (probably atime).
250          * Just return MIN(ctime, mtime).
251          */
252         return ret;
253 }
254
255 /****************************************************************************
256  Return the best approximation to a 'create time' under UNIX from a stat_ex
257  structure.
258 ****************************************************************************/
259
260 static struct timespec calc_create_time_stat_ex(const struct stat_ex *st)
261 {
262         struct timespec ret, ret1;
263         struct timespec c_time = st->st_ex_ctime;
264         struct timespec m_time = st->st_ex_mtime;
265         struct timespec a_time = st->st_ex_atime;
266
267         ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
268         ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
269
270         if(!null_timespec(ret1)) {
271                 return ret1;
272         }
273
274         /*
275          * One of ctime, mtime or atime was zero (probably atime).
276          * Just return MIN(ctime, mtime).
277          */
278         return ret;
279 }
280
281 /****************************************************************************
282  Return the 'create time' from a stat struct if it exists (birthtime) or else
283  use the best approximation.
284 ****************************************************************************/
285
286 static void make_create_timespec(const struct stat *pst, struct stat_ex *dst,
287                                  bool fake_dir_create_times)
288 {
289         if (S_ISDIR(pst->st_mode) && fake_dir_create_times) {
290                 dst->st_ex_btime.tv_sec = 315493200L;          /* 1/1/1980 */
291                 dst->st_ex_btime.tv_nsec = 0;
292         }
293
294         dst->st_ex_calculated_birthtime = false;
295
296 #if defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
297         dst->st_ex_btime = pst->st_birthtimespec;
298 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC)
299         dst->st_ex_btime.tv_sec = pst->st_birthtime;
300         dst->st_ex_btime.tv_nsec = pst->st_birthtimenspec;
301 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIME)
302         dst->st_ex_btime.tv_sec = pst->st_birthtime;
303         dst->st_ex_btime.tv_nsec = 0;
304 #else
305         dst->st_ex_btime = calc_create_time_stat(pst);
306         dst->st_ex_calculated_birthtime = true;
307 #endif
308
309         /* Deal with systems that don't initialize birthtime correctly.
310          * Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
311          */
312         if (null_timespec(dst->st_ex_btime)) {
313                 dst->st_ex_btime = calc_create_time_stat(pst);
314                 dst->st_ex_calculated_birthtime = true;
315         }
316 }
317
318 /****************************************************************************
319  If we update a timestamp in a stat_ex struct we may have to recalculate
320  the birthtime. For now only implement this for write time, but we may
321  also need to do it for atime and ctime. JRA.
322 ****************************************************************************/
323
324 void update_stat_ex_mtime(struct stat_ex *dst,
325                                 struct timespec write_ts)
326 {
327         dst->st_ex_mtime = write_ts;
328
329         /* We may have to recalculate btime. */
330         if (dst->st_ex_calculated_birthtime) {
331                 dst->st_ex_btime = calc_create_time_stat_ex(dst);
332         }
333 }
334
335 void update_stat_ex_create_time(struct stat_ex *dst,
336                                 struct timespec create_time)
337 {
338         dst->st_ex_btime = create_time;
339         dst->st_ex_calculated_birthtime = false;
340 }
341
342 void init_stat_ex_from_stat (struct stat_ex *dst,
343                             const struct stat *src,
344                             bool fake_dir_create_times)
345 {
346         dst->st_ex_dev = src->st_dev;
347         dst->st_ex_ino = src->st_ino;
348         dst->st_ex_mode = src->st_mode;
349         dst->st_ex_nlink = src->st_nlink;
350         dst->st_ex_uid = src->st_uid;
351         dst->st_ex_gid = src->st_gid;
352         dst->st_ex_rdev = src->st_rdev;
353         dst->st_ex_size = src->st_size;
354         dst->st_ex_atime = get_atimespec(src);
355         dst->st_ex_mtime = get_mtimespec(src);
356         dst->st_ex_ctime = get_ctimespec(src);
357         make_create_timespec(src, dst, fake_dir_create_times);
358 #ifdef HAVE_STAT_ST_BLKSIZE
359         dst->st_ex_blksize = src->st_blksize;
360 #else
361         dst->st_ex_blksize = STAT_ST_BLOCKSIZE;
362 #endif
363
364 #ifdef HAVE_STAT_ST_BLOCKS
365         dst->st_ex_blocks = src->st_blocks;
366 #else
367         dst->st_ex_blocks = src->st_size / dst->st_ex_blksize + 1;
368 #endif
369
370 #ifdef HAVE_STAT_ST_FLAGS
371         dst->st_ex_flags = src->st_flags;
372 #else
373         dst->st_ex_flags = 0;
374 #endif
375 }
376
377 /*******************************************************************
378 A stat() wrapper.
379 ********************************************************************/
380
381 int sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf,
382              bool fake_dir_create_times)
383 {
384         int ret;
385         struct stat statbuf;
386         ret = stat(fname, &statbuf);
387         if (ret == 0) {
388                 /* we always want directories to appear zero size */
389                 if (S_ISDIR(statbuf.st_mode)) {
390                         statbuf.st_size = 0;
391                 }
392                 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
393         }
394         return ret;
395 }
396
397 /*******************************************************************
398  An fstat() wrapper.
399 ********************************************************************/
400
401 int sys_fstat(int fd, SMB_STRUCT_STAT *sbuf, bool fake_dir_create_times)
402 {
403         int ret;
404         struct stat statbuf;
405         ret = fstat(fd, &statbuf);
406         if (ret == 0) {
407                 /* we always want directories to appear zero size */
408                 if (S_ISDIR(statbuf.st_mode)) {
409                         statbuf.st_size = 0;
410                 }
411                 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
412         }
413         return ret;
414 }
415
416 /*******************************************************************
417  An lstat() wrapper.
418 ********************************************************************/
419
420 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
421               bool fake_dir_create_times)
422 {
423         int ret;
424         struct stat statbuf;
425         ret = lstat(fname, &statbuf);
426         if (ret == 0) {
427                 /* we always want directories to appear zero size */
428                 if (S_ISDIR(statbuf.st_mode)) {
429                         statbuf.st_size = 0;
430                 }
431                 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
432         }
433         return ret;
434 }
435
436 /*******************************************************************
437  An posix_fallocate() wrapper.
438 ********************************************************************/
439 int sys_posix_fallocate(int fd, off_t offset, off_t len)
440 {
441 #if defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
442         return posix_fallocate(fd, offset, len);
443 #elif defined(F_RESVSP64)
444         /* this handles XFS on IRIX */
445         struct flock64 fl;
446         off_t new_len = offset + len;
447         int ret;
448         struct stat64 sbuf;
449
450         /* unlikely to get a too large file on a 64bit system but ... */
451         if (new_len < 0)
452                 return EFBIG;
453
454         fl.l_whence = SEEK_SET;
455         fl.l_start = offset;
456         fl.l_len = len;
457
458         ret=fcntl(fd, F_RESVSP64, &fl);
459
460         if (ret != 0)
461                 return errno;
462
463         /* Make sure the file gets enlarged after we allocated space: */
464         fstat64(fd, &sbuf);
465         if (new_len > sbuf.st_size)
466                 ftruncate64(fd, new_len);
467         return 0;
468 #else
469         return ENOSYS;
470 #endif
471 }
472
473 /*******************************************************************
474  An fallocate() function that matches the semantics of the Linux one.
475 ********************************************************************/
476
477 #ifdef HAVE_LINUX_FALLOC_H
478 #include <linux/falloc.h>
479 #endif
480
481 int sys_fallocate(int fd, uint32_t mode, off_t offset, off_t len)
482 {
483 #if defined(HAVE_LINUX_FALLOCATE)
484         int lmode = 0;
485
486         if (mode & VFS_FALLOCATE_FL_KEEP_SIZE) {
487                 lmode |= FALLOC_FL_KEEP_SIZE;
488                 mode &= ~VFS_FALLOCATE_FL_KEEP_SIZE;
489         }
490
491 #if defined(HAVE_FALLOC_FL_PUNCH_HOLE)
492         if (mode & VFS_FALLOCATE_FL_PUNCH_HOLE) {
493                 lmode |= FALLOC_FL_PUNCH_HOLE;
494                 mode &= ~VFS_FALLOCATE_FL_PUNCH_HOLE;
495         }
496 #endif  /* HAVE_FALLOC_FL_PUNCH_HOLE */
497
498         if (mode != 0) {
499                 DEBUG(2, ("unmapped fallocate flags: %lx\n",
500                       (unsigned long)mode));
501                 errno = EINVAL;
502                 return -1;
503         }
504         return fallocate(fd, lmode, offset, len);
505 #else   /* HAVE_LINUX_FALLOCATE */
506         /* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
507         errno = ENOSYS;
508         return -1;
509 #endif  /* HAVE_LINUX_FALLOCATE */
510 }
511
512 #if HAVE_KERNEL_SHARE_MODES
513 #ifndef LOCK_MAND
514 #define LOCK_MAND       32      /* This is a mandatory flock */
515 #define LOCK_READ       64      /* ... Which allows concurrent read operations */
516 #define LOCK_WRITE      128     /* ... Which allows concurrent write operations */
517 #define LOCK_RW         192     /* ... Which allows concurrent read & write ops */
518 #endif
519 #endif
520
521 /*******************************************************************
522  A flock() wrapper that will perform the kernel flock.
523 ********************************************************************/
524
525 void kernel_flock(int fd, uint32_t share_mode, uint32_t access_mask)
526 {
527 #if HAVE_KERNEL_SHARE_MODES
528         int kernel_mode = 0;
529         if (share_mode == FILE_SHARE_WRITE) {
530                 kernel_mode = LOCK_MAND|LOCK_WRITE;
531         } else if (share_mode == FILE_SHARE_READ) {
532                 kernel_mode = LOCK_MAND|LOCK_READ;
533         } else if (share_mode == FILE_SHARE_NONE) {
534                 kernel_mode = LOCK_MAND;
535         }
536         if (kernel_mode) {
537                 flock(fd, kernel_mode);
538         }
539 #endif
540         ;
541 }
542
543
544
545 /*******************************************************************
546  An fdopendir wrapper.
547 ********************************************************************/
548
549 DIR *sys_fdopendir(int fd)
550 {
551 #if defined(HAVE_FDOPENDIR)
552         return fdopendir(fd);
553 #else
554         errno = ENOSYS;
555         return NULL;
556 #endif
557 }
558
559 /*******************************************************************
560  An mknod() wrapper.
561 ********************************************************************/
562
563 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
564 {
565 #if defined(HAVE_MKNOD)
566         return mknod(path, mode, dev);
567 #else
568         /* No mknod system call. */
569         errno = ENOSYS;
570         return -1;
571 #endif
572 }
573
574 /*******************************************************************
575  System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
576  on error (malloc fail usually).
577 ********************************************************************/
578
579 char *sys_getwd(void)
580 {
581 #ifdef GETCWD_TAKES_NULL
582         return getcwd(NULL, 0);
583 #elif HAVE_GETCWD
584         char *wd = NULL, *s = NULL;
585         size_t allocated = PATH_MAX;
586
587         while (1) {
588                 s = SMB_REALLOC_ARRAY(s, char, allocated);
589                 if (s == NULL) {
590                         return NULL;
591                 }
592                 wd = getcwd(s, allocated);
593                 if (wd) {
594                         break;
595                 }
596                 if (errno != ERANGE) {
597                         SAFE_FREE(s);
598                         break;
599                 }
600                 allocated *= 2;
601                 if (allocated < PATH_MAX) {
602                         SAFE_FREE(s);
603                         break;
604                 }
605         }
606         return wd;
607 #else
608         char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
609         if (s == NULL) {
610                 return NULL;
611         }
612         return getwd(s);
613 #endif
614 }
615
616 #if defined(HAVE_POSIX_CAPABILITIES)
617
618 /**************************************************************************
619  Try and abstract process capabilities (for systems that have them).
620 ****************************************************************************/
621
622 /* Set the POSIX capabilities needed for the given purpose into the effective
623  * capability set of the current process. Make sure they are always removed
624  * from the inheritable set, because there is no circumstance in which our
625  * children should inherit our elevated privileges.
626  */
627 static bool set_process_capability(enum smbd_capability capability,
628                                    bool enable)
629 {
630         cap_value_t cap_vals[2] = {0};
631         int num_cap_vals = 0;
632
633         cap_t cap;
634
635 #if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
636         /* On Linux, make sure that any capabilities we grab are sticky
637          * across UID changes. We expect that this would allow us to keep both
638          * the effective and permitted capability sets, but as of circa 2.6.16,
639          * only the permitted set is kept. It is a bug (which we work around)
640          * that the effective set is lost, but we still require the effective
641          * set to be kept.
642          */
643         if (!prctl(PR_GET_KEEPCAPS)) {
644                 prctl(PR_SET_KEEPCAPS, 1);
645         }
646 #endif
647
648         cap = cap_get_proc();
649         if (cap == NULL) {
650                 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
651                         strerror(errno)));
652                 return False;
653         }
654
655         switch (capability) {
656                 case KERNEL_OPLOCK_CAPABILITY:
657 #ifdef CAP_NETWORK_MGT
658                         /* IRIX has CAP_NETWORK_MGT for oplocks. */
659                         cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
660 #endif
661                         break;
662                 case DMAPI_ACCESS_CAPABILITY:
663 #ifdef CAP_DEVICE_MGT
664                         /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
665                         cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
666 #elif CAP_MKNOD
667                         /* Linux has CAP_MKNOD for DMAPI access. */
668                         cap_vals[num_cap_vals++] = CAP_MKNOD;
669 #endif
670                         break;
671                 case LEASE_CAPABILITY:
672 #ifdef CAP_LEASE
673                         cap_vals[num_cap_vals++] = CAP_LEASE;
674 #endif
675                         break;
676                 case DAC_OVERRIDE_CAPABILITY:
677 #ifdef CAP_DAC_OVERRIDE
678                         cap_vals[num_cap_vals++] = CAP_DAC_OVERRIDE;
679 #endif
680         }
681
682         SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
683
684         if (num_cap_vals == 0) {
685                 cap_free(cap);
686                 return True;
687         }
688
689         cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
690                 enable ? CAP_SET : CAP_CLEAR);
691
692         /* We never want to pass capabilities down to our children, so make
693          * sure they are not inherited.
694          */
695         cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
696
697         if (cap_set_proc(cap) == -1) {
698                 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
699                         strerror(errno)));
700                 cap_free(cap);
701                 return False;
702         }
703
704         cap_free(cap);
705         return True;
706 }
707
708 #endif /* HAVE_POSIX_CAPABILITIES */
709
710 /****************************************************************************
711  Gain the oplock capability from the kernel if possible.
712 ****************************************************************************/
713
714 void set_effective_capability(enum smbd_capability capability)
715 {
716 #if defined(HAVE_POSIX_CAPABILITIES)
717         set_process_capability(capability, True);
718 #endif /* HAVE_POSIX_CAPABILITIES */
719 }
720
721 void drop_effective_capability(enum smbd_capability capability)
722 {
723 #if defined(HAVE_POSIX_CAPABILITIES)
724         set_process_capability(capability, False);
725 #endif /* HAVE_POSIX_CAPABILITIES */
726 }
727
728 /**************************************************************************
729  Wrapper for random().
730 ****************************************************************************/
731
732 long sys_random(void)
733 {
734 #if defined(HAVE_RANDOM)
735         return (long)random();
736 #elif defined(HAVE_RAND)
737         return (long)rand();
738 #else
739         DEBUG(0,("Error - no random function available !\n"));
740         exit(1);
741 #endif
742 }
743
744 /**************************************************************************
745  Wrapper for srandom().
746 ****************************************************************************/
747
748 void sys_srandom(unsigned int seed)
749 {
750 #if defined(HAVE_SRANDOM)
751         srandom(seed);
752 #elif defined(HAVE_SRAND)
753         srand(seed);
754 #else
755         DEBUG(0,("Error - no srandom function available !\n"));
756         exit(1);
757 #endif
758 }
759
760 #ifndef NGROUPS_MAX
761 #define NGROUPS_MAX 32 /* Guess... */
762 #endif
763
764 /**************************************************************************
765  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
766 ****************************************************************************/
767
768 int groups_max(void)
769 {
770 #if defined(SYSCONF_SC_NGROUPS_MAX)
771         int ret = sysconf(_SC_NGROUPS_MAX);
772         return (ret == -1) ? NGROUPS_MAX : ret;
773 #else
774         return NGROUPS_MAX;
775 #endif
776 }
777
778 /**************************************************************************
779  Wrap setgroups and getgroups for systems that declare getgroups() as
780  returning an array of gid_t, but actuall return an array of int.
781 ****************************************************************************/
782
783 #if defined(HAVE_BROKEN_GETGROUPS)
784
785 #ifdef HAVE_BROKEN_GETGROUPS
786 #define GID_T int
787 #else
788 #define GID_T gid_t
789 #endif
790
791 static int sys_broken_getgroups(int setlen, gid_t *gidset)
792 {
793         GID_T gid;
794         GID_T *group_list;
795         int i, ngroups;
796
797         if(setlen == 0) {
798                 return getgroups(setlen, &gid);
799         }
800
801         /*
802          * Broken case. We need to allocate a
803          * GID_T array of size setlen.
804          */
805
806         if(setlen < 0) {
807                 errno = EINVAL; 
808                 return -1;
809         } 
810
811         if (setlen == 0)
812                 setlen = groups_max();
813
814         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
815                 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
816                 return -1;
817         }
818
819         if((ngroups = getgroups(setlen, group_list)) < 0) {
820                 int saved_errno = errno;
821                 SAFE_FREE(group_list);
822                 errno = saved_errno;
823                 return -1;
824         }
825
826         for(i = 0; i < ngroups; i++)
827                 gidset[i] = (gid_t)group_list[i];
828
829         SAFE_FREE(group_list);
830         return ngroups;
831 }
832
833 static int sys_broken_setgroups(int setlen, gid_t *gidset)
834 {
835         GID_T *group_list;
836         int i ; 
837
838         if (setlen == 0)
839                 return 0 ;
840
841         if (setlen < 0 || setlen > groups_max()) {
842                 errno = EINVAL; 
843                 return -1;   
844         }
845
846         /*
847          * Broken case. We need to allocate a
848          * GID_T array of size setlen.
849          */
850
851         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
852                 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
853                 return -1;    
854         }
855
856         for(i = 0; i < setlen; i++) 
857                 group_list[i] = (GID_T) gidset[i]; 
858
859         if(samba_setgroups(setlen, group_list) != 0) {
860                 int saved_errno = errno;
861                 SAFE_FREE(group_list);
862                 errno = saved_errno;
863                 return -1;
864         }
865
866         SAFE_FREE(group_list);
867         return 0 ;
868 }
869
870 #endif /* HAVE_BROKEN_GETGROUPS */
871
872 /* This is a list of systems that require the first GID passed to setgroups(2)
873  * to be the effective GID. If your system is one of these, add it here.
874  */
875 #if defined (FREEBSD) || defined (DARWINOS)
876 #define USE_BSD_SETGROUPS
877 #endif
878
879 #if defined(USE_BSD_SETGROUPS)
880 /* Depending on the particular BSD implementation, the first GID that is
881  * passed to setgroups(2) will either be ignored or will set the credential's
882  * effective GID. In either case, the right thing to do is to guarantee that
883  * gidset[0] is the effective GID.
884  */
885 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
886 {
887         gid_t *new_gidset = NULL;
888         int max;
889         int ret;
890
891         /* setgroups(2) will fail with EINVAL if we pass too many groups. */
892         max = groups_max();
893
894         /* No group list, just make sure we are setting the efective GID. */
895         if (setlen == 0) {
896                 return samba_setgroups(1, &primary_gid);
897         }
898
899         /* If the primary gid is not the first array element, grow the array
900          * and insert it at the front.
901          */
902         if (gidset[0] != primary_gid) {
903                 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
904                 if (new_gidset == NULL) {
905                         return -1;
906                 }
907
908                 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
909                 new_gidset[0] = primary_gid;
910                 setlen++;
911         }
912
913         if (setlen > max) {
914                 DEBUG(3, ("forced to truncate group list from %d to %d\n",
915                         setlen, max));
916                 setlen = max;
917         }
918
919 #if defined(HAVE_BROKEN_GETGROUPS)
920         ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
921 #else
922         ret = samba_setgroups(setlen, new_gidset ? new_gidset : gidset);
923 #endif
924
925         if (new_gidset) {
926                 int errsav = errno;
927                 SAFE_FREE(new_gidset);
928                 errno = errsav;
929         }
930
931         return ret;
932 }
933
934 #endif /* USE_BSD_SETGROUPS */
935
936 /**************************************************************************
937  Wrapper for getgroups. Deals with broken (int) case.
938 ****************************************************************************/
939
940 int sys_getgroups(int setlen, gid_t *gidset)
941 {
942 #if defined(HAVE_BROKEN_GETGROUPS)
943         return sys_broken_getgroups(setlen, gidset);
944 #else
945         return getgroups(setlen, gidset);
946 #endif
947 }
948
949 /**************************************************************************
950  Wrapper for setgroups. Deals with broken (int) case and BSD case.
951 ****************************************************************************/
952
953 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
954 {
955 #if !defined(HAVE_SETGROUPS)
956         errno = ENOSYS;
957         return -1;
958 #endif /* HAVE_SETGROUPS */
959
960 #if defined(USE_BSD_SETGROUPS)
961         return sys_bsd_setgroups(primary_gid, setlen, gidset);
962 #elif defined(HAVE_BROKEN_GETGROUPS)
963         return sys_broken_setgroups(setlen, gidset);
964 #else
965         return samba_setgroups(setlen, gidset);
966 #endif
967 }
968
969 /**************************************************************************
970  Extract a command into an arg list.
971 ****************************************************************************/
972
973 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
974 {
975         char *trunc_cmd;
976         char *saveptr;
977         char *ptr;
978         int argcl;
979         char **argl = NULL;
980         int i;
981
982         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
983                 DEBUG(0, ("talloc failed\n"));
984                 goto nomem;
985         }
986
987         if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
988                 TALLOC_FREE(trunc_cmd);
989                 errno = EINVAL;
990                 return NULL;
991         }
992
993         /*
994          * Count the args.
995          */
996
997         for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
998                 argcl++;
999
1000         TALLOC_FREE(trunc_cmd);
1001
1002         if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
1003                 goto nomem;
1004         }
1005
1006         /*
1007          * Now do the extraction.
1008          */
1009
1010         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1011                 goto nomem;
1012         }
1013
1014         ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1015         i = 0;
1016
1017         if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1018                 goto nomem;
1019         }
1020
1021         while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1022
1023                 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1024                         goto nomem;
1025                 }
1026         }
1027
1028         argl[i++] = NULL;
1029         TALLOC_FREE(trunc_cmd);
1030         return argl;
1031
1032  nomem:
1033         DEBUG(0, ("talloc failed\n"));
1034         TALLOC_FREE(trunc_cmd);
1035         TALLOC_FREE(argl);
1036         errno = ENOMEM;
1037         return NULL;
1038 }
1039
1040 /**************************************************************************
1041  Wrapper for popen. Safer as it doesn't search a path.
1042  Modified from the glibc sources.
1043  modified by tridge to return a file descriptor. We must kick our FILE* habit
1044 ****************************************************************************/
1045
1046 typedef struct _popen_list
1047 {
1048         int fd;
1049         pid_t child_pid;
1050         struct _popen_list *next;
1051 } popen_list;
1052
1053 static popen_list *popen_chain;
1054
1055 int sys_popen(const char *command)
1056 {
1057         int parent_end, child_end;
1058         int pipe_fds[2];
1059         popen_list *entry = NULL;
1060         char **argl = NULL;
1061         int ret;
1062
1063         if (!*command) {
1064                 errno = EINVAL;
1065                 return -1;
1066         }
1067
1068         ret = pipe(pipe_fds);
1069         if (ret < 0) {
1070                 DEBUG(0, ("sys_popen: error opening pipe: %s\n",
1071                           strerror(errno)));
1072                 return -1;
1073         }
1074
1075         parent_end = pipe_fds[0];
1076         child_end = pipe_fds[1];
1077
1078         entry = SMB_MALLOC_P(popen_list);
1079         if (entry == NULL) {
1080                 DEBUG(0, ("sys_popen: malloc failed\n"));
1081                 goto err_exit;
1082         }
1083
1084         ZERO_STRUCTP(entry);
1085
1086         /*
1087          * Extract the command and args into a NULL terminated array.
1088          */
1089
1090         argl = extract_args(NULL, command);
1091         if (argl == NULL) {
1092                 DEBUG(0, ("sys_popen: extract_args() failed: %s\n", strerror(errno)));
1093                 goto err_exit;
1094         }
1095
1096         entry->child_pid = fork();
1097
1098         if (entry->child_pid == -1) {
1099                 DEBUG(0, ("sys_popen: fork failed: %s\n", strerror(errno)));
1100                 goto err_exit;
1101         }
1102
1103         if (entry->child_pid == 0) {
1104
1105                 /*
1106                  * Child !
1107                  */
1108
1109                 int child_std_end = STDOUT_FILENO;
1110                 popen_list *p;
1111
1112                 close(parent_end);
1113                 if (child_end != child_std_end) {
1114                         dup2 (child_end, child_std_end);
1115                         close (child_end);
1116                 }
1117
1118                 /*
1119                  * POSIX.2:  "popen() shall ensure that any streams from previous
1120                  * popen() calls that remain open in the parent process are closed
1121                  * in the new child process."
1122                  */
1123
1124                 for (p = popen_chain; p; p = p->next)
1125                         close(p->fd);
1126
1127                 ret = execv(argl[0], argl);
1128                 if (ret == -1) {
1129                         DEBUG(0, ("sys_popen: ERROR executing command "
1130                                   "'%s': %s\n", command, strerror(errno)));
1131                 }
1132                 _exit (127);
1133         }
1134
1135         /*
1136          * Parent.
1137          */
1138
1139         close (child_end);
1140         TALLOC_FREE(argl);
1141
1142         /* Link into popen_chain. */
1143         entry->next = popen_chain;
1144         popen_chain = entry;
1145         entry->fd = parent_end;
1146
1147         return entry->fd;
1148
1149 err_exit:
1150
1151         SAFE_FREE(entry);
1152         TALLOC_FREE(argl);
1153         close(pipe_fds[0]);
1154         close(pipe_fds[1]);
1155         return -1;
1156 }
1157
1158 /**************************************************************************
1159  Wrapper for pclose. Modified from the glibc sources.
1160 ****************************************************************************/
1161
1162 int sys_pclose(int fd)
1163 {
1164         int wstatus;
1165         popen_list **ptr = &popen_chain;
1166         popen_list *entry = NULL;
1167         pid_t wait_pid;
1168         int status = -1;
1169
1170         /* Unlink from popen_chain. */
1171         for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1172                 if ((*ptr)->fd == fd) {
1173                         entry = *ptr;
1174                         *ptr = (*ptr)->next;
1175                         status = 0;
1176                         break;
1177                 }
1178         }
1179
1180         if (status < 0 || close(entry->fd) < 0)
1181                 return -1;
1182
1183         /*
1184          * As Samba is catching and eating child process
1185          * exits we don't really care about the child exit
1186          * code, a -1 with errno = ECHILD will do fine for us.
1187          */
1188
1189         do {
1190                 wait_pid = waitpid (entry->child_pid, &wstatus, 0);
1191         } while (wait_pid == -1 && errno == EINTR);
1192
1193         SAFE_FREE(entry);
1194
1195         if (wait_pid == -1)
1196                 return -1;
1197         return wstatus;
1198 }
1199
1200 /****************************************************************************
1201  Return the major devicenumber for UNIX extensions.
1202 ****************************************************************************/
1203
1204 uint32_t unix_dev_major(SMB_DEV_T dev)
1205 {
1206 #if defined(HAVE_DEVICE_MAJOR_FN)
1207         return (uint32_t)major(dev);
1208 #else
1209         return (uint32_t)(dev >> 8);
1210 #endif
1211 }
1212
1213 /****************************************************************************
1214  Return the minor devicenumber for UNIX extensions.
1215 ****************************************************************************/
1216
1217 uint32_t unix_dev_minor(SMB_DEV_T dev)
1218 {
1219 #if defined(HAVE_DEVICE_MINOR_FN)
1220         return (uint32_t)minor(dev);
1221 #else
1222         return (uint32_t)(dev & 0xff);
1223 #endif
1224 }
1225
1226 /**************************************************************************
1227  Wrapper for realpath.
1228 ****************************************************************************/
1229
1230 char *sys_realpath(const char *path)
1231 {
1232         char *result;
1233
1234 #ifdef REALPATH_TAKES_NULL
1235         result = realpath(path, NULL);
1236 #else
1237         result = SMB_MALLOC_ARRAY(char, PATH_MAX + 1);
1238         if (result) {
1239                 char *resolved_path = realpath(path, result);
1240                 if (!resolved_path) {
1241                         SAFE_FREE(result);
1242                 } else {
1243                         /* SMB_ASSERT(result == resolved_path) ? */
1244                         result = resolved_path;
1245                 }
1246         }
1247 #endif
1248         return result;
1249 }
1250
1251 #if 0
1252 /*******************************************************************
1253  Return the number of CPUs.
1254 ********************************************************************/
1255
1256 int sys_get_number_of_cores(void)
1257 {
1258         int ret = -1;
1259
1260 #if defined(HAVE_SYSCONF)
1261 #if defined(_SC_NPROCESSORS_ONLN)
1262         ret = (int)sysconf(_SC_NPROCESSORS_ONLN);
1263 #endif
1264 #if defined(_SC_NPROCESSORS_CONF)
1265         if (ret < 1) {
1266                 ret = (int)sysconf(_SC_NPROCESSORS_CONF);
1267         }
1268 #endif
1269 #elif defined(HAVE_SYSCTL) && defined(CTL_HW)
1270         int name[2];
1271         unsigned int len = sizeof(ret);
1272
1273         name[0] = CTL_HW;
1274 #if defined(HW_AVAILCPU)
1275         name[1] = HW_AVAILCPU;
1276
1277         if (sysctl(name, 2, &ret, &len, NULL, 0) == -1) {
1278                 ret = -1;
1279         }
1280 #endif
1281 #if defined(HW_NCPU)
1282         if(ret < 1) {
1283                 name[0] = CTL_HW;
1284                 name[1] = HW_NCPU;
1285                 if (sysctl(nm, 2, &count, &len, NULL, 0) == -1) {
1286                         ret = -1;
1287                 }
1288         }
1289 #endif
1290 #endif
1291         if (ret < 1) {
1292                 ret = 1;
1293         }
1294         return ret;
1295 }
1296 #endif