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
  25 #ifdef HAVE_SYS_PRCTL_H
  26 #include <sys/prctl.h>
  27 #endif
  28
  29 /*
  30    The idea is that this file will eventually have wrappers around all
  31    important system calls in samba. The aims are:
  32
  33    - to enable easier porting by putting OS dependent stuff in here
  34
  35    - to allow for hooks into other "pseudo-filesystems"
  36
  37    - to allow easier integration of things like the japanese extensions
  38
  39    - to support the philosophy of Samba to expose the features of
  40      the OS within the SMB model. In general whatever file/printer/variable
  41      expansions/etc make sense to the OS should be acceptable to Samba.
  42 */
  43
  44
  45
  46 /*******************************************************************
  47  A wrapper for memalign
  48 ********************************************************************/
  49
  50 void *sys_memalign( size_t align, size_t size )
  51 {
  52 #if defined(HAVE_POSIX_MEMALIGN)
  53         void *p = NULL;
  54         int ret = posix_memalign( &p, align, size );
  55         if ( ret == 0 )
  56                 return p;
  57
  58         return NULL;
  59 #elif defined(HAVE_MEMALIGN)
  60         return memalign( align, size );
  61 #else
  62         /* On *BSD systems memaligns doesn't exist, but memory will
  63          * be aligned on allocations of > pagesize. */
  64 #if defined(SYSCONF_SC_PAGESIZE)
  65         size_t pagesize = (size_t)sysconf(_SC_PAGESIZE);
  66 #elif defined(HAVE_GETPAGESIZE)
  67         size_t pagesize = (size_t)getpagesize();
  68 #else
  69         size_t pagesize = (size_t)-1;
  70 #endif
  71         if (pagesize == (size_t)-1) {
  72                 DEBUG(0,("memalign functionalaity not available on this platform!\n"));
  73                 return NULL;
  74         }
  75         if (size < pagesize) {
  76                 size = pagesize;
  77         }
  78         return SMB_MALLOC(size);
  79 #endif
  80 }
  81
  82 /*******************************************************************
  83  A wrapper for usleep in case we don't have one.
  84 ********************************************************************/
  85
  86 int sys_usleep(long usecs)
  87 {
  88 #ifndef HAVE_USLEEP
  89         struct timeval tval;
  90 #endif
  91
  92         /*
  93          * We need this braindamage as the glibc usleep
  94          * is not SPEC1170 complient... grumble... JRA.
  95          */
  96
  97         if(usecs < 0 || usecs > 1000000) {
  98                 errno = EINVAL;
  99                 return -1;
 100         }
 101
 102 #if HAVE_USLEEP
 103         usleep(usecs);
 104         return 0;
 105 #else /* HAVE_USLEEP */
 106         /*
 107          * Fake it with select...
 108          */
 109         tval.tv_sec = 0;
 110         tval.tv_usec = usecs/1000;
 111         select(0,NULL,NULL,NULL,&tval);
 112         return 0;
 113 #endif /* HAVE_USLEEP */
 114 }
 115
 116 /*******************************************************************
 117 A read wrapper that will deal with EINTR.
 118 ********************************************************************/
 119
 120 ssize_t sys_read(int fd, void *buf, size_t count)
 121 {
 122         ssize_t ret;
 123
 124         do {
 125                 ret = read(fd, buf, count);
 126         } while (ret == -1 && errno == EINTR);
 127         return ret;
 128 }
 129
 130 /*******************************************************************
 131 A write wrapper that will deal with EINTR.
 132 ********************************************************************/
 133
 134 ssize_t sys_write(int fd, const void *buf, size_t count)
 135 {
 136         ssize_t ret;
 137
 138         do {
 139                 ret = write(fd, buf, count);
 140         } while (ret == -1 && errno == EINTR);
 141         return ret;
 142 }
 143
 144 /*******************************************************************
 145 A pread wrapper that will deal with EINTR and 64-bit file offsets.
 146 ********************************************************************/
 147
 148 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
 149 ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
 150 {
 151         ssize_t ret;
 152
 153         do {
 154 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PREAD64)
 155                 ret = pread64(fd, buf, count, off);
 156 #else
 157                 ret = pread(fd, buf, count, off);
 158 #endif
 159         } while (ret == -1 && errno == EINTR);
 160         return ret;
 161 }
 162 #endif
 163
 164 /*******************************************************************
 165 A write wrapper that will deal with EINTR and 64-bit file offsets.
 166 ********************************************************************/
 167
 168 #if defined(HAVE_PWRITE) || defined(HAVE_PWRITE64)
 169 ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off)
 170 {
 171         ssize_t ret;
 172
 173         do {
 174 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64)
 175                 ret = pwrite64(fd, buf, count, off);
 176 #else
 177                 ret = pwrite(fd, buf, count, off);
 178 #endif
 179         } while (ret == -1 && errno == EINTR);
 180         return ret;
 181 }
 182 #endif
 183
 184 /*******************************************************************
 185 A send wrapper that will deal with EINTR.
 186 ********************************************************************/
 187
 188 ssize_t sys_send(int s, const void *msg, size_t len, int flags)
 189 {
 190         ssize_t ret;
 191
 192         do {
 193                 ret = send(s, msg, len, flags);
 194         } while (ret == -1 && errno == EINTR);
 195         return ret;
 196 }
 197
 198 /*******************************************************************
 199 A sendto wrapper that will deal with EINTR.
 200 ********************************************************************/
 201
 202 ssize_t sys_sendto(int s,  const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
 203 {
 204         ssize_t ret;
 205
 206         do {
 207                 ret = sendto(s, msg, len, flags, to, tolen);
 208         } while (ret == -1 && errno == EINTR);
 209         return ret;
 210 }
 211
 212 /*******************************************************************
 213 A recv wrapper that will deal with EINTR.
 214 ********************************************************************/
 215
 216 ssize_t sys_recv(int fd, void *buf, size_t count, int flags)
 217 {
 218         ssize_t ret;
 219
 220         do {
 221                 ret = recv(fd, buf, count, flags);
 222         } while (ret == -1 && errno == EINTR);
 223         return ret;
 224 }
 225
 226 /*******************************************************************
 227 A recvfrom wrapper that will deal with EINTR.
 228 ********************************************************************/
 229
 230 ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 231 {
 232         ssize_t ret;
 233
 234         do {
 235                 ret = recvfrom(s, buf, len, flags, from, fromlen);
 236         } while (ret == -1 && errno == EINTR);
 237         return ret;
 238 }
 239
 240 /*******************************************************************
 241 A fcntl wrapper that will deal with EINTR.
 242 ********************************************************************/
 243
 244 int sys_fcntl_ptr(int fd, int cmd, void *arg)
 245 {
 246         int ret;
 247
 248         do {
 249                 ret = fcntl(fd, cmd, arg);
 250         } while (ret == -1 && errno == EINTR);
 251         return ret;
 252 }
 253
 254 /*******************************************************************
 255 A fcntl wrapper that will deal with EINTR.
 256 ********************************************************************/
 257
 258 int sys_fcntl_long(int fd, int cmd, long arg)
 259 {
 260         int ret;
 261
 262         do {
 263                 ret = fcntl(fd, cmd, arg);
 264         } while (ret == -1 && errno == EINTR);
 265         return ret;
 266 }
 267
 268 /*******************************************************************
 269 A stat() wrapper that will deal with 64 bit filesizes.
 270 ********************************************************************/
 271
 272 int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
 273 {
 274         int ret;
 275 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
 276         ret = stat64(fname, sbuf);
 277 #else
 278         ret = stat(fname, sbuf);
 279 #endif
 280         /* we always want directories to appear zero size */
 281         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
 282         return ret;
 283 }
 284
 285 /*******************************************************************
 286  An fstat() wrapper that will deal with 64 bit filesizes.
 287 ********************************************************************/
 288
 289 int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
 290 {
 291         int ret;
 292 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
 293         ret = fstat64(fd, sbuf);
 294 #else
 295         ret = fstat(fd, sbuf);
 296 #endif
 297         /* we always want directories to appear zero size */
 298         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
 299         return ret;
 300 }
 301
 302 /*******************************************************************
 303  An lstat() wrapper that will deal with 64 bit filesizes.
 304 ********************************************************************/
 305
 306 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
 307 {
 308         int ret;
 309 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
 310         ret = lstat64(fname, sbuf);
 311 #else
 312         ret = lstat(fname, sbuf);
 313 #endif
 314         /* we always want directories to appear zero size */
 315         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
 316         return ret;
 317 }
 318
 319 /*******************************************************************
 320  An ftruncate() wrapper that will deal with 64 bit filesizes.
 321 ********************************************************************/
 322
 323 int sys_ftruncate(int fd, SMB_OFF_T offset)
 324 {
 325 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
 326         return ftruncate64(fd, offset);
 327 #else
 328         return ftruncate(fd, offset);
 329 #endif
 330 }
 331
 332 /*******************************************************************
 333  An lseek() wrapper that will deal with 64 bit filesizes.
 334 ********************************************************************/
 335
 336 SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
 337 {
 338 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
 339         return lseek64(fd, offset, whence);
 340 #else
 341         return lseek(fd, offset, whence);
 342 #endif
 343 }
 344
 345 /*******************************************************************
 346  An fseek() wrapper that will deal with 64 bit filesizes.
 347 ********************************************************************/
 348
 349 int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
 350 {
 351 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
 352         return fseek64(fp, offset, whence);
 353 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
 354         return fseeko64(fp, offset, whence);
 355 #else
 356         return fseek(fp, offset, whence);
 357 #endif
 358 }
 359
 360 /*******************************************************************
 361  An ftell() wrapper that will deal with 64 bit filesizes.
 362 ********************************************************************/
 363
 364 SMB_OFF_T sys_ftell(FILE *fp)
 365 {
 366 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
 367         return (SMB_OFF_T)ftell64(fp);
 368 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
 369         return (SMB_OFF_T)ftello64(fp);
 370 #else
 371         return (SMB_OFF_T)ftell(fp);
 372 #endif
 373 }
 374
 375 /*******************************************************************
 376  A creat() wrapper that will deal with 64 bit filesizes.
 377 ********************************************************************/
 378
 379 int sys_creat(const char *path, mode_t mode)
 380 {
 381 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
 382         return creat64(path, mode);
 383 #else
 384         /*
 385          * If creat64 isn't defined then ensure we call a potential open64.
 386          * JRA.
 387          */
 388         return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
 389 #endif
 390 }
 391
 392 /*******************************************************************
 393  An open() wrapper that will deal with 64 bit filesizes.
 394 ********************************************************************/
 395
 396 int sys_open(const char *path, int oflag, mode_t mode)
 397 {
 398 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
 399         return open64(path, oflag, mode);
 400 #else
 401         return open(path, oflag, mode);
 402 #endif
 403 }
 404
 405 /*******************************************************************
 406  An fopen() wrapper that will deal with 64 bit filesizes.
 407 ********************************************************************/
 408
 409 FILE *sys_fopen(const char *path, const char *type)
 410 {
 411 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
 412         return fopen64(path, type);
 413 #else
 414         return fopen(path, type);
 415 #endif
 416 }
 417
 418
 419 /*******************************************************************
 420  A flock() wrapper that will perform the kernel flock.
 421 ********************************************************************/
 422
 423 void kernel_flock(int fd, uint32 share_mode)
 424 {
 425 #if HAVE_KERNEL_SHARE_MODES
 426         int kernel_mode = 0;
 427         if (share_mode == FILE_SHARE_WRITE) {
 428                 kernel_mode = LOCK_MAND|LOCK_WRITE;
 429         } else if (share_mode == FILE_SHARE_READ) {
 430                 kernel_mode = LOCK_MAND|LOCK_READ;
 431         } else if (share_mode == FILE_SHARE_NONE) {
 432                 kernel_mode = LOCK_MAND;
 433         }
 434         if (kernel_mode) {
 435                 flock(fd, kernel_mode);
 436         }
 437 #endif
 438         ;
 439 }
 440
 441
 442
 443 /*******************************************************************
 444  An opendir wrapper that will deal with 64 bit filesizes.
 445 ********************************************************************/
 446
 447 SMB_STRUCT_DIR *sys_opendir(const char *name)
 448 {
 449 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
 450         return opendir64(name);
 451 #else
 452         return opendir(name);
 453 #endif
 454 }
 455
 456 /*******************************************************************
 457  A readdir wrapper that will deal with 64 bit filesizes.
 458 ********************************************************************/
 459
 460 SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
 461 {
 462 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
 463         return readdir64(dirp);
 464 #else
 465         return readdir(dirp);
 466 #endif
 467 }
 468
 469 /*******************************************************************
 470  A seekdir wrapper that will deal with 64 bit filesizes.
 471 ********************************************************************/
 472
 473 void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset)
 474 {
 475 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_SEEKDIR64)
 476         seekdir64(dirp, offset);
 477 #else
 478         seekdir(dirp, offset);
 479 #endif
 480 }
 481
 482 /*******************************************************************
 483  A telldir wrapper that will deal with 64 bit filesizes.
 484 ********************************************************************/
 485
 486 long sys_telldir(SMB_STRUCT_DIR *dirp)
 487 {
 488 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_TELLDIR64)
 489         return (long)telldir64(dirp);
 490 #else
 491         return (long)telldir(dirp);
 492 #endif
 493 }
 494
 495 /*******************************************************************
 496  A rewinddir wrapper that will deal with 64 bit filesizes.
 497 ********************************************************************/
 498
 499 void sys_rewinddir(SMB_STRUCT_DIR *dirp)
 500 {
 501 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
 502         rewinddir64(dirp);
 503 #else
 504         rewinddir(dirp);
 505 #endif
 506 }
 507
 508 /*******************************************************************
 509  A close wrapper that will deal with 64 bit filesizes.
 510 ********************************************************************/
 511
 512 int sys_closedir(SMB_STRUCT_DIR *dirp)
 513 {
 514 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
 515         return closedir64(dirp);
 516 #else
 517         return closedir(dirp);
 518 #endif
 519 }
 520
 521 /*******************************************************************
 522  An mknod() wrapper that will deal with 64 bit filesizes.
 523 ********************************************************************/
 524
 525 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
 526 {
 527 #if defined(HAVE_MKNOD) || defined(HAVE_MKNOD64)
 528 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_MKNOD64) && defined(HAVE_DEV64_T)
 529         return mknod64(path, mode, dev);
 530 #else
 531         return mknod(path, mode, dev);
 532 #endif
 533 #else
 534         /* No mknod system call. */
 535         errno = ENOSYS;
 536         return -1;
 537 #endif
 538 }
 539
 540 /*******************************************************************
 541  Wrapper for realpath.
 542 ********************************************************************/
 543
 544 char *sys_realpath(const char *path, char *resolved_path)
 545 {
 546 #if defined(HAVE_REALPATH)
 547         return realpath(path, resolved_path);
 548 #else
 549         /* As realpath is not a system call we can't return ENOSYS. */
 550         errno = EINVAL;
 551         return NULL;
 552 #endif
 553 }
 554
 555 /*******************************************************************
 556 The wait() calls vary between systems
 557 ********************************************************************/
 558
 559 int sys_waitpid(pid_t pid,int *status,int options)
 560 {
 561 #ifdef HAVE_WAITPID
 562         return waitpid(pid,status,options);
 563 #else /* HAVE_WAITPID */
 564         return wait4(pid, status, options, NULL);
 565 #endif /* HAVE_WAITPID */
 566 }
 567
 568 /*******************************************************************
 569  System wrapper for getwd
 570 ********************************************************************/
 571
 572 char *sys_getwd(char *s)
 573 {
 574         char *wd;
 575 #ifdef HAVE_GETCWD
 576         wd = (char *)getcwd(s, PATH_MAX);
 577 #else
 578         wd = (char *)getwd(s);
 579 #endif
 580         return wd;
 581 }
 582
 583 /*******************************************************************
 584 system wrapper for symlink
 585 ********************************************************************/
 586
 587 int sys_symlink(const char *oldpath, const char *newpath)
 588 {
 589 #ifndef HAVE_SYMLINK
 590         errno = ENOSYS;
 591         return -1;
 592 #else
 593         return symlink(oldpath, newpath);
 594 #endif
 595 }
 596
 597 /*******************************************************************
 598 system wrapper for readlink
 599 ********************************************************************/
 600
 601 int sys_readlink(const char *path, char *buf, size_t bufsiz)
 602 {
 603 #ifndef HAVE_READLINK
 604         errno = ENOSYS;
 605         return -1;
 606 #else
 607         return readlink(path, buf, bufsiz);
 608 #endif
 609 }
 610
 611 /*******************************************************************
 612 system wrapper for link
 613 ********************************************************************/
 614
 615 int sys_link(const char *oldpath, const char *newpath)
 616 {
 617 #ifndef HAVE_LINK
 618         errno = ENOSYS;
 619         return -1;
 620 #else
 621         return link(oldpath, newpath);
 622 #endif
 623 }
 624
 625 /*******************************************************************
 626 chown isn't used much but OS/2 doesn't have it
 627 ********************************************************************/
 628
 629 int sys_chown(const char *fname,uid_t uid,gid_t gid)
 630 {
 631 #ifndef HAVE_CHOWN
 632         static int done;
 633         if (!done) {
 634                 DEBUG(1,("WARNING: no chown!\n"));
 635                 done=1;
 636         }
 637         errno = ENOSYS;
 638         return -1;
 639 #else
 640         return(chown(fname,uid,gid));
 641 #endif
 642 }
 643
 644 /*******************************************************************
 645  Wrapper for lchown.
 646 ********************************************************************/
 647
 648 int sys_lchown(const char *fname,uid_t uid,gid_t gid)
 649 {
 650 #ifndef HAVE_LCHOWN
 651         static int done;
 652         if (!done) {
 653                 DEBUG(1,("WARNING: no lchown!\n"));
 654                 done=1;
 655         }
 656         errno = ENOSYS;
 657         return -1;
 658 #else
 659         return(lchown(fname,uid,gid));
 660 #endif
 661 }
 662
 663 /*******************************************************************
 664 os/2 also doesn't have chroot
 665 ********************************************************************/
 666 int sys_chroot(const char *dname)
 667 {
 668 #ifndef HAVE_CHROOT
 669         static int done;
 670         if (!done) {
 671                 DEBUG(1,("WARNING: no chroot!\n"));
 672                 done=1;
 673         }
 674         errno = ENOSYS;
 675         return -1;
 676 #else
 677         return(chroot(dname));
 678 #endif
 679 }
 680
 681 #if defined(HAVE_POSIX_CAPABILITIES)
 682
 683 /**************************************************************************
 684  Try and abstract process capabilities (for systems that have them).
 685 ****************************************************************************/
 686
 687 /* Set the POSIX capabilities needed for the given purpose into the effective
 688  * capability set of the current process. Make sure they are always removed
 689  * from the inheritable set, because there is no circumstance in which our
 690  * children should inherit our elevated privileges.
 691  */
 692 static bool set_process_capability(enum smbd_capability capability,
 693                                    bool enable)
 694 {
 695         cap_value_t cap_vals[2] = {0};
 696         int num_cap_vals = 0;
 697
 698         cap_t cap;
 699
 700 #if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
 701         /* On Linux, make sure that any capabilities we grab are sticky
 702          * across UID changes. We expect that this would allow us to keep both
 703          * the effective and permitted capability sets, but as of circa 2.6.16,
 704          * only the permitted set is kept. It is a bug (which we work around)
 705          * that the effective set is lost, but we still require the effective
 706          * set to be kept.
 707          */
 708         if (!prctl(PR_GET_KEEPCAPS)) {
 709                 prctl(PR_SET_KEEPCAPS, 1);
 710         }
 711 #endif
 712
 713         cap = cap_get_proc();
 714         if (cap == NULL) {
 715                 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
 716                         strerror(errno)));
 717                 return False;
 718         }
 719
 720         switch (capability) {
 721                 case KERNEL_OPLOCK_CAPABILITY:
 722 #ifdef CAP_NETWORK_MGT
 723                         /* IRIX has CAP_NETWORK_MGT for oplocks. */
 724                         cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
 725 #endif
 726                         break;
 727                 case DMAPI_ACCESS_CAPABILITY:
 728 #ifdef CAP_DEVICE_MGT
 729                         /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
 730                         cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
 731 #elif CAP_MKNOD
 732                         /* Linux has CAP_MKNOD for DMAPI access. */
 733                         cap_vals[num_cap_vals++] = CAP_MKNOD;
 734 #endif
 735                         break;
 736         }
 737
 738         SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
 739
 740         if (num_cap_vals == 0) {
 741                 cap_free(cap);
 742                 return True;
 743         }
 744
 745         cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
 746                 enable ? CAP_SET : CAP_CLEAR);
 747
 748         /* We never want to pass capabilities down to our children, so make
 749          * sure they are not inherited.
 750          */
 751         cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
 752
 753         if (cap_set_proc(cap) == -1) {
 754                 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
 755                         strerror(errno)));
 756                 cap_free(cap);
 757                 return False;
 758         }
 759
 760         cap_free(cap);
 761         return True;
 762 }
 763
 764 #endif /* HAVE_POSIX_CAPABILITIES */
 765
 766 /****************************************************************************
 767  Gain the oplock capability from the kernel if possible.
 768 ****************************************************************************/
 769
 770 void set_effective_capability(enum smbd_capability capability)
 771 {
 772 #if defined(HAVE_POSIX_CAPABILITIES)
 773         set_process_capability(capability, True);
 774 #endif /* HAVE_POSIX_CAPABILITIES */
 775 }
 776
 777 void drop_effective_capability(enum smbd_capability capability)
 778 {
 779 #if defined(HAVE_POSIX_CAPABILITIES)
 780         set_process_capability(capability, False);
 781 #endif /* HAVE_POSIX_CAPABILITIES */
 782 }
 783
 784 /**************************************************************************
 785  Wrapper for random().
 786 ****************************************************************************/
 787
 788 long sys_random(void)
 789 {
 790 #if defined(HAVE_RANDOM)
 791         return (long)random();
 792 #elif defined(HAVE_RAND)
 793         return (long)rand();
 794 #else
 795         DEBUG(0,("Error - no random function available !\n"));
 796         exit(1);
 797 #endif
 798 }
 799
 800 /**************************************************************************
 801  Wrapper for srandom().
 802 ****************************************************************************/
 803
 804 void sys_srandom(unsigned int seed)
 805 {
 806 #if defined(HAVE_SRANDOM)
 807         srandom(seed);
 808 #elif defined(HAVE_SRAND)
 809         srand(seed);
 810 #else
 811         DEBUG(0,("Error - no srandom function available !\n"));
 812         exit(1);
 813 #endif
 814 }
 815
 816 /**************************************************************************
 817  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
 818 ****************************************************************************/
 819
 820 int groups_max(void)
 821 {
 822 #if defined(SYSCONF_SC_NGROUPS_MAX)
 823         int ret = sysconf(_SC_NGROUPS_MAX);
 824         return (ret == -1) ? NGROUPS_MAX : ret;
 825 #else
 826         return NGROUPS_MAX;
 827 #endif
 828 }
 829
 830 /**************************************************************************
 831  Wrap setgroups and getgroups for systems that declare getgroups() as
 832  returning an array of gid_t, but actuall return an array of int.
 833 ****************************************************************************/
 834
 835 #if defined(HAVE_BROKEN_GETGROUPS)
 836 static int sys_broken_getgroups(int setlen, gid_t *gidset)
 837 {
 838         GID_T gid;
 839         GID_T *group_list;
 840         int i, ngroups;
 841
 842         if(setlen == 0) {
 843                 return getgroups(setlen, &gid);
 844         }
 845
 846         /*
 847          * Broken case. We need to allocate a
 848          * GID_T array of size setlen.
 849          */
 850
 851         if(setlen < 0) {
 852                 errno = EINVAL;
 853                 return -1;
 854         }
 855
 856         if (setlen == 0)
 857                 setlen = groups_max();
 858
 859         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
 860                 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
 861                 return -1;
 862         }
 863
 864         if((ngroups = getgroups(setlen, group_list)) < 0) {
 865                 int saved_errno = errno;
 866                 SAFE_FREE(group_list);
 867                 errno = saved_errno;
 868                 return -1;
 869         }
 870
 871         for(i = 0; i < ngroups; i++)
 872                 gidset[i] = (gid_t)group_list[i];
 873
 874         SAFE_FREE(group_list);
 875         return ngroups;
 876 }
 877
 878 static int sys_broken_setgroups(int setlen, gid_t *gidset)
 879 {
 880         GID_T *group_list;
 881         int i ;
 882
 883         if (setlen == 0)
 884                 return 0 ;
 885
 886         if (setlen < 0 || setlen > groups_max()) {
 887                 errno = EINVAL;
 888                 return -1;
 889         }
 890
 891         /*
 892          * Broken case. We need to allocate a
 893          * GID_T array of size setlen.
 894          */
 895
 896         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
 897                 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
 898                 return -1;
 899         }
 900
 901         for(i = 0; i < setlen; i++)
 902                 group_list[i] = (GID_T) gidset[i];
 903
 904         if(setgroups(setlen, group_list) != 0) {
 905                 int saved_errno = errno;
 906                 SAFE_FREE(group_list);
 907                 errno = saved_errno;
 908                 return -1;
 909         }
 910
 911         SAFE_FREE(group_list);
 912         return 0 ;
 913 }
 914
 915 #endif /* HAVE_BROKEN_GETGROUPS */
 916
 917 /* This is a list of systems that require the first GID passed to setgroups(2)
 918  * to be the effective GID. If your system is one of these, add it here.
 919  */
 920 #if defined (FREEBSD) || defined (DARWINOS)
 921 #define USE_BSD_SETGROUPS
 922 #endif
 923
 924 #if defined(USE_BSD_SETGROUPS)
 925 /* Depending on the particular BSD implementation, the first GID that is
 926  * passed to setgroups(2) will either be ignored or will set the credential's
 927  * effective GID. In either case, the right thing to do is to guarantee that
 928  * gidset[0] is the effective GID.
 929  */
 930 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
 931 {
 932         gid_t *new_gidset = NULL;
 933         int max;
 934         int ret;
 935
 936         /* setgroups(2) will fail with EINVAL if we pass too many groups. */
 937         max = groups_max();
 938
 939         /* No group list, just make sure we are setting the efective GID. */
 940         if (setlen == 0) {
 941                 return setgroups(1, &primary_gid);
 942         }
 943
 944         /* If the primary gid is not the first array element, grow the array
 945          * and insert it at the front.
 946          */
 947         if (gidset[0] != primary_gid) {
 948                 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
 949                 if (new_gidset == NULL) {
 950                         return -1;
 951                 }
 952
 953                 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
 954                 new_gidset[0] = primary_gid;
 955                 setlen++;
 956         }
 957
 958         if (setlen > max) {
 959                 DEBUG(3, ("forced to truncate group list from %d to %d\n",
 960                         setlen, max));
 961                 setlen = max;
 962         }
 963
 964 #if defined(HAVE_BROKEN_GETGROUPS)
 965         ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
 966 #else
 967         ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
 968 #endif
 969
 970         if (new_gidset) {
 971                 int errsav = errno;
 972                 SAFE_FREE(new_gidset);
 973                 errno = errsav;
 974         }
 975
 976         return ret;
 977 }
 978
 979 #endif /* USE_BSD_SETGROUPS */
 980
 981 /**************************************************************************
 982  Wrapper for getgroups. Deals with broken (int) case.
 983 ****************************************************************************/
 984
 985 int sys_getgroups(int setlen, gid_t *gidset)
 986 {
 987 #if defined(HAVE_BROKEN_GETGROUPS)
 988         return sys_broken_getgroups(setlen, gidset);
 989 #else
 990         return getgroups(setlen, gidset);
 991 #endif
 992 }
 993
 994 /**************************************************************************
 995  Wrapper for setgroups. Deals with broken (int) case and BSD case.
 996 ****************************************************************************/
 997
 998 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
 999 {
1000 #if !defined(HAVE_SETGROUPS)
1001         errno = ENOSYS;
1002         return -1;
1003 #endif /* HAVE_SETGROUPS */
1004
1005 #if defined(USE_BSD_SETGROUPS)
1006         return sys_bsd_setgroups(primary_gid, setlen, gidset);
1007 #elif defined(HAVE_BROKEN_GETGROUPS)
1008         return sys_broken_setgroups(setlen, gidset);
1009 #else
1010         return setgroups(setlen, gidset);
1011 #endif
1012 }
1013
1014 /**************************************************************************
1015  Wrappers for setpwent(), getpwent() and endpwent()
1016 ****************************************************************************/
1017
1018 void sys_setpwent(void)
1019 {
1020         setpwent();
1021 }
1022
1023 struct passwd *sys_getpwent(void)
1024 {
1025         return getpwent();
1026 }
1027
1028 void sys_endpwent(void)
1029 {
1030         endpwent();
1031 }
1032
1033 /**************************************************************************
1034  Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
1035 ****************************************************************************/
1036
1037
1038 struct passwd *sys_getpwnam(const char *name)
1039 {
1040         return getpwnam(name);
1041 }
1042
1043 struct passwd *sys_getpwuid(uid_t uid)
1044 {
1045         return getpwuid(uid);
1046 }
1047
1048 struct group *sys_getgrnam(const char *name)
1049 {
1050         return getgrnam(name);
1051 }
1052
1053 struct group *sys_getgrgid(gid_t gid)
1054 {
1055         return getgrgid(gid);
1056 }
1057
1058 /**************************************************************************
1059  Extract a command into an arg list.
1060 ****************************************************************************/
1061
1062 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
1063 {
1064         char *trunc_cmd;
1065         char *saveptr;
1066         char *ptr;
1067         int argcl;
1068         char **argl = NULL;
1069         int i;
1070
1071         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1072                 DEBUG(0, ("talloc failed\n"));
1073                 goto nomem;
1074         }
1075
1076         if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1077                 TALLOC_FREE(trunc_cmd);
1078                 errno = EINVAL;
1079                 return NULL;
1080         }
1081
1082         /*
1083          * Count the args.
1084          */
1085
1086         for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1087                 argcl++;
1088
1089         TALLOC_FREE(trunc_cmd);
1090
1091         if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
1092                 goto nomem;
1093         }
1094
1095         /*
1096          * Now do the extraction.
1097          */
1098
1099         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1100                 goto nomem;
1101         }
1102
1103         ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1104         i = 0;
1105
1106         if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1107                 goto nomem;
1108         }
1109
1110         while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1111
1112                 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1113                         goto nomem;
1114                 }
1115         }
1116
1117         argl[i++] = NULL;
1118         return argl;
1119
1120  nomem:
1121         DEBUG(0, ("talloc failed\n"));
1122         TALLOC_FREE(trunc_cmd);
1123         TALLOC_FREE(argl);
1124         errno = ENOMEM;
1125         return NULL;
1126 }
1127
1128 /**************************************************************************
1129  Wrapper for fork. Ensures that mypid is reset. Used so we can write
1130  a sys_getpid() that only does a system call *once*.
1131 ****************************************************************************/
1132
1133 static pid_t mypid = (pid_t)-1;
1134
1135 pid_t sys_fork(void)
1136 {
1137         pid_t forkret = fork();
1138
1139         if (forkret == (pid_t)0) /* Child - reset mypid so sys_getpid does a system call. */
1140                 mypid = (pid_t) -1;
1141
1142         return forkret;
1143 }
1144
1145 /**************************************************************************
1146  Wrapper for getpid. Ensures we only do a system call *once*.
1147 ****************************************************************************/
1148
1149 pid_t sys_getpid(void)
1150 {
1151         if (mypid == (pid_t)-1)
1152                 mypid = getpid();
1153
1154         return mypid;
1155 }
1156
1157 /**************************************************************************
1158  Wrapper for popen. Safer as it doesn't search a path.
1159  Modified from the glibc sources.
1160  modified by tridge to return a file descriptor. We must kick our FILE* habit
1161 ****************************************************************************/
1162
1163 typedef struct _popen_list
1164 {
1165         int fd;
1166         pid_t child_pid;
1167         struct _popen_list *next;
1168 } popen_list;
1169
1170 static popen_list *popen_chain;
1171
1172 int sys_popen(const char *command)
1173 {
1174         int parent_end, child_end;
1175         int pipe_fds[2];
1176         popen_list *entry = NULL;
1177         char **argl = NULL;
1178
1179         if (pipe(pipe_fds) < 0)
1180                 return -1;
1181
1182         parent_end = pipe_fds[0];
1183         child_end = pipe_fds[1];
1184
1185         if (!*command) {
1186                 errno = EINVAL;
1187                 goto err_exit;
1188         }
1189
1190         if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1191                 goto err_exit;
1192
1193         ZERO_STRUCTP(entry);
1194
1195         /*
1196          * Extract the command and args into a NULL terminated array.
1197          */
1198
1199         if(!(argl = extract_args(NULL, command)))
1200                 goto err_exit;
1201
1202         entry->child_pid = sys_fork();
1203
1204         if (entry->child_pid == -1) {
1205                 goto err_exit;
1206         }
1207
1208         if (entry->child_pid == 0) {
1209
1210                 /*
1211                  * Child !
1212                  */
1213
1214                 int child_std_end = STDOUT_FILENO;
1215                 popen_list *p;
1216
1217                 close(parent_end);
1218                 if (child_end != child_std_end) {
1219                         dup2 (child_end, child_std_end);
1220                         close (child_end);
1221                 }
1222
1223                 /*
1224                  * POSIX.2:  "popen() shall ensure that any streams from previous
1225                  * popen() calls that remain open in the parent process are closed
1226                  * in the new child process."
1227                  */
1228
1229                 for (p = popen_chain; p; p = p->next)
1230                         close(p->fd);
1231
1232                 execv(argl[0], argl);
1233                 _exit (127);
1234         }
1235
1236         /*
1237          * Parent.
1238          */
1239
1240         close (child_end);
1241         TALLOC_FREE(argl);
1242
1243         /* Link into popen_chain. */
1244         entry->next = popen_chain;
1245         popen_chain = entry;
1246         entry->fd = parent_end;
1247
1248         return entry->fd;
1249
1250 err_exit:
1251
1252         SAFE_FREE(entry);
1253         SAFE_FREE(argl);
1254         close(pipe_fds[0]);
1255         close(pipe_fds[1]);
1256         return -1;
1257 }
1258
1259 /**************************************************************************
1260  Wrapper for pclose. Modified from the glibc sources.
1261 ****************************************************************************/
1262
1263 int sys_pclose(int fd)
1264 {
1265         int wstatus;
1266         popen_list **ptr = &popen_chain;
1267         popen_list *entry = NULL;
1268         pid_t wait_pid;
1269         int status = -1;
1270
1271         /* Unlink from popen_chain. */
1272         for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1273                 if ((*ptr)->fd == fd) {
1274                         entry = *ptr;
1275                         *ptr = (*ptr)->next;
1276                         status = 0;
1277                         break;
1278                 }
1279         }
1280
1281         if (status < 0 || close(entry->fd) < 0)
1282                 return -1;
1283
1284         /*
1285          * As Samba is catching and eating child process
1286          * exits we don't really care about the child exit
1287          * code, a -1 with errno = ECHILD will do fine for us.
1288          */
1289
1290         do {
1291                 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1292         } while (wait_pid == -1 && errno == EINTR);
1293
1294         SAFE_FREE(entry);
1295
1296         if (wait_pid == -1)
1297                 return -1;
1298         return wstatus;
1299 }
1300
1301 /**************************************************************************
1302  Wrappers for dlopen, dlsym, dlclose.
1303 ****************************************************************************/
1304
1305 void *sys_dlopen(const char *name, int flags)
1306 {
1307 #if defined(HAVE_DLOPEN)
1308         return dlopen(name, flags);
1309 #else
1310         return NULL;
1311 #endif
1312 }
1313
1314 void *sys_dlsym(void *handle, const char *symbol)
1315 {
1316 #if defined(HAVE_DLSYM)
1317     return dlsym(handle, symbol);
1318 #else
1319     return NULL;
1320 #endif
1321 }
1322
1323 int sys_dlclose (void *handle)
1324 {
1325 #if defined(HAVE_DLCLOSE)
1326         return dlclose(handle);
1327 #else
1328         return 0;
1329 #endif
1330 }
1331
1332 const char *sys_dlerror(void)
1333 {
1334 #if defined(HAVE_DLERROR)
1335         return dlerror();
1336 #else
1337         return NULL;
1338 #endif
1339 }
1340
1341 int sys_dup2(int oldfd, int newfd)
1342 {
1343 #if defined(HAVE_DUP2)
1344         return dup2(oldfd, newfd);
1345 #else
1346         errno = ENOSYS;
1347         return -1;
1348 #endif
1349 }
1350
1351 /**************************************************************************
1352  Wrapper for Admin Logs.
1353 ****************************************************************************/
1354
1355  void sys_adminlog(int priority, const char *format_str, ...)
1356 {
1357         va_list ap;
1358         int ret;
1359         char *msgbuf = NULL;
1360
1361         va_start( ap, format_str );
1362         ret = vasprintf( &msgbuf, format_str, ap );
1363         va_end( ap );
1364
1365         if (ret == -1)
1366                 return;
1367
1368 #if defined(HAVE_SYSLOG)
1369         syslog( priority, "%s", msgbuf );
1370 #else
1371         DEBUG(0,("%s", msgbuf ));
1372 #endif
1373         SAFE_FREE(msgbuf);
1374 }
1375
1376 /******** Solaris EA helper function prototypes ********/
1377 #ifdef HAVE_ATTROPEN
1378 #define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP
1379 static int solaris_write_xattr(int attrfd, const char *value, size_t size);
1380 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size);
1381 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size);
1382 static int solaris_unlinkat(int attrdirfd, const char *name);
1383 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode);
1384 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode);
1385 #endif
1386
1387 /**************************************************************************
1388  Wrappers for extented attribute calls. Based on the Linux package with
1389  support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
1390 ****************************************************************************/
1391
1392 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
1393 {
1394 #if defined(HAVE_GETXATTR)
1395 #ifndef XATTR_ADD_OPT
1396         return getxattr(path, name, value, size);
1397 #else
1398         int options = 0;
1399         return getxattr(path, name, value, size, 0, options);
1400 #endif
1401 #elif defined(HAVE_GETEA)
1402         return getea(path, name, value, size);
1403 #elif defined(HAVE_EXTATTR_GET_FILE)
1404         char *s;
1405         ssize_t retval;
1406         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1407                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1408         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1409         /*
1410          * The BSD implementation has a nasty habit of silently truncating
1411          * the returned value to the size of the buffer, so we have to check
1412          * that the buffer is large enough to fit the returned value.
1413          */
1414         if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1415                 if(retval > size) {
1416                         errno = ERANGE;
1417                         return -1;
1418                 }
1419                 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
1420                         return retval;
1421         }
1422
1423         DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
1424         return -1;
1425 #elif defined(HAVE_ATTR_GET)
1426         int retval, flags = 0;
1427         int valuelength = (int)size;
1428         char *attrname = strchr(name,'.') + 1;
1429
1430         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1431
1432         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1433
1434         return retval ? retval : valuelength;
1435 #elif defined(HAVE_ATTROPEN)
1436         ssize_t ret = -1;
1437         int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
1438         if (attrfd >= 0) {
1439                 ret = solaris_read_xattr(attrfd, value, size);
1440                 close(attrfd);
1441         }
1442         return ret;
1443 #else
1444         errno = ENOSYS;
1445         return -1;
1446 #endif
1447 }
1448
1449 ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
1450 {
1451 #if defined(HAVE_LGETXATTR)
1452         return lgetxattr(path, name, value, size);
1453 #elif defined(HAVE_GETXATTR) && defined(XATTR_ADD_OPT)
1454         int options = XATTR_NOFOLLOW;
1455         return getxattr(path, name, value, size, 0, options);
1456 #elif defined(HAVE_LGETEA)
1457         return lgetea(path, name, value, size);
1458 #elif defined(HAVE_EXTATTR_GET_LINK)
1459         char *s;
1460         ssize_t retval;
1461         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1462                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1463         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1464
1465         if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1466                 if(retval > size) {
1467                         errno = ERANGE;
1468                         return -1;
1469                 }
1470                 if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
1471                         return retval;
1472         }
1473
1474         DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
1475         return -1;
1476 #elif defined(HAVE_ATTR_GET)
1477         int retval, flags = ATTR_DONTFOLLOW;
1478         int valuelength = (int)size;
1479         char *attrname = strchr(name,'.') + 1;
1480
1481         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1482
1483         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1484
1485         return retval ? retval : valuelength;
1486 #elif defined(HAVE_ATTROPEN)
1487         ssize_t ret = -1;
1488         int attrfd = solaris_attropen(path, name, O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1489         if (attrfd >= 0) {
1490                 ret = solaris_read_xattr(attrfd, value, size);
1491                 close(attrfd);
1492         }
1493         return ret;
1494 #else
1495         errno = ENOSYS;
1496         return -1;
1497 #endif
1498 }
1499
1500 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
1501 {
1502 #if defined(HAVE_FGETXATTR)
1503 #ifndef XATTR_ADD_OPT
1504         return fgetxattr(filedes, name, value, size);
1505 #else
1506         int options = 0;
1507         return fgetxattr(filedes, name, value, size, 0, options);
1508 #endif
1509 #elif defined(HAVE_FGETEA)
1510         return fgetea(filedes, name, value, size);
1511 #elif defined(HAVE_EXTATTR_GET_FD)
1512         char *s;
1513         ssize_t retval;
1514         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1515                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1516         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1517
1518         if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
1519                 if(retval > size) {
1520                         errno = ERANGE;
1521                         return -1;
1522                 }
1523                 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
1524                         return retval;
1525         }
1526
1527         DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
1528         return -1;
1529 #elif defined(HAVE_ATTR_GETF)
1530         int retval, flags = 0;
1531         int valuelength = (int)size;
1532         char *attrname = strchr(name,'.') + 1;
1533
1534         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1535
1536         retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
1537
1538         return retval ? retval : valuelength;
1539 #elif defined(HAVE_ATTROPEN)
1540         ssize_t ret = -1;
1541         int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
1542         if (attrfd >= 0) {
1543                 ret = solaris_read_xattr(attrfd, value, size);
1544                 close(attrfd);
1545         }
1546         return ret;
1547 #else
1548         errno = ENOSYS;
1549         return -1;
1550 #endif
1551 }
1552
1553 #if defined(HAVE_EXTATTR_LIST_FILE)
1554
1555 #define EXTATTR_PREFIX(s)       (s), (sizeof((s))-1)
1556
1557 static struct {
1558         int space;
1559         const char *name;
1560         size_t len;
1561 }
1562 extattr[] = {
1563         { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
1564         { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
1565 };
1566
1567 typedef union {
1568         const char *path;
1569         int filedes;
1570 } extattr_arg;
1571
1572 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
1573 {
1574         ssize_t list_size, total_size = 0;
1575         int i, t, len;
1576         char *buf;
1577         /* Iterate through extattr(2) namespaces */
1578         for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
1579                 switch(type) {
1580 #if defined(HAVE_EXTATTR_LIST_FILE)
1581                         case 0:
1582                                 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
1583                                 break;
1584 #endif
1585 #if defined(HAVE_EXTATTR_LIST_LINK)
1586                         case 1:
1587                                 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
1588                                 break;
1589 #endif
1590 #if defined(HAVE_EXTATTR_LIST_FD)
1591                         case 2:
1592                                 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
1593                                 break;
1594 #endif
1595                         default:
1596                                 errno = ENOSYS;
1597                                 return -1;
1598                 }
1599                 /* Some error happend. Errno should be set by the previous call */
1600                 if(list_size < 0)
1601                         return -1;
1602                 /* No attributes */
1603                 if(list_size == 0)
1604                         continue;
1605                 /* XXX: Call with an empty buffer may be used to calculate
1606                    necessary buffer size. Unfortunately, we can't say, how
1607                    many attributes were returned, so here is the potential
1608                    problem with the emulation.
1609                 */
1610                 if(list == NULL) {
1611                         /* Take the worse case of one char attribute names -
1612                            two bytes per name plus one more for sanity.
1613                         */
1614                         total_size += list_size + (list_size/2 + 1)*extattr[t].len;
1615                         continue;
1616                 }
1617                 /* Count necessary offset to fit namespace prefixes */
1618                 len = 0;
1619                 for(i = 0; i < list_size; i += list[i] + 1)
1620                         len += extattr[t].len;
1621
1622                 total_size += list_size + len;
1623                 /* Buffer is too small to fit the results */
1624                 if(total_size > size) {
1625                         errno = ERANGE;
1626                         return -1;
1627                 }
1628                 /* Shift results back, so we can prepend prefixes */
1629                 buf = memmove(list + len, list, list_size);
1630
1631                 for(i = 0; i < list_size; i += len + 1) {
1632                         len = buf[i];
1633                         strncpy(list, extattr[t].name, extattr[t].len + 1);
1634                         list += extattr[t].len;
1635                         strncpy(list, buf + i + 1, len);
1636                         list[len] = '\0';
1637                         list += len + 1;
1638                 }
1639                 size -= total_size;
1640         }
1641         return total_size;
1642 }
1643
1644 #endif
1645
1646 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1647 static char attr_buffer[ATTR_MAX_VALUELEN];
1648
1649 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
1650 {
1651         int retval = 0, index;
1652         attrlist_cursor_t *cursor = 0;
1653         int total_size = 0;
1654         attrlist_t * al = (attrlist_t *)attr_buffer;
1655         attrlist_ent_t *ae;
1656         size_t ent_size, left = size;
1657         char *bp = list;
1658
1659         while (True) {
1660             if (filedes)
1661                 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1662             else
1663                 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1664             if (retval) break;
1665             for (index = 0; index < al->al_count; index++) {
1666                 ae = ATTR_ENTRY(attr_buffer, index);
1667                 ent_size = strlen(ae->a_name) + sizeof("user.");
1668                 if (left >= ent_size) {
1669                     strncpy(bp, "user.", sizeof("user."));
1670                     strncat(bp, ae->a_name, ent_size - sizeof("user."));
1671                     bp += ent_size;
1672                     left -= ent_size;
1673                 } else if (size) {
1674                     errno = ERANGE;
1675                     retval = -1;
1676                     break;
1677                 }
1678                 total_size += ent_size;
1679             }
1680             if (al->al_more == 0) break;
1681         }
1682         if (retval == 0) {
1683             flags |= ATTR_ROOT;
1684             cursor = 0;
1685             while (True) {
1686                 if (filedes)
1687                     retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1688                 else
1689                     retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1690                 if (retval) break;
1691                 for (index = 0; index < al->al_count; index++) {
1692                     ae = ATTR_ENTRY(attr_buffer, index);
1693                     ent_size = strlen(ae->a_name) + sizeof("system.");
1694                     if (left >= ent_size) {
1695                         strncpy(bp, "system.", sizeof("system."));
1696                         strncat(bp, ae->a_name, ent_size - sizeof("system."));
1697                         bp += ent_size;
1698                         left -= ent_size;
1699                     } else if (size) {
1700                         errno = ERANGE;
1701                         retval = -1;
1702                         break;
1703                     }
1704                     total_size += ent_size;
1705                 }
1706                 if (al->al_more == 0) break;
1707             }
1708         }
1709         return (ssize_t)(retval ? retval : total_size);
1710 }
1711
1712 #endif
1713
1714 ssize_t sys_listxattr (const char *path, char *list, size_t size)
1715 {
1716 #if defined(HAVE_LISTXATTR)
1717 #ifndef XATTR_ADD_OPT
1718         return listxattr(path, list, size);
1719 #else
1720         int options = 0;
1721         return listxattr(path, list, size, options);
1722 #endif
1723 #elif defined(HAVE_LISTEA)
1724         return listea(path, list, size);
1725 #elif defined(HAVE_EXTATTR_LIST_FILE)
1726         extattr_arg arg;
1727         arg.path = path;
1728         return bsd_attr_list(0, arg, list, size);
1729 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1730         return irix_attr_list(path, 0, list, size, 0);
1731 #elif defined(HAVE_ATTROPEN)
1732         ssize_t ret = -1;
1733         int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1734         if (attrdirfd >= 0) {
1735                 ret = solaris_list_xattr(attrdirfd, list, size);
1736                 close(attrdirfd);
1737         }
1738         return ret;
1739 #else
1740         errno = ENOSYS;
1741         return -1;
1742 #endif
1743 }
1744
1745 ssize_t sys_llistxattr (const char *path, char *list, size_t size)
1746 {
1747 #if defined(HAVE_LLISTXATTR)
1748         return llistxattr(path, list, size);
1749 #elif defined(HAVE_LISTXATTR) && defined(XATTR_ADD_OPT)
1750         int options = XATTR_NOFOLLOW;
1751         return listxattr(path, list, size, options);
1752 #elif defined(HAVE_LLISTEA)
1753         return llistea(path, list, size);
1754 #elif defined(HAVE_EXTATTR_LIST_LINK)
1755         extattr_arg arg;
1756         arg.path = path;
1757         return bsd_attr_list(1, arg, list, size);
1758 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1759         return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW);
1760 #elif defined(HAVE_ATTROPEN)
1761         ssize_t ret = -1;
1762         int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1763         if (attrdirfd >= 0) {
1764                 ret = solaris_list_xattr(attrdirfd, list, size);
1765                 close(attrdirfd);
1766         }
1767         return ret;
1768 #else
1769         errno = ENOSYS;
1770         return -1;
1771 #endif
1772 }
1773
1774 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
1775 {
1776 #if defined(HAVE_FLISTXATTR)
1777 #ifndef XATTR_ADD_OPT
1778         return flistxattr(filedes, list, size);
1779 #else
1780         int options = 0;
1781         return flistxattr(filedes, list, size, options);
1782 #endif
1783 #elif defined(HAVE_FLISTEA)
1784         return flistea(filedes, list, size);
1785 #elif defined(HAVE_EXTATTR_LIST_FD)
1786         extattr_arg arg;
1787         arg.filedes = filedes;
1788         return bsd_attr_list(2, arg, list, size);
1789 #elif defined(HAVE_ATTR_LISTF)
1790         return irix_attr_list(NULL, filedes, list, size, 0);
1791 #elif defined(HAVE_ATTROPEN)
1792         ssize_t ret = -1;
1793         int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1794         if (attrdirfd >= 0) {
1795                 ret = solaris_list_xattr(attrdirfd, list, size);
1796                 close(attrdirfd);
1797         }
1798         return ret;
1799 #else
1800         errno = ENOSYS;
1801         return -1;
1802 #endif
1803 }
1804
1805 int sys_removexattr (const char *path, const char *name)
1806 {
1807 #if defined(HAVE_REMOVEXATTR)
1808 #ifndef XATTR_ADD_OPT
1809         return removexattr(path, name);
1810 #else
1811         int options = 0;
1812         return removexattr(path, name, options);
1813 #endif
1814 #elif defined(HAVE_REMOVEEA)
1815         return removeea(path, name);
1816 #elif defined(HAVE_EXTATTR_DELETE_FILE)
1817         char *s;
1818         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1819                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1820         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1821
1822         return extattr_delete_file(path, attrnamespace, attrname);
1823 #elif defined(HAVE_ATTR_REMOVE)
1824         int flags = 0;
1825         char *attrname = strchr(name,'.') + 1;
1826
1827         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1828
1829         return attr_remove(path, attrname, flags);
1830 #elif defined(HAVE_ATTROPEN)
1831         int ret = -1;
1832         int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1833         if (attrdirfd >= 0) {
1834                 ret = solaris_unlinkat(attrdirfd, name);
1835                 close(attrdirfd);
1836         }
1837         return ret;
1838 #else
1839         errno = ENOSYS;
1840         return -1;
1841 #endif
1842 }
1843
1844 int sys_lremovexattr (const char *path, const char *name)
1845 {
1846 #if defined(HAVE_LREMOVEXATTR)
1847         return lremovexattr(path, name);
1848 #elif defined(HAVE_REMOVEXATTR) && defined(XATTR_ADD_OPT)
1849         int options = XATTR_NOFOLLOW;
1850         return removexattr(path, name, options);
1851 #elif defined(HAVE_LREMOVEEA)
1852         return lremoveea(path, name);
1853 #elif defined(HAVE_EXTATTR_DELETE_LINK)
1854         char *s;
1855         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1856                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1857         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1858
1859         return extattr_delete_link(path, attrnamespace, attrname);
1860 #elif defined(HAVE_ATTR_REMOVE)
1861         int flags = ATTR_DONTFOLLOW;
1862         char *attrname = strchr(name,'.') + 1;
1863
1864         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1865
1866         return attr_remove(path, attrname, flags);
1867 #elif defined(HAVE_ATTROPEN)
1868         int ret = -1;
1869         int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1870         if (attrdirfd >= 0) {
1871                 ret = solaris_unlinkat(attrdirfd, name);
1872                 close(attrdirfd);
1873         }
1874         return ret;
1875 #else
1876         errno = ENOSYS;
1877         return -1;
1878 #endif
1879 }
1880
1881 int sys_fremovexattr (int filedes, const char *name)
1882 {
1883 #if defined(HAVE_FREMOVEXATTR)
1884 #ifndef XATTR_ADD_OPT
1885         return fremovexattr(filedes, name);
1886 #else
1887         int options = 0;
1888         return fremovexattr(filedes, name, options);
1889 #endif
1890 #elif defined(HAVE_FREMOVEEA)
1891         return fremoveea(filedes, name);
1892 #elif defined(HAVE_EXTATTR_DELETE_FD)
1893         char *s;
1894         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1895                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1896         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1897
1898         return extattr_delete_fd(filedes, attrnamespace, attrname);
1899 #elif defined(HAVE_ATTR_REMOVEF)
1900         int flags = 0;
1901         char *attrname = strchr(name,'.') + 1;
1902
1903         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1904
1905         return attr_removef(filedes, attrname, flags);
1906 #elif defined(HAVE_ATTROPEN)
1907         int ret = -1;
1908         int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1909         if (attrdirfd >= 0) {
1910                 ret = solaris_unlinkat(attrdirfd, name);
1911                 close(attrdirfd);
1912         }
1913         return ret;
1914 #else
1915         errno = ENOSYS;
1916         return -1;
1917 #endif
1918 }
1919
1920 #if !defined(HAVE_SETXATTR)
1921 #define XATTR_CREATE  0x1       /* set value, fail if attr already exists */
1922 #define XATTR_REPLACE 0x2       /* set value, fail if attr does not exist */
1923 #endif
1924
1925 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1926 {
1927 #if defined(HAVE_SETXATTR)
1928 #ifndef XATTR_ADD_OPT
1929         return setxattr(path, name, value, size, flags);
1930 #else
1931         int options = 0;
1932         return setxattr(path, name, value, size, 0, options);
1933 #endif
1934 #elif defined(HAVE_SETEA)
1935         return setea(path, name, value, size, flags);
1936 #elif defined(HAVE_EXTATTR_SET_FILE)
1937         char *s;
1938         int retval = 0;
1939         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1940                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1941         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1942         if (flags) {
1943                 /* Check attribute existence */
1944                 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
1945                 if (retval < 0) {
1946                         /* REPLACE attribute, that doesn't exist */
1947                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
1948                                 errno = ENOATTR;
1949                                 return -1;
1950                         }
1951                         /* Ignore other errors */
1952                 }
1953                 else {
1954                         /* CREATE attribute, that already exists */
1955                         if (flags & XATTR_CREATE) {
1956                                 errno = EEXIST;
1957                                 return -1;
1958                         }
1959                 }
1960         }
1961         retval = extattr_set_file(path, attrnamespace, attrname, value, size);
1962         return (retval < 0) ? -1 : 0;
1963 #elif defined(HAVE_ATTR_SET)
1964         int myflags = 0;
1965         char *attrname = strchr(name,'.') + 1;
1966
1967         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1968         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1969         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1970
1971         return attr_set(path, attrname, (const char *)value, size, myflags);
1972 #elif defined(HAVE_ATTROPEN)
1973         int ret = -1;
1974         int myflags = O_RDWR;
1975         int attrfd;
1976         if (flags & XATTR_CREATE) myflags |= O_EXCL;
1977         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
1978         attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
1979         if (attrfd >= 0) {
1980                 ret = solaris_write_xattr(attrfd, value, size);
1981                 close(attrfd);
1982         }
1983         return ret;
1984 #else
1985         errno = ENOSYS;
1986         return -1;
1987 #endif
1988 }
1989
1990 int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1991 {
1992 #if defined(HAVE_LSETXATTR)
1993         return lsetxattr(path, name, value, size, flags);
1994 #elif defined(HAVE_SETXATTR) && defined(XATTR_ADD_OPT)
1995         int options = XATTR_NOFOLLOW;
1996         return setxattr(path, name, value, size, 0, options);
1997 #elif defined(LSETEA)
1998         return lsetea(path, name, value, size, flags);
1999 #elif defined(HAVE_EXTATTR_SET_LINK)
2000         char *s;
2001         int retval = 0;
2002         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2003                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2004         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2005         if (flags) {
2006                 /* Check attribute existence */
2007                 retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
2008                 if (retval < 0) {
2009                         /* REPLACE attribute, that doesn't exist */
2010                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
2011                                 errno = ENOATTR;
2012                                 return -1;
2013                         }
2014                         /* Ignore other errors */
2015                 }
2016                 else {
2017                         /* CREATE attribute, that already exists */
2018                         if (flags & XATTR_CREATE) {
2019                                 errno = EEXIST;
2020                                 return -1;
2021                         }
2022                 }
2023         }
2024
2025         retval = extattr_set_link(path, attrnamespace, attrname, value, size);
2026         return (retval < 0) ? -1 : 0;
2027 #elif defined(HAVE_ATTR_SET)
2028         int myflags = ATTR_DONTFOLLOW;
2029         char *attrname = strchr(name,'.') + 1;
2030
2031         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2032         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2033         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2034
2035         return attr_set(path, attrname, (const char *)value, size, myflags);
2036 #elif defined(HAVE_ATTROPEN)
2037         int ret = -1;
2038         int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW;
2039         int attrfd;
2040         if (flags & XATTR_CREATE) myflags |= O_EXCL;
2041         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2042         attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2043         if (attrfd >= 0) {
2044                 ret = solaris_write_xattr(attrfd, value, size);
2045                 close(attrfd);
2046         }
2047         return ret;
2048 #else
2049         errno = ENOSYS;
2050         return -1;
2051 #endif
2052 }
2053
2054 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
2055 {
2056 #if defined(HAVE_FSETXATTR)
2057 #ifndef XATTR_ADD_OPT
2058         return fsetxattr(filedes, name, value, size, flags);
2059 #else
2060         int options = 0;
2061         return fsetxattr(filedes, name, value, size, 0, options);
2062 #endif
2063 #elif defined(HAVE_FSETEA)
2064         return fsetea(filedes, name, value, size, flags);
2065 #elif defined(HAVE_EXTATTR_SET_FD)
2066         char *s;
2067         int retval = 0;
2068         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2069                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2070         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2071         if (flags) {
2072                 /* Check attribute existence */
2073                 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
2074                 if (retval < 0) {
2075                         /* REPLACE attribute, that doesn't exist */
2076                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
2077                                 errno = ENOATTR;
2078                                 return -1;
2079                         }
2080                         /* Ignore other errors */
2081                 }
2082                 else {
2083                         /* CREATE attribute, that already exists */
2084                         if (flags & XATTR_CREATE) {
2085                                 errno = EEXIST;
2086                                 return -1;
2087                         }
2088                 }
2089         }
2090         retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
2091         return (retval < 0) ? -1 : 0;
2092 #elif defined(HAVE_ATTR_SETF)
2093         int myflags = 0;
2094         char *attrname = strchr(name,'.') + 1;
2095
2096         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2097         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2098         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2099
2100         return attr_setf(filedes, attrname, (const char *)value, size, myflags);
2101 #elif defined(HAVE_ATTROPEN)
2102         int ret = -1;
2103         int myflags = O_RDWR | O_XATTR;
2104         int attrfd;
2105         if (flags & XATTR_CREATE) myflags |= O_EXCL;
2106         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2107         attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2108         if (attrfd >= 0) {
2109                 ret = solaris_write_xattr(attrfd, value, size);
2110                 close(attrfd);
2111         }
2112         return ret;
2113 #else
2114         errno = ENOSYS;
2115         return -1;
2116 #endif
2117 }
2118
2119 /**************************************************************************
2120  helper functions for Solaris' EA support
2121 ****************************************************************************/
2122 #ifdef HAVE_ATTROPEN
2123 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
2124 {
2125         struct stat sbuf;
2126
2127         if (fstat(attrfd, &sbuf) == -1) {
2128                 errno = ENOATTR;
2129                 return -1;
2130         }
2131
2132         /* This is to return the current size of the named extended attribute */
2133         if (size == 0) {
2134                 return sbuf.st_size;
2135         }
2136
2137         /* check size and read xattr */
2138         if (sbuf.st_size > size) {
2139                 errno = ERANGE;
2140                 return -1;
2141         }
2142
2143         return read(attrfd, value, sbuf.st_size);
2144 }
2145
2146 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
2147 {
2148         ssize_t len = 0;
2149         int stop = 0;
2150         DIR *dirp;
2151         struct dirent *de;
2152         int newfd = dup(attrdirfd);
2153         /* CAUTION: The originating file descriptor should not be
2154                     used again following the call to fdopendir().
2155                     For that reason we dup() the file descriptor
2156                     here to make things more clear. */
2157         dirp = fdopendir(newfd);
2158
2159         while ((de = readdir(dirp))) {
2160                 size_t listlen = strlen(de->d_name);
2161                 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
2162                         /* we don't want "." and ".." here: */
2163                         DEBUG(10,("skipped EA %s\n",de->d_name));
2164                         continue;
2165                 }
2166
2167                 if (size == 0) {
2168                         /* return the current size of the list of extended attribute names*/
2169                         len += listlen + 1;
2170                 } else {
2171                         /* check size and copy entrieѕ + nul into list. */
2172                         if ((len + listlen + 1) > size) {
2173                                 errno = ERANGE;
2174                                 len = -1;
2175                                 break;
2176                         } else {
2177                                 safe_strcpy(list + len, de->d_name, listlen);
2178                                 len += listlen;
2179                                 list[len] = '\0';
2180                                 ++len;
2181                         }
2182                 }
2183         }
2184
2185         if (closedir(dirp) == -1) {
2186                 DEBUG(0,("closedir dirp failed: %s\n",strerror(errno)));
2187                 return -1;
2188         }
2189         return len;
2190 }
2191
2192 static int solaris_unlinkat(int attrdirfd, const char *name)
2193 {
2194         if (unlinkat(attrdirfd, name, 0) == -1) {
2195                 if (errno == ENOENT) {
2196                         errno = ENOATTR;
2197                 }
2198                 return -1;
2199         }
2200         return 0;
2201 }
2202
2203 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
2204 {
2205         int filedes = attropen(path, attrpath, oflag, mode);
2206         if (filedes == -1) {
2207                 DEBUG(10,("attropen FAILED: path: %s, name: %s, errno: %s\n",path,attrpath,strerror(errno)));
2208                 if (errno == EINVAL) {
2209                         errno = ENOTSUP;
2210                 } else {
2211                         errno = ENOATTR;
2212                 }
2213         }
2214         return filedes;
2215 }
2216
2217 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
2218 {
2219         int filedes = openat(fildes, path, oflag, mode);
2220         if (filedes == -1) {
2221                 DEBUG(10,("openat FAILED: fd: %s, path: %s, errno: %s\n",filedes,path,strerror(errno)));
2222                 if (errno == EINVAL) {
2223                         errno = ENOTSUP;
2224                 } else {
2225                         errno = ENOATTR;
2226                 }
2227         }
2228         return filedes;
2229 }
2230
2231 static int solaris_write_xattr(int attrfd, const char *value, size_t size)
2232 {
2233         if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
2234                 return 0;
2235         } else {
2236                 DEBUG(10,("solaris_write_xattr FAILED!\n"));
2237                 return -1;
2238         }
2239 }
2240 #endif /*HAVE_ATTROPEN*/
2241
2242
2243 /****************************************************************************
2244  Return the major devicenumber for UNIX extensions.
2245 ****************************************************************************/
2246
2247 uint32 unix_dev_major(SMB_DEV_T dev)
2248 {
2249 #if defined(HAVE_DEVICE_MAJOR_FN)
2250         return (uint32)major(dev);
2251 #else
2252         return (uint32)(dev >> 8);
2253 #endif
2254 }
2255
2256 /****************************************************************************
2257  Return the minor devicenumber for UNIX extensions.
2258 ****************************************************************************/
2259
2260 uint32 unix_dev_minor(SMB_DEV_T dev)
2261 {
2262 #if defined(HAVE_DEVICE_MINOR_FN)
2263         return (uint32)minor(dev);
2264 #else
2265         return (uint32)(dev & 0xff);
2266 #endif
2267 }
2268
2269 #if defined(WITH_AIO)
2270
2271 /*******************************************************************
2272  An aio_read wrapper that will deal with 64-bit sizes.
2273 ********************************************************************/
2274
2275 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2276 {
2277 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
2278         return aio_read64(aiocb);
2279 #elif defined(HAVE_AIO_READ)
2280         return aio_read(aiocb);
2281 #else
2282         errno = ENOSYS;
2283         return -1;
2284 #endif
2285 }
2286
2287 /*******************************************************************
2288  An aio_write wrapper that will deal with 64-bit sizes.
2289 ********************************************************************/
2290
2291 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2292 {
2293 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
2294         return aio_write64(aiocb);
2295 #elif defined(HAVE_AIO_WRITE)
2296         return aio_write(aiocb);
2297 #else
2298         errno = ENOSYS;
2299         return -1;
2300 #endif
2301 }
2302
2303 /*******************************************************************
2304  An aio_return wrapper that will deal with 64-bit sizes.
2305 ********************************************************************/
2306
2307 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2308 {
2309 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
2310         return aio_return64(aiocb);
2311 #elif defined(HAVE_AIO_RETURN)
2312         return aio_return(aiocb);
2313 #else
2314         errno = ENOSYS;
2315         return -1;
2316 #endif
2317 }
2318
2319 /*******************************************************************
2320  An aio_cancel wrapper that will deal with 64-bit sizes.
2321 ********************************************************************/
2322
2323 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2324 {
2325 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
2326         return aio_cancel64(fd, aiocb);
2327 #elif defined(HAVE_AIO_CANCEL)
2328         return aio_cancel(fd, aiocb);
2329 #else
2330         errno = ENOSYS;
2331         return -1;
2332 #endif
2333 }
2334
2335 /*******************************************************************
2336  An aio_error wrapper that will deal with 64-bit sizes.
2337 ********************************************************************/
2338
2339 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2340 {
2341 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
2342         return aio_error64(aiocb);
2343 #elif defined(HAVE_AIO_ERROR)
2344         return aio_error(aiocb);
2345 #else
2346         errno = ENOSYS;
2347         return -1;
2348 #endif
2349 }
2350
2351 /*******************************************************************
2352  An aio_fsync wrapper that will deal with 64-bit sizes.
2353 ********************************************************************/
2354
2355 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2356 {
2357 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64)
2358         return aio_fsync64(op, aiocb);
2359 #elif defined(HAVE_AIO_FSYNC)
2360         return aio_fsync(op, aiocb);
2361 #else
2362         errno = ENOSYS;
2363         return -1;
2364 #endif
2365 }
2366
2367 /*******************************************************************
2368  An aio_fsync wrapper that will deal with 64-bit sizes.
2369 ********************************************************************/
2370
2371 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2372 {
2373 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64)
2374         return aio_suspend64(cblist, n, timeout);
2375 #elif defined(HAVE_AIO_FSYNC)
2376         return aio_suspend(cblist, n, timeout);
2377 #else
2378         errno = ENOSYS;
2379         return -1;
2380 #endif
2381 }
2382 #else /* !WITH_AIO */
2383
2384 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2385 {
2386         errno = ENOSYS;
2387         return -1;
2388 }
2389
2390 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2391 {
2392         errno = ENOSYS;
2393         return -1;
2394 }
2395
2396 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2397 {
2398         errno = ENOSYS;
2399         return -1;
2400 }
2401
2402 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2403 {
2404         errno = ENOSYS;
2405         return -1;
2406 }
2407
2408 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2409 {
2410         errno = ENOSYS;
2411         return -1;
2412 }
2413
2414 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2415 {
2416         errno = ENOSYS;
2417         return -1;
2418 }
2419
2420 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2421 {
2422         errno = ENOSYS;
2423         return -1;
2424 }
2425 #endif /* WITH_AIO */
2426
2427 int sys_getpeereid( int s, uid_t *uid)
2428 {
2429 #if defined(HAVE_PEERCRED)
2430         struct ucred cred;
2431         socklen_t cred_len = sizeof(struct ucred);
2432         int ret;
2433
2434         ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
2435         if (ret != 0) {
2436                 return -1;
2437         }
2438
2439         if (cred_len != sizeof(struct ucred)) {
2440                 errno = EINVAL;
2441                 return -1;
2442         }
2443
2444         *uid = cred.uid;
2445         return 0;
2446 #else
2447         errno = ENOSYS;
2448         return -1;
2449 #endif
2450 }
2451
2452 int sys_getnameinfo(const struct sockaddr *psa,
2453                         socklen_t salen,
2454                         char *host,
2455                         size_t hostlen,
2456                         char *service,
2457                         size_t servlen,
2458                         int flags)
2459 {
2460         /*
2461          * For Solaris we must make sure salen is the
2462          * correct length for the incoming sa_family.
2463          */
2464
2465         if (salen == sizeof(struct sockaddr_storage)) {
2466                 salen = sizeof(struct sockaddr_in);
2467 #if defined(HAVE_IPV6)
2468                 if (psa->sa_family == AF_INET6) {
2469                         salen = sizeof(struct sockaddr_in6);
2470                 }
2471 #endif
2472         }
2473         return getnameinfo(psa, salen, host, hostlen, service, servlen, flags);
2474 }
2475
2476 int sys_connect(int fd, const struct sockaddr * addr)
2477 {
2478         socklen_t salen = -1;
2479
2480         if (addr->sa_family == AF_INET) {
2481             salen = sizeof(struct sockaddr_in);
2482         } else if (addr->sa_family == AF_UNIX) {
2483             salen = sizeof(struct sockaddr_un);
2484         }
2485 #if defined(HAVE_IPV6)
2486         else if (addr->sa_family == AF_INET6) {
2487             salen = sizeof(struct sockaddr_in6);
2488         }
2489 #endif
2490
2491         return connect(fd, addr, salen);
2492 }