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