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                 case LEASE_CAPABILITY:
 737 #ifdef CAP_LEASE
 738                         cap_vals[num_cap_vals++] = CAP_LEASE;
 739 #endif
 740                         break;
 741         }
 742
 743         SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
 744
 745         if (num_cap_vals == 0) {
 746                 cap_free(cap);
 747                 return True;
 748         }
 749
 750         cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
 751                 enable ? CAP_SET : CAP_CLEAR);
 752
 753         /* We never want to pass capabilities down to our children, so make
 754          * sure they are not inherited.
 755          */
 756         cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
 757
 758         if (cap_set_proc(cap) == -1) {
 759                 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
 760                         strerror(errno)));
 761                 cap_free(cap);
 762                 return False;
 763         }
 764
 765         cap_free(cap);
 766         return True;
 767 }
 768
 769 #endif /* HAVE_POSIX_CAPABILITIES */
 770
 771 /****************************************************************************
 772  Gain the oplock capability from the kernel if possible.
 773 ****************************************************************************/
 774
 775 void set_effective_capability(enum smbd_capability capability)
 776 {
 777 #if defined(HAVE_POSIX_CAPABILITIES)
 778         set_process_capability(capability, True);
 779 #endif /* HAVE_POSIX_CAPABILITIES */
 780 }
 781
 782 void drop_effective_capability(enum smbd_capability capability)
 783 {
 784 #if defined(HAVE_POSIX_CAPABILITIES)
 785         set_process_capability(capability, False);
 786 #endif /* HAVE_POSIX_CAPABILITIES */
 787 }
 788
 789 /**************************************************************************
 790  Wrapper for random().
 791 ****************************************************************************/
 792
 793 long sys_random(void)
 794 {
 795 #if defined(HAVE_RANDOM)
 796         return (long)random();
 797 #elif defined(HAVE_RAND)
 798         return (long)rand();
 799 #else
 800         DEBUG(0,("Error - no random function available !\n"));
 801         exit(1);
 802 #endif
 803 }
 804
 805 /**************************************************************************
 806  Wrapper for srandom().
 807 ****************************************************************************/
 808
 809 void sys_srandom(unsigned int seed)
 810 {
 811 #if defined(HAVE_SRANDOM)
 812         srandom(seed);
 813 #elif defined(HAVE_SRAND)
 814         srand(seed);
 815 #else
 816         DEBUG(0,("Error - no srandom function available !\n"));
 817         exit(1);
 818 #endif
 819 }
 820
 821 /**************************************************************************
 822  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
 823 ****************************************************************************/
 824
 825 int groups_max(void)
 826 {
 827 #if defined(SYSCONF_SC_NGROUPS_MAX)
 828         int ret = sysconf(_SC_NGROUPS_MAX);
 829         return (ret == -1) ? NGROUPS_MAX : ret;
 830 #else
 831         return NGROUPS_MAX;
 832 #endif
 833 }
 834
 835 /**************************************************************************
 836  Wrap setgroups and getgroups for systems that declare getgroups() as
 837  returning an array of gid_t, but actuall return an array of int.
 838 ****************************************************************************/
 839
 840 #if defined(HAVE_BROKEN_GETGROUPS)
 841 static int sys_broken_getgroups(int setlen, gid_t *gidset)
 842 {
 843         GID_T gid;
 844         GID_T *group_list;
 845         int i, ngroups;
 846
 847         if(setlen == 0) {
 848                 return getgroups(setlen, &gid);
 849         }
 850
 851         /*
 852          * Broken case. We need to allocate a
 853          * GID_T array of size setlen.
 854          */
 855
 856         if(setlen < 0) {
 857                 errno = EINVAL;
 858                 return -1;
 859         }
 860
 861         if (setlen == 0)
 862                 setlen = groups_max();
 863
 864         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
 865                 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
 866                 return -1;
 867         }
 868
 869         if((ngroups = getgroups(setlen, group_list)) < 0) {
 870                 int saved_errno = errno;
 871                 SAFE_FREE(group_list);
 872                 errno = saved_errno;
 873                 return -1;
 874         }
 875
 876         for(i = 0; i < ngroups; i++)
 877                 gidset[i] = (gid_t)group_list[i];
 878
 879         SAFE_FREE(group_list);
 880         return ngroups;
 881 }
 882
 883 static int sys_broken_setgroups(int setlen, gid_t *gidset)
 884 {
 885         GID_T *group_list;
 886         int i ;
 887
 888         if (setlen == 0)
 889                 return 0 ;
 890
 891         if (setlen < 0 || setlen > groups_max()) {
 892                 errno = EINVAL;
 893                 return -1;
 894         }
 895
 896         /*
 897          * Broken case. We need to allocate a
 898          * GID_T array of size setlen.
 899          */
 900
 901         if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
 902                 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
 903                 return -1;
 904         }
 905
 906         for(i = 0; i < setlen; i++)
 907                 group_list[i] = (GID_T) gidset[i];
 908
 909         if(setgroups(setlen, group_list) != 0) {
 910                 int saved_errno = errno;
 911                 SAFE_FREE(group_list);
 912                 errno = saved_errno;
 913                 return -1;
 914         }
 915
 916         SAFE_FREE(group_list);
 917         return 0 ;
 918 }
 919
 920 #endif /* HAVE_BROKEN_GETGROUPS */
 921
 922 /* This is a list of systems that require the first GID passed to setgroups(2)
 923  * to be the effective GID. If your system is one of these, add it here.
 924  */
 925 #if defined (FREEBSD) || defined (DARWINOS)
 926 #define USE_BSD_SETGROUPS
 927 #endif
 928
 929 #if defined(USE_BSD_SETGROUPS)
 930 /* Depending on the particular BSD implementation, the first GID that is
 931  * passed to setgroups(2) will either be ignored or will set the credential's
 932  * effective GID. In either case, the right thing to do is to guarantee that
 933  * gidset[0] is the effective GID.
 934  */
 935 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
 936 {
 937         gid_t *new_gidset = NULL;
 938         int max;
 939         int ret;
 940
 941         /* setgroups(2) will fail with EINVAL if we pass too many groups. */
 942         max = groups_max();
 943
 944         /* No group list, just make sure we are setting the efective GID. */
 945         if (setlen == 0) {
 946                 return setgroups(1, &primary_gid);
 947         }
 948
 949         /* If the primary gid is not the first array element, grow the array
 950          * and insert it at the front.
 951          */
 952         if (gidset[0] != primary_gid) {
 953                 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
 954                 if (new_gidset == NULL) {
 955                         return -1;
 956                 }
 957
 958                 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
 959                 new_gidset[0] = primary_gid;
 960                 setlen++;
 961         }
 962
 963         if (setlen > max) {
 964                 DEBUG(3, ("forced to truncate group list from %d to %d\n",
 965                         setlen, max));
 966                 setlen = max;
 967         }
 968
 969 #if defined(HAVE_BROKEN_GETGROUPS)
 970         ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
 971 #else
 972         ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
 973 #endif
 974
 975         if (new_gidset) {
 976                 int errsav = errno;
 977                 SAFE_FREE(new_gidset);
 978                 errno = errsav;
 979         }
 980
 981         return ret;
 982 }
 983
 984 #endif /* USE_BSD_SETGROUPS */
 985
 986 /**************************************************************************
 987  Wrapper for getgroups. Deals with broken (int) case.
 988 ****************************************************************************/
 989
 990 int sys_getgroups(int setlen, gid_t *gidset)
 991 {
 992 #if defined(HAVE_BROKEN_GETGROUPS)
 993         return sys_broken_getgroups(setlen, gidset);
 994 #else
 995         return getgroups(setlen, gidset);
 996 #endif
 997 }
 998
 999 /**************************************************************************
1000  Wrapper for setgroups. Deals with broken (int) case and BSD case.
1001 ****************************************************************************/
1002
1003 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
1004 {
1005 #if !defined(HAVE_SETGROUPS)
1006         errno = ENOSYS;
1007         return -1;
1008 #endif /* HAVE_SETGROUPS */
1009
1010 #if defined(USE_BSD_SETGROUPS)
1011         return sys_bsd_setgroups(primary_gid, setlen, gidset);
1012 #elif defined(HAVE_BROKEN_GETGROUPS)
1013         return sys_broken_setgroups(setlen, gidset);
1014 #else
1015         return setgroups(setlen, gidset);
1016 #endif
1017 }
1018
1019 /**************************************************************************
1020  Wrappers for setpwent(), getpwent() and endpwent()
1021 ****************************************************************************/
1022
1023 void sys_setpwent(void)
1024 {
1025         setpwent();
1026 }
1027
1028 struct passwd *sys_getpwent(void)
1029 {
1030         return getpwent();
1031 }
1032
1033 void sys_endpwent(void)
1034 {
1035         endpwent();
1036 }
1037
1038 /**************************************************************************
1039  Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
1040 ****************************************************************************/
1041
1042
1043 struct passwd *sys_getpwnam(const char *name)
1044 {
1045         return getpwnam(name);
1046 }
1047
1048 struct passwd *sys_getpwuid(uid_t uid)
1049 {
1050         return getpwuid(uid);
1051 }
1052
1053 struct group *sys_getgrnam(const char *name)
1054 {
1055         return getgrnam(name);
1056 }
1057
1058 struct group *sys_getgrgid(gid_t gid)
1059 {
1060         return getgrgid(gid);
1061 }
1062
1063 /**************************************************************************
1064  Extract a command into an arg list.
1065 ****************************************************************************/
1066
1067 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
1068 {
1069         char *trunc_cmd;
1070         char *saveptr;
1071         char *ptr;
1072         int argcl;
1073         char **argl = NULL;
1074         int i;
1075
1076         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1077                 DEBUG(0, ("talloc failed\n"));
1078                 goto nomem;
1079         }
1080
1081         if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1082                 TALLOC_FREE(trunc_cmd);
1083                 errno = EINVAL;
1084                 return NULL;
1085         }
1086
1087         /*
1088          * Count the args.
1089          */
1090
1091         for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1092                 argcl++;
1093
1094         TALLOC_FREE(trunc_cmd);
1095
1096         if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
1097                 goto nomem;
1098         }
1099
1100         /*
1101          * Now do the extraction.
1102          */
1103
1104         if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1105                 goto nomem;
1106         }
1107
1108         ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1109         i = 0;
1110
1111         if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1112                 goto nomem;
1113         }
1114
1115         while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1116
1117                 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1118                         goto nomem;
1119                 }
1120         }
1121
1122         argl[i++] = NULL;
1123         return argl;
1124
1125  nomem:
1126         DEBUG(0, ("talloc failed\n"));
1127         TALLOC_FREE(trunc_cmd);
1128         TALLOC_FREE(argl);
1129         errno = ENOMEM;
1130         return NULL;
1131 }
1132
1133 /**************************************************************************
1134  Wrapper for fork. Ensures that mypid is reset. Used so we can write
1135  a sys_getpid() that only does a system call *once*.
1136 ****************************************************************************/
1137
1138 static pid_t mypid = (pid_t)-1;
1139
1140 pid_t sys_fork(void)
1141 {
1142         pid_t forkret = fork();
1143
1144         if (forkret == (pid_t)0) /* Child - reset mypid so sys_getpid does a system call. */
1145                 mypid = (pid_t) -1;
1146
1147         return forkret;
1148 }
1149
1150 /**************************************************************************
1151  Wrapper for getpid. Ensures we only do a system call *once*.
1152 ****************************************************************************/
1153
1154 pid_t sys_getpid(void)
1155 {
1156         if (mypid == (pid_t)-1)
1157                 mypid = getpid();
1158
1159         return mypid;
1160 }
1161
1162 /**************************************************************************
1163  Wrapper for popen. Safer as it doesn't search a path.
1164  Modified from the glibc sources.
1165  modified by tridge to return a file descriptor. We must kick our FILE* habit
1166 ****************************************************************************/
1167
1168 typedef struct _popen_list
1169 {
1170         int fd;
1171         pid_t child_pid;
1172         struct _popen_list *next;
1173 } popen_list;
1174
1175 static popen_list *popen_chain;
1176
1177 int sys_popen(const char *command)
1178 {
1179         int parent_end, child_end;
1180         int pipe_fds[2];
1181         popen_list *entry = NULL;
1182         char **argl = NULL;
1183
1184         if (pipe(pipe_fds) < 0)
1185                 return -1;
1186
1187         parent_end = pipe_fds[0];
1188         child_end = pipe_fds[1];
1189
1190         if (!*command) {
1191                 errno = EINVAL;
1192                 goto err_exit;
1193         }
1194
1195         if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1196                 goto err_exit;
1197
1198         ZERO_STRUCTP(entry);
1199
1200         /*
1201          * Extract the command and args into a NULL terminated array.
1202          */
1203
1204         if(!(argl = extract_args(NULL, command)))
1205                 goto err_exit;
1206
1207         entry->child_pid = sys_fork();
1208
1209         if (entry->child_pid == -1) {
1210                 goto err_exit;
1211         }
1212
1213         if (entry->child_pid == 0) {
1214
1215                 /*
1216                  * Child !
1217                  */
1218
1219                 int child_std_end = STDOUT_FILENO;
1220                 popen_list *p;
1221
1222                 close(parent_end);
1223                 if (child_end != child_std_end) {
1224                         dup2 (child_end, child_std_end);
1225                         close (child_end);
1226                 }
1227
1228                 /*
1229                  * POSIX.2:  "popen() shall ensure that any streams from previous
1230                  * popen() calls that remain open in the parent process are closed
1231                  * in the new child process."
1232                  */
1233
1234                 for (p = popen_chain; p; p = p->next)
1235                         close(p->fd);
1236
1237                 execv(argl[0], argl);
1238                 _exit (127);
1239         }
1240
1241         /*
1242          * Parent.
1243          */
1244
1245         close (child_end);
1246         TALLOC_FREE(argl);
1247
1248         /* Link into popen_chain. */
1249         entry->next = popen_chain;
1250         popen_chain = entry;
1251         entry->fd = parent_end;
1252
1253         return entry->fd;
1254
1255 err_exit:
1256
1257         SAFE_FREE(entry);
1258         SAFE_FREE(argl);
1259         close(pipe_fds[0]);
1260         close(pipe_fds[1]);
1261         return -1;
1262 }
1263
1264 /**************************************************************************
1265  Wrapper for pclose. Modified from the glibc sources.
1266 ****************************************************************************/
1267
1268 int sys_pclose(int fd)
1269 {
1270         int wstatus;
1271         popen_list **ptr = &popen_chain;
1272         popen_list *entry = NULL;
1273         pid_t wait_pid;
1274         int status = -1;
1275
1276         /* Unlink from popen_chain. */
1277         for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1278                 if ((*ptr)->fd == fd) {
1279                         entry = *ptr;
1280                         *ptr = (*ptr)->next;
1281                         status = 0;
1282                         break;
1283                 }
1284         }
1285
1286         if (status < 0 || close(entry->fd) < 0)
1287                 return -1;
1288
1289         /*
1290          * As Samba is catching and eating child process
1291          * exits we don't really care about the child exit
1292          * code, a -1 with errno = ECHILD will do fine for us.
1293          */
1294
1295         do {
1296                 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1297         } while (wait_pid == -1 && errno == EINTR);
1298
1299         SAFE_FREE(entry);
1300
1301         if (wait_pid == -1)
1302                 return -1;
1303         return wstatus;
1304 }
1305
1306 /**************************************************************************
1307  Wrappers for dlopen, dlsym, dlclose.
1308 ****************************************************************************/
1309
1310 void *sys_dlopen(const char *name, int flags)
1311 {
1312 #if defined(HAVE_DLOPEN)
1313         return dlopen(name, flags);
1314 #else
1315         return NULL;
1316 #endif
1317 }
1318
1319 void *sys_dlsym(void *handle, const char *symbol)
1320 {
1321 #if defined(HAVE_DLSYM)
1322     return dlsym(handle, symbol);
1323 #else
1324     return NULL;
1325 #endif
1326 }
1327
1328 int sys_dlclose (void *handle)
1329 {
1330 #if defined(HAVE_DLCLOSE)
1331         return dlclose(handle);
1332 #else
1333         return 0;
1334 #endif
1335 }
1336
1337 const char *sys_dlerror(void)
1338 {
1339 #if defined(HAVE_DLERROR)
1340         return dlerror();
1341 #else
1342         return NULL;
1343 #endif
1344 }
1345
1346 /**************************************************************************
1347  Wrapper for Admin Logs.
1348 ****************************************************************************/
1349
1350  void sys_adminlog(int priority, const char *format_str, ...)
1351 {
1352         va_list ap;
1353         int ret;
1354         char *msgbuf = NULL;
1355
1356         va_start( ap, format_str );
1357         ret = vasprintf( &msgbuf, format_str, ap );
1358         va_end( ap );
1359
1360         if (ret == -1)
1361                 return;
1362
1363 #if defined(HAVE_SYSLOG)
1364         syslog( priority, "%s", msgbuf );
1365 #else
1366         DEBUG(0,("%s", msgbuf ));
1367 #endif
1368         SAFE_FREE(msgbuf);
1369 }
1370
1371 /******** Solaris EA helper function prototypes ********/
1372 #ifdef HAVE_ATTROPEN
1373 #define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP
1374 static int solaris_write_xattr(int attrfd, const char *value, size_t size);
1375 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size);
1376 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size);
1377 static int solaris_unlinkat(int attrdirfd, const char *name);
1378 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode);
1379 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode);
1380 #endif
1381
1382 /**************************************************************************
1383  Wrappers for extented attribute calls. Based on the Linux package with
1384  support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
1385 ****************************************************************************/
1386
1387 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
1388 {
1389 #if defined(HAVE_GETXATTR)
1390 #ifndef XATTR_ADD_OPT
1391         return getxattr(path, name, value, size);
1392 #else
1393         int options = 0;
1394         return getxattr(path, name, value, size, 0, options);
1395 #endif
1396 #elif defined(HAVE_GETEA)
1397         return getea(path, name, value, size);
1398 #elif defined(HAVE_EXTATTR_GET_FILE)
1399         char *s;
1400         ssize_t retval;
1401         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1402                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1403         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1404         /*
1405          * The BSD implementation has a nasty habit of silently truncating
1406          * the returned value to the size of the buffer, so we have to check
1407          * that the buffer is large enough to fit the returned value.
1408          */
1409         if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1410                 if(retval > size) {
1411                         errno = ERANGE;
1412                         return -1;
1413                 }
1414                 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
1415                         return retval;
1416         }
1417
1418         DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
1419         return -1;
1420 #elif defined(HAVE_ATTR_GET)
1421         int retval, flags = 0;
1422         int valuelength = (int)size;
1423         char *attrname = strchr(name,'.') + 1;
1424
1425         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1426
1427         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1428
1429         return retval ? retval : valuelength;
1430 #elif defined(HAVE_ATTROPEN)
1431         ssize_t ret = -1;
1432         int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
1433         if (attrfd >= 0) {
1434                 ret = solaris_read_xattr(attrfd, value, size);
1435                 close(attrfd);
1436         }
1437         return ret;
1438 #else
1439         errno = ENOSYS;
1440         return -1;
1441 #endif
1442 }
1443
1444 ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
1445 {
1446 #if defined(HAVE_LGETXATTR)
1447         return lgetxattr(path, name, value, size);
1448 #elif defined(HAVE_GETXATTR) && defined(XATTR_ADD_OPT)
1449         int options = XATTR_NOFOLLOW;
1450         return getxattr(path, name, value, size, 0, options);
1451 #elif defined(HAVE_LGETEA)
1452         return lgetea(path, name, value, size);
1453 #elif defined(HAVE_EXTATTR_GET_LINK)
1454         char *s;
1455         ssize_t retval;
1456         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1457                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1458         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1459
1460         if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1461                 if(retval > size) {
1462                         errno = ERANGE;
1463                         return -1;
1464                 }
1465                 if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
1466                         return retval;
1467         }
1468
1469         DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
1470         return -1;
1471 #elif defined(HAVE_ATTR_GET)
1472         int retval, flags = ATTR_DONTFOLLOW;
1473         int valuelength = (int)size;
1474         char *attrname = strchr(name,'.') + 1;
1475
1476         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1477
1478         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1479
1480         return retval ? retval : valuelength;
1481 #elif defined(HAVE_ATTROPEN)
1482         ssize_t ret = -1;
1483         int attrfd = solaris_attropen(path, name, O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1484         if (attrfd >= 0) {
1485                 ret = solaris_read_xattr(attrfd, value, size);
1486                 close(attrfd);
1487         }
1488         return ret;
1489 #else
1490         errno = ENOSYS;
1491         return -1;
1492 #endif
1493 }
1494
1495 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
1496 {
1497 #if defined(HAVE_FGETXATTR)
1498 #ifndef XATTR_ADD_OPT
1499         return fgetxattr(filedes, name, value, size);
1500 #else
1501         int options = 0;
1502         return fgetxattr(filedes, name, value, size, 0, options);
1503 #endif
1504 #elif defined(HAVE_FGETEA)
1505         return fgetea(filedes, name, value, size);
1506 #elif defined(HAVE_EXTATTR_GET_FD)
1507         char *s;
1508         ssize_t retval;
1509         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1510                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1511         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1512
1513         if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
1514                 if(retval > size) {
1515                         errno = ERANGE;
1516                         return -1;
1517                 }
1518                 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
1519                         return retval;
1520         }
1521
1522         DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
1523         return -1;
1524 #elif defined(HAVE_ATTR_GETF)
1525         int retval, flags = 0;
1526         int valuelength = (int)size;
1527         char *attrname = strchr(name,'.') + 1;
1528
1529         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1530
1531         retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
1532
1533         return retval ? retval : valuelength;
1534 #elif defined(HAVE_ATTROPEN)
1535         ssize_t ret = -1;
1536         int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
1537         if (attrfd >= 0) {
1538                 ret = solaris_read_xattr(attrfd, value, size);
1539                 close(attrfd);
1540         }
1541         return ret;
1542 #else
1543         errno = ENOSYS;
1544         return -1;
1545 #endif
1546 }
1547
1548 #if defined(HAVE_EXTATTR_LIST_FILE)
1549
1550 #define EXTATTR_PREFIX(s)       (s), (sizeof((s))-1)
1551
1552 static struct {
1553         int space;
1554         const char *name;
1555         size_t len;
1556 }
1557 extattr[] = {
1558         { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
1559         { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
1560 };
1561
1562 typedef union {
1563         const char *path;
1564         int filedes;
1565 } extattr_arg;
1566
1567 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
1568 {
1569         ssize_t list_size, total_size = 0;
1570         int i, t, len;
1571         char *buf;
1572         /* Iterate through extattr(2) namespaces */
1573         for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
1574                 switch(type) {
1575 #if defined(HAVE_EXTATTR_LIST_FILE)
1576                         case 0:
1577                                 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
1578                                 break;
1579 #endif
1580 #if defined(HAVE_EXTATTR_LIST_LINK)
1581                         case 1:
1582                                 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
1583                                 break;
1584 #endif
1585 #if defined(HAVE_EXTATTR_LIST_FD)
1586                         case 2:
1587                                 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
1588                                 break;
1589 #endif
1590                         default:
1591                                 errno = ENOSYS;
1592                                 return -1;
1593                 }
1594                 /* Some error happend. Errno should be set by the previous call */
1595                 if(list_size < 0)
1596                         return -1;
1597                 /* No attributes */
1598                 if(list_size == 0)
1599                         continue;
1600                 /* XXX: Call with an empty buffer may be used to calculate
1601                    necessary buffer size. Unfortunately, we can't say, how
1602                    many attributes were returned, so here is the potential
1603                    problem with the emulation.
1604                 */
1605                 if(list == NULL) {
1606                         /* Take the worse case of one char attribute names -
1607                            two bytes per name plus one more for sanity.
1608                         */
1609                         total_size += list_size + (list_size/2 + 1)*extattr[t].len;
1610                         continue;
1611                 }
1612                 /* Count necessary offset to fit namespace prefixes */
1613                 len = 0;
1614                 for(i = 0; i < list_size; i += list[i] + 1)
1615                         len += extattr[t].len;
1616
1617                 total_size += list_size + len;
1618                 /* Buffer is too small to fit the results */
1619                 if(total_size > size) {
1620                         errno = ERANGE;
1621                         return -1;
1622                 }
1623                 /* Shift results back, so we can prepend prefixes */
1624                 buf = memmove(list + len, list, list_size);
1625
1626                 for(i = 0; i < list_size; i += len + 1) {
1627                         len = buf[i];
1628                         strncpy(list, extattr[t].name, extattr[t].len + 1);
1629                         list += extattr[t].len;
1630                         strncpy(list, buf + i + 1, len);
1631                         list[len] = '\0';
1632                         list += len + 1;
1633                 }
1634                 size -= total_size;
1635         }
1636         return total_size;
1637 }
1638
1639 #endif
1640
1641 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1642 static char attr_buffer[ATTR_MAX_VALUELEN];
1643
1644 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
1645 {
1646         int retval = 0, index;
1647         attrlist_cursor_t *cursor = 0;
1648         int total_size = 0;
1649         attrlist_t * al = (attrlist_t *)attr_buffer;
1650         attrlist_ent_t *ae;
1651         size_t ent_size, left = size;
1652         char *bp = list;
1653
1654         while (True) {
1655             if (filedes)
1656                 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1657             else
1658                 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1659             if (retval) break;
1660             for (index = 0; index < al->al_count; index++) {
1661                 ae = ATTR_ENTRY(attr_buffer, index);
1662                 ent_size = strlen(ae->a_name) + sizeof("user.");
1663                 if (left >= ent_size) {
1664                     strncpy(bp, "user.", sizeof("user."));
1665                     strncat(bp, ae->a_name, ent_size - sizeof("user."));
1666                     bp += ent_size;
1667                     left -= ent_size;
1668                 } else if (size) {
1669                     errno = ERANGE;
1670                     retval = -1;
1671                     break;
1672                 }
1673                 total_size += ent_size;
1674             }
1675             if (al->al_more == 0) break;
1676         }
1677         if (retval == 0) {
1678             flags |= ATTR_ROOT;
1679             cursor = 0;
1680             while (True) {
1681                 if (filedes)
1682                     retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1683                 else
1684                     retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1685                 if (retval) break;
1686                 for (index = 0; index < al->al_count; index++) {
1687                     ae = ATTR_ENTRY(attr_buffer, index);
1688                     ent_size = strlen(ae->a_name) + sizeof("system.");
1689                     if (left >= ent_size) {
1690                         strncpy(bp, "system.", sizeof("system."));
1691                         strncat(bp, ae->a_name, ent_size - sizeof("system."));
1692                         bp += ent_size;
1693                         left -= ent_size;
1694                     } else if (size) {
1695                         errno = ERANGE;
1696                         retval = -1;
1697                         break;
1698                     }
1699                     total_size += ent_size;
1700                 }
1701                 if (al->al_more == 0) break;
1702             }
1703         }
1704         return (ssize_t)(retval ? retval : total_size);
1705 }
1706
1707 #endif
1708
1709 ssize_t sys_listxattr (const char *path, char *list, size_t size)
1710 {
1711 #if defined(HAVE_LISTXATTR)
1712 #ifndef XATTR_ADD_OPT
1713         return listxattr(path, list, size);
1714 #else
1715         int options = 0;
1716         return listxattr(path, list, size, options);
1717 #endif
1718 #elif defined(HAVE_LISTEA)
1719         return listea(path, list, size);
1720 #elif defined(HAVE_EXTATTR_LIST_FILE)
1721         extattr_arg arg;
1722         arg.path = path;
1723         return bsd_attr_list(0, arg, list, size);
1724 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1725         return irix_attr_list(path, 0, list, size, 0);
1726 #elif defined(HAVE_ATTROPEN)
1727         ssize_t ret = -1;
1728         int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1729         if (attrdirfd >= 0) {
1730                 ret = solaris_list_xattr(attrdirfd, list, size);
1731                 close(attrdirfd);
1732         }
1733         return ret;
1734 #else
1735         errno = ENOSYS;
1736         return -1;
1737 #endif
1738 }
1739
1740 ssize_t sys_llistxattr (const char *path, char *list, size_t size)
1741 {
1742 #if defined(HAVE_LLISTXATTR)
1743         return llistxattr(path, list, size);
1744 #elif defined(HAVE_LISTXATTR) && defined(XATTR_ADD_OPT)
1745         int options = XATTR_NOFOLLOW;
1746         return listxattr(path, list, size, options);
1747 #elif defined(HAVE_LLISTEA)
1748         return llistea(path, list, size);
1749 #elif defined(HAVE_EXTATTR_LIST_LINK)
1750         extattr_arg arg;
1751         arg.path = path;
1752         return bsd_attr_list(1, arg, list, size);
1753 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1754         return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW);
1755 #elif defined(HAVE_ATTROPEN)
1756         ssize_t ret = -1;
1757         int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1758         if (attrdirfd >= 0) {
1759                 ret = solaris_list_xattr(attrdirfd, list, size);
1760                 close(attrdirfd);
1761         }
1762         return ret;
1763 #else
1764         errno = ENOSYS;
1765         return -1;
1766 #endif
1767 }
1768
1769 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
1770 {
1771 #if defined(HAVE_FLISTXATTR)
1772 #ifndef XATTR_ADD_OPT
1773         return flistxattr(filedes, list, size);
1774 #else
1775         int options = 0;
1776         return flistxattr(filedes, list, size, options);
1777 #endif
1778 #elif defined(HAVE_FLISTEA)
1779         return flistea(filedes, list, size);
1780 #elif defined(HAVE_EXTATTR_LIST_FD)
1781         extattr_arg arg;
1782         arg.filedes = filedes;
1783         return bsd_attr_list(2, arg, list, size);
1784 #elif defined(HAVE_ATTR_LISTF)
1785         return irix_attr_list(NULL, filedes, list, size, 0);
1786 #elif defined(HAVE_ATTROPEN)
1787         ssize_t ret = -1;
1788         int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1789         if (attrdirfd >= 0) {
1790                 ret = solaris_list_xattr(attrdirfd, list, size);
1791                 close(attrdirfd);
1792         }
1793         return ret;
1794 #else
1795         errno = ENOSYS;
1796         return -1;
1797 #endif
1798 }
1799
1800 int sys_removexattr (const char *path, const char *name)
1801 {
1802 #if defined(HAVE_REMOVEXATTR)
1803 #ifndef XATTR_ADD_OPT
1804         return removexattr(path, name);
1805 #else
1806         int options = 0;
1807         return removexattr(path, name, options);
1808 #endif
1809 #elif defined(HAVE_REMOVEEA)
1810         return removeea(path, name);
1811 #elif defined(HAVE_EXTATTR_DELETE_FILE)
1812         char *s;
1813         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1814                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1815         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1816
1817         return extattr_delete_file(path, attrnamespace, attrname);
1818 #elif defined(HAVE_ATTR_REMOVE)
1819         int flags = 0;
1820         char *attrname = strchr(name,'.') + 1;
1821
1822         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1823
1824         return attr_remove(path, attrname, flags);
1825 #elif defined(HAVE_ATTROPEN)
1826         int ret = -1;
1827         int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1828         if (attrdirfd >= 0) {
1829                 ret = solaris_unlinkat(attrdirfd, name);
1830                 close(attrdirfd);
1831         }
1832         return ret;
1833 #else
1834         errno = ENOSYS;
1835         return -1;
1836 #endif
1837 }
1838
1839 int sys_lremovexattr (const char *path, const char *name)
1840 {
1841 #if defined(HAVE_LREMOVEXATTR)
1842         return lremovexattr(path, name);
1843 #elif defined(HAVE_REMOVEXATTR) && defined(XATTR_ADD_OPT)
1844         int options = XATTR_NOFOLLOW;
1845         return removexattr(path, name, options);
1846 #elif defined(HAVE_LREMOVEEA)
1847         return lremoveea(path, name);
1848 #elif defined(HAVE_EXTATTR_DELETE_LINK)
1849         char *s;
1850         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1851                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1852         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1853
1854         return extattr_delete_link(path, attrnamespace, attrname);
1855 #elif defined(HAVE_ATTR_REMOVE)
1856         int flags = ATTR_DONTFOLLOW;
1857         char *attrname = strchr(name,'.') + 1;
1858
1859         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1860
1861         return attr_remove(path, attrname, flags);
1862 #elif defined(HAVE_ATTROPEN)
1863         int ret = -1;
1864         int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1865         if (attrdirfd >= 0) {
1866                 ret = solaris_unlinkat(attrdirfd, name);
1867                 close(attrdirfd);
1868         }
1869         return ret;
1870 #else
1871         errno = ENOSYS;
1872         return -1;
1873 #endif
1874 }
1875
1876 int sys_fremovexattr (int filedes, const char *name)
1877 {
1878 #if defined(HAVE_FREMOVEXATTR)
1879 #ifndef XATTR_ADD_OPT
1880         return fremovexattr(filedes, name);
1881 #else
1882         int options = 0;
1883         return fremovexattr(filedes, name, options);
1884 #endif
1885 #elif defined(HAVE_FREMOVEEA)
1886         return fremoveea(filedes, name);
1887 #elif defined(HAVE_EXTATTR_DELETE_FD)
1888         char *s;
1889         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1890                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1891         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1892
1893         return extattr_delete_fd(filedes, attrnamespace, attrname);
1894 #elif defined(HAVE_ATTR_REMOVEF)
1895         int flags = 0;
1896         char *attrname = strchr(name,'.') + 1;
1897
1898         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1899
1900         return attr_removef(filedes, attrname, flags);
1901 #elif defined(HAVE_ATTROPEN)
1902         int ret = -1;
1903         int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
1904         if (attrdirfd >= 0) {
1905                 ret = solaris_unlinkat(attrdirfd, name);
1906                 close(attrdirfd);
1907         }
1908         return ret;
1909 #else
1910         errno = ENOSYS;
1911         return -1;
1912 #endif
1913 }
1914
1915 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1916 {
1917 #if defined(HAVE_SETXATTR)
1918 #ifndef XATTR_ADD_OPT
1919         return setxattr(path, name, value, size, flags);
1920 #else
1921         int options = 0;
1922         return setxattr(path, name, value, size, 0, options);
1923 #endif
1924 #elif defined(HAVE_SETEA)
1925         return setea(path, name, value, size, flags);
1926 #elif defined(HAVE_EXTATTR_SET_FILE)
1927         char *s;
1928         int retval = 0;
1929         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1930                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1931         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1932         if (flags) {
1933                 /* Check attribute existence */
1934                 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
1935                 if (retval < 0) {
1936                         /* REPLACE attribute, that doesn't exist */
1937                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
1938                                 errno = ENOATTR;
1939                                 return -1;
1940                         }
1941                         /* Ignore other errors */
1942                 }
1943                 else {
1944                         /* CREATE attribute, that already exists */
1945                         if (flags & XATTR_CREATE) {
1946                                 errno = EEXIST;
1947                                 return -1;
1948                         }
1949                 }
1950         }
1951         retval = extattr_set_file(path, attrnamespace, attrname, value, size);
1952         return (retval < 0) ? -1 : 0;
1953 #elif defined(HAVE_ATTR_SET)
1954         int myflags = 0;
1955         char *attrname = strchr(name,'.') + 1;
1956
1957         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1958         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1959         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1960
1961         return attr_set(path, attrname, (const char *)value, size, myflags);
1962 #elif defined(HAVE_ATTROPEN)
1963         int ret = -1;
1964         int myflags = O_RDWR;
1965         int attrfd;
1966         if (flags & XATTR_CREATE) myflags |= O_EXCL;
1967         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
1968         attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
1969         if (attrfd >= 0) {
1970                 ret = solaris_write_xattr(attrfd, value, size);
1971                 close(attrfd);
1972         }
1973         return ret;
1974 #else
1975         errno = ENOSYS;
1976         return -1;
1977 #endif
1978 }
1979
1980 int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1981 {
1982 #if defined(HAVE_LSETXATTR)
1983         return lsetxattr(path, name, value, size, flags);
1984 #elif defined(HAVE_SETXATTR) && defined(XATTR_ADD_OPT)
1985         int options = XATTR_NOFOLLOW;
1986         return setxattr(path, name, value, size, 0, options);
1987 #elif defined(LSETEA)
1988         return lsetea(path, name, value, size, flags);
1989 #elif defined(HAVE_EXTATTR_SET_LINK)
1990         char *s;
1991         int retval = 0;
1992         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1993                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1994         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1995         if (flags) {
1996                 /* Check attribute existence */
1997                 retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
1998                 if (retval < 0) {
1999                         /* REPLACE attribute, that doesn't exist */
2000                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
2001                                 errno = ENOATTR;
2002                                 return -1;
2003                         }
2004                         /* Ignore other errors */
2005                 }
2006                 else {
2007                         /* CREATE attribute, that already exists */
2008                         if (flags & XATTR_CREATE) {
2009                                 errno = EEXIST;
2010                                 return -1;
2011                         }
2012                 }
2013         }
2014
2015         retval = extattr_set_link(path, attrnamespace, attrname, value, size);
2016         return (retval < 0) ? -1 : 0;
2017 #elif defined(HAVE_ATTR_SET)
2018         int myflags = ATTR_DONTFOLLOW;
2019         char *attrname = strchr(name,'.') + 1;
2020
2021         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2022         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2023         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2024
2025         return attr_set(path, attrname, (const char *)value, size, myflags);
2026 #elif defined(HAVE_ATTROPEN)
2027         int ret = -1;
2028         int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW;
2029         int attrfd;
2030         if (flags & XATTR_CREATE) myflags |= O_EXCL;
2031         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2032         attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2033         if (attrfd >= 0) {
2034                 ret = solaris_write_xattr(attrfd, value, size);
2035                 close(attrfd);
2036         }
2037         return ret;
2038 #else
2039         errno = ENOSYS;
2040         return -1;
2041 #endif
2042 }
2043
2044 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
2045 {
2046 #if defined(HAVE_FSETXATTR)
2047 #ifndef XATTR_ADD_OPT
2048         return fsetxattr(filedes, name, value, size, flags);
2049 #else
2050         int options = 0;
2051         return fsetxattr(filedes, name, value, size, 0, options);
2052 #endif
2053 #elif defined(HAVE_FSETEA)
2054         return fsetea(filedes, name, value, size, flags);
2055 #elif defined(HAVE_EXTATTR_SET_FD)
2056         char *s;
2057         int retval = 0;
2058         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2059                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2060         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2061         if (flags) {
2062                 /* Check attribute existence */
2063                 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
2064                 if (retval < 0) {
2065                         /* REPLACE attribute, that doesn't exist */
2066                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
2067                                 errno = ENOATTR;
2068                                 return -1;
2069                         }
2070                         /* Ignore other errors */
2071                 }
2072                 else {
2073                         /* CREATE attribute, that already exists */
2074                         if (flags & XATTR_CREATE) {
2075                                 errno = EEXIST;
2076                                 return -1;
2077                         }
2078                 }
2079         }
2080         retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
2081         return (retval < 0) ? -1 : 0;
2082 #elif defined(HAVE_ATTR_SETF)
2083         int myflags = 0;
2084         char *attrname = strchr(name,'.') + 1;
2085
2086         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2087         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2088         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2089
2090         return attr_setf(filedes, attrname, (const char *)value, size, myflags);
2091 #elif defined(HAVE_ATTROPEN)
2092         int ret = -1;
2093         int myflags = O_RDWR | O_XATTR;
2094         int attrfd;
2095         if (flags & XATTR_CREATE) myflags |= O_EXCL;
2096         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2097         attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2098         if (attrfd >= 0) {
2099                 ret = solaris_write_xattr(attrfd, value, size);
2100                 close(attrfd);
2101         }
2102         return ret;
2103 #else
2104         errno = ENOSYS;
2105         return -1;
2106 #endif
2107 }
2108
2109 /**************************************************************************
2110  helper functions for Solaris' EA support
2111 ****************************************************************************/
2112 #ifdef HAVE_ATTROPEN
2113 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
2114 {
2115         struct stat sbuf;
2116
2117         if (fstat(attrfd, &sbuf) == -1) {
2118                 errno = ENOATTR;
2119                 return -1;
2120         }
2121
2122         /* This is to return the current size of the named extended attribute */
2123         if (size == 0) {
2124                 return sbuf.st_size;
2125         }
2126
2127         /* check size and read xattr */
2128         if (sbuf.st_size > size) {
2129                 errno = ERANGE;
2130                 return -1;
2131         }
2132
2133         return read(attrfd, value, sbuf.st_size);
2134 }
2135
2136 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
2137 {
2138         ssize_t len = 0;
2139         int stop = 0;
2140         DIR *dirp;
2141         struct dirent *de;
2142         int newfd = dup(attrdirfd);
2143         /* CAUTION: The originating file descriptor should not be
2144                     used again following the call to fdopendir().
2145                     For that reason we dup() the file descriptor
2146                     here to make things more clear. */
2147         dirp = fdopendir(newfd);
2148
2149         while ((de = readdir(dirp))) {
2150                 size_t listlen = strlen(de->d_name);
2151                 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
2152                         /* we don't want "." and ".." here: */
2153                         DEBUG(10,("skipped EA %s\n",de->d_name));
2154                         continue;
2155                 }
2156
2157                 if (size == 0) {
2158                         /* return the current size of the list of extended attribute names*/
2159                         len += listlen + 1;
2160                 } else {
2161                         /* check size and copy entrieѕ + nul into list. */
2162                         if ((len + listlen + 1) > size) {
2163                                 errno = ERANGE;
2164                                 len = -1;
2165                                 break;
2166                         } else {
2167                                 safe_strcpy(list + len, de->d_name, listlen);
2168                                 len += listlen;
2169                                 list[len] = '\0';
2170                                 ++len;
2171                         }
2172                 }
2173         }
2174
2175         if (closedir(dirp) == -1) {
2176                 DEBUG(0,("closedir dirp failed: %s\n",strerror(errno)));
2177                 return -1;
2178         }
2179         return len;
2180 }
2181
2182 static int solaris_unlinkat(int attrdirfd, const char *name)
2183 {
2184         if (unlinkat(attrdirfd, name, 0) == -1) {
2185                 if (errno == ENOENT) {
2186                         errno = ENOATTR;
2187                 }
2188                 return -1;
2189         }
2190         return 0;
2191 }
2192
2193 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
2194 {
2195         int filedes = attropen(path, attrpath, oflag, mode);
2196         if (filedes == -1) {
2197                 DEBUG(10,("attropen FAILED: path: %s, name: %s, errno: %s\n",path,attrpath,strerror(errno)));
2198                 if (errno == EINVAL) {
2199                         errno = ENOTSUP;
2200                 } else {
2201                         errno = ENOATTR;
2202                 }
2203         }
2204         return filedes;
2205 }
2206
2207 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
2208 {
2209         int filedes = openat(fildes, path, oflag, mode);
2210         if (filedes == -1) {
2211                 DEBUG(10,("openat FAILED: fd: %s, path: %s, errno: %s\n",filedes,path,strerror(errno)));
2212                 if (errno == EINVAL) {
2213                         errno = ENOTSUP;
2214                 } else {
2215                         errno = ENOATTR;
2216                 }
2217         }
2218         return filedes;
2219 }
2220
2221 static int solaris_write_xattr(int attrfd, const char *value, size_t size)
2222 {
2223         if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
2224                 return 0;
2225         } else {
2226                 DEBUG(10,("solaris_write_xattr FAILED!\n"));
2227                 return -1;
2228         }
2229 }
2230 #endif /*HAVE_ATTROPEN*/
2231
2232
2233 /****************************************************************************
2234  Return the major devicenumber for UNIX extensions.
2235 ****************************************************************************/
2236
2237 uint32 unix_dev_major(SMB_DEV_T dev)
2238 {
2239 #if defined(HAVE_DEVICE_MAJOR_FN)
2240         return (uint32)major(dev);
2241 #else
2242         return (uint32)(dev >> 8);
2243 #endif
2244 }
2245
2246 /****************************************************************************
2247  Return the minor devicenumber for UNIX extensions.
2248 ****************************************************************************/
2249
2250 uint32 unix_dev_minor(SMB_DEV_T dev)
2251 {
2252 #if defined(HAVE_DEVICE_MINOR_FN)
2253         return (uint32)minor(dev);
2254 #else
2255         return (uint32)(dev & 0xff);
2256 #endif
2257 }
2258
2259 #if defined(WITH_AIO)
2260
2261 /*******************************************************************
2262  An aio_read wrapper that will deal with 64-bit sizes.
2263 ********************************************************************/
2264
2265 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2266 {
2267 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
2268         return aio_read64(aiocb);
2269 #elif defined(HAVE_AIO_READ)
2270         return aio_read(aiocb);
2271 #else
2272         errno = ENOSYS;
2273         return -1;
2274 #endif
2275 }
2276
2277 /*******************************************************************
2278  An aio_write wrapper that will deal with 64-bit sizes.
2279 ********************************************************************/
2280
2281 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2282 {
2283 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
2284         return aio_write64(aiocb);
2285 #elif defined(HAVE_AIO_WRITE)
2286         return aio_write(aiocb);
2287 #else
2288         errno = ENOSYS;
2289         return -1;
2290 #endif
2291 }
2292
2293 /*******************************************************************
2294  An aio_return wrapper that will deal with 64-bit sizes.
2295 ********************************************************************/
2296
2297 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2298 {
2299 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
2300         return aio_return64(aiocb);
2301 #elif defined(HAVE_AIO_RETURN)
2302         return aio_return(aiocb);
2303 #else
2304         errno = ENOSYS;
2305         return -1;
2306 #endif
2307 }
2308
2309 /*******************************************************************
2310  An aio_cancel wrapper that will deal with 64-bit sizes.
2311 ********************************************************************/
2312
2313 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2314 {
2315 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
2316         return aio_cancel64(fd, aiocb);
2317 #elif defined(HAVE_AIO_CANCEL)
2318         return aio_cancel(fd, aiocb);
2319 #else
2320         errno = ENOSYS;
2321         return -1;
2322 #endif
2323 }
2324
2325 /*******************************************************************
2326  An aio_error wrapper that will deal with 64-bit sizes.
2327 ********************************************************************/
2328
2329 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2330 {
2331 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
2332         return aio_error64(aiocb);
2333 #elif defined(HAVE_AIO_ERROR)
2334         return aio_error(aiocb);
2335 #else
2336         errno = ENOSYS;
2337         return -1;
2338 #endif
2339 }
2340
2341 /*******************************************************************
2342  An aio_fsync wrapper that will deal with 64-bit sizes.
2343 ********************************************************************/
2344
2345 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2346 {
2347 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64)
2348         return aio_fsync64(op, aiocb);
2349 #elif defined(HAVE_AIO_FSYNC)
2350         return aio_fsync(op, aiocb);
2351 #else
2352         errno = ENOSYS;
2353         return -1;
2354 #endif
2355 }
2356
2357 /*******************************************************************
2358  An aio_fsync wrapper that will deal with 64-bit sizes.
2359 ********************************************************************/
2360
2361 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2362 {
2363 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64)
2364         return aio_suspend64(cblist, n, timeout);
2365 #elif defined(HAVE_AIO_FSYNC)
2366         return aio_suspend(cblist, n, timeout);
2367 #else
2368         errno = ENOSYS;
2369         return -1;
2370 #endif
2371 }
2372 #else /* !WITH_AIO */
2373
2374 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2375 {
2376         errno = ENOSYS;
2377         return -1;
2378 }
2379
2380 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2381 {
2382         errno = ENOSYS;
2383         return -1;
2384 }
2385
2386 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2387 {
2388         errno = ENOSYS;
2389         return -1;
2390 }
2391
2392 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2393 {
2394         errno = ENOSYS;
2395         return -1;
2396 }
2397
2398 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2399 {
2400         errno = ENOSYS;
2401         return -1;
2402 }
2403
2404 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2405 {
2406         errno = ENOSYS;
2407         return -1;
2408 }
2409
2410 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2411 {
2412         errno = ENOSYS;
2413         return -1;
2414 }
2415 #endif /* WITH_AIO */
2416
2417 int sys_getpeereid( int s, uid_t *uid)
2418 {
2419 #if defined(HAVE_PEERCRED)
2420         struct ucred cred;
2421         socklen_t cred_len = sizeof(struct ucred);
2422         int ret;
2423
2424         ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
2425         if (ret != 0) {
2426                 return -1;
2427         }
2428
2429         if (cred_len != sizeof(struct ucred)) {
2430                 errno = EINVAL;
2431                 return -1;
2432         }
2433
2434         *uid = cred.uid;
2435         return 0;
2436 #else
2437         errno = ENOSYS;
2438         return -1;
2439 #endif
2440 }
2441
2442 int sys_getnameinfo(const struct sockaddr *psa,
2443                         socklen_t salen,
2444                         char *host,
2445                         size_t hostlen,
2446                         char *service,
2447                         size_t servlen,
2448                         int flags)
2449 {
2450         /*
2451          * For Solaris we must make sure salen is the
2452          * correct length for the incoming sa_family.
2453          */
2454
2455         if (salen == sizeof(struct sockaddr_storage)) {
2456                 salen = sizeof(struct sockaddr_in);
2457 #if defined(HAVE_IPV6)
2458                 if (psa->sa_family == AF_INET6) {
2459                         salen = sizeof(struct sockaddr_in6);
2460                 }
2461 #endif
2462         }
2463         return getnameinfo(psa, salen, host, hostlen, service, servlen, flags);
2464 }
2465
2466 int sys_connect(int fd, const struct sockaddr * addr)
2467 {
2468         socklen_t salen = -1;
2469
2470         if (addr->sa_family == AF_INET) {
2471             salen = sizeof(struct sockaddr_in);
2472         } else if (addr->sa_family == AF_UNIX) {
2473             salen = sizeof(struct sockaddr_un);
2474         }
2475 #if defined(HAVE_IPV6)
2476         else if (addr->sa_family == AF_INET6) {
2477             salen = sizeof(struct sockaddr_in6);
2478         }
2479 #endif
2480
2481         return connect(fd, addr, salen);
2482 }