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 The wait() calls vary between systems
 576 ********************************************************************/
 577
 578 int 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
 592 char *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  */
 640 static 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
 727 void 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
 734 void 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
 745 long 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
 761 void 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
 781 int 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
 804 static 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
 846 static 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  */
 898 static 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
 953 int 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
 966 int 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
 986 static 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
1059 typedef struct _popen_list
1060 {
1061         int fd;
1062         pid_t child_pid;
1063         struct _popen_list *next;
1064 } popen_list;
1065
1066 static popen_list *popen_chain;
1067
1068 int 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
1162 err_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
1175 int 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
1217 uint32_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
1230 uint32_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
1244 int 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