2 Unix SMB/CIFS implementation.
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
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.
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.
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/>.
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"
30 #ifdef HAVE_SYS_SYSCTL_H
31 #include <sys/sysctl.h>
34 #ifdef HAVE_SYS_PRCTL_H
35 #include <sys/prctl.h>
38 #if defined(HAVE_AIO_H)
43 The idea is that this file will eventually have wrappers around all
44 important system calls in samba. The aims are:
46 - to enable easier porting by putting OS dependent stuff in here
48 - to allow for hooks into other "pseudo-filesystems"
50 - to allow easier integration of things like the japanese extensions
52 - to support the philosophy of Samba to expose the features of
53 the OS within the SMB model. In general whatever file/printer/variable
54 expansions/etc make sense to the OS should be acceptable to Samba.
59 /*******************************************************************
60 A read wrapper that will deal with EINTR.
61 ********************************************************************/
63 ssize_t sys_read(int fd, void *buf, size_t count)
68 ret = read(fd, buf, count);
69 #if defined(EWOULDBLOCK)
70 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
72 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
77 /*******************************************************************
78 A write wrapper that will deal with EINTR.
79 ********************************************************************/
81 ssize_t sys_write(int fd, const void *buf, size_t count)
86 ret = write(fd, buf, count);
87 #if defined(EWOULDBLOCK)
88 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
90 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
95 /*******************************************************************
96 A writev wrapper that will deal with EINTR.
97 ********************************************************************/
99 ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt)
104 /* Try to confuse write_data_iov a bit */
105 if ((random() % 5) == 0) {
106 return sys_write(fd, iov[0].iov_base, iov[0].iov_len);
108 if (iov[0].iov_len > 1) {
109 return sys_write(fd, iov[0].iov_base,
110 (random() % (iov[0].iov_len-1)) + 1);
115 ret = writev(fd, iov, iovcnt);
116 #if defined(EWOULDBLOCK)
117 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
119 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
124 /*******************************************************************
125 A pread wrapper that will deal with EINTR
126 ********************************************************************/
128 #if defined(HAVE_PREAD)
129 ssize_t sys_pread(int fd, void *buf, size_t count, off_t off)
134 ret = pread(fd, buf, count, off);
135 } while (ret == -1 && errno == EINTR);
140 /*******************************************************************
141 A write wrapper that will deal with EINTR
142 ********************************************************************/
144 #if defined(HAVE_PWRITE)
145 ssize_t sys_pwrite(int fd, const void *buf, size_t count, off_t off)
150 ret = pwrite(fd, buf, count, off);
151 } while (ret == -1 && errno == EINTR);
156 /*******************************************************************
157 A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
158 ********************************************************************/
160 ssize_t sys_send(int s, const void *msg, size_t len, int flags)
165 ret = send(s, msg, len, flags);
166 #if defined(EWOULDBLOCK)
167 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
169 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
174 /*******************************************************************
175 A recvfrom wrapper that will deal with EINTR.
176 ********************************************************************/
178 ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
183 ret = recvfrom(s, buf, len, flags, from, fromlen);
184 #if defined(EWOULDBLOCK)
185 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
187 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
192 /*******************************************************************
193 A fcntl wrapper that will deal with EINTR.
194 ********************************************************************/
196 int sys_fcntl_ptr(int fd, int cmd, void *arg)
201 ret = fcntl(fd, cmd, arg);
202 } while (ret == -1 && errno == EINTR);
206 /*******************************************************************
207 A fcntl wrapper that will deal with EINTR.
208 ********************************************************************/
210 int sys_fcntl_long(int fd, int cmd, long arg)
215 ret = fcntl(fd, cmd, arg);
216 } while (ret == -1 && errno == EINTR);
220 /****************************************************************************
221 Get/Set all the possible time fields from a stat struct as a timespec.
222 ****************************************************************************/
224 static struct timespec get_atimespec(const struct stat *pst)
226 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
229 /* Old system - no ns timestamp. */
230 ret.tv_sec = pst->st_atime;
234 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
236 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
238 ret.tv_sec = pst->st_atime;
239 ret.tv_nsec = pst->st_atimensec;
241 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
243 ret.tv_sec = pst->st_atime;
244 ret.tv_nsec = pst->st_atime_n;
246 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
248 ret.tv_sec = pst->st_atime;
249 ret.tv_nsec = pst->st_uatime * 1000;
251 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
252 return pst->st_atimespec;
254 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
259 static struct timespec get_mtimespec(const struct stat *pst)
261 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
264 /* Old system - no ns timestamp. */
265 ret.tv_sec = pst->st_mtime;
269 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
271 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
273 ret.tv_sec = pst->st_mtime;
274 ret.tv_nsec = pst->st_mtimensec;
276 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
278 ret.tv_sec = pst->st_mtime;
279 ret.tv_nsec = pst->st_mtime_n;
281 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
283 ret.tv_sec = pst->st_mtime;
284 ret.tv_nsec = pst->st_umtime * 1000;
286 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
287 return pst->st_mtimespec;
289 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
294 static struct timespec get_ctimespec(const struct stat *pst)
296 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
299 /* Old system - no ns timestamp. */
300 ret.tv_sec = pst->st_ctime;
304 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
306 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
308 ret.tv_sec = pst->st_ctime;
309 ret.tv_nsec = pst->st_ctimensec;
311 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
313 ret.tv_sec = pst->st_ctime;
314 ret.tv_nsec = pst->st_ctime_n;
316 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
318 ret.tv_sec = pst->st_ctime;
319 ret.tv_nsec = pst->st_uctime * 1000;
321 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
322 return pst->st_ctimespec;
324 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
329 /****************************************************************************
330 Return the best approximation to a 'create time' under UNIX from a stat
332 ****************************************************************************/
334 static struct timespec calc_create_time_stat(const struct stat *st)
336 struct timespec ret, ret1;
337 struct timespec c_time = get_ctimespec(st);
338 struct timespec m_time = get_mtimespec(st);
339 struct timespec a_time = get_atimespec(st);
341 ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
342 ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
344 if(!null_timespec(ret1)) {
349 * One of ctime, mtime or atime was zero (probably atime).
350 * Just return MIN(ctime, mtime).
355 /****************************************************************************
356 Return the best approximation to a 'create time' under UNIX from a stat_ex
358 ****************************************************************************/
360 static struct timespec calc_create_time_stat_ex(const struct stat_ex *st)
362 struct timespec ret, ret1;
363 struct timespec c_time = st->st_ex_ctime;
364 struct timespec m_time = st->st_ex_mtime;
365 struct timespec a_time = st->st_ex_atime;
367 ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
368 ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
370 if(!null_timespec(ret1)) {
375 * One of ctime, mtime or atime was zero (probably atime).
376 * Just return MIN(ctime, mtime).
381 /****************************************************************************
382 Return the 'create time' from a stat struct if it exists (birthtime) or else
383 use the best approximation.
384 ****************************************************************************/
386 static void make_create_timespec(const struct stat *pst, struct stat_ex *dst,
387 bool fake_dir_create_times)
389 if (S_ISDIR(pst->st_mode) && fake_dir_create_times) {
390 dst->st_ex_btime.tv_sec = 315493200L; /* 1/1/1980 */
391 dst->st_ex_btime.tv_nsec = 0;
394 dst->st_ex_calculated_birthtime = false;
396 #if defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
397 dst->st_ex_btime = pst->st_birthtimespec;
398 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC)
399 dst->st_ex_btime.tv_sec = pst->st_birthtime;
400 dst->st_ex_btime.tv_nsec = pst->st_birthtimenspec;
401 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIME)
402 dst->st_ex_btime.tv_sec = pst->st_birthtime;
403 dst->st_ex_btime.tv_nsec = 0;
405 dst->st_ex_btime = calc_create_time_stat(pst);
406 dst->st_ex_calculated_birthtime = true;
409 /* Deal with systems that don't initialize birthtime correctly.
410 * Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
412 if (null_timespec(dst->st_ex_btime)) {
413 dst->st_ex_btime = calc_create_time_stat(pst);
414 dst->st_ex_calculated_birthtime = true;
418 /****************************************************************************
419 If we update a timestamp in a stat_ex struct we may have to recalculate
420 the birthtime. For now only implement this for write time, but we may
421 also need to do it for atime and ctime. JRA.
422 ****************************************************************************/
424 void update_stat_ex_mtime(struct stat_ex *dst,
425 struct timespec write_ts)
427 dst->st_ex_mtime = write_ts;
429 /* We may have to recalculate btime. */
430 if (dst->st_ex_calculated_birthtime) {
431 dst->st_ex_btime = calc_create_time_stat_ex(dst);
435 void update_stat_ex_create_time(struct stat_ex *dst,
436 struct timespec create_time)
438 dst->st_ex_btime = create_time;
439 dst->st_ex_calculated_birthtime = false;
442 void init_stat_ex_from_stat (struct stat_ex *dst,
443 const struct stat *src,
444 bool fake_dir_create_times)
446 dst->st_ex_dev = src->st_dev;
447 dst->st_ex_ino = src->st_ino;
448 dst->st_ex_mode = src->st_mode;
449 dst->st_ex_nlink = src->st_nlink;
450 dst->st_ex_uid = src->st_uid;
451 dst->st_ex_gid = src->st_gid;
452 dst->st_ex_rdev = src->st_rdev;
453 dst->st_ex_size = src->st_size;
454 dst->st_ex_atime = get_atimespec(src);
455 dst->st_ex_mtime = get_mtimespec(src);
456 dst->st_ex_ctime = get_ctimespec(src);
457 make_create_timespec(src, dst, fake_dir_create_times);
458 #ifdef HAVE_STAT_ST_BLKSIZE
459 dst->st_ex_blksize = src->st_blksize;
461 dst->st_ex_blksize = STAT_ST_BLOCKSIZE;
464 #ifdef HAVE_STAT_ST_BLOCKS
465 dst->st_ex_blocks = src->st_blocks;
467 dst->st_ex_blocks = src->st_size / dst->st_ex_blksize + 1;
470 #ifdef HAVE_STAT_ST_FLAGS
471 dst->st_ex_flags = src->st_flags;
473 dst->st_ex_flags = 0;
477 /*******************************************************************
479 ********************************************************************/
481 int sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf,
482 bool fake_dir_create_times)
486 ret = stat(fname, &statbuf);
488 /* we always want directories to appear zero size */
489 if (S_ISDIR(statbuf.st_mode)) {
492 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
497 /*******************************************************************
499 ********************************************************************/
501 int sys_fstat(int fd, SMB_STRUCT_STAT *sbuf, bool fake_dir_create_times)
505 ret = fstat(fd, &statbuf);
507 /* we always want directories to appear zero size */
508 if (S_ISDIR(statbuf.st_mode)) {
511 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
516 /*******************************************************************
518 ********************************************************************/
520 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
521 bool fake_dir_create_times)
525 ret = lstat(fname, &statbuf);
527 /* we always want directories to appear zero size */
528 if (S_ISDIR(statbuf.st_mode)) {
531 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
536 /*******************************************************************
537 An posix_fallocate() wrapper.
538 ********************************************************************/
539 int sys_posix_fallocate(int fd, off_t offset, off_t len)
541 #if defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
542 return posix_fallocate(fd, offset, len);
543 #elif defined(F_RESVSP64)
544 /* this handles XFS on IRIX */
546 off_t new_len = offset + len;
550 /* unlikely to get a too large file on a 64bit system but ... */
554 fl.l_whence = SEEK_SET;
558 ret=fcntl(fd, F_RESVSP64, &fl);
563 /* Make sure the file gets enlarged after we allocated space: */
565 if (new_len > sbuf.st_size)
566 ftruncate64(fd, new_len);
573 /*******************************************************************
574 An fallocate() function that matches the semantics of the Linux one.
575 ********************************************************************/
577 #ifdef HAVE_LINUX_FALLOC_H
578 #include <linux/falloc.h>
581 int sys_fallocate(int fd, enum vfs_fallocate_mode mode, off_t offset, off_t len)
583 #if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE)
586 case VFS_FALLOCATE_EXTEND_SIZE:
589 case VFS_FALLOCATE_KEEP_SIZE:
590 lmode = FALLOC_FL_KEEP_SIZE;
596 #if defined(HAVE_LINUX_FALLOCATE)
597 return fallocate(fd, lmode, offset, len);
600 /* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
606 #if HAVE_KERNEL_SHARE_MODES
608 #define LOCK_MAND 32 /* This is a mandatory flock */
609 #define LOCK_READ 64 /* ... Which allows concurrent read operations */
610 #define LOCK_WRITE 128 /* ... Which allows concurrent write operations */
611 #define LOCK_RW 192 /* ... Which allows concurrent read & write ops */
615 /*******************************************************************
616 A flock() wrapper that will perform the kernel flock.
617 ********************************************************************/
619 void kernel_flock(int fd, uint32 share_mode, uint32 access_mask)
621 #if HAVE_KERNEL_SHARE_MODES
623 if (share_mode == FILE_SHARE_WRITE) {
624 kernel_mode = LOCK_MAND|LOCK_WRITE;
625 } else if (share_mode == FILE_SHARE_READ) {
626 kernel_mode = LOCK_MAND|LOCK_READ;
627 } else if (share_mode == FILE_SHARE_NONE) {
628 kernel_mode = LOCK_MAND;
631 flock(fd, kernel_mode);
639 /*******************************************************************
640 An fdopendir wrapper.
641 Ugly hack - we need dirfd for this to work correctly in the
643 ********************************************************************/
645 DIR *sys_fdopendir(int fd)
647 #if defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD)
648 return fdopendir(fd);
655 /*******************************************************************
657 ********************************************************************/
659 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
661 #if defined(HAVE_MKNOD)
662 return mknod(path, mode, dev);
664 /* No mknod system call. */
670 /*******************************************************************
671 The wait() calls vary between systems
672 ********************************************************************/
674 int sys_waitpid(pid_t pid,int *status,int options)
677 return waitpid(pid,status,options);
678 #else /* HAVE_WAITPID */
679 return wait4(pid, status, options, NULL);
680 #endif /* HAVE_WAITPID */
683 /*******************************************************************
684 System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
685 on error (malloc fail usually).
686 ********************************************************************/
688 char *sys_getwd(void)
690 #ifdef GETCWD_TAKES_NULL
691 return getcwd(NULL, 0);
693 char *wd = NULL, *s = NULL;
694 size_t allocated = PATH_MAX;
697 s = SMB_REALLOC_ARRAY(s, char, allocated);
701 wd = getcwd(s, allocated);
705 if (errno != ERANGE) {
710 if (allocated < PATH_MAX) {
717 char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
725 #if defined(HAVE_POSIX_CAPABILITIES)
727 /**************************************************************************
728 Try and abstract process capabilities (for systems that have them).
729 ****************************************************************************/
731 /* Set the POSIX capabilities needed for the given purpose into the effective
732 * capability set of the current process. Make sure they are always removed
733 * from the inheritable set, because there is no circumstance in which our
734 * children should inherit our elevated privileges.
736 static bool set_process_capability(enum smbd_capability capability,
739 cap_value_t cap_vals[2] = {0};
740 int num_cap_vals = 0;
744 #if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
745 /* On Linux, make sure that any capabilities we grab are sticky
746 * across UID changes. We expect that this would allow us to keep both
747 * the effective and permitted capability sets, but as of circa 2.6.16,
748 * only the permitted set is kept. It is a bug (which we work around)
749 * that the effective set is lost, but we still require the effective
752 if (!prctl(PR_GET_KEEPCAPS)) {
753 prctl(PR_SET_KEEPCAPS, 1);
757 cap = cap_get_proc();
759 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
764 switch (capability) {
765 case KERNEL_OPLOCK_CAPABILITY:
766 #ifdef CAP_NETWORK_MGT
767 /* IRIX has CAP_NETWORK_MGT for oplocks. */
768 cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
771 case DMAPI_ACCESS_CAPABILITY:
772 #ifdef CAP_DEVICE_MGT
773 /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
774 cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
776 /* Linux has CAP_MKNOD for DMAPI access. */
777 cap_vals[num_cap_vals++] = CAP_MKNOD;
780 case LEASE_CAPABILITY:
782 cap_vals[num_cap_vals++] = CAP_LEASE;
787 SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
789 if (num_cap_vals == 0) {
794 cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
795 enable ? CAP_SET : CAP_CLEAR);
797 /* We never want to pass capabilities down to our children, so make
798 * sure they are not inherited.
800 cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
802 if (cap_set_proc(cap) == -1) {
803 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
813 #endif /* HAVE_POSIX_CAPABILITIES */
815 /****************************************************************************
816 Gain the oplock capability from the kernel if possible.
817 ****************************************************************************/
819 void set_effective_capability(enum smbd_capability capability)
821 #if defined(HAVE_POSIX_CAPABILITIES)
822 set_process_capability(capability, True);
823 #endif /* HAVE_POSIX_CAPABILITIES */
826 void drop_effective_capability(enum smbd_capability capability)
828 #if defined(HAVE_POSIX_CAPABILITIES)
829 set_process_capability(capability, False);
830 #endif /* HAVE_POSIX_CAPABILITIES */
833 /**************************************************************************
834 Wrapper for random().
835 ****************************************************************************/
837 long sys_random(void)
839 #if defined(HAVE_RANDOM)
840 return (long)random();
841 #elif defined(HAVE_RAND)
844 DEBUG(0,("Error - no random function available !\n"));
849 /**************************************************************************
850 Wrapper for srandom().
851 ****************************************************************************/
853 void sys_srandom(unsigned int seed)
855 #if defined(HAVE_SRANDOM)
857 #elif defined(HAVE_SRAND)
860 DEBUG(0,("Error - no srandom function available !\n"));
866 #define NGROUPS_MAX 32 /* Guess... */
869 /**************************************************************************
870 Returns equivalent to NGROUPS_MAX - using sysconf if needed.
871 ****************************************************************************/
875 #if defined(SYSCONF_SC_NGROUPS_MAX)
876 int ret = sysconf(_SC_NGROUPS_MAX);
877 return (ret == -1) ? NGROUPS_MAX : ret;
883 /**************************************************************************
884 Wrap setgroups and getgroups for systems that declare getgroups() as
885 returning an array of gid_t, but actuall return an array of int.
886 ****************************************************************************/
888 #if defined(HAVE_BROKEN_GETGROUPS)
890 #ifdef HAVE_BROKEN_GETGROUPS
896 static int sys_broken_getgroups(int setlen, gid_t *gidset)
903 return getgroups(setlen, &gid);
907 * Broken case. We need to allocate a
908 * GID_T array of size setlen.
917 setlen = groups_max();
919 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
920 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
924 if((ngroups = getgroups(setlen, group_list)) < 0) {
925 int saved_errno = errno;
926 SAFE_FREE(group_list);
931 for(i = 0; i < ngroups; i++)
932 gidset[i] = (gid_t)group_list[i];
934 SAFE_FREE(group_list);
938 static int sys_broken_setgroups(int setlen, gid_t *gidset)
946 if (setlen < 0 || setlen > groups_max()) {
952 * Broken case. We need to allocate a
953 * GID_T array of size setlen.
956 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
957 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
961 for(i = 0; i < setlen; i++)
962 group_list[i] = (GID_T) gidset[i];
964 if(samba_setgroups(setlen, group_list) != 0) {
965 int saved_errno = errno;
966 SAFE_FREE(group_list);
971 SAFE_FREE(group_list);
975 #endif /* HAVE_BROKEN_GETGROUPS */
977 /* This is a list of systems that require the first GID passed to setgroups(2)
978 * to be the effective GID. If your system is one of these, add it here.
980 #if defined (FREEBSD) || defined (DARWINOS)
981 #define USE_BSD_SETGROUPS
984 #if defined(USE_BSD_SETGROUPS)
985 /* Depending on the particular BSD implementation, the first GID that is
986 * passed to setgroups(2) will either be ignored or will set the credential's
987 * effective GID. In either case, the right thing to do is to guarantee that
988 * gidset[0] is the effective GID.
990 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
992 gid_t *new_gidset = NULL;
996 /* setgroups(2) will fail with EINVAL if we pass too many groups. */
999 /* No group list, just make sure we are setting the efective GID. */
1001 return samba_setgroups(1, &primary_gid);
1004 /* If the primary gid is not the first array element, grow the array
1005 * and insert it at the front.
1007 if (gidset[0] != primary_gid) {
1008 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
1009 if (new_gidset == NULL) {
1013 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
1014 new_gidset[0] = primary_gid;
1019 DEBUG(3, ("forced to truncate group list from %d to %d\n",
1024 #if defined(HAVE_BROKEN_GETGROUPS)
1025 ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
1027 ret = samba_setgroups(setlen, new_gidset ? new_gidset : gidset);
1032 SAFE_FREE(new_gidset);
1039 #endif /* USE_BSD_SETGROUPS */
1041 /**************************************************************************
1042 Wrapper for getgroups. Deals with broken (int) case.
1043 ****************************************************************************/
1045 int sys_getgroups(int setlen, gid_t *gidset)
1047 #if defined(HAVE_BROKEN_GETGROUPS)
1048 return sys_broken_getgroups(setlen, gidset);
1050 return getgroups(setlen, gidset);
1054 /**************************************************************************
1055 Wrapper for setgroups. Deals with broken (int) case and BSD case.
1056 ****************************************************************************/
1058 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
1060 #if !defined(HAVE_SETGROUPS)
1063 #endif /* HAVE_SETGROUPS */
1065 #if defined(USE_BSD_SETGROUPS)
1066 return sys_bsd_setgroups(primary_gid, setlen, gidset);
1067 #elif defined(HAVE_BROKEN_GETGROUPS)
1068 return sys_broken_setgroups(setlen, gidset);
1070 return samba_setgroups(setlen, gidset);
1074 /**************************************************************************
1075 Extract a command into an arg list.
1076 ****************************************************************************/
1078 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
1087 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1088 DEBUG(0, ("talloc failed\n"));
1092 if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1093 TALLOC_FREE(trunc_cmd);
1102 for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1105 TALLOC_FREE(trunc_cmd);
1107 if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
1112 * Now do the extraction.
1115 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1119 ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1122 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1126 while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1128 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1134 TALLOC_FREE(trunc_cmd);
1138 DEBUG(0, ("talloc failed\n"));
1139 TALLOC_FREE(trunc_cmd);
1145 /**************************************************************************
1146 Wrapper for popen. Safer as it doesn't search a path.
1147 Modified from the glibc sources.
1148 modified by tridge to return a file descriptor. We must kick our FILE* habit
1149 ****************************************************************************/
1151 typedef struct _popen_list
1155 struct _popen_list *next;
1158 static popen_list *popen_chain;
1160 int sys_popen(const char *command)
1162 int parent_end, child_end;
1164 popen_list *entry = NULL;
1167 if (pipe(pipe_fds) < 0)
1170 parent_end = pipe_fds[0];
1171 child_end = pipe_fds[1];
1178 if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1181 ZERO_STRUCTP(entry);
1184 * Extract the command and args into a NULL terminated array.
1187 if(!(argl = extract_args(NULL, command)))
1190 entry->child_pid = fork();
1192 if (entry->child_pid == -1) {
1196 if (entry->child_pid == 0) {
1202 int child_std_end = STDOUT_FILENO;
1206 if (child_end != child_std_end) {
1207 dup2 (child_end, child_std_end);
1212 * POSIX.2: "popen() shall ensure that any streams from previous
1213 * popen() calls that remain open in the parent process are closed
1214 * in the new child process."
1217 for (p = popen_chain; p; p = p->next)
1220 execv(argl[0], argl);
1231 /* Link into popen_chain. */
1232 entry->next = popen_chain;
1233 popen_chain = entry;
1234 entry->fd = parent_end;
1247 /**************************************************************************
1248 Wrapper for pclose. Modified from the glibc sources.
1249 ****************************************************************************/
1251 int sys_pclose(int fd)
1254 popen_list **ptr = &popen_chain;
1255 popen_list *entry = NULL;
1259 /* Unlink from popen_chain. */
1260 for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1261 if ((*ptr)->fd == fd) {
1263 *ptr = (*ptr)->next;
1269 if (status < 0 || close(entry->fd) < 0)
1273 * As Samba is catching and eating child process
1274 * exits we don't really care about the child exit
1275 * code, a -1 with errno = ECHILD will do fine for us.
1279 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1280 } while (wait_pid == -1 && errno == EINTR);
1289 /**************************************************************************
1290 Wrapper for Admin Logs.
1291 ****************************************************************************/
1293 void sys_adminlog(int priority, const char *format_str, ...)
1297 char *msgbuf = NULL;
1299 va_start( ap, format_str );
1300 ret = vasprintf( &msgbuf, format_str, ap );
1306 #if defined(HAVE_SYSLOG)
1307 syslog( priority, "%s", msgbuf );
1309 DEBUG(0,("%s", msgbuf ));
1314 /****************************************************************************
1315 Return the major devicenumber for UNIX extensions.
1316 ****************************************************************************/
1318 uint32 unix_dev_major(SMB_DEV_T dev)
1320 #if defined(HAVE_DEVICE_MAJOR_FN)
1321 return (uint32)major(dev);
1323 return (uint32)(dev >> 8);
1327 /****************************************************************************
1328 Return the minor devicenumber for UNIX extensions.
1329 ****************************************************************************/
1331 uint32 unix_dev_minor(SMB_DEV_T dev)
1333 #if defined(HAVE_DEVICE_MINOR_FN)
1334 return (uint32)minor(dev);
1336 return (uint32)(dev & 0xff);
1341 /*******************************************************************
1342 Return the number of CPUs.
1343 ********************************************************************/
1345 int sys_get_number_of_cores(void)
1349 #if defined(HAVE_SYSCONF)
1350 #if defined(_SC_NPROCESSORS_ONLN)
1351 ret = (int)sysconf(_SC_NPROCESSORS_ONLN);
1353 #if defined(_SC_NPROCESSORS_CONF)
1355 ret = (int)sysconf(_SC_NPROCESSORS_CONF);
1358 #elif defined(HAVE_SYSCTL) && defined(CTL_HW)
1360 unsigned int len = sizeof(ret);
1363 #if defined(HW_AVAILCPU)
1364 name[1] = HW_AVAILCPU;
1366 if (sysctl(name, 2, &ret, &len, NULL, 0) == -1) {
1370 #if defined(HW_NCPU)
1374 if (sysctl(nm, 2, &count, &len, NULL, 0) == -1) {
1387 #if defined(HAVE_AIO)
1389 /*******************************************************************
1390 An aio_read wrapper.
1391 ********************************************************************/
1393 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
1395 #if defined(HAVE_AIO_READ)
1396 return aio_read(aiocb);
1403 /*******************************************************************
1404 An aio_write wrapper.
1405 ********************************************************************/
1407 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
1409 #if defined(HAVE_AIO_WRITE)
1410 return aio_write(aiocb);
1417 /*******************************************************************
1418 An aio_return wrapper.
1419 ********************************************************************/
1421 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
1423 #if defined(HAVE_AIO_RETURN)
1424 return aio_return(aiocb);
1431 /*******************************************************************
1432 An aio_cancel wrapper.
1433 ********************************************************************/
1435 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
1437 #if defined(HAVE_AIO_CANCEL)
1438 return aio_cancel(fd, aiocb);
1445 /*******************************************************************
1446 An aio_error wrapper.
1447 ********************************************************************/
1449 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
1451 #if defined(HAVE_AIO_ERROR)
1452 return aio_error(aiocb);
1459 /*******************************************************************
1460 An aio_fsync wrapper.
1461 ********************************************************************/
1463 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
1465 #if defined(HAVE_AIO_FSYNC)
1466 return aio_fsync(op, aiocb);
1473 /*******************************************************************
1474 An aio_fsync wrapper.
1475 ********************************************************************/
1477 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
1479 #if defined(HAVE_AIO_FSYNC)
1480 return aio_suspend(cblist, n, timeout);
1486 #else /* !HAVE_AIO */
1488 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
1494 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
1500 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
1506 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
1512 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
1518 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
1524 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
1529 #endif /* HAVE_AIO */