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
  29 #ifdef HAVE_SYS_SYSCTL_H
  30 #include <sys/sysctl.h>
  31 #endif
  32
  33 #ifdef HAVE_SYS_PRCTL_H
  34 #include <sys/prctl.h>
  35 #endif
  36
  37 /*
  38    The idea is that this file will eventually have wrappers around all
  39    important system calls in samba. The aims are:
  40
  41    - to enable easier porting by putting OS dependent stuff in here
  42
  43    - to allow for hooks into other "pseudo-filesystems"
  44
  45    - to allow easier integration of things like the japanese extensions
  46
  47    - to support the philosophy of Samba to expose the features of
  48      the OS within the SMB model. In general whatever file/printer/variable
  49      expansions/etc make sense to the OS should be acceptable to Samba.
  50 */
  51
  52
  53
  54 /*******************************************************************
  55 A read wrapper that will deal with EINTR.
  56 ********************************************************************/
  57
  58 ssize_t sys_read(int fd, void *buf, size_t count)
  59 {
  60         ssize_t ret;
  61
  62         do {
  63                 ret = read(fd, buf, count);
  64 #if defined(EWOULDBLOCK)
  65         } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
  66 #else
  67         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
  68 #endif
  69         return ret;
  70 }
  71
  72 /*******************************************************************
  73 A write wrapper that will deal with EINTR.
  74 ********************************************************************/
  75
  76 ssize_t sys_write(int fd, const void *buf, size_t count)
  77 {
  78         ssize_t ret;
  79
  80         do {
  81                 ret = write(fd, buf, count);
  82 #if defined(EWOULDBLOCK)
  83         } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
  84 #else
  85         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
  86 #endif
  87         return ret;
  88 }
  89
  90 /*******************************************************************
  91 A writev wrapper that will deal with EINTR.
  92 ********************************************************************/
  93
  94 ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt)
  95 {
  96         ssize_t ret;
  97
  98 #if 0
  99         /* Try to confuse write_data_iov a bit */
 100         if ((random() % 5) == 0) {
 101                 return sys_write(fd, iov[0].iov_base, iov[0].iov_len);
 102         }
 103         if (iov[0].iov_len > 1) {
 104                 return sys_write(fd, iov[0].iov_base,
 105                                  (random() % (iov[0].iov_len-1)) + 1);
 106         }
 107 #endif
 108
 109         do {
 110                 ret = writev(fd, iov, iovcnt);
 111 #if defined(EWOULDBLOCK)
 112         } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
 113 #else
 114         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 115 #endif
 116         return ret;
 117 }
 118
 119 /*******************************************************************
 120 A pread wrapper that will deal with EINTR
 121 ********************************************************************/
 122
 123 #if defined(HAVE_PREAD)
 124 ssize_t sys_pread(int fd, void *buf, size_t count, off_t off)
 125 {
 126         ssize_t ret;
 127
 128         do {
 129                 ret = pread(fd, buf, count, off);
 130         } while (ret == -1 && errno == EINTR);
 131         return ret;
 132 }
 133 #endif
 134
 135 /*******************************************************************
 136 A write wrapper that will deal with EINTR
 137 ********************************************************************/
 138
 139 #if defined(HAVE_PWRITE)
 140 ssize_t sys_pwrite(int fd, const void *buf, size_t count, off_t off)
 141 {
 142         ssize_t ret;
 143
 144         do {
 145                 ret = pwrite(fd, buf, count, off);
 146         } while (ret == -1 && errno == EINTR);
 147         return ret;
 148 }
 149 #endif
 150
 151 /*******************************************************************
 152 A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
 153 ********************************************************************/
 154
 155 ssize_t sys_send(int s, const void *msg, size_t len, int flags)
 156 {
 157         ssize_t ret;
 158
 159         do {
 160                 ret = send(s, msg, len, flags);
 161 #if defined(EWOULDBLOCK)
 162         } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
 163 #else
 164         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 165 #endif
 166         return ret;
 167 }
 168
 169 /*******************************************************************
 170 A recvfrom wrapper that will deal with EINTR.
 171 ********************************************************************/
 172
 173 ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 174 {
 175         ssize_t ret;
 176
 177         do {
 178                 ret = recvfrom(s, buf, len, flags, from, fromlen);
 179 #if defined(EWOULDBLOCK)
 180         } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
 181 #else
 182         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 183 #endif
 184         return ret;
 185 }
 186
 187 /*******************************************************************
 188 A fcntl wrapper that will deal with EINTR.
 189 ********************************************************************/
 190
 191 int sys_fcntl_ptr(int fd, int cmd, void *arg)
 192 {
 193         int ret;
 194
 195         do {
 196                 ret = fcntl(fd, cmd, arg);
 197         } while (ret == -1 && errno == EINTR);
 198         return ret;
 199 }
 200
 201 /****************************************************************************
 202  Get/Set all the possible time fields from a stat struct as a timespec.
 203 ****************************************************************************/
 204
 205 static struct timespec get_atimespec(const struct stat *pst)
 206 {
 207 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
 208         struct timespec ret;
 209
 210         /* Old system - no ns timestamp. */
 211         ret.tv_sec = pst->st_atime;
 212         ret.tv_nsec = 0;
 213         return ret;
 214 #else
 215 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
 216         return pst->st_atim;
 217 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
 218         struct timespec ret;
 219         ret.tv_sec = pst->st_atime;
 220         ret.tv_nsec = pst->st_atimensec;
 221         return ret;
 222 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
 223         struct timespec ret;
 224         ret.tv_sec = pst->st_atime;
 225         ret.tv_nsec = pst->st_atime_n;
 226         return ret;
 227 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
 228         struct timespec ret;
 229         ret.tv_sec = pst->st_atime;
 230         ret.tv_nsec = pst->st_uatime * 1000;
 231         return ret;
 232 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
 233         return pst->st_atimespec;
 234 #else
 235 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
 236 #endif
 237 #endif
 238 }
 239
 240 static struct timespec get_mtimespec(const struct stat *pst)
 241 {
 242 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
 243         struct timespec ret;
 244
 245         /* Old system - no ns timestamp. */
 246         ret.tv_sec = pst->st_mtime;
 247         ret.tv_nsec = 0;
 248         return ret;
 249 #else
 250 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
 251         return pst->st_mtim;
 252 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
 253         struct timespec ret;
 254         ret.tv_sec = pst->st_mtime;
 255         ret.tv_nsec = pst->st_mtimensec;
 256         return ret;
 257 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
 258         struct timespec ret;
 259         ret.tv_sec = pst->st_mtime;
 260         ret.tv_nsec = pst->st_mtime_n;
 261         return ret;
 262 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
 263         struct timespec ret;
 264         ret.tv_sec = pst->st_mtime;
 265         ret.tv_nsec = pst->st_umtime * 1000;
 266         return ret;
 267 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
 268         return pst->st_mtimespec;
 269 #else
 270 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
 271 #endif
 272 #endif
 273 }
 274
 275 static struct timespec get_ctimespec(const struct stat *pst)
 276 {
 277 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
 278         struct timespec ret;
 279
 280         /* Old system - no ns timestamp. */
 281         ret.tv_sec = pst->st_ctime;
 282         ret.tv_nsec = 0;
 283         return ret;
 284 #else
 285 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
 286         return pst->st_ctim;
 287 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
 288         struct timespec ret;
 289         ret.tv_sec = pst->st_ctime;
 290         ret.tv_nsec = pst->st_ctimensec;
 291         return ret;
 292 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
 293         struct timespec ret;
 294         ret.tv_sec = pst->st_ctime;
 295         ret.tv_nsec = pst->st_ctime_n;
 296         return ret;
 297 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
 298         struct timespec ret;
 299         ret.tv_sec = pst->st_ctime;
 300         ret.tv_nsec = pst->st_uctime * 1000;
 301         return ret;
 302 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
 303         return pst->st_ctimespec;
 304 #else
 305 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
 306 #endif
 307 #endif
 308 }
 309
 310 /****************************************************************************
 311  Return the best approximation to a 'create time' under UNIX from a stat
 312  structure.
 313 ****************************************************************************/
 314
 315 static struct timespec calc_create_time_stat(const struct stat *st)
 316 {
 317         struct timespec ret, ret1;
 318         struct timespec c_time = get_ctimespec(st);
 319         struct timespec m_time = get_mtimespec(st);
 320         struct timespec a_time = get_atimespec(st);
 321
 322         ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
 323         ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
 324
 325         if(!null_timespec(ret1)) {
 326                 return ret1;
 327         }
 328
 329         /*
 330          * One of ctime, mtime or atime was zero (probably atime).
 331          * Just return MIN(ctime, mtime).
 332          */
 333         return ret;
 334 }
 335
 336 /****************************************************************************
 337  Return the best approximation to a 'create time' under UNIX from a stat_ex
 338  structure.
 339 ****************************************************************************/
 340
 341 static struct timespec calc_create_time_stat_ex(const struct stat_ex *st)
 342 {
 343         struct timespec ret, ret1;
 344         struct timespec c_time = st->st_ex_ctime;
 345         struct timespec m_time = st->st_ex_mtime;
 346         struct timespec a_time = st->st_ex_atime;
 347
 348         ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
 349         ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
 350
 351         if(!null_timespec(ret1)) {
 352                 return ret1;
 353         }
 354
 355         /*
 356          * One of ctime, mtime or atime was zero (probably atime).
 357          * Just return MIN(ctime, mtime).
 358          */
 359         return ret;
 360 }
 361
 362 /****************************************************************************
 363  Return the 'create time' from a stat struct if it exists (birthtime) or else
 364  use the best approximation.
 365 ****************************************************************************/
 366
 367 static void make_create_timespec(const struct stat *pst, struct stat_ex *dst,
 368                                  bool fake_dir_create_times)
 369 {
 370         if (S_ISDIR(pst->st_mode) && fake_dir_create_times) {
 371                 dst->st_ex_btime.tv_sec = 315493200L;          /* 1/1/1980 */
 372                 dst->st_ex_btime.tv_nsec = 0;
 373         }
 374
 375         dst->st_ex_calculated_birthtime = false;
 376
 377 #if defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
 378         dst->st_ex_btime = pst->st_birthtimespec;
 379 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC)
 380         dst->st_ex_btime.tv_sec = pst->st_birthtime;
 381         dst->st_ex_btime.tv_nsec = pst->st_birthtimenspec;
 382 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIME)
 383         dst->st_ex_btime.tv_sec = pst->st_birthtime;
 384         dst->st_ex_btime.tv_nsec = 0;
 385 #else
 386         dst->st_ex_btime = calc_create_time_stat(pst);
 387         dst->st_ex_calculated_birthtime = true;
 388 #endif
 389
 390         /* Deal with systems that don't initialize birthtime correctly.
 391          * Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
 392          */
 393         if (null_timespec(dst->st_ex_btime)) {
 394                 dst->st_ex_btime = calc_create_time_stat(pst);
 395                 dst->st_ex_calculated_birthtime = true;
 396         }
 397 }
 398
 399 /****************************************************************************
 400  If we update a timestamp in a stat_ex struct we may have to recalculate
 401  the birthtime. For now only implement this for write time, but we may
 402  also need to do it for atime and ctime. JRA.
 403 ****************************************************************************/
 404
 405 void update_stat_ex_mtime(struct stat_ex *dst,
 406                                 struct timespec write_ts)
 407 {
 408         dst->st_ex_mtime = write_ts;
 409
 410         /* We may have to recalculate btime. */
 411         if (dst->st_ex_calculated_birthtime) {
 412                 dst->st_ex_btime = calc_create_time_stat_ex(dst);
 413         }
 414 }
 415
 416 void update_stat_ex_create_time(struct stat_ex *dst,
 417                                 struct timespec create_time)
 418 {
 419         dst->st_ex_btime = create_time;
 420         dst->st_ex_calculated_birthtime = false;
 421 }
 422
 423 void init_stat_ex_from_stat (struct stat_ex *dst,
 424                             const struct stat *src,
 425                             bool fake_dir_create_times)
 426 {
 427         dst->st_ex_dev = src->st_dev;
 428         dst->st_ex_ino = src->st_ino;
 429         dst->st_ex_mode = src->st_mode;
 430         dst->st_ex_nlink = src->st_nlink;
 431         dst->st_ex_uid = src->st_uid;
 432         dst->st_ex_gid = src->st_gid;
 433         dst->st_ex_rdev = src->st_rdev;
 434         dst->st_ex_size = src->st_size;
 435         dst->st_ex_atime = get_atimespec(src);
 436         dst->st_ex_mtime = get_mtimespec(src);
 437         dst->st_ex_ctime = get_ctimespec(src);
 438         make_create_timespec(src, dst, fake_dir_create_times);
 439 #ifdef HAVE_STAT_ST_BLKSIZE
 440         dst->st_ex_blksize = src->st_blksize;
 441 #else
 442         dst->st_ex_blksize = STAT_ST_BLOCKSIZE;
 443 #endif
 444
 445 #ifdef HAVE_STAT_ST_BLOCKS
 446         dst->st_ex_blocks = src->st_blocks;
 447 #else
 448         dst->st_ex_blocks = src->st_size / dst->st_ex_blksize + 1;
 449 #endif
 450
 451 #ifdef HAVE_STAT_ST_FLAGS
 452         dst->st_ex_flags = src->st_flags;
 453 #else
 454         dst->st_ex_flags = 0;
 455 #endif
 456 }
 457
 458 /*******************************************************************
 459 A stat() wrapper.
 460 ********************************************************************/
 461
 462 int sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf,
 463              bool fake_dir_create_times)
 464 {
 465         int ret;
 466         struct stat statbuf;
 467         ret = stat(fname, &statbuf);
 468         if (ret == 0) {
 469                 /* we always want directories to appear zero size */
 470                 if (S_ISDIR(statbuf.st_mode)) {
 471                         statbuf.st_size = 0;
 472                 }
 473                 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
 474         }
 475         return ret;
 476 }
 477
 478 /*******************************************************************
 479  An fstat() wrapper.
 480 ********************************************************************/
 481
 482 int sys_fstat(int fd, SMB_STRUCT_STAT *sbuf, bool fake_dir_create_times)
 483 {
 484         int ret;
 485         struct stat statbuf;
 486         ret = fstat(fd, &statbuf);
 487         if (ret == 0) {
 488                 /* we always want directories to appear zero size */
 489                 if (S_ISDIR(statbuf.st_mode)) {
 490                         statbuf.st_size = 0;
 491                 }
 492                 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
 493         }
 494         return ret;
 495 }
 496
 497 /*******************************************************************
 498  An lstat() wrapper.
 499 ********************************************************************/
 500
 501 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
 502               bool fake_dir_create_times)
 503 {
 504         int ret;
 505         struct stat statbuf;
 506         ret = lstat(fname, &statbuf);
 507         if (ret == 0) {
 508                 /* we always want directories to appear zero size */
 509                 if (S_ISDIR(statbuf.st_mode)) {
 510                         statbuf.st_size = 0;
 511                 }
 512                 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
 513         }
 514         return ret;
 515 }
 516
 517 /*******************************************************************
 518  An posix_fallocate() wrapper.
 519 ********************************************************************/
 520 int sys_posix_fallocate(int fd, off_t offset, off_t len)
 521 {
 522 #if defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
 523         return posix_fallocate(fd, offset, len);
 524 #elif defined(F_RESVSP64)
 525         /* this handles XFS on IRIX */
 526         struct flock64 fl;
 527         off_t new_len = offset + len;
 528         int ret;
 529         struct stat64 sbuf;
 530
 531         /* unlikely to get a too large file on a 64bit system but ... */
 532         if (new_len < 0)
 533                 return EFBIG;
 534
 535         fl.l_whence = SEEK_SET;
 536         fl.l_start = offset;
 537         fl.l_len = len;
 538
 539         ret=fcntl(fd, F_RESVSP64, &fl);
 540
 541         if (ret != 0)
 542                 return errno;
 543
 544         /* Make sure the file gets enlarged after we allocated space: */
 545         fstat64(fd, &sbuf);
 546         if (new_len > sbuf.st_size)
 547                 ftruncate64(fd, new_len);
 548         return 0;
 549 #else
 550         return ENOSYS;
 551 #endif
 552 }
 553
 554 /*******************************************************************
 555  An fallocate() function that matches the semantics of the Linux one.
 556 ********************************************************************/
 557
 558 #ifdef HAVE_LINUX_FALLOC_H
 559 #include <linux/falloc.h>
 560 #endif
 561
 562 int sys_fallocate(int fd, enum vfs_fallocate_mode mode, off_t offset, off_t len)
 563 {
 564 #if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE)
 565         int lmode;
 566         switch (mode) {
 567         case VFS_FALLOCATE_EXTEND_SIZE:
 568                 lmode = 0;
 569                 break;
 570         case VFS_FALLOCATE_KEEP_SIZE:
 571                 lmode = FALLOC_FL_KEEP_SIZE;
 572                 break;
 573         default:
 574                 errno = EINVAL;
 575                 return -1;
 576         }
 577 #if defined(HAVE_LINUX_FALLOCATE)
 578         return fallocate(fd, lmode, offset, len);
 579 #endif
 580 #else
 581         /* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
 582         errno = ENOSYS;
 583         return -1;
 584 #endif
 585 }
 586
 587 #if HAVE_KERNEL_SHARE_MODES
 588 #ifndef LOCK_MAND
 589 #define LOCK_MAND       32      /* This is a mandatory flock */
 590 #define LOCK_READ       64      /* ... Which allows concurrent read operations */
 591 #define LOCK_WRITE      128     /* ... Which allows concurrent write operations */
 592 #define LOCK_RW         192     /* ... Which allows concurrent read & write ops */
 593 #endif
 594 #endif
 595
 596 /*******************************************************************
 597  A flock() wrapper that will perform the kernel flock.
 598 ********************************************************************/
 599
 600 void kernel_flock(int fd, uint32 share_mode, uint32 access_mask)
 601 {
 602 #if HAVE_KERNEL_SHARE_MODES
 603         int kernel_mode = 0;
 604         if (share_mode == FILE_SHARE_WRITE) {
 605                 kernel_mode = LOCK_MAND|LOCK_WRITE;
 606         } else if (share_mode == FILE_SHARE_READ) {
 607                 kernel_mode = LOCK_MAND|LOCK_READ;
 608         } else if (share_mode == FILE_SHARE_NONE) {
 609                 kernel_mode = LOCK_MAND;
 610         }
 611         if (kernel_mode) {
 612                 flock(fd, kernel_mode);
 613         }
 614 #endif
 615         ;
 616 }
 617
 618
 619
 620 /*******************************************************************
 621  An fdopendir wrapper.
 622  Ugly hack - we need dirfd for this to work correctly in the
 623  calling code.. JRA.
 624 ********************************************************************/
 625
 626 DIR *sys_fdopendir(int fd)
 627 {
 628 #if defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD)
 629         return fdopendir(fd);
 630 #else
 631         errno = ENOSYS;
 632         return NULL;
 633 #endif
 634 }
 635
 636 /*******************************************************************
 637  An mknod() wrapper.
 638 ********************************************************************/
 639
 640 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
 641 {
 642 #if defined(HAVE_MKNOD)
 643         return mknod(path, mode, dev);
 644 #else
 645         /* No mknod system call. */
 646         errno = ENOSYS;
 647         return -1;
 648 #endif
 649 }
 650
 651 /*******************************************************************
 652 The wait() calls vary between systems
 653 ********************************************************************/
 654
 655 int sys_waitpid(pid_t pid,int *status,int options)
 656 {
 657 #ifdef HAVE_WAITPID
 658         return waitpid(pid,status,options);
 659 #else /* HAVE_WAITPID */
 660         return wait4(pid, status, options, NULL);
 661 #endif /* HAVE_WAITPID */
 662 }
 663
 664 /*******************************************************************
 665  System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
 666  on error (malloc fail usually).
 667 ********************************************************************/
 668
 669 char *sys_getwd(void)
 670 {
 671 #ifdef GETCWD_TAKES_NULL
 672         return getcwd(NULL, 0);
 673 #elif HAVE_GETCWD
 674         char *wd = NULL, *s = NULL;
 675         size_t allocated = PATH_MAX;
 676
 677         while (1) {
 678                 s = SMB_REALLOC_ARRAY(s, char, allocated);
 679                 if (s == NULL) {
 680                         return NULL;
 681                 }
 682                 wd = getcwd(s, allocated);
 683                 if (wd) {
 684                         break;
 685                 }
 686                 if (errno != ERANGE) {
 687                         SAFE_FREE(s);
 688                         break;
 689                 }
 690                 allocated *= 2;
 691                 if (allocated < PATH_MAX) {
 692                         SAFE_FREE(s);
 693                         break;
 694                 }
 695         }
 696         return wd;
 697 #else
 698         char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
 699         if (s == NULL) {
 700                 return NULL;
 701         }
 702         return getwd(s);
 703 #endif
 704 }
 705
 706 #if defined(HAVE_POSIX_CAPABILITIES)
 707
 708 /**************************************************************************
 709  Try and abstract process capabilities (for systems that have them).
 710 ****************************************************************************/
 711
 712 /* Set the POSIX capabilities needed for the given purpose into the effective
 713  * capability set of the current process. Make sure they are always removed
 714  * from the inheritable set, because there is no circumstance in which our
 715  * children should inherit our elevated privileges.
 716  */
 717 static bool set_process_capability(enum smbd_capability capability,
 718                                    bool enable)
 719 {
 720         cap_value_t cap_vals[2] = {0};
 721         int num_cap_vals = 0;
 722
 723         cap_t cap;
 724
 725 #if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
 726         /* On Linux, make sure that any capabilities we grab are sticky
 727          * across UID changes. We expect that this would allow us to keep both
 728          * the effective and permitted capability sets, but as of circa 2.6.16,
 729          * only the permitted set is kept. It is a bug (which we work around)
 730          * that the effective set is lost, but we still require the effective
 731          * set to be kept.
 732          */
 733         if (!prctl(PR_GET_KEEPCAPS)) {
 734                 prctl(PR_SET_KEEPCAPS, 1);
 735         }
 736 #endif
 737
 738         cap = cap_get_proc();
 739         if (cap == NULL) {
 740                 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
 741                         strerror(errno)));
 742                 return False;
 743         }
 744
 745         switch (capability) {
 746                 case KERNEL_OPLOCK_CAPABILITY:
 747 #ifdef CAP_NETWORK_MGT
 748                         /* IRIX has CAP_NETWORK_MGT for oplocks. */
 749                         cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
 750 #endif
 751                         break;
 752                 case DMAPI_ACCESS_CAPABILITY:
 753 #ifdef CAP_DEVICE_MGT
 754                         /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
 755                         cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
 756 #elif CAP_MKNOD
 757                         /* Linux has CAP_MKNOD for DMAPI access. */
 758                         cap_vals[num_cap_vals++] = CAP_MKNOD;
 759 #endif
 760                         break;
 761                 case LEASE_CAPABILITY:
 762 #ifdef CAP_LEASE
 763                         cap_vals[num_cap_vals++] = CAP_LEASE;
 764 #endif
 765                         break;
 766         }
 767
 768         SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
 769
 770         if (num_cap_vals == 0) {
 771                 cap_free(cap);
 772                 return True;
 773         }
 774
 775         cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
 776                 enable ? CAP_SET : CAP_CLEAR);
 777
 778         /* We never want to pass capabilities down to our children, so make
 779          * sure they are not inherited.
 780          */
 781         cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
 782
 783         if (cap_set_proc(cap) == -1) {
 784                 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
 785                         strerror(errno)));
 786                 cap_free(cap);
 787                 return False;
 788         }
 789
 790         cap_free(cap);
 791         return True;
 792 }
 793
 794 #endif /* HAVE_POSIX_CAPABILITIES */
 795
 796 /****************************************************************************
 797  Gain the oplock capability from the kernel if possible.
 798 ****************************************************************************/
 799
 800 void set_effective_capability(enum smbd_capability capability)
 801 {
 802 #if defined(HAVE_POSIX_CAPABILITIES)
 803         set_process_capability(capability, True);
 804 #endif /* HAVE_POSIX_CAPABILITIES */
 805 }
 806
 807 void drop_effective_capability(enum smbd_capability capability)
 808 {
 809 #if defined(HAVE_POSIX_CAPABILITIES)
 810         set_process_capability(capability, False);
 811 #endif /* HAVE_POSIX_CAPABILITIES */
 812 }
 813
 814 /**************************************************************************
 815  Wrapper for random().
 816 ****************************************************************************/
 817
 818 long sys_random(void)
 819 {
 820 #if defined(HAVE_RANDOM)
 821         return (long)random();
 822 #elif defined(HAVE_RAND)
 823         return (long)rand();
 824 #else
 825         DEBUG(0,("Error - no random function available !\n"));
 826         exit(1);
 827 #endif
 828 }
 829
 830 /**************************************************************************
 831  Wrapper for srandom().
 832 ****************************************************************************/
 833
 834 void sys_srandom(unsigned int seed)
 835 {
 836 #if defined(HAVE_SRANDOM)
 837         srandom(seed);
 838 #elif defined(HAVE_SRAND)
 839         srand(seed);
 840 #else
 841         DEBUG(0,("Error - no srandom function available !\n"));
 842         exit(1);
 843 #endif
 844 }
 845
 846 #ifndef NGROUPS_MAX
 847 #define NGROUPS_MAX 32 /* Guess... */
 848 #endif
 849
 850 /**************************************************************************
 851  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
 852 ****************************************************************************/
 853
 854 int groups_max(void)
 855 {
 856 #if defined(SYSCONF_SC_NGROUPS_MAX)
 857         int ret = sysconf(_SC_NGROUPS_MAX);
 858         return (ret == -1) ? NGROUPS_MAX : ret;
 859 #else
 860         return NGROUPS_MAX;
 861 #endif
 862 }
 863
 864 /**************************************************************************
 865  Wrap setgroups and getgroups for systems that declare getgroups() as
 866  returning an array of gid_t, but actuall return an array of int.
 867 ****************************************************************************/
 868
 869 #if defined(HAVE_BROKEN_GETGROUPS)
 870
 871 #ifdef HAVE_BROKEN_GETGROUPS
 872 #define GID_T int
 873 #else
 874 #define GID_T gid_t
 875 #endif
 876
 877 static int sys_broken_getgroups(int setlen, gid_t *gidset)
 878 {
 879         GID_T gid;
 880         GID_T *group_list;
 881         int i, ngroups;
 882
 883         if(setlen == 0) {
 884                 return getgroups(setlen, &gid);
 885         }
 886
 887         /*
 888          * Broken case. We need to allocate a
 889          * GID_T array of size setlen.
 890          */
 891
 892         if(setlen < 0) {
 893                 errno = EINVAL;
 894                 return -1;
 895         }
 896
 897         if (setlen == 0)
 898                 setlen = groups_max();
 899
 900         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
 901                 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
 902                 return -1;
 903         }
 904
 905         if((ngroups = getgroups(setlen, group_list)) < 0) {
 906                 int saved_errno = errno;
 907                 SAFE_FREE(group_list);
 908                 errno = saved_errno;
 909                 return -1;
 910         }
 911
 912         for(i = 0; i < ngroups; i++)
 913                 gidset[i] = (gid_t)group_list[i];
 914
 915         SAFE_FREE(group_list);
 916         return ngroups;
 917 }
 918
 919 static int sys_broken_setgroups(int setlen, gid_t *gidset)
 920 {
 921         GID_T *group_list;
 922         int i ;
 923
 924         if (setlen == 0)
 925                 return 0 ;
 926
 927         if (setlen < 0 || setlen > groups_max()) {
 928                 errno = EINVAL;
 929                 return -1;
 930         }
 931
 932         /*
 933          * Broken case. We need to allocate a
 934          * GID_T array of size setlen.
 935          */
 936
 937         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
 938                 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
 939                 return -1;
 940         }
 941
 942         for(i = 0; i < setlen; i++)
 943                 group_list[i] = (GID_T) gidset[i];
 944
 945         if(setgroups(setlen, group_list) != 0) {
 946                 int saved_errno = errno;
 947                 SAFE_FREE(group_list);
 948                 errno = saved_errno;
 949                 return -1;
 950         }
 951
 952         SAFE_FREE(group_list);
 953         return 0 ;
 954 }
 955
 956 #endif /* HAVE_BROKEN_GETGROUPS */
 957
 958 /* This is a list of systems that require the first GID passed to setgroups(2)
 959  * to be the effective GID. If your system is one of these, add it here.
 960  */
 961 #if defined (FREEBSD) || defined (DARWINOS)
 962 #define USE_BSD_SETGROUPS
 963 #endif
 964
 965 #if defined(USE_BSD_SETGROUPS)
 966 /* Depending on the particular BSD implementation, the first GID that is
 967  * passed to setgroups(2) will either be ignored or will set the credential's
 968  * effective GID. In either case, the right thing to do is to guarantee that
 969  * gidset[0] is the effective GID.
 970  */
 971 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
 972 {
 973         gid_t *new_gidset = NULL;
 974         int max;
 975         int ret;
 976
 977         /* setgroups(2) will fail with EINVAL if we pass too many groups. */
 978         max = groups_max();
 979
 980         /* No group list, just make sure we are setting the efective GID. */
 981         if (setlen == 0) {
 982                 return setgroups(1, &primary_gid);
 983         }
 984
 985         /* If the primary gid is not the first array element, grow the array
 986          * and insert it at the front.
 987          */
 988         if (gidset[0] != primary_gid) {
 989                 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
 990                 if (new_gidset == NULL) {
 991                         return -1;
 992                 }
 993
 994                 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
 995                 new_gidset[0] = primary_gid;
 996                 setlen++;
 997         }
 998
 999         if (setlen > max) {
1000                 DEBUG(3, ("forced to truncate group list from %d to %d\n",
1001                         setlen, max));
1002                 setlen = max;
1003         }
1004
1005 #if defined(HAVE_BROKEN_GETGROUPS)
1006         ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
1007 #else
1008         ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
1009 #endif
1010
1011         if (new_gidset) {
1012                 int errsav = errno;
1013                 SAFE_FREE(new_gidset);
1014                 errno = errsav;
1015         }
1016
1017         return ret;
1018 }
1019
1020 #endif /* USE_BSD_SETGROUPS */
1021
1022 /**************************************************************************
1023  Wrapper for getgroups. Deals with broken (int) case.
1024 ****************************************************************************/
1025
1026 int sys_getgroups(int setlen, gid_t *gidset)
1027 {
1028 #if defined(HAVE_BROKEN_GETGROUPS)
1029         return sys_broken_getgroups(setlen, gidset);
1030 #else
1031         return getgroups(setlen, gidset);
1032 #endif
1033 }
1034
1035 /**************************************************************************
1036  Wrapper for setgroups. Deals with broken (int) case and BSD case.
1037 ****************************************************************************/
1038
1039 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
1040 {
1041 #if !defined(HAVE_SETGROUPS)
1042         errno = ENOSYS;
1043         return -1;
1044 #endif /* HAVE_SETGROUPS */
1045
1046 #if defined(USE_BSD_SETGROUPS)
1047         return sys_bsd_setgroups(primary_gid, setlen, gidset);
1048 #elif defined(HAVE_BROKEN_GETGROUPS)
1049         return sys_broken_setgroups(setlen, gidset);
1050 #else
1051         return setgroups(setlen, gidset);
1052 #endif
1053 }
1054
1055 /**************************************************************************
1056  Extract a command into an arg list.
1057 ****************************************************************************/
1058
1059 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
1060 {
1061         char *trunc_cmd;
1062         char *saveptr;
1063         char *ptr;
1064         int argcl;
1065         char **argl = NULL;
1066         int i;
1067
1068         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1069                 DEBUG(0, ("talloc failed\n"));
1070                 goto nomem;
1071         }
1072
1073         if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1074                 TALLOC_FREE(trunc_cmd);
1075                 errno = EINVAL;
1076                 return NULL;
1077         }
1078
1079         /*
1080          * Count the args.
1081          */
1082
1083         for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1084                 argcl++;
1085
1086         TALLOC_FREE(trunc_cmd);
1087
1088         if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
1089                 goto nomem;
1090         }
1091
1092         /*
1093          * Now do the extraction.
1094          */
1095
1096         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1097                 goto nomem;
1098         }
1099
1100         ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1101         i = 0;
1102
1103         if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1104                 goto nomem;
1105         }
1106
1107         while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1108
1109                 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1110                         goto nomem;
1111                 }
1112         }
1113
1114         argl[i++] = NULL;
1115         TALLOC_FREE(trunc_cmd);
1116         return argl;
1117
1118  nomem:
1119         DEBUG(0, ("talloc failed\n"));
1120         TALLOC_FREE(trunc_cmd);
1121         TALLOC_FREE(argl);
1122         errno = ENOMEM;
1123         return NULL;
1124 }
1125
1126 /**************************************************************************
1127  Wrapper for popen. Safer as it doesn't search a path.
1128  Modified from the glibc sources.
1129  modified by tridge to return a file descriptor. We must kick our FILE* habit
1130 ****************************************************************************/
1131
1132 typedef struct _popen_list
1133 {
1134         int fd;
1135         pid_t child_pid;
1136         struct _popen_list *next;
1137 } popen_list;
1138
1139 static popen_list *popen_chain;
1140
1141 int sys_popen(const char *command)
1142 {
1143         int parent_end, child_end;
1144         int pipe_fds[2];
1145         popen_list *entry = NULL;
1146         char **argl = NULL;
1147
1148         if (pipe(pipe_fds) < 0)
1149                 return -1;
1150
1151         parent_end = pipe_fds[0];
1152         child_end = pipe_fds[1];
1153
1154         if (!*command) {
1155                 errno = EINVAL;
1156                 goto err_exit;
1157         }
1158
1159         if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1160                 goto err_exit;
1161
1162         ZERO_STRUCTP(entry);
1163
1164         /*
1165          * Extract the command and args into a NULL terminated array.
1166          */
1167
1168         if(!(argl = extract_args(NULL, command)))
1169                 goto err_exit;
1170
1171         entry->child_pid = fork();
1172
1173         if (entry->child_pid == -1) {
1174                 goto err_exit;
1175         }
1176
1177         if (entry->child_pid == 0) {
1178
1179                 /*
1180                  * Child !
1181                  */
1182
1183                 int child_std_end = STDOUT_FILENO;
1184                 popen_list *p;
1185
1186                 close(parent_end);
1187                 if (child_end != child_std_end) {
1188                         dup2 (child_end, child_std_end);
1189                         close (child_end);
1190                 }
1191
1192                 /*
1193                  * POSIX.2:  "popen() shall ensure that any streams from previous
1194                  * popen() calls that remain open in the parent process are closed
1195                  * in the new child process."
1196                  */
1197
1198                 for (p = popen_chain; p; p = p->next)
1199                         close(p->fd);
1200
1201                 execv(argl[0], argl);
1202                 _exit (127);
1203         }
1204
1205         /*
1206          * Parent.
1207          */
1208
1209         close (child_end);
1210         TALLOC_FREE(argl);
1211
1212         /* Link into popen_chain. */
1213         entry->next = popen_chain;
1214         popen_chain = entry;
1215         entry->fd = parent_end;
1216
1217         return entry->fd;
1218
1219 err_exit:
1220
1221         SAFE_FREE(entry);
1222         TALLOC_FREE(argl);
1223         close(pipe_fds[0]);
1224         close(pipe_fds[1]);
1225         return -1;
1226 }
1227
1228 /**************************************************************************
1229  Wrapper for pclose. Modified from the glibc sources.
1230 ****************************************************************************/
1231
1232 int sys_pclose(int fd)
1233 {
1234         int wstatus;
1235         popen_list **ptr = &popen_chain;
1236         popen_list *entry = NULL;
1237         pid_t wait_pid;
1238         int status = -1;
1239
1240         /* Unlink from popen_chain. */
1241         for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1242                 if ((*ptr)->fd == fd) {
1243                         entry = *ptr;
1244                         *ptr = (*ptr)->next;
1245                         status = 0;
1246                         break;
1247                 }
1248         }
1249
1250         if (status < 0 || close(entry->fd) < 0)
1251                 return -1;
1252
1253         /*
1254          * As Samba is catching and eating child process
1255          * exits we don't really care about the child exit
1256          * code, a -1 with errno = ECHILD will do fine for us.
1257          */
1258
1259         do {
1260                 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1261         } while (wait_pid == -1 && errno == EINTR);
1262
1263         SAFE_FREE(entry);
1264
1265         if (wait_pid == -1)
1266                 return -1;
1267         return wstatus;
1268 }
1269
1270 /**************************************************************************
1271  Wrapper for Admin Logs.
1272 ****************************************************************************/
1273
1274  void sys_adminlog(int priority, const char *format_str, ...)
1275 {
1276         va_list ap;
1277         int ret;
1278         char *msgbuf = NULL;
1279
1280         va_start( ap, format_str );
1281         ret = vasprintf( &msgbuf, format_str, ap );
1282         va_end( ap );
1283
1284         if (ret == -1)
1285                 return;
1286
1287 #if defined(HAVE_SYSLOG)
1288         syslog( priority, "%s", msgbuf );
1289 #else
1290         DEBUG(0,("%s", msgbuf ));
1291 #endif
1292         SAFE_FREE(msgbuf);
1293 }
1294
1295 /******** Solaris EA helper function prototypes ********/
1296 #ifdef HAVE_ATTROPEN
1297 #define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP
1298 static int solaris_write_xattr(int attrfd, const char *value, size_t size);
1299 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size);
1300 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size);
1301 static int solaris_unlinkat(int attrdirfd, const char *name);
1302 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode);
1303 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode);
1304 #endif
1305
1306 /**************************************************************************
1307  Wrappers for extented attribute calls. Based on the Linux package with
1308  support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
1309 ****************************************************************************/
1310
1311 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
1312 {
1313 #if defined(HAVE_GETXATTR)
1314 #ifndef XATTR_ADD_OPT
1315         return getxattr(path, name, value, size);
1316 #else
1317         int options = 0;
1318         return getxattr(path, name, value, size, 0, options);
1319 #endif
1320 #elif defined(HAVE_GETEA)
1321         return getea(path, name, value, size);
1322 #elif defined(HAVE_EXTATTR_GET_FILE)
1323         char *s;
1324         ssize_t retval;
1325         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1326                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1327         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1328         /*
1329          * The BSD implementation has a nasty habit of silently truncating
1330          * the returned value to the size of the buffer, so we have to check
1331          * that the buffer is large enough to fit the returned value.
1332          */
1333         if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1334                 if(retval > size) {
1335                         errno = ERANGE;
1336                         return -1;
1337                 }
1338                 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
1339                         return retval;
1340         }
1341
1342         DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
1343         return -1;
1344 #elif defined(HAVE_ATTR_GET)
1345         int retval, flags = 0;
1346         int valuelength = (int)size;
1347         char *attrname = strchr(name,'.') + 1;
1348
1349         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1350
1351         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1352
1353         return retval ? retval : valuelength;
1354 #elif defined(HAVE_ATTROPEN)
1355         ssize_t ret = -1;
1356         int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
1357         if (attrfd >= 0) {
1358                 ret = solaris_read_xattr(attrfd, value, size);
1359                 close(attrfd);
1360         }
1361         return ret;
1362 #else
1363         errno = ENOSYS;
1364         return -1;
1365 #endif
1366 }
1367
1368 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
1369 {
1370 #if defined(HAVE_FGETXATTR)
1371 #ifndef XATTR_ADD_OPT
1372         return fgetxattr(filedes, name, value, size);
1373 #else
1374         int options = 0;
1375         return fgetxattr(filedes, name, value, size, 0, options);
1376 #endif
1377 #elif defined(HAVE_FGETEA)
1378         return fgetea(filedes, name, value, size);
1379 #elif defined(HAVE_EXTATTR_GET_FD)
1380         char *s;
1381         ssize_t retval;
1382         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1383                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1384         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1385
1386         if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
1387                 if(retval > size) {
1388                         errno = ERANGE;
1389                         return -1;
1390                 }
1391                 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
1392                         return retval;
1393         }
1394
1395         DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
1396         return -1;
1397 #elif defined(HAVE_ATTR_GETF)
1398         int retval, flags = 0;
1399         int valuelength = (int)size;
1400         char *attrname = strchr(name,'.') + 1;
1401
1402         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1403
1404         retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
1405
1406         return retval ? retval : valuelength;
1407 #elif defined(HAVE_ATTROPEN)
1408         ssize_t ret = -1;
1409         int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
1410         if (attrfd >= 0) {
1411                 ret = solaris_read_xattr(attrfd, value, size);
1412                 close(attrfd);
1413         }
1414         return ret;
1415 #else
1416         errno = ENOSYS;
1417         return -1;
1418 #endif
1419 }
1420
1421 #if defined(HAVE_EXTATTR_LIST_FILE)
1422
1423 #define EXTATTR_PREFIX(s)       (s), (sizeof((s))-1)
1424
1425 static struct {
1426         int space;
1427         const char *name;
1428         size_t len;
1429 }
1430 extattr[] = {
1431         { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
1432         { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
1433 };
1434
1435 typedef union {
1436         const char *path;
1437         int filedes;
1438 } extattr_arg;
1439
1440 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
1441 {
1442         ssize_t list_size, total_size = 0;
1443         int i, t, len;
1444         char *buf;
1445         /* Iterate through extattr(2) namespaces */
1446         for(t = 0; t < ARRAY_SIZE(extattr); t++) {
1447                 switch(type) {
1448 #if defined(HAVE_EXTATTR_LIST_FILE)
1449                         case 0:
1450                                 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
1451                                 break;
1452 #endif
1453 #if defined(HAVE_EXTATTR_LIST_LINK)
1454                         case 1:
1455                                 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
1456                                 break;
1457 #endif
1458 #if defined(HAVE_EXTATTR_LIST_FD)
1459                         case 2:
1460                                 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
1461                                 break;
1462 #endif
1463                         default:
1464                                 errno = ENOSYS;
1465                                 return -1;
1466                 }
1467                 /* Some error happend. Errno should be set by the previous call */
1468                 if(list_size < 0)
1469                         return -1;
1470                 /* No attributes */
1471                 if(list_size == 0)
1472                         continue;
1473                 /* XXX: Call with an empty buffer may be used to calculate
1474                    necessary buffer size. Unfortunately, we can't say, how
1475                    many attributes were returned, so here is the potential
1476                    problem with the emulation.
1477                 */
1478                 if(list == NULL) {
1479                         /* Take the worse case of one char attribute names -
1480                            two bytes per name plus one more for sanity.
1481                         */
1482                         total_size += list_size + (list_size/2 + 1)*extattr[t].len;
1483                         continue;
1484                 }
1485                 /* Count necessary offset to fit namespace prefixes */
1486                 len = 0;
1487                 for(i = 0; i < list_size; i += list[i] + 1)
1488                         len += extattr[t].len;
1489
1490                 total_size += list_size + len;
1491                 /* Buffer is too small to fit the results */
1492                 if(total_size > size) {
1493                         errno = ERANGE;
1494                         return -1;
1495                 }
1496                 /* Shift results back, so we can prepend prefixes */
1497                 buf = (char *)memmove(list + len, list, list_size);
1498
1499                 for(i = 0; i < list_size; i += len + 1) {
1500                         len = buf[i];
1501                         strncpy(list, extattr[t].name, extattr[t].len + 1);
1502                         list += extattr[t].len;
1503                         strncpy(list, buf + i + 1, len);
1504                         list[len] = '\0';
1505                         list += len + 1;
1506                 }
1507                 size -= total_size;
1508         }
1509         return total_size;
1510 }
1511
1512 #endif
1513
1514 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1515 static char attr_buffer[ATTR_MAX_VALUELEN];
1516
1517 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
1518 {
1519         int retval = 0, index;
1520         attrlist_cursor_t *cursor = 0;
1521         int total_size = 0;
1522         attrlist_t * al = (attrlist_t *)attr_buffer;
1523         attrlist_ent_t *ae;
1524         size_t ent_size, left = size;
1525         char *bp = list;
1526
1527         while (True) {
1528             if (filedes)
1529                 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1530             else
1531                 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1532             if (retval) break;
1533             for (index = 0; index < al->al_count; index++) {
1534                 ae = ATTR_ENTRY(attr_buffer, index);
1535                 ent_size = strlen(ae->a_name) + sizeof("user.");
1536                 if (left >= ent_size) {
1537                     strncpy(bp, "user.", sizeof("user."));
1538                     strncat(bp, ae->a_name, ent_size - sizeof("user."));
1539                     bp += ent_size;
1540                     left -= ent_size;
1541                 } else if (size) {
1542                     errno = ERANGE;
1543                     retval = -1;
1544                     break;
1545                 }
1546                 total_size += ent_size;
1547             }
1548             if (al->al_more == 0) break;
1549         }
1550         if (retval == 0) {
1551             flags |= ATTR_ROOT;
1552             cursor = 0;
1553             while (True) {
1554                 if (filedes)
1555                     retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1556                 else
1557                     retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1558                 if (retval) break;
1559                 for (index = 0; index < al->al_count; index++) {
1560                     ae = ATTR_ENTRY(attr_buffer, index);
1561                     ent_size = strlen(ae->a_name) + sizeof("system.");
1562                     if (left >= ent_size) {
1563                         strncpy(bp, "system.", sizeof("system."));
1564                         strncat(bp, ae->a_name, ent_size - sizeof("system."));
1565                         bp += ent_size;
1566                         left -= ent_size;
1567                     } else if (size) {
1568                         errno = ERANGE;
1569                         retval = -1;
1570                         break;
1571                     }
1572                     total_size += ent_size;
1573                 }
1574                 if (al->al_more == 0) break;
1575             }
1576         }
1577         return (ssize_t)(retval ? retval : total_size);
1578 }
1579
1580 #endif
1581
1582 ssize_t sys_listxattr (const char *path, char *list, size_t size)
1583 {
1584 #if defined(HAVE_LISTXATTR)
1585 #ifndef XATTR_ADD_OPT
1586         return listxattr(path, list, size);
1587 #else
1588         int options = 0;
1589         return listxattr(path, list, size, options);
1590 #endif
1591 #elif defined(HAVE_LISTEA)
1592         return listea(path, list, size);
1593 #elif defined(HAVE_EXTATTR_LIST_FILE)
1594         extattr_arg arg;
1595         arg.path = path;
1596         return bsd_attr_list(0, arg, list, size);
1597 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1598         return irix_attr_list(path, 0, list, size, 0);
1599 #elif defined(HAVE_ATTROPEN)
1600         ssize_t ret = -1;
1601         int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1602         if (attrdirfd >= 0) {
1603                 ret = solaris_list_xattr(attrdirfd, list, size);
1604                 close(attrdirfd);
1605         }
1606         return ret;
1607 #else
1608         errno = ENOSYS;
1609         return -1;
1610 #endif
1611 }
1612
1613 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
1614 {
1615 #if defined(HAVE_FLISTXATTR)
1616 #ifndef XATTR_ADD_OPT
1617         return flistxattr(filedes, list, size);
1618 #else
1619         int options = 0;
1620         return flistxattr(filedes, list, size, options);
1621 #endif
1622 #elif defined(HAVE_FLISTEA)
1623         return flistea(filedes, list, size);
1624 #elif defined(HAVE_EXTATTR_LIST_FD)
1625         extattr_arg arg;
1626         arg.filedes = filedes;
1627         return bsd_attr_list(2, arg, list, size);
1628 #elif defined(HAVE_ATTR_LISTF)
1629         return irix_attr_list(NULL, filedes, list, size, 0);
1630 #elif defined(HAVE_ATTROPEN)
1631         ssize_t ret = -1;
1632         int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1633         if (attrdirfd >= 0) {
1634                 ret = solaris_list_xattr(attrdirfd, list, size);
1635                 close(attrdirfd);
1636         }
1637         return ret;
1638 #else
1639         errno = ENOSYS;
1640         return -1;
1641 #endif
1642 }
1643
1644 int sys_removexattr (const char *path, const char *name)
1645 {
1646 #if defined(HAVE_REMOVEXATTR)
1647 #ifndef XATTR_ADD_OPT
1648         return removexattr(path, name);
1649 #else
1650         int options = 0;
1651         return removexattr(path, name, options);
1652 #endif
1653 #elif defined(HAVE_REMOVEEA)
1654         return removeea(path, name);
1655 #elif defined(HAVE_EXTATTR_DELETE_FILE)
1656         char *s;
1657         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1658                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1659         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1660
1661         return extattr_delete_file(path, attrnamespace, attrname);
1662 #elif defined(HAVE_ATTR_REMOVE)
1663         int flags = 0;
1664         char *attrname = strchr(name,'.') + 1;
1665
1666         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1667
1668         return attr_remove(path, attrname, flags);
1669 #elif defined(HAVE_ATTROPEN)
1670         int ret = -1;
1671         int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1672         if (attrdirfd >= 0) {
1673                 ret = solaris_unlinkat(attrdirfd, name);
1674                 close(attrdirfd);
1675         }
1676         return ret;
1677 #else
1678         errno = ENOSYS;
1679         return -1;
1680 #endif
1681 }
1682
1683 int sys_fremovexattr (int filedes, const char *name)
1684 {
1685 #if defined(HAVE_FREMOVEXATTR)
1686 #ifndef XATTR_ADD_OPT
1687         return fremovexattr(filedes, name);
1688 #else
1689         int options = 0;
1690         return fremovexattr(filedes, name, options);
1691 #endif
1692 #elif defined(HAVE_FREMOVEEA)
1693         return fremoveea(filedes, name);
1694 #elif defined(HAVE_EXTATTR_DELETE_FD)
1695         char *s;
1696         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1697                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1698         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1699
1700         return extattr_delete_fd(filedes, attrnamespace, attrname);
1701 #elif defined(HAVE_ATTR_REMOVEF)
1702         int flags = 0;
1703         char *attrname = strchr(name,'.') + 1;
1704
1705         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1706
1707         return attr_removef(filedes, attrname, flags);
1708 #elif defined(HAVE_ATTROPEN)
1709         int ret = -1;
1710         int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1711         if (attrdirfd >= 0) {
1712                 ret = solaris_unlinkat(attrdirfd, name);
1713                 close(attrdirfd);
1714         }
1715         return ret;
1716 #else
1717         errno = ENOSYS;
1718         return -1;
1719 #endif
1720 }
1721
1722 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1723 {
1724 #if defined(HAVE_SETXATTR)
1725 #ifndef XATTR_ADD_OPT
1726         return setxattr(path, name, value, size, flags);
1727 #else
1728         int options = 0;
1729         return setxattr(path, name, value, size, 0, options);
1730 #endif
1731 #elif defined(HAVE_SETEA)
1732         return setea(path, name, value, size, flags);
1733 #elif defined(HAVE_EXTATTR_SET_FILE)
1734         char *s;
1735         int retval = 0;
1736         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1737                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1738         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1739         if (flags) {
1740                 /* Check attribute existence */
1741                 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
1742                 if (retval < 0) {
1743                         /* REPLACE attribute, that doesn't exist */
1744                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
1745                                 errno = ENOATTR;
1746                                 return -1;
1747                         }
1748                         /* Ignore other errors */
1749                 }
1750                 else {
1751                         /* CREATE attribute, that already exists */
1752                         if (flags & XATTR_CREATE) {
1753                                 errno = EEXIST;
1754                                 return -1;
1755                         }
1756                 }
1757         }
1758         retval = extattr_set_file(path, attrnamespace, attrname, value, size);
1759         return (retval < 0) ? -1 : 0;
1760 #elif defined(HAVE_ATTR_SET)
1761         int myflags = 0;
1762         char *attrname = strchr(name,'.') + 1;
1763
1764         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1765         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1766         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1767
1768         return attr_set(path, attrname, (const char *)value, size, myflags);
1769 #elif defined(HAVE_ATTROPEN)
1770         int ret = -1;
1771         int myflags = O_RDWR;
1772         int attrfd;
1773         if (flags & XATTR_CREATE) myflags |= O_EXCL;
1774         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
1775         attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
1776         if (attrfd >= 0) {
1777                 ret = solaris_write_xattr(attrfd, value, size);
1778                 close(attrfd);
1779         }
1780         return ret;
1781 #else
1782         errno = ENOSYS;
1783         return -1;
1784 #endif
1785 }
1786
1787 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
1788 {
1789 #if defined(HAVE_FSETXATTR)
1790 #ifndef XATTR_ADD_OPT
1791         return fsetxattr(filedes, name, value, size, flags);
1792 #else
1793         int options = 0;
1794         return fsetxattr(filedes, name, value, size, 0, options);
1795 #endif
1796 #elif defined(HAVE_FSETEA)
1797         return fsetea(filedes, name, value, size, flags);
1798 #elif defined(HAVE_EXTATTR_SET_FD)
1799         char *s;
1800         int retval = 0;
1801         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1802                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1803         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1804         if (flags) {
1805                 /* Check attribute existence */
1806                 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
1807                 if (retval < 0) {
1808                         /* REPLACE attribute, that doesn't exist */
1809                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
1810                                 errno = ENOATTR;
1811                                 return -1;
1812                         }
1813                         /* Ignore other errors */
1814                 }
1815                 else {
1816                         /* CREATE attribute, that already exists */
1817                         if (flags & XATTR_CREATE) {
1818                                 errno = EEXIST;
1819                                 return -1;
1820                         }
1821                 }
1822         }
1823         retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
1824         return (retval < 0) ? -1 : 0;
1825 #elif defined(HAVE_ATTR_SETF)
1826         int myflags = 0;
1827         char *attrname = strchr(name,'.') + 1;
1828
1829         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1830         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1831         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1832
1833         return attr_setf(filedes, attrname, (const char *)value, size, myflags);
1834 #elif defined(HAVE_ATTROPEN)
1835         int ret = -1;
1836         int myflags = O_RDWR | O_XATTR;
1837         int attrfd;
1838         if (flags & XATTR_CREATE) myflags |= O_EXCL;
1839         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
1840         attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
1841         if (attrfd >= 0) {
1842                 ret = solaris_write_xattr(attrfd, value, size);
1843                 close(attrfd);
1844         }
1845         return ret;
1846 #else
1847         errno = ENOSYS;
1848         return -1;
1849 #endif
1850 }
1851
1852 /**************************************************************************
1853  helper functions for Solaris' EA support
1854 ****************************************************************************/
1855 #ifdef HAVE_ATTROPEN
1856 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
1857 {
1858         struct stat sbuf;
1859
1860         if (fstat(attrfd, &sbuf) == -1) {
1861                 errno = ENOATTR;
1862                 return -1;
1863         }
1864
1865         /* This is to return the current size of the named extended attribute */
1866         if (size == 0) {
1867                 return sbuf.st_size;
1868         }
1869
1870         /* check size and read xattr */
1871         if (sbuf.st_size > size) {
1872                 errno = ERANGE;
1873                 return -1;
1874         }
1875
1876         return read(attrfd, value, sbuf.st_size);
1877 }
1878
1879 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
1880 {
1881         ssize_t len = 0;
1882         DIR *dirp;
1883         struct dirent *de;
1884         int newfd = dup(attrdirfd);
1885         /* CAUTION: The originating file descriptor should not be
1886                     used again following the call to fdopendir().
1887                     For that reason we dup() the file descriptor
1888                     here to make things more clear. */
1889         dirp = fdopendir(newfd);
1890
1891         while ((de = readdir(dirp))) {
1892                 size_t listlen = strlen(de->d_name) + 1;
1893                 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
1894                         /* we don't want "." and ".." here: */
1895                         DEBUG(10,("skipped EA %s\n",de->d_name));
1896                         continue;
1897                 }
1898
1899                 if (size == 0) {
1900                         /* return the current size of the list of extended attribute names*/
1901                         len += listlen;
1902                 } else {
1903                         /* check size and copy entrieѕ + nul into list. */
1904                         if ((len + listlen) > size) {
1905                                 errno = ERANGE;
1906                                 len = -1;
1907                                 break;
1908                         } else {
1909                                 strlcpy(list + len, de->d_name, listlen);
1910                                 len += listlen;
1911                         }
1912                 }
1913         }
1914
1915         if (closedir(dirp) == -1) {
1916                 DEBUG(0,("closedir dirp failed: %s\n",strerror(errno)));
1917                 return -1;
1918         }
1919         return len;
1920 }
1921
1922 static int solaris_unlinkat(int attrdirfd, const char *name)
1923 {
1924         if (unlinkat(attrdirfd, name, 0) == -1) {
1925                 if (errno == ENOENT) {
1926                         errno = ENOATTR;
1927                 }
1928                 return -1;
1929         }
1930         return 0;
1931 }
1932
1933 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
1934 {
1935         int filedes = attropen(path, attrpath, oflag, mode);
1936         if (filedes == -1) {
1937                 DEBUG(10,("attropen FAILED: path: %s, name: %s, errno: %s\n",path,attrpath,strerror(errno)));
1938                 if (errno == EINVAL) {
1939                         errno = ENOTSUP;
1940                 } else {
1941                         errno = ENOATTR;
1942                 }
1943         }
1944         return filedes;
1945 }
1946
1947 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
1948 {
1949         int filedes = openat(fildes, path, oflag, mode);
1950         if (filedes == -1) {
1951                 DEBUG(10,("openat FAILED: fd: %d, path: %s, errno: %s\n",filedes,path,strerror(errno)));
1952                 if (errno == EINVAL) {
1953                         errno = ENOTSUP;
1954                 } else {
1955                         errno = ENOATTR;
1956                 }
1957         }
1958         return filedes;
1959 }
1960
1961 static int solaris_write_xattr(int attrfd, const char *value, size_t size)
1962 {
1963         if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
1964                 return 0;
1965         } else {
1966                 DEBUG(10,("solaris_write_xattr FAILED!\n"));
1967                 return -1;
1968         }
1969 }
1970 #endif /*HAVE_ATTROPEN*/
1971
1972
1973 /****************************************************************************
1974  Return the major devicenumber for UNIX extensions.
1975 ****************************************************************************/
1976
1977 uint32 unix_dev_major(SMB_DEV_T dev)
1978 {
1979 #if defined(HAVE_DEVICE_MAJOR_FN)
1980         return (uint32)major(dev);
1981 #else
1982         return (uint32)(dev >> 8);
1983 #endif
1984 }
1985
1986 /****************************************************************************
1987  Return the minor devicenumber for UNIX extensions.
1988 ****************************************************************************/
1989
1990 uint32 unix_dev_minor(SMB_DEV_T dev)
1991 {
1992 #if defined(HAVE_DEVICE_MINOR_FN)
1993         return (uint32)minor(dev);
1994 #else
1995         return (uint32)(dev & 0xff);
1996 #endif
1997 }
1998
1999 #if 0
2000 /*******************************************************************
2001  Return the number of CPUs.
2002 ********************************************************************/
2003
2004 int sys_get_number_of_cores(void)
2005 {
2006         int ret = -1;
2007
2008 #if defined(HAVE_SYSCONF)
2009 #if defined(_SC_NPROCESSORS_ONLN)
2010         ret = (int)sysconf(_SC_NPROCESSORS_ONLN);
2011 #endif
2012 #if defined(_SC_NPROCESSORS_CONF)
2013         if (ret < 1) {
2014                 ret = (int)sysconf(_SC_NPROCESSORS_CONF);
2015         }
2016 #endif
2017 #elif defined(HAVE_SYSCTL) && defined(CTL_HW)
2018         int name[2];
2019         unsigned int len = sizeof(ret);
2020
2021         name[0] = CTL_HW;
2022 #if defined(HW_AVAILCPU)
2023         name[1] = HW_AVAILCPU;
2024
2025         if (sysctl(name, 2, &ret, &len, NULL, 0) == -1) {
2026                 ret = -1;
2027         }
2028 #endif
2029 #if defined(HW_NCPU)
2030         if(ret < 1) {
2031                 name[0] = CTL_HW;
2032                 name[1] = HW_NCPU;
2033                 if (sysctl(nm, 2, &count, &len, NULL, 0) == -1) {
2034                         ret = -1;
2035                 }
2036         }
2037 #endif
2038 #endif
2039         if (ret < 1) {
2040                 ret = 1;
2041         }
2042         return ret;
2043 }
2044 #endif
2045
2046 #if defined(WITH_AIO)
2047
2048 /*******************************************************************
2049  An aio_read wrapper.
2050 ********************************************************************/
2051
2052 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2053 {
2054 #if defined(HAVE_AIO_READ)
2055         return aio_read(aiocb);
2056 #else
2057         errno = ENOSYS;
2058         return -1;
2059 #endif
2060 }
2061
2062 /*******************************************************************
2063  An aio_write wrapper.
2064 ********************************************************************/
2065
2066 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2067 {
2068 #if defined(HAVE_AIO_WRITE)
2069         return aio_write(aiocb);
2070 #else
2071         errno = ENOSYS;
2072         return -1;
2073 #endif
2074 }
2075
2076 /*******************************************************************
2077  An aio_return wrapper.
2078 ********************************************************************/
2079
2080 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2081 {
2082 #if defined(HAVE_AIO_RETURN)
2083         return aio_return(aiocb);
2084 #else
2085         errno = ENOSYS;
2086         return -1;
2087 #endif
2088 }
2089
2090 /*******************************************************************
2091  An aio_cancel wrapper.
2092 ********************************************************************/
2093
2094 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2095 {
2096 #if defined(HAVE_AIO_CANCEL)
2097         return aio_cancel(fd, aiocb);
2098 #else
2099         errno = ENOSYS;
2100         return -1;
2101 #endif
2102 }
2103
2104 /*******************************************************************
2105  An aio_error wrapper.
2106 ********************************************************************/
2107
2108 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2109 {
2110 #if defined(HAVE_AIO_ERROR)
2111         return aio_error(aiocb);
2112 #else
2113         errno = ENOSYS;
2114         return -1;
2115 #endif
2116 }
2117
2118 /*******************************************************************
2119  An aio_fsync wrapper.
2120 ********************************************************************/
2121
2122 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2123 {
2124 #if defined(HAVE_AIO_FSYNC)
2125         return aio_fsync(op, aiocb);
2126 #else
2127         errno = ENOSYS;
2128         return -1;
2129 #endif
2130 }
2131
2132 /*******************************************************************
2133  An aio_fsync wrapper.
2134 ********************************************************************/
2135
2136 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2137 {
2138 #if defined(HAVE_AIO_FSYNC)
2139         return aio_suspend(cblist, n, timeout);
2140 #else
2141         errno = ENOSYS;
2142         return -1;
2143 #endif
2144 }
2145 #else /* !WITH_AIO */
2146
2147 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2148 {
2149         errno = ENOSYS;
2150         return -1;
2151 }
2152
2153 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2154 {
2155         errno = ENOSYS;
2156         return -1;
2157 }
2158
2159 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2160 {
2161         errno = ENOSYS;
2162         return -1;
2163 }
2164
2165 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2166 {
2167         errno = ENOSYS;
2168         return -1;
2169 }
2170
2171 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2172 {
2173         errno = ENOSYS;
2174         return -1;
2175 }
2176
2177 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2178 {
2179         errno = ENOSYS;
2180         return -1;
2181 }
2182
2183 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2184 {
2185         errno = ENOSYS;
2186         return -1;
2187 }
2188 #endif /* WITH_AIO */