source: vendor/current/source3/lib/system.c

Last change on this file was 988, checked in by Silvan Scherrer, 8 years ago

Samba Server: update vendor to version 4.4.3
File size: 31.7 KB
Line 
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/*******************************************************************
54A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
55********************************************************************/
56
57ssize_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/*******************************************************************
69A recvfrom wrapper that will deal with EINTR.
70NB. As used with non-blocking sockets, return on EAGAIN/EWOULDBLOCK
71********************************************************************/
72
73ssize_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/*******************************************************************
84A fcntl wrapper that will deal with EINTR.
85********************************************************************/
86
87int 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/*******************************************************************
98A fcntl wrapper that will deal with EINTR.
99********************************************************************/
100
101int 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
115static 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
153static 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
191static 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
234static 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
260static 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
286static 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
324void 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
335void 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
342void 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/*******************************************************************
378A stat() wrapper.
379********************************************************************/
380
381int 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
401int 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
420int 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********************************************************************/
439int 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
481int 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
525void 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
549DIR *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
563int 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/*******************************************************************
575The wait() calls vary between systems
576********************************************************************/
577
578int sys_waitpid(pid_t pid,int *status,int options)
579{
580#ifdef HAVE_WAITPID
581 return waitpid(pid,status,options);
582#else /* HAVE_WAITPID */
583 return wait4(pid, status, options, NULL);
584#endif /* HAVE_WAITPID */
585}
586
587/*******************************************************************
588 System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
589 on error (malloc fail usually).
590********************************************************************/
591
592char *sys_getwd(void)
593{
594#ifdef GETCWD_TAKES_NULL
595 return getcwd(NULL, 0);
596#elif HAVE_GETCWD
597 char *wd = NULL, *s = NULL;
598 size_t allocated = PATH_MAX;
599
600 while (1) {
601 s = SMB_REALLOC_ARRAY(s, char, allocated);
602 if (s == NULL) {
603 return NULL;
604 }
605 wd = getcwd(s, allocated);
606 if (wd) {
607 break;
608 }
609 if (errno != ERANGE) {
610 SAFE_FREE(s);
611 break;
612 }
613 allocated *= 2;
614 if (allocated < PATH_MAX) {
615 SAFE_FREE(s);
616 break;
617 }
618 }
619 return wd;
620#else
621 char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
622 if (s == NULL) {
623 return NULL;
624 }
625 return getwd(s);
626#endif
627}
628
629#if defined(HAVE_POSIX_CAPABILITIES)
630
631/**************************************************************************
632 Try and abstract process capabilities (for systems that have them).
633****************************************************************************/
634
635/* Set the POSIX capabilities needed for the given purpose into the effective
636 * capability set of the current process. Make sure they are always removed
637 * from the inheritable set, because there is no circumstance in which our
638 * children should inherit our elevated privileges.
639 */
640static bool set_process_capability(enum smbd_capability capability,
641 bool enable)
642{
643 cap_value_t cap_vals[2] = {0};
644 int num_cap_vals = 0;
645
646 cap_t cap;
647
648#if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
649 /* On Linux, make sure that any capabilities we grab are sticky
650 * across UID changes. We expect that this would allow us to keep both
651 * the effective and permitted capability sets, but as of circa 2.6.16,
652 * only the permitted set is kept. It is a bug (which we work around)
653 * that the effective set is lost, but we still require the effective
654 * set to be kept.
655 */
656 if (!prctl(PR_GET_KEEPCAPS)) {
657 prctl(PR_SET_KEEPCAPS, 1);
658 }
659#endif
660
661 cap = cap_get_proc();
662 if (cap == NULL) {
663 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
664 strerror(errno)));
665 return False;
666 }
667
668 switch (capability) {
669 case KERNEL_OPLOCK_CAPABILITY:
670#ifdef CAP_NETWORK_MGT
671 /* IRIX has CAP_NETWORK_MGT for oplocks. */
672 cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
673#endif
674 break;
675 case DMAPI_ACCESS_CAPABILITY:
676#ifdef CAP_DEVICE_MGT
677 /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
678 cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
679#elif CAP_MKNOD
680 /* Linux has CAP_MKNOD for DMAPI access. */
681 cap_vals[num_cap_vals++] = CAP_MKNOD;
682#endif
683 break;
684 case LEASE_CAPABILITY:
685#ifdef CAP_LEASE
686 cap_vals[num_cap_vals++] = CAP_LEASE;
687#endif
688 break;
689 case DAC_OVERRIDE_CAPABILITY:
690#ifdef CAP_DAC_OVERRIDE
691 cap_vals[num_cap_vals++] = CAP_DAC_OVERRIDE;
692#endif
693 }
694
695 SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
696
697 if (num_cap_vals == 0) {
698 cap_free(cap);
699 return True;
700 }
701
702 cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
703 enable ? CAP_SET : CAP_CLEAR);
704
705 /* We never want to pass capabilities down to our children, so make
706 * sure they are not inherited.
707 */
708 cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
709
710 if (cap_set_proc(cap) == -1) {
711 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
712 strerror(errno)));
713 cap_free(cap);
714 return False;
715 }
716
717 cap_free(cap);
718 return True;
719}
720
721#endif /* HAVE_POSIX_CAPABILITIES */
722
723/****************************************************************************
724 Gain the oplock capability from the kernel if possible.
725****************************************************************************/
726
727void set_effective_capability(enum smbd_capability capability)
728{
729#if defined(HAVE_POSIX_CAPABILITIES)
730 set_process_capability(capability, True);
731#endif /* HAVE_POSIX_CAPABILITIES */
732}
733
734void drop_effective_capability(enum smbd_capability capability)
735{
736#if defined(HAVE_POSIX_CAPABILITIES)
737 set_process_capability(capability, False);
738#endif /* HAVE_POSIX_CAPABILITIES */
739}
740
741/**************************************************************************
742 Wrapper for random().
743****************************************************************************/
744
745long sys_random(void)
746{
747#if defined(HAVE_RANDOM)
748 return (long)random();
749#elif defined(HAVE_RAND)
750 return (long)rand();
751#else
752 DEBUG(0,("Error - no random function available !\n"));
753 exit(1);
754#endif
755}
756
757/**************************************************************************
758 Wrapper for srandom().
759****************************************************************************/
760
761void sys_srandom(unsigned int seed)
762{
763#if defined(HAVE_SRANDOM)
764 srandom(seed);
765#elif defined(HAVE_SRAND)
766 srand(seed);
767#else
768 DEBUG(0,("Error - no srandom function available !\n"));
769 exit(1);
770#endif
771}
772
773#ifndef NGROUPS_MAX
774#define NGROUPS_MAX 32 /* Guess... */
775#endif
776
777/**************************************************************************
778 Returns equivalent to NGROUPS_MAX - using sysconf if needed.
779****************************************************************************/
780
781int groups_max(void)
782{
783#if defined(SYSCONF_SC_NGROUPS_MAX)
784 int ret = sysconf(_SC_NGROUPS_MAX);
785 return (ret == -1) ? NGROUPS_MAX : ret;
786#else
787 return NGROUPS_MAX;
788#endif
789}
790
791/**************************************************************************
792 Wrap setgroups and getgroups for systems that declare getgroups() as
793 returning an array of gid_t, but actuall return an array of int.
794****************************************************************************/
795
796#if defined(HAVE_BROKEN_GETGROUPS)
797
798#ifdef HAVE_BROKEN_GETGROUPS
799#define GID_T int
800#else
801#define GID_T gid_t
802#endif
803
804static int sys_broken_getgroups(int setlen, gid_t *gidset)
805{
806 GID_T gid;
807 GID_T *group_list;
808 int i, ngroups;
809
810 if(setlen == 0) {
811 return getgroups(setlen, &gid);
812 }
813
814 /*
815 * Broken case. We need to allocate a
816 * GID_T array of size setlen.
817 */
818
819 if(setlen < 0) {
820 errno = EINVAL;
821 return -1;
822 }
823
824 if (setlen == 0)
825 setlen = groups_max();
826
827 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
828 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
829 return -1;
830 }
831
832 if((ngroups = getgroups(setlen, group_list)) < 0) {
833 int saved_errno = errno;
834 SAFE_FREE(group_list);
835 errno = saved_errno;
836 return -1;
837 }
838
839 for(i = 0; i < ngroups; i++)
840 gidset[i] = (gid_t)group_list[i];
841
842 SAFE_FREE(group_list);
843 return ngroups;
844}
845
846static int sys_broken_setgroups(int setlen, gid_t *gidset)
847{
848 GID_T *group_list;
849 int i ;
850
851 if (setlen == 0)
852 return 0 ;
853
854 if (setlen < 0 || setlen > groups_max()) {
855 errno = EINVAL;
856 return -1;
857 }
858
859 /*
860 * Broken case. We need to allocate a
861 * GID_T array of size setlen.
862 */
863
864 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
865 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
866 return -1;
867 }
868
869 for(i = 0; i < setlen; i++)
870 group_list[i] = (GID_T) gidset[i];
871
872 if(samba_setgroups(setlen, group_list) != 0) {
873 int saved_errno = errno;
874 SAFE_FREE(group_list);
875 errno = saved_errno;
876 return -1;
877 }
878
879 SAFE_FREE(group_list);
880 return 0 ;
881}
882
883#endif /* HAVE_BROKEN_GETGROUPS */
884
885/* This is a list of systems that require the first GID passed to setgroups(2)
886 * to be the effective GID. If your system is one of these, add it here.
887 */
888#if defined (FREEBSD) || defined (DARWINOS)
889#define USE_BSD_SETGROUPS
890#endif
891
892#if defined(USE_BSD_SETGROUPS)
893/* Depending on the particular BSD implementation, the first GID that is
894 * passed to setgroups(2) will either be ignored or will set the credential's
895 * effective GID. In either case, the right thing to do is to guarantee that
896 * gidset[0] is the effective GID.
897 */
898static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
899{
900 gid_t *new_gidset = NULL;
901 int max;
902 int ret;
903
904 /* setgroups(2) will fail with EINVAL if we pass too many groups. */
905 max = groups_max();
906
907 /* No group list, just make sure we are setting the efective GID. */
908 if (setlen == 0) {
909 return samba_setgroups(1, &primary_gid);
910 }
911
912 /* If the primary gid is not the first array element, grow the array
913 * and insert it at the front.
914 */
915 if (gidset[0] != primary_gid) {
916 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
917 if (new_gidset == NULL) {
918 return -1;
919 }
920
921 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
922 new_gidset[0] = primary_gid;
923 setlen++;
924 }
925
926 if (setlen > max) {
927 DEBUG(3, ("forced to truncate group list from %d to %d\n",
928 setlen, max));
929 setlen = max;
930 }
931
932#if defined(HAVE_BROKEN_GETGROUPS)
933 ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
934#else
935 ret = samba_setgroups(setlen, new_gidset ? new_gidset : gidset);
936#endif
937
938 if (new_gidset) {
939 int errsav = errno;
940 SAFE_FREE(new_gidset);
941 errno = errsav;
942 }
943
944 return ret;
945}
946
947#endif /* USE_BSD_SETGROUPS */
948
949/**************************************************************************
950 Wrapper for getgroups. Deals with broken (int) case.
951****************************************************************************/
952
953int sys_getgroups(int setlen, gid_t *gidset)
954{
955#if defined(HAVE_BROKEN_GETGROUPS)
956 return sys_broken_getgroups(setlen, gidset);
957#else
958 return getgroups(setlen, gidset);
959#endif
960}
961
962/**************************************************************************
963 Wrapper for setgroups. Deals with broken (int) case and BSD case.
964****************************************************************************/
965
966int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
967{
968#if !defined(HAVE_SETGROUPS)
969 errno = ENOSYS;
970 return -1;
971#endif /* HAVE_SETGROUPS */
972
973#if defined(USE_BSD_SETGROUPS)
974 return sys_bsd_setgroups(primary_gid, setlen, gidset);
975#elif defined(HAVE_BROKEN_GETGROUPS)
976 return sys_broken_setgroups(setlen, gidset);
977#else
978 return samba_setgroups(setlen, gidset);
979#endif
980}
981
982/**************************************************************************
983 Extract a command into an arg list.
984****************************************************************************/
985
986static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
987{
988 char *trunc_cmd;
989 char *saveptr;
990 char *ptr;
991 int argcl;
992 char **argl = NULL;
993 int i;
994
995 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
996 DEBUG(0, ("talloc failed\n"));
997 goto nomem;
998 }
999
1000 if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1001 TALLOC_FREE(trunc_cmd);
1002 errno = EINVAL;
1003 return NULL;
1004 }
1005
1006 /*
1007 * Count the args.
1008 */
1009
1010 for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1011 argcl++;
1012
1013 TALLOC_FREE(trunc_cmd);
1014
1015 if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
1016 goto nomem;
1017 }
1018
1019 /*
1020 * Now do the extraction.
1021 */
1022
1023 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1024 goto nomem;
1025 }
1026
1027 ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1028 i = 0;
1029
1030 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1031 goto nomem;
1032 }
1033
1034 while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1035
1036 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1037 goto nomem;
1038 }
1039 }
1040
1041 argl[i++] = NULL;
1042 TALLOC_FREE(trunc_cmd);
1043 return argl;
1044
1045 nomem:
1046 DEBUG(0, ("talloc failed\n"));
1047 TALLOC_FREE(trunc_cmd);
1048 TALLOC_FREE(argl);
1049 errno = ENOMEM;
1050 return NULL;
1051}
1052
1053/**************************************************************************
1054 Wrapper for popen. Safer as it doesn't search a path.
1055 Modified from the glibc sources.
1056 modified by tridge to return a file descriptor. We must kick our FILE* habit
1057****************************************************************************/
1058
1059typedef struct _popen_list
1060{
1061 int fd;
1062 pid_t child_pid;
1063 struct _popen_list *next;
1064} popen_list;
1065
1066static popen_list *popen_chain;
1067
1068int sys_popen(const char *command)
1069{
1070 int parent_end, child_end;
1071 int pipe_fds[2];
1072 popen_list *entry = NULL;
1073 char **argl = NULL;
1074 int ret;
1075
1076 if (!*command) {
1077 errno = EINVAL;
1078 return -1;
1079 }
1080
1081 ret = pipe(pipe_fds);
1082 if (ret < 0) {
1083 DEBUG(0, ("sys_popen: error opening pipe: %s\n",
1084 strerror(errno)));
1085 return -1;
1086 }
1087
1088 parent_end = pipe_fds[0];
1089 child_end = pipe_fds[1];
1090
1091 entry = SMB_MALLOC_P(popen_list);
1092 if (entry == NULL) {
1093 DEBUG(0, ("sys_popen: malloc failed\n"));
1094 goto err_exit;
1095 }
1096
1097 ZERO_STRUCTP(entry);
1098
1099 /*
1100 * Extract the command and args into a NULL terminated array.
1101 */
1102
1103 argl = extract_args(NULL, command);
1104 if (argl == NULL) {
1105 DEBUG(0, ("sys_popen: extract_args() failed: %s\n", strerror(errno)));
1106 goto err_exit;
1107 }
1108
1109 entry->child_pid = fork();
1110
1111 if (entry->child_pid == -1) {
1112 DEBUG(0, ("sys_popen: fork failed: %s\n", strerror(errno)));
1113 goto err_exit;
1114 }
1115
1116 if (entry->child_pid == 0) {
1117
1118 /*
1119 * Child !
1120 */
1121
1122 int child_std_end = STDOUT_FILENO;
1123 popen_list *p;
1124
1125 close(parent_end);
1126 if (child_end != child_std_end) {
1127 dup2 (child_end, child_std_end);
1128 close (child_end);
1129 }
1130
1131 /*
1132 * POSIX.2: "popen() shall ensure that any streams from previous
1133 * popen() calls that remain open in the parent process are closed
1134 * in the new child process."
1135 */
1136
1137 for (p = popen_chain; p; p = p->next)
1138 close(p->fd);
1139
1140 ret = execv(argl[0], argl);
1141 if (ret == -1) {
1142 DEBUG(0, ("sys_popen: ERROR executing command "
1143 "'%s': %s\n", command, strerror(errno)));
1144 }
1145 _exit (127);
1146 }
1147
1148 /*
1149 * Parent.
1150 */
1151
1152 close (child_end);
1153 TALLOC_FREE(argl);
1154
1155 /* Link into popen_chain. */
1156 entry->next = popen_chain;
1157 popen_chain = entry;
1158 entry->fd = parent_end;
1159
1160 return entry->fd;
1161
1162err_exit:
1163
1164 SAFE_FREE(entry);
1165 TALLOC_FREE(argl);
1166 close(pipe_fds[0]);
1167 close(pipe_fds[1]);
1168 return -1;
1169}
1170
1171/**************************************************************************
1172 Wrapper for pclose. Modified from the glibc sources.
1173****************************************************************************/
1174
1175int sys_pclose(int fd)
1176{
1177 int wstatus;
1178 popen_list **ptr = &popen_chain;
1179 popen_list *entry = NULL;
1180 pid_t wait_pid;
1181 int status = -1;
1182
1183 /* Unlink from popen_chain. */
1184 for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1185 if ((*ptr)->fd == fd) {
1186 entry = *ptr;
1187 *ptr = (*ptr)->next;
1188 status = 0;
1189 break;
1190 }
1191 }
1192
1193 if (status < 0 || close(entry->fd) < 0)
1194 return -1;
1195
1196 /*
1197 * As Samba is catching and eating child process
1198 * exits we don't really care about the child exit
1199 * code, a -1 with errno = ECHILD will do fine for us.
1200 */
1201
1202 do {
1203 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1204 } while (wait_pid == -1 && errno == EINTR);
1205
1206 SAFE_FREE(entry);
1207
1208 if (wait_pid == -1)
1209 return -1;
1210 return wstatus;
1211}
1212
1213/****************************************************************************
1214 Return the major devicenumber for UNIX extensions.
1215****************************************************************************/
1216
1217uint32_t unix_dev_major(SMB_DEV_T dev)
1218{
1219#if defined(HAVE_DEVICE_MAJOR_FN)
1220 return (uint32_t)major(dev);
1221#else
1222 return (uint32_t)(dev >> 8);
1223#endif
1224}
1225
1226/****************************************************************************
1227 Return the minor devicenumber for UNIX extensions.
1228****************************************************************************/
1229
1230uint32_t unix_dev_minor(SMB_DEV_T dev)
1231{
1232#if defined(HAVE_DEVICE_MINOR_FN)
1233 return (uint32_t)minor(dev);
1234#else
1235 return (uint32_t)(dev & 0xff);
1236#endif
1237}
1238
1239#if 0
1240/*******************************************************************
1241 Return the number of CPUs.
1242********************************************************************/
1243
1244int sys_get_number_of_cores(void)
1245{
1246 int ret = -1;
1247
1248#if defined(HAVE_SYSCONF)
1249#if defined(_SC_NPROCESSORS_ONLN)
1250 ret = (int)sysconf(_SC_NPROCESSORS_ONLN);
1251#endif
1252#if defined(_SC_NPROCESSORS_CONF)
1253 if (ret < 1) {
1254 ret = (int)sysconf(_SC_NPROCESSORS_CONF);
1255 }
1256#endif
1257#elif defined(HAVE_SYSCTL) && defined(CTL_HW)
1258 int name[2];
1259 unsigned int len = sizeof(ret);
1260
1261 name[0] = CTL_HW;
1262#if defined(HW_AVAILCPU)
1263 name[1] = HW_AVAILCPU;
1264
1265 if (sysctl(name, 2, &ret, &len, NULL, 0) == -1) {
1266 ret = -1;
1267 }
1268#endif
1269#if defined(HW_NCPU)
1270 if(ret < 1) {
1271 name[0] = CTL_HW;
1272 name[1] = HW_NCPU;
1273 if (sysctl(nm, 2, &count, &len, NULL, 0) == -1) {
1274 ret = -1;
1275 }
1276 }
1277#endif
1278#endif
1279 if (ret < 1) {
1280 ret = 1;
1281 }
1282 return ret;
1283}
1284#endif
Note: See TracBrowser for help on using the repository browser.