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
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 /*
  26    The idea is that this file will eventually have wrappers around all
  27    important system calls in samba. The aims are:
  28
  29    - to enable easier porting by putting OS dependent stuff in here
  30
  31    - to allow for hooks into other "pseudo-filesystems"
  32
  33    - to allow easier integration of things like the japanese extensions
  34
  35    - to support the philosophy of Samba to expose the features of
  36      the OS within the SMB model. In general whatever file/printer/variable
  37      expansions/etc make sense to the OS should be acceptable to Samba.
  38 */
  39
  40
  41
  42 /*******************************************************************
  43  A wrapper for usleep in case we don't have one.
  44 ********************************************************************/
  45
  46 int sys_usleep(long usecs)
  47 {
  48 #ifndef HAVE_USLEEP
  49         struct timeval tval;
  50 #endif
  51
  52         /*
  53          * We need this braindamage as the glibc usleep
  54          * is not SPEC1170 complient... grumble... JRA.
  55          */
  56
  57         if(usecs < 0 || usecs > 1000000) {
  58                 errno = EINVAL;
  59                 return -1;
  60         }
  61
  62 #if HAVE_USLEEP
  63         usleep(usecs);
  64         return 0;
  65 #else /* HAVE_USLEEP */
  66         /*
  67          * Fake it with select...
  68          */
  69         tval.tv_sec = 0;
  70         tval.tv_usec = usecs/1000;
  71         select(0,NULL,NULL,NULL,&tval);
  72         return 0;
  73 #endif /* HAVE_USLEEP */
  74 }
  75
  76 /*******************************************************************
  77 A read wrapper that will deal with EINTR.
  78 ********************************************************************/
  79
  80 ssize_t sys_read(int fd, void *buf, size_t count)
  81 {
  82         ssize_t ret;
  83
  84         do {
  85                 ret = read(fd, buf, count);
  86         } while (ret == -1 && errno == EINTR);
  87         return ret;
  88 }
  89
  90 /*******************************************************************
  91 A write wrapper that will deal with EINTR.
  92 ********************************************************************/
  93
  94 ssize_t sys_write(int fd, const void *buf, size_t count)
  95 {
  96         ssize_t ret;
  97
  98         do {
  99                 ret = write(fd, buf, count);
 100         } while (ret == -1 && errno == EINTR);
 101         return ret;
 102 }
 103
 104
 105 /*******************************************************************
 106 A pread wrapper that will deal with EINTR and 64-bit file offsets.
 107 ********************************************************************/
 108
 109 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
 110 ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
 111 {
 112         ssize_t ret;
 113
 114         do {
 115 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PREAD64)
 116                 ret = pread64(fd, buf, count, off);
 117 #else
 118                 ret = pread(fd, buf, count, off);
 119 #endif
 120         } while (ret == -1 && errno == EINTR);
 121         return ret;
 122 }
 123 #endif
 124
 125 /*******************************************************************
 126 A write wrapper that will deal with EINTR and 64-bit file offsets.
 127 ********************************************************************/
 128
 129 #if defined(HAVE_PWRITE) || defined(HAVE_PWRITE64)
 130 ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off)
 131 {
 132         ssize_t ret;
 133
 134         do {
 135 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64)
 136                 ret = pwrite64(fd, buf, count, off);
 137 #else
 138                 ret = pwrite(fd, buf, count, off);
 139 #endif
 140         } while (ret == -1 && errno == EINTR);
 141         return ret;
 142 }
 143 #endif
 144
 145 /*******************************************************************
 146 A send wrapper that will deal with EINTR.
 147 ********************************************************************/
 148
 149 ssize_t sys_send(int s, const void *msg, size_t len, int flags)
 150 {
 151         ssize_t ret;
 152
 153         do {
 154                 ret = send(s, msg, len, flags);
 155         } while (ret == -1 && errno == EINTR);
 156         return ret;
 157 }
 158
 159 /*******************************************************************
 160 A sendto wrapper that will deal with EINTR.
 161 ********************************************************************/
 162
 163 ssize_t sys_sendto(int s,  const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
 164 {
 165         ssize_t ret;
 166
 167         do {
 168                 ret = sendto(s, msg, len, flags, to, tolen);
 169         } while (ret == -1 && errno == EINTR);
 170         return ret;
 171 }
 172
 173 /*******************************************************************
 174 A recvfrom wrapper that will deal with EINTR.
 175 ********************************************************************/
 176
 177 ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 178 {
 179         ssize_t ret;
 180
 181         do {
 182                 ret = recvfrom(s, buf, len, flags, from, fromlen);
 183         } while (ret == -1 && errno == EINTR);
 184         return ret;
 185 }
 186
 187 /*******************************************************************
 188 A fcntl wrapper that will deal with EINTR.
 189 ********************************************************************/
 190
 191 int sys_fcntl_ptr(int fd, int cmd, void *arg)
 192 {
 193         int ret;
 194
 195         do {
 196                 ret = fcntl(fd, cmd, arg);
 197         } while (ret == -1 && errno == EINTR);
 198         return ret;
 199 }
 200
 201 /*******************************************************************
 202 A fcntl wrapper that will deal with EINTR.
 203 ********************************************************************/
 204
 205 int sys_fcntl_long(int fd, int cmd, long arg)
 206 {
 207         int ret;
 208
 209         do {
 210                 ret = fcntl(fd, cmd, arg);
 211         } while (ret == -1 && errno == EINTR);
 212         return ret;
 213 }
 214
 215 /*******************************************************************
 216 A stat() wrapper that will deal with 64 bit filesizes.
 217 ********************************************************************/
 218
 219 int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
 220 {
 221         int ret;
 222 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
 223         ret = stat64(fname, sbuf);
 224 #else
 225         ret = stat(fname, sbuf);
 226 #endif
 227         /* we always want directories to appear zero size */
 228         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
 229         return ret;
 230 }
 231
 232 /*******************************************************************
 233  An fstat() wrapper that will deal with 64 bit filesizes.
 234 ********************************************************************/
 235
 236 int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
 237 {
 238         int ret;
 239 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
 240         ret = fstat64(fd, sbuf);
 241 #else
 242         ret = fstat(fd, sbuf);
 243 #endif
 244         /* we always want directories to appear zero size */
 245         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
 246         return ret;
 247 }
 248
 249 /*******************************************************************
 250  An lstat() wrapper that will deal with 64 bit filesizes.
 251 ********************************************************************/
 252
 253 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
 254 {
 255         int ret;
 256 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
 257         ret = lstat64(fname, sbuf);
 258 #else
 259         ret = lstat(fname, sbuf);
 260 #endif
 261         /* we always want directories to appear zero size */
 262         if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
 263         return ret;
 264 }
 265
 266 /*******************************************************************
 267  An ftruncate() wrapper that will deal with 64 bit filesizes.
 268 ********************************************************************/
 269
 270 int sys_ftruncate(int fd, SMB_OFF_T offset)
 271 {
 272 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
 273         return ftruncate64(fd, offset);
 274 #else
 275         return ftruncate(fd, offset);
 276 #endif
 277 }
 278
 279 /*******************************************************************
 280  An lseek() wrapper that will deal with 64 bit filesizes.
 281 ********************************************************************/
 282
 283 SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
 284 {
 285 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
 286         return lseek64(fd, offset, whence);
 287 #else
 288         return lseek(fd, offset, whence);
 289 #endif
 290 }
 291
 292 /*******************************************************************
 293  An fseek() wrapper that will deal with 64 bit filesizes.
 294 ********************************************************************/
 295
 296 int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
 297 {
 298 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
 299         return fseek64(fp, offset, whence);
 300 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
 301         return fseeko64(fp, offset, whence);
 302 #else
 303         return fseek(fp, offset, whence);
 304 #endif
 305 }
 306
 307 /*******************************************************************
 308  An ftell() wrapper that will deal with 64 bit filesizes.
 309 ********************************************************************/
 310
 311 SMB_OFF_T sys_ftell(FILE *fp)
 312 {
 313 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
 314         return (SMB_OFF_T)ftell64(fp);
 315 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
 316         return (SMB_OFF_T)ftello64(fp);
 317 #else
 318         return (SMB_OFF_T)ftell(fp);
 319 #endif
 320 }
 321
 322 /*******************************************************************
 323  A creat() wrapper that will deal with 64 bit filesizes.
 324 ********************************************************************/
 325
 326 int sys_creat(const char *path, mode_t mode)
 327 {
 328 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
 329         return creat64(path, mode);
 330 #else
 331         /*
 332          * If creat64 isn't defined then ensure we call a potential open64.
 333          * JRA.
 334          */
 335         return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
 336 #endif
 337 }
 338
 339 /*******************************************************************
 340  An open() wrapper that will deal with 64 bit filesizes.
 341 ********************************************************************/
 342
 343 int sys_open(const char *path, int oflag, mode_t mode)
 344 {
 345 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
 346         return open64(path, oflag, mode);
 347 #else
 348         return open(path, oflag, mode);
 349 #endif
 350 }
 351
 352 /*******************************************************************
 353  An fopen() wrapper that will deal with 64 bit filesizes.
 354 ********************************************************************/
 355
 356 FILE *sys_fopen(const char *path, const char *type)
 357 {
 358 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
 359         return fopen64(path, type);
 360 #else
 361         return fopen(path, type);
 362 #endif
 363 }
 364
 365 /*******************************************************************
 366  An opendir wrapper that will deal with 64 bit filesizes.
 367 ********************************************************************/
 368
 369 SMB_STRUCT_DIR *sys_opendir(const char *name)
 370 {
 371 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
 372         return opendir64(name);
 373 #else
 374         return opendir(name);
 375 #endif
 376 }
 377
 378 /*******************************************************************
 379  A readdir wrapper that will deal with 64 bit filesizes.
 380 ********************************************************************/
 381
 382 SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
 383 {
 384 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
 385         return readdir64(dirp);
 386 #else
 387         return readdir(dirp);
 388 #endif
 389 }
 390
 391 /*******************************************************************
 392  A seekdir wrapper that will deal with 64 bit filesizes.
 393 ********************************************************************/
 394
 395 void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset)
 396 {
 397 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_SEEKDIR64)
 398         seekdir64(dirp, offset);
 399 #else
 400         seekdir(dirp, offset);
 401 #endif
 402 }
 403
 404 /*******************************************************************
 405  A telldir wrapper that will deal with 64 bit filesizes.
 406 ********************************************************************/
 407
 408 long sys_telldir(SMB_STRUCT_DIR *dirp)
 409 {
 410 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_TELLDIR64)
 411         return (long)telldir64(dirp);
 412 #else
 413         return (long)telldir(dirp);
 414 #endif
 415 }
 416
 417 /*******************************************************************
 418  A rewinddir wrapper that will deal with 64 bit filesizes.
 419 ********************************************************************/
 420
 421 void sys_rewinddir(SMB_STRUCT_DIR *dirp)
 422 {
 423 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
 424         rewinddir64(dirp);
 425 #else
 426         rewinddir(dirp);
 427 #endif
 428 }
 429
 430 /*******************************************************************
 431  A close wrapper that will deal with 64 bit filesizes.
 432 ********************************************************************/
 433
 434 int sys_closedir(SMB_STRUCT_DIR *dirp)
 435 {
 436 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
 437         return closedir64(dirp);
 438 #else
 439         return closedir(dirp);
 440 #endif
 441 }
 442
 443 /*******************************************************************
 444  An mknod() wrapper that will deal with 64 bit filesizes.
 445 ********************************************************************/
 446
 447 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
 448 {
 449 #if defined(HAVE_MKNOD) || defined(HAVE_MKNOD64)
 450 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_MKNOD64) && defined(HAVE_DEV64_T)
 451         return mknod64(path, mode, dev);
 452 #else
 453         return mknod(path, mode, dev);
 454 #endif
 455 #else
 456         /* No mknod system call. */
 457         errno = ENOSYS;
 458         return -1;
 459 #endif
 460 }
 461
 462 /*******************************************************************
 463  Wrapper for realpath.
 464 ********************************************************************/
 465
 466 char *sys_realpath(const char *path, char *resolved_path)
 467 {
 468 #if defined(HAVE_REALPATH)
 469         return realpath(path, resolved_path);
 470 #else
 471         /* As realpath is not a system call we can't return ENOSYS. */
 472         errno = EINVAL;
 473         return NULL;
 474 #endif
 475 }
 476
 477 /*******************************************************************
 478 The wait() calls vary between systems
 479 ********************************************************************/
 480
 481 int sys_waitpid(pid_t pid,int *status,int options)
 482 {
 483 #ifdef HAVE_WAITPID
 484         return waitpid(pid,status,options);
 485 #else /* HAVE_WAITPID */
 486         return wait4(pid, status, options, NULL);
 487 #endif /* HAVE_WAITPID */
 488 }
 489
 490 /*******************************************************************
 491  System wrapper for getwd
 492 ********************************************************************/
 493
 494 char *sys_getwd(char *s)
 495 {
 496         char *wd;
 497 #ifdef HAVE_GETCWD
 498         wd = (char *)getcwd(s, sizeof (pstring));
 499 #else
 500         wd = (char *)getwd(s);
 501 #endif
 502         return wd;
 503 }
 504
 505 /*******************************************************************
 506 system wrapper for symlink
 507 ********************************************************************/
 508
 509 int sys_symlink(const char *oldpath, const char *newpath)
 510 {
 511 #ifndef HAVE_SYMLINK
 512         errno = ENOSYS;
 513         return -1;
 514 #else
 515         return symlink(oldpath, newpath);
 516 #endif
 517 }
 518
 519 /*******************************************************************
 520 system wrapper for readlink
 521 ********************************************************************/
 522
 523 int sys_readlink(const char *path, char *buf, size_t bufsiz)
 524 {
 525 #ifndef HAVE_READLINK
 526         errno = ENOSYS;
 527         return -1;
 528 #else
 529         return readlink(path, buf, bufsiz);
 530 #endif
 531 }
 532
 533 /*******************************************************************
 534 system wrapper for link
 535 ********************************************************************/
 536
 537 int sys_link(const char *oldpath, const char *newpath)
 538 {
 539 #ifndef HAVE_LINK
 540         errno = ENOSYS;
 541         return -1;
 542 #else
 543         return link(oldpath, newpath);
 544 #endif
 545 }
 546
 547 /*******************************************************************
 548 chown isn't used much but OS/2 doesn't have it
 549 ********************************************************************/
 550
 551 int sys_chown(const char *fname,uid_t uid,gid_t gid)
 552 {
 553 #ifndef HAVE_CHOWN
 554         static int done;
 555         if (!done) {
 556                 DEBUG(1,("WARNING: no chown!\n"));
 557                 done=1;
 558         }
 559         errno = ENOSYS;
 560         return -1;
 561 #else
 562         return(chown(fname,uid,gid));
 563 #endif
 564 }
 565
 566 /*******************************************************************
 567 os/2 also doesn't have chroot
 568 ********************************************************************/
 569 int sys_chroot(const char *dname)
 570 {
 571 #ifndef HAVE_CHROOT
 572         static int done;
 573         if (!done) {
 574                 DEBUG(1,("WARNING: no chroot!\n"));
 575                 done=1;
 576         }
 577         errno = ENOSYS;
 578         return -1;
 579 #else
 580         return(chroot(dname));
 581 #endif
 582 }
 583
 584 /**************************************************************************
 585 A wrapper for gethostbyname() that tries avoids looking up hostnames
 586 in the root domain, which can cause dial-on-demand links to come up for no
 587 apparent reason.
 588 ****************************************************************************/
 589
 590 struct hostent *sys_gethostbyname(const char *name)
 591 {
 592 #ifdef REDUCE_ROOT_DNS_LOOKUPS
 593         char query[256], hostname[256];
 594         char *domain;
 595
 596         /* Does this name have any dots in it? If so, make no change */
 597
 598         if (strchr_m(name, '.'))
 599                 return(gethostbyname(name));
 600
 601         /* Get my hostname, which should have domain name
 602                 attached. If not, just do the gethostname on the
 603                 original string.
 604         */
 605
 606         gethostname(hostname, sizeof(hostname) - 1);
 607         hostname[sizeof(hostname) - 1] = 0;
 608         if ((domain = strchr_m(hostname, '.')) == NULL)
 609                 return(gethostbyname(name));
 610
 611         /* Attach domain name to query and do modified query.
 612                 If names too large, just do gethostname on the
 613                 original string.
 614         */
 615
 616         if((strlen(name) + strlen(domain)) >= sizeof(query))
 617                 return(gethostbyname(name));
 618
 619         slprintf(query, sizeof(query)-1, "%s%s", name, domain);
 620         return(gethostbyname(query));
 621 #else /* REDUCE_ROOT_DNS_LOOKUPS */
 622         return(gethostbyname(name));
 623 #endif /* REDUCE_ROOT_DNS_LOOKUPS */
 624 }
 625
 626
 627 #if defined(HAVE_IRIX_SPECIFIC_CAPABILITIES)
 628 /**************************************************************************
 629  Try and abstract process capabilities (for systems that have them).
 630 ****************************************************************************/
 631 static BOOL set_process_capability( uint32 cap_flag, BOOL enable )
 632 {
 633         if(cap_flag == KERNEL_OPLOCK_CAPABILITY) {
 634                 cap_t cap = cap_get_proc();
 635
 636                 if (cap == NULL) {
 637                         DEBUG(0,("set_process_capability: cap_get_proc failed. Error was %s\n",
 638                                 strerror(errno)));
 639                         return False;
 640                 }
 641
 642                 if(enable)
 643                         cap->cap_effective |= CAP_NETWORK_MGT;
 644                 else
 645                         cap->cap_effective &= ~CAP_NETWORK_MGT;
 646
 647                 if (cap_set_proc(cap) == -1) {
 648                         DEBUG(0,("set_process_capability: cap_set_proc failed. Error was %s\n",
 649                                 strerror(errno)));
 650                         cap_free(cap);
 651                         return False;
 652                 }
 653
 654                 cap_free(cap);
 655
 656                 DEBUG(10,("set_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
 657         }
 658         return True;
 659 }
 660
 661 /**************************************************************************
 662  Try and abstract inherited process capabilities (for systems that have them).
 663 ****************************************************************************/
 664
 665 static BOOL set_inherited_process_capability( uint32 cap_flag, BOOL enable )
 666 {
 667         if(cap_flag == KERNEL_OPLOCK_CAPABILITY) {
 668                 cap_t cap = cap_get_proc();
 669
 670                 if (cap == NULL) {
 671                         DEBUG(0,("set_inherited_process_capability: cap_get_proc failed. Error was %s\n",
 672                                 strerror(errno)));
 673                         return False;
 674                 }
 675
 676                 if(enable)
 677                         cap->cap_inheritable |= CAP_NETWORK_MGT;
 678                 else
 679                         cap->cap_inheritable &= ~CAP_NETWORK_MGT;
 680
 681                 if (cap_set_proc(cap) == -1) {
 682                         DEBUG(0,("set_inherited_process_capability: cap_set_proc failed. Error was %s\n",
 683                                 strerror(errno)));
 684                         cap_free(cap);
 685                         return False;
 686                 }
 687
 688                 cap_free(cap);
 689
 690                 DEBUG(10,("set_inherited_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
 691         }
 692         return True;
 693 }
 694 #endif
 695
 696 /****************************************************************************
 697  Gain the oplock capability from the kernel if possible.
 698 ****************************************************************************/
 699
 700 void oplock_set_capability(BOOL this_process, BOOL inherit)
 701 {
 702 #if HAVE_KERNEL_OPLOCKS_IRIX
 703         set_process_capability(KERNEL_OPLOCK_CAPABILITY,this_process);
 704         set_inherited_process_capability(KERNEL_OPLOCK_CAPABILITY,inherit);
 705 #endif
 706 }
 707
 708 /**************************************************************************
 709  Wrapper for random().
 710 ****************************************************************************/
 711
 712 long sys_random(void)
 713 {
 714 #if defined(HAVE_RANDOM)
 715         return (long)random();
 716 #elif defined(HAVE_RAND)
 717         return (long)rand();
 718 #else
 719         DEBUG(0,("Error - no random function available !\n"));
 720         exit(1);
 721 #endif
 722 }
 723
 724 /**************************************************************************
 725  Wrapper for srandom().
 726 ****************************************************************************/
 727
 728 void sys_srandom(unsigned int seed)
 729 {
 730 #if defined(HAVE_SRANDOM)
 731         srandom(seed);
 732 #elif defined(HAVE_SRAND)
 733         srand(seed);
 734 #else
 735         DEBUG(0,("Error - no srandom function available !\n"));
 736         exit(1);
 737 #endif
 738 }
 739
 740 /**************************************************************************
 741  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
 742 ****************************************************************************/
 743
 744 int groups_max(void)
 745 {
 746 #if defined(SYSCONF_SC_NGROUPS_MAX)
 747         int ret = sysconf(_SC_NGROUPS_MAX);
 748         return (ret == -1) ? NGROUPS_MAX : ret;
 749 #else
 750         return NGROUPS_MAX;
 751 #endif
 752 }
 753
 754 /**************************************************************************
 755  Wrapper for getgroups. Deals with broken (int) case.
 756 ****************************************************************************/
 757
 758 int sys_getgroups(int setlen, gid_t *gidset)
 759 {
 760 #if !defined(HAVE_BROKEN_GETGROUPS)
 761         return getgroups(setlen, gidset);
 762 #else
 763
 764         GID_T gid;
 765         GID_T *group_list;
 766         int i, ngroups;
 767
 768         if(setlen == 0) {
 769                 return getgroups(setlen, &gid);
 770         }
 771
 772         /*
 773          * Broken case. We need to allocate a
 774          * GID_T array of size setlen.
 775          */
 776
 777         if(setlen < 0) {
 778                 errno = EINVAL;
 779                 return -1;
 780         }
 781
 782         if (setlen == 0)
 783                 setlen = groups_max();
 784
 785         if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
 786                 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
 787                 return -1;
 788         }
 789
 790         if((ngroups = getgroups(setlen, group_list)) < 0) {
 791                 int saved_errno = errno;
 792                 SAFE_FREE(group_list);
 793                 errno = saved_errno;
 794                 return -1;
 795         }
 796
 797         for(i = 0; i < ngroups; i++)
 798                 gidset[i] = (gid_t)group_list[i];
 799
 800         SAFE_FREE(group_list);
 801         return ngroups;
 802 #endif /* HAVE_BROKEN_GETGROUPS */
 803 }
 804
 805
 806 /**************************************************************************
 807  Wrapper for setgroups. Deals with broken (int) case. Automatically used
 808  if we have broken getgroups.
 809 ****************************************************************************/
 810
 811 int sys_setgroups(int setlen, gid_t *gidset)
 812 {
 813 #if !defined(HAVE_SETGROUPS)
 814         errno = ENOSYS;
 815         return -1;
 816 #endif /* HAVE_SETGROUPS */
 817
 818 #if !defined(HAVE_BROKEN_GETGROUPS)
 819         return setgroups(setlen, gidset);
 820 #else
 821
 822         GID_T *group_list;
 823         int i ;
 824
 825         if (setlen == 0)
 826                 return 0 ;
 827
 828         if (setlen < 0 || setlen > groups_max()) {
 829                 errno = EINVAL;
 830                 return -1;
 831         }
 832
 833         /*
 834          * Broken case. We need to allocate a
 835          * GID_T array of size setlen.
 836          */
 837
 838         if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
 839                 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
 840                 return -1;
 841         }
 842
 843         for(i = 0; i < setlen; i++)
 844                 group_list[i] = (GID_T) gidset[i];
 845
 846         if(setgroups(setlen, group_list) != 0) {
 847                 int saved_errno = errno;
 848                 SAFE_FREE(group_list);
 849                 errno = saved_errno;
 850                 return -1;
 851         }
 852
 853         SAFE_FREE(group_list);
 854         return 0 ;
 855 #endif /* HAVE_BROKEN_GETGROUPS */
 856 }
 857
 858 /**************************************************************************
 859  Wrappers for setpwent(), getpwent() and endpwent()
 860 ****************************************************************************/
 861
 862 void sys_setpwent(void)
 863 {
 864         setpwent();
 865 }
 866
 867 struct passwd *sys_getpwent(void)
 868 {
 869         return getpwent();
 870 }
 871
 872 void sys_endpwent(void)
 873 {
 874         endpwent();
 875 }
 876
 877 /**************************************************************************
 878  Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
 879 ****************************************************************************/
 880
 881 struct passwd *sys_getpwnam(const char *name)
 882 {
 883         return getpwnam(name);
 884 }
 885
 886 struct passwd *sys_getpwuid(uid_t uid)
 887 {
 888         return getpwuid(uid);
 889 }
 890
 891 struct group *sys_getgrnam(const char *name)
 892 {
 893         return getgrnam(name);
 894 }
 895
 896 struct group *sys_getgrgid(gid_t gid)
 897 {
 898         return getgrgid(gid);
 899 }
 900
 901 #if 0 /* NOT CURRENTLY USED - JRA */
 902 /**************************************************************************
 903  The following are the UNICODE versions of *all* system interface functions
 904  called within Samba. Ok, ok, the exceptions are the gethostbyXX calls,
 905  which currently are left as ascii as they are not used other than in name
 906  resolution.
 907 ****************************************************************************/
 908
 909 /**************************************************************************
 910  Wide stat. Just narrow and call sys_xxx.
 911 ****************************************************************************/
 912
 913 int wsys_stat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf)
 914 {
 915         pstring fname;
 916         return sys_stat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf);
 917 }
 918
 919 /**************************************************************************
 920  Wide lstat. Just narrow and call sys_xxx.
 921 ****************************************************************************/
 922
 923 int wsys_lstat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf)
 924 {
 925         pstring fname;
 926         return sys_lstat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf);
 927 }
 928
 929 /**************************************************************************
 930  Wide creat. Just narrow and call sys_xxx.
 931 ****************************************************************************/
 932
 933 int wsys_creat(const smb_ucs2_t *wfname, mode_t mode)
 934 {
 935         pstring fname;
 936         return sys_creat(unicode_to_unix(fname,wfname,sizeof(fname)), mode);
 937 }
 938
 939 /**************************************************************************
 940  Wide open. Just narrow and call sys_xxx.
 941 ****************************************************************************/
 942
 943 int wsys_open(const smb_ucs2_t *wfname, int oflag, mode_t mode)
 944 {
 945         pstring fname;
 946         return sys_open(unicode_to_unix(fname,wfname,sizeof(fname)), oflag, mode);
 947 }
 948
 949 /**************************************************************************
 950  Wide fopen. Just narrow and call sys_xxx.
 951 ****************************************************************************/
 952
 953 FILE *wsys_fopen(const smb_ucs2_t *wfname, const char *type)
 954 {
 955         pstring fname;
 956         return sys_fopen(unicode_to_unix(fname,wfname,sizeof(fname)), type);
 957 }
 958
 959 /**************************************************************************
 960  Wide opendir. Just narrow and call sys_xxx.
 961 ****************************************************************************/
 962
 963 SMB_STRUCT_DIR *wsys_opendir(const smb_ucs2_t *wfname)
 964 {
 965         pstring fname;
 966         return opendir(unicode_to_unix(fname,wfname,sizeof(fname)));
 967 }
 968
 969 /**************************************************************************
 970  Wide readdir. Return a structure pointer containing a wide filename.
 971 ****************************************************************************/
 972
 973 SMB_STRUCT_WDIRENT *wsys_readdir(SMB_STRUCT_DIR *dirp)
 974 {
 975         static SMB_STRUCT_WDIRENT retval;
 976         SMB_STRUCT_DIRENT *dirval = sys_readdir(dirp);
 977
 978         if(!dirval)
 979                 return NULL;
 980
 981         /*
 982          * The only POSIX defined member of this struct is d_name.
 983          */
 984
 985         unix_to_unicode(retval.d_name,dirval->d_name,sizeof(retval.d_name));
 986
 987         return &retval;
 988 }
 989
 990 /**************************************************************************
 991  Wide getwd. Call sys_xxx and widen. Assumes s points to a wpstring.
 992 ****************************************************************************/
 993
 994 smb_ucs2_t *wsys_getwd(smb_ucs2_t *s)
 995 {
 996         pstring fname;
 997         char *p = sys_getwd(fname);
 998
 999         if(!p)
1000                 return NULL;
1001
1002         return unix_to_unicode(s, p, sizeof(wpstring));
1003 }
1004
1005 /**************************************************************************
1006  Wide chown. Just narrow and call sys_xxx.
1007 ****************************************************************************/
1008
1009 int wsys_chown(const smb_ucs2_t *wfname, uid_t uid, gid_t gid)
1010 {
1011         pstring fname;
1012         return chown(unicode_to_unix(fname,wfname,sizeof(fname)), uid, gid);
1013 }
1014
1015 /**************************************************************************
1016  Wide chroot. Just narrow and call sys_xxx.
1017 ****************************************************************************/
1018
1019 int wsys_chroot(const smb_ucs2_t *wfname)
1020 {
1021         pstring fname;
1022         return chroot(unicode_to_unix(fname,wfname,sizeof(fname)));
1023 }
1024
1025 /**************************************************************************
1026  Wide getpwnam. Return a structure pointer containing wide names.
1027 ****************************************************************************/
1028
1029 SMB_STRUCT_WPASSWD *wsys_getpwnam(const smb_ucs2_t *wname)
1030 {
1031         static SMB_STRUCT_WPASSWD retval;
1032         fstring name;
1033         struct passwd *pwret = sys_getpwnam(unicode_to_unix(name,wname,sizeof(name)));
1034
1035         if(!pwret)
1036                 return NULL;
1037
1038         unix_to_unicode(retval.pw_name, pwret->pw_name, sizeof(retval.pw_name));
1039         retval.pw_passwd = pwret->pw_passwd;
1040         retval.pw_uid = pwret->pw_uid;
1041         retval.pw_gid = pwret->pw_gid;
1042         unix_to_unicode(retval.pw_gecos, pwret->pw_gecos, sizeof(retval.pw_gecos));
1043         unix_to_unicode(retval.pw_dir, pwret->pw_dir, sizeof(retval.pw_dir));
1044         unix_to_unicode(retval.pw_shell, pwret->pw_shell, sizeof(retval.pw_shell));
1045
1046         return &retval;
1047 }
1048
1049 /**************************************************************************
1050  Wide getpwuid. Return a structure pointer containing wide names.
1051 ****************************************************************************/
1052
1053 SMB_STRUCT_WPASSWD *wsys_getpwuid(uid_t uid)
1054 {
1055         static SMB_STRUCT_WPASSWD retval;
1056         struct passwd *pwret = sys_getpwuid(uid);
1057
1058         if(!pwret)
1059                 return NULL;
1060
1061         unix_to_unicode(retval.pw_name, pwret->pw_name, sizeof(retval.pw_name));
1062         retval.pw_passwd = pwret->pw_passwd;
1063         retval.pw_uid = pwret->pw_uid;
1064         retval.pw_gid = pwret->pw_gid;
1065         unix_to_unicode(retval.pw_gecos, pwret->pw_gecos, sizeof(retval.pw_gecos));
1066         unix_to_unicode(retval.pw_dir, pwret->pw_dir, sizeof(retval.pw_dir));
1067         unix_to_unicode(retval.pw_shell, pwret->pw_shell, sizeof(retval.pw_shell));
1068
1069         return &retval;
1070 }
1071 #endif /* NOT CURRENTLY USED - JRA */
1072
1073 /**************************************************************************
1074  Extract a command into an arg list. Uses a static pstring for storage.
1075  Caller frees returned arg list (which contains pointers into the static pstring).
1076 ****************************************************************************/
1077
1078 static char **extract_args(const char *command)
1079 {
1080         static pstring trunc_cmd;
1081         char *ptr;
1082         int argcl;
1083         char **argl = NULL;
1084         int i;
1085
1086         pstrcpy(trunc_cmd, command);
1087
1088         if(!(ptr = strtok(trunc_cmd, " \t"))) {
1089                 errno = EINVAL;
1090                 return NULL;
1091         }
1092
1093         /*
1094          * Count the args.
1095          */
1096
1097         for( argcl = 1; ptr; ptr = strtok(NULL, " \t"))
1098                 argcl++;
1099
1100         if((argl = (char **)SMB_MALLOC((argcl + 1) * sizeof(char *))) == NULL)
1101                 return NULL;
1102
1103         /*
1104          * Now do the extraction.
1105          */
1106
1107         pstrcpy(trunc_cmd, command);
1108
1109         ptr = strtok(trunc_cmd, " \t");
1110         i = 0;
1111         argl[i++] = ptr;
1112
1113         while((ptr = strtok(NULL, " \t")) != NULL)
1114                 argl[i++] = ptr;
1115
1116         argl[i++] = NULL;
1117         return argl;
1118 }
1119
1120 /**************************************************************************
1121  Wrapper for fork. Ensures that mypid is reset. Used so we can write
1122  a sys_getpid() that only does a system call *once*.
1123 ****************************************************************************/
1124
1125 static pid_t mypid = (pid_t)-1;
1126
1127 pid_t sys_fork(void)
1128 {
1129         pid_t forkret = fork();
1130
1131         if (forkret == (pid_t)0) /* Child - reset mypid so sys_getpid does a system call. */
1132                 mypid = (pid_t) -1;
1133
1134         return forkret;
1135 }
1136
1137 /**************************************************************************
1138  Wrapper for getpid. Ensures we only do a system call *once*.
1139 ****************************************************************************/
1140
1141 pid_t sys_getpid(void)
1142 {
1143         if (mypid == (pid_t)-1)
1144                 mypid = getpid();
1145
1146         return mypid;
1147 }
1148
1149 /**************************************************************************
1150  Wrapper for popen. Safer as it doesn't search a path.
1151  Modified from the glibc sources.
1152  modified by tridge to return a file descriptor. We must kick our FILE* habit
1153 ****************************************************************************/
1154
1155 typedef struct _popen_list
1156 {
1157         int fd;
1158         pid_t child_pid;
1159         struct _popen_list *next;
1160 } popen_list;
1161
1162 static popen_list *popen_chain;
1163
1164 int sys_popen(const char *command)
1165 {
1166         int parent_end, child_end;
1167         int pipe_fds[2];
1168         popen_list *entry = NULL;
1169         char **argl = NULL;
1170
1171         if (pipe(pipe_fds) < 0)
1172                 return -1;
1173
1174         parent_end = pipe_fds[0];
1175         child_end = pipe_fds[1];
1176
1177         if (!*command) {
1178                 errno = EINVAL;
1179                 goto err_exit;
1180         }
1181
1182         if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1183                 goto err_exit;
1184
1185         ZERO_STRUCTP(entry);
1186
1187         /*
1188          * Extract the command and args into a NULL terminated array.
1189          */
1190
1191         if(!(argl = extract_args(command)))
1192                 goto err_exit;
1193
1194         entry->child_pid = sys_fork();
1195
1196         if (entry->child_pid == -1) {
1197                 goto err_exit;
1198         }
1199
1200         if (entry->child_pid == 0) {
1201
1202                 /*
1203                  * Child !
1204                  */
1205
1206                 int child_std_end = STDOUT_FILENO;
1207                 popen_list *p;
1208
1209                 close(parent_end);
1210                 if (child_end != child_std_end) {
1211                         dup2 (child_end, child_std_end);
1212                         close (child_end);
1213                 }
1214
1215                 /*
1216                  * POSIX.2:  "popen() shall ensure that any streams from previous
1217                  * popen() calls that remain open in the parent process are closed
1218                  * in the new child process."
1219                  */
1220
1221                 for (p = popen_chain; p; p = p->next)
1222                         close(p->fd);
1223
1224                 execv(argl[0], argl);
1225                 _exit (127);
1226         }
1227
1228         /*
1229          * Parent.
1230          */
1231
1232         close (child_end);
1233         SAFE_FREE(argl);
1234
1235         /* Link into popen_chain. */
1236         entry->next = popen_chain;
1237         popen_chain = entry;
1238         entry->fd = parent_end;
1239
1240         return entry->fd;
1241
1242 err_exit:
1243
1244         SAFE_FREE(entry);
1245         SAFE_FREE(argl);
1246         close(pipe_fds[0]);
1247         close(pipe_fds[1]);
1248         return -1;
1249 }
1250
1251 /**************************************************************************
1252  Wrapper for pclose. Modified from the glibc sources.
1253 ****************************************************************************/
1254
1255 int sys_pclose(int fd)
1256 {
1257         int wstatus;
1258         popen_list **ptr = &popen_chain;
1259         popen_list *entry = NULL;
1260         pid_t wait_pid;
1261         int status = -1;
1262
1263         /* Unlink from popen_chain. */
1264         for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1265                 if ((*ptr)->fd == fd) {
1266                         entry = *ptr;
1267                         *ptr = (*ptr)->next;
1268                         status = 0;
1269                         break;
1270                 }
1271         }
1272
1273         if (status < 0 || close(entry->fd) < 0)
1274                 return -1;
1275
1276         /*
1277          * As Samba is catching and eating child process
1278          * exits we don't really care about the child exit
1279          * code, a -1 with errno = ECHILD will do fine for us.
1280          */
1281
1282         do {
1283                 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1284         } while (wait_pid == -1 && errno == EINTR);
1285
1286         SAFE_FREE(entry);
1287
1288         if (wait_pid == -1)
1289                 return -1;
1290         return wstatus;
1291 }
1292
1293 /**************************************************************************
1294  Wrappers for dlopen, dlsym, dlclose.
1295 ****************************************************************************/
1296
1297 void *sys_dlopen(const char *name, int flags)
1298 {
1299 #if defined(HAVE_DLOPEN)
1300         return dlopen(name, flags);
1301 #else
1302         return NULL;
1303 #endif
1304 }
1305
1306 void *sys_dlsym(void *handle, const char *symbol)
1307 {
1308 #if defined(HAVE_DLSYM)
1309     return dlsym(handle, symbol);
1310 #else
1311     return NULL;
1312 #endif
1313 }
1314
1315 int sys_dlclose (void *handle)
1316 {
1317 #if defined(HAVE_DLCLOSE)
1318         return dlclose(handle);
1319 #else
1320         return 0;
1321 #endif
1322 }
1323
1324 const char *sys_dlerror(void)
1325 {
1326 #if defined(HAVE_DLERROR)
1327         return dlerror();
1328 #else
1329         return NULL;
1330 #endif
1331 }
1332
1333 int sys_dup2(int oldfd, int newfd)
1334 {
1335 #if defined(HAVE_DUP2)
1336         return dup2(oldfd, newfd);
1337 #else
1338         errno = ENOSYS;
1339         return -1;
1340 #endif
1341 }
1342
1343 /**************************************************************************
1344  Wrapper for Admin Logs.
1345 ****************************************************************************/
1346
1347  void sys_adminlog(int priority, const char *format_str, ...)
1348 {
1349         va_list ap;
1350         int ret;
1351         char *msgbuf = NULL;
1352
1353         va_start( ap, format_str );
1354         ret = vasprintf( &msgbuf, format_str, ap );
1355         va_end( ap );
1356
1357         if (ret == -1)
1358                 return;
1359
1360 #if defined(HAVE_SYSLOG)
1361         syslog( priority, "%s", msgbuf );
1362 #else
1363         DEBUG(0,("%s", msgbuf ));
1364 #endif
1365         SAFE_FREE(msgbuf);
1366 }
1367
1368 /**************************************************************************
1369  Wrappers for extented attribute calls. Based on the Linux package with
1370  support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
1371 ****************************************************************************/
1372
1373 /* Possible error codes are: ENOATTR, ERANGE, ENOTSUP. From stat(2):
1374    EBADF, ENOENT, ENOTDIR, ELOOP, EFAULT, EACCES, ENOMEM, ENAMETOOLONG. */
1375 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
1376 {
1377 #if defined(HAVE_GETXATTR)
1378         return getxattr(path, name, value, size);
1379 #elif defined(HAVE_EXTATTR_GET_FILE)
1380         char *s;
1381         ssize_t retval;
1382         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1383                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1384         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1385         /*
1386          * The BSD implementation has a nasty habit of silently truncating
1387          * the returned value to the size of the buffer, so we have to check
1388          * that the buffer is large enough to fit the returned value.
1389          */
1390         if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1391                 if(retval > size) {
1392                         errno = ERANGE;
1393                         return -1;
1394                 }
1395                 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
1396                         return retval;
1397         }
1398
1399         DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
1400         return -1;
1401 #elif defined(HAVE_ATTR_GET)
1402         int retval, flags = 0;
1403         int valuelength = (int)size;
1404         char *attrname = strchr(name,'.') + 1;
1405
1406         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1407
1408         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1409
1410         return retval ? retval : valuelength;
1411 #else
1412         errno = ENOSYS;
1413         return -1;
1414 #endif
1415 }
1416
1417 ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
1418 {
1419 #if defined(HAVE_LGETXATTR)
1420         return lgetxattr(path, name, value, size);
1421 #elif defined(HAVE_EXTATTR_GET_LINK)
1422         char *s;
1423         ssize_t retval;
1424         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1425                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1426         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1427
1428         if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1429                 if(retval > size) {
1430                         errno = ERANGE;
1431                         return -1;
1432                 }
1433                 if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
1434                         return retval;
1435         }
1436
1437         DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
1438         return -1;
1439 #elif defined(HAVE_ATTR_GET)
1440         int retval, flags = ATTR_DONTFOLLOW;
1441         int valuelength = (int)size;
1442         char *attrname = strchr(name,'.') + 1;
1443
1444         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1445
1446         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1447
1448         return retval ? retval : valuelength;
1449 #else
1450         errno = ENOSYS;
1451         return -1;
1452 #endif
1453 }
1454
1455 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
1456 {
1457 #if defined(HAVE_FGETXATTR)
1458         return fgetxattr(filedes, name, value, size);
1459 #elif defined(HAVE_EXTATTR_GET_FD)
1460         char *s;
1461         ssize_t retval;
1462         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1463                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1464         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1465
1466         if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
1467                 if(retval > size) {
1468                         errno = ERANGE;
1469                         return -1;
1470                 }
1471                 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
1472                         return retval;
1473         }
1474
1475         DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
1476         return -1;
1477 #elif defined(HAVE_ATTR_GETF)
1478         int retval, flags = 0;
1479         int valuelength = (int)size;
1480         char *attrname = strchr(name,'.') + 1;
1481
1482         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1483
1484         retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
1485
1486         return retval ? retval : valuelength;
1487 #else
1488         errno = ENOSYS;
1489         return -1;
1490 #endif
1491 }
1492
1493 #if defined(HAVE_EXTATTR_LIST_FILE)
1494
1495 #define EXTATTR_PREFIX(s)       (s), (sizeof((s))-1)
1496
1497 static struct {
1498         int space;
1499         const char *name;
1500         size_t len;
1501 }
1502 extattr[] = {
1503         { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
1504         { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
1505 };
1506
1507 typedef union {
1508         const char *path;
1509         int filedes;
1510 } extattr_arg;
1511
1512 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
1513 {
1514         ssize_t list_size, total_size = 0;
1515         int i, t, len;
1516         char *buf;
1517         /* Iterate through extattr(2) namespaces */
1518         for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
1519                 switch(type) {
1520 #if defined(HAVE_EXTATTR_LIST_FILE)
1521                         case 0:
1522                                 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
1523                                 break;
1524 #endif
1525 #if defined(HAVE_EXTATTR_LIST_LINK)
1526                         case 1:
1527                                 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
1528                                 break;
1529 #endif
1530 #if defined(HAVE_EXTATTR_LIST_FD)
1531                         case 2:
1532                                 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
1533                                 break;
1534 #endif
1535                         default:
1536                                 errno = ENOSYS;
1537                                 return -1;
1538                 }
1539                 /* Some error happend. Errno should be set by the previous call */
1540                 if(list_size < 0)
1541                         return -1;
1542                 /* No attributes */
1543                 if(list_size == 0)
1544                         continue;
1545                 /* XXX: Call with an empty buffer may be used to calculate
1546                    necessary buffer size. Unfortunately, we can't say, how
1547                    many attributes were returned, so here is the potential
1548                    problem with the emulation.
1549                 */
1550                 if(list == NULL) {
1551                         /* Take the worse case of one char attribute names -
1552                            two bytes per name plus one more for sanity.
1553                         */
1554                         total_size += list_size + (list_size/2 + 1)*extattr[t].len;
1555                         continue;
1556                 }
1557                 /* Count necessary offset to fit namespace prefixes */
1558                 len = 0;
1559                 for(i = 0; i < list_size; i += list[i] + 1)
1560                         len += extattr[t].len;
1561
1562                 total_size += list_size + len;
1563                 /* Buffer is too small to fit the results */
1564                 if(total_size > size) {
1565                         errno = ERANGE;
1566                         return -1;
1567                 }
1568                 /* Shift results back, so we can prepend prefixes */
1569                 buf = memmove(list + len, list, list_size);
1570
1571                 for(i = 0; i < list_size; i += len + 1) {
1572                         len = buf[i];
1573                         strncpy(list, extattr[t].name, extattr[t].len + 1);
1574                         list += extattr[t].len;
1575                         strncpy(list, buf + i + 1, len);
1576                         list[len] = '\0';
1577                         list += len + 1;
1578                 }
1579                 size -= total_size;
1580         }
1581         return total_size;
1582 }
1583
1584 #endif
1585
1586 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1587 static char attr_buffer[ATTR_MAX_VALUELEN];
1588
1589 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
1590 {
1591         int retval = 0, index;
1592         attrlist_cursor_t *cursor = 0;
1593         int total_size = 0;
1594         attrlist_t * al = (attrlist_t *)attr_buffer;
1595         attrlist_ent_t *ae;
1596         size_t ent_size, left = size;
1597         char *bp = list;
1598
1599         while (True) {
1600             if (filedes)
1601                 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1602             else
1603                 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1604             if (retval) break;
1605             for (index = 0; index < al->al_count; index++) {
1606                 ae = ATTR_ENTRY(attr_buffer, index);
1607                 ent_size = strlen(ae->a_name) + sizeof("user.");
1608                 if (left >= ent_size) {
1609                     strncpy(bp, "user.", sizeof("user."));
1610                     strncat(bp, ae->a_name, ent_size - sizeof("user."));
1611                     bp += ent_size;
1612                     left -= ent_size;
1613                 } else if (size) {
1614                     errno = ERANGE;
1615                     retval = -1;
1616                     break;
1617                 }
1618                 total_size += ent_size;
1619             }
1620             if (al->al_more == 0) break;
1621         }
1622         if (retval == 0) {
1623             flags |= ATTR_ROOT;
1624             cursor = 0;
1625             while (True) {
1626                 if (filedes)
1627                     retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1628                 else
1629                     retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1630                 if (retval) break;
1631                 for (index = 0; index < al->al_count; index++) {
1632                     ae = ATTR_ENTRY(attr_buffer, index);
1633                     ent_size = strlen(ae->a_name) + sizeof("system.");
1634                     if (left >= ent_size) {
1635                         strncpy(bp, "system.", sizeof("system."));
1636                         strncat(bp, ae->a_name, ent_size - sizeof("system."));
1637                         bp += ent_size;
1638                         left -= ent_size;
1639                     } else if (size) {
1640                         errno = ERANGE;
1641                         retval = -1;
1642                         break;
1643                     }
1644                     total_size += ent_size;
1645                 }
1646                 if (al->al_more == 0) break;
1647             }
1648         }
1649         return (ssize_t)(retval ? retval : total_size);
1650 }
1651
1652 #endif
1653
1654 /* Possible error codes are: ERANGE, ENOTSUP. From stat(2):
1655    EBADF, ENOENT, ENOTDIR, ELOOP, EFAULT, EACCES, ENOMEM, ENAMETOOLONG. */
1656 ssize_t sys_listxattr (const char *path, char *list, size_t size)
1657 {
1658 #if defined(HAVE_LISTXATTR)
1659         return listxattr(path, list, size);
1660 #elif defined(HAVE_EXTATTR_LIST_FILE)
1661         extattr_arg arg;
1662         arg.path = path;
1663         return bsd_attr_list(0, arg, list, size);
1664 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1665         return irix_attr_list(path, 0, list, size, 0);
1666 #else
1667         errno = ENOSYS;
1668         return -1;
1669 #endif
1670 }
1671
1672 ssize_t sys_llistxattr (const char *path, char *list, size_t size)
1673 {
1674 #if defined(HAVE_LLISTXATTR)
1675         return llistxattr(path, list, size);
1676 #elif defined(HAVE_EXTATTR_LIST_LINK)
1677         extattr_arg arg;
1678         arg.path = path;
1679         return bsd_attr_list(1, arg, list, size);
1680 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1681         return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW);
1682 #else
1683         errno = ENOSYS;
1684         return -1;
1685 #endif
1686 }
1687
1688 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
1689 {
1690 #if defined(HAVE_FLISTXATTR)
1691         return flistxattr(filedes, list, size);
1692 #elif defined(HAVE_EXTATTR_LIST_FD)
1693         extattr_arg arg;
1694         arg.filedes = filedes;
1695         return bsd_attr_list(2, arg, list, size);
1696 #elif defined(HAVE_ATTR_LISTF)
1697         return irix_attr_list(NULL, filedes, list, size, 0);
1698 #else
1699         errno = ENOSYS;
1700         return -1;
1701 #endif
1702 }
1703
1704 /* Possible error codes are: ENOATTR, ENOTSUP. From stat(2):
1705    EBADF, ENOENT, ENOTDIR, ELOOP, EFAULT, EACCES, ENOMEM, ENAMETOOLONG. */
1706 int sys_removexattr (const char *path, const char *name)
1707 {
1708 #if defined(HAVE_REMOVEXATTR)
1709         return removexattr(path, name);
1710 #elif defined(HAVE_EXTATTR_DELETE_FILE)
1711         char *s;
1712         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1713                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1714         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1715
1716         return extattr_delete_file(path, attrnamespace, attrname);
1717 #elif defined(HAVE_ATTR_REMOVE)
1718         int flags = 0;
1719         char *attrname = strchr(name,'.') + 1;
1720
1721         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1722
1723         return attr_remove(path, attrname, flags);
1724 #else
1725         errno = ENOSYS;
1726         return -1;
1727 #endif
1728 }
1729
1730 int sys_lremovexattr (const char *path, const char *name)
1731 {
1732 #if defined(HAVE_LREMOVEXATTR)
1733         return lremovexattr(path, name);
1734 #elif defined(HAVE_EXTATTR_DELETE_LINK)
1735         char *s;
1736         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1737                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1738         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1739
1740         return extattr_delete_link(path, attrnamespace, attrname);
1741 #elif defined(HAVE_ATTR_REMOVE)
1742         int flags = ATTR_DONTFOLLOW;
1743         char *attrname = strchr(name,'.') + 1;
1744
1745         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1746
1747         return attr_remove(path, attrname, flags);
1748 #else
1749         errno = ENOSYS;
1750         return -1;
1751 #endif
1752 }
1753
1754 int sys_fremovexattr (int filedes, const char *name)
1755 {
1756 #if defined(HAVE_FREMOVEXATTR)
1757         return fremovexattr(filedes, name);
1758 #elif defined(HAVE_EXTATTR_DELETE_FD)
1759         char *s;
1760         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1761                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1762         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1763
1764         return extattr_delete_fd(filedes, attrnamespace, attrname);
1765 #elif defined(HAVE_ATTR_REMOVEF)
1766         int flags = 0;
1767         char *attrname = strchr(name,'.') + 1;
1768
1769         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1770
1771         return attr_removef(filedes, attrname, flags);
1772 #else
1773         errno = ENOSYS;
1774         return -1;
1775 #endif
1776 }
1777
1778 #if !defined(HAVE_SETXATTR)
1779 #define XATTR_CREATE  0x1       /* set value, fail if attr already exists */
1780 #define XATTR_REPLACE 0x2       /* set value, fail if attr does not exist */
1781 #endif
1782
1783 /* Possible error codes are: EEXIST, ENOATTR, ENOSPC, EDQUOT, ENOTSUP. From
1784    stat(2): EBADF, ENOENT, ENOTDIR, ELOOP, EFAULT, EACCES, ENOMEM, ENAMETOOLONG. */
1785 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1786 {
1787 #if defined(HAVE_SETXATTR)
1788         return setxattr(path, name, value, size, flags);
1789 #elif defined(HAVE_EXTATTR_SET_FILE)
1790         char *s;
1791         int retval = 0;
1792         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1793                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1794         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1795         if (flags) {
1796                 /* Check attribute existence */
1797                 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
1798                 if (retval < 0) {
1799                         /* REPLACE attribute, that doesn't exist */
1800                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
1801                                 errno = ENOATTR;
1802                                 return -1;
1803                         }
1804                         /* Ignore other errors */
1805                 }
1806                 else {
1807                         /* CREATE attribute, that already exists */
1808                         if (flags & XATTR_CREATE) {
1809                                 errno = EEXIST;
1810                                 return -1;
1811                         }
1812                 }
1813         }
1814         retval = extattr_set_file(path, attrnamespace, attrname, value, size);
1815         return (retval < 0) ? -1 : 0;
1816 #elif defined(HAVE_ATTR_SET)
1817         int myflags = 0;
1818         char *attrname = strchr(name,'.') + 1;
1819
1820         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1821         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1822         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1823
1824         return attr_set(path, attrname, (const char *)value, size, myflags);
1825 #else
1826         errno = ENOSYS;
1827         return -1;
1828 #endif
1829 }
1830
1831 int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags)
1832 {
1833 #if defined(HAVE_LSETXATTR)
1834         return lsetxattr(path, name, value, size, flags);
1835 #elif defined(HAVE_EXTATTR_SET_LINK)
1836         char *s;
1837         int retval = 0;
1838         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1839                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1840         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1841         if (flags) {
1842                 /* Check attribute existence */
1843                 retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
1844                 if (retval < 0) {
1845                         /* REPLACE attribute, that doesn't exist */
1846                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
1847                                 errno = ENOATTR;
1848                                 return -1;
1849                         }
1850                         /* Ignore other errors */
1851                 }
1852                 else {
1853                         /* CREATE attribute, that already exists */
1854                         if (flags & XATTR_CREATE) {
1855                                 errno = EEXIST;
1856                                 return -1;
1857                         }
1858                 }
1859         }
1860
1861         retval = extattr_set_link(path, attrnamespace, attrname, value, size);
1862         return (retval < 0) ? -1 : 0;
1863 #elif defined(HAVE_ATTR_SET)
1864         int myflags = ATTR_DONTFOLLOW;
1865         char *attrname = strchr(name,'.') + 1;
1866
1867         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1868         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1869         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1870
1871         return attr_set(path, attrname, (const char *)value, size, myflags);
1872 #else
1873         errno = ENOSYS;
1874         return -1;
1875 #endif
1876 }
1877
1878 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
1879 {
1880 #if defined(HAVE_FSETXATTR)
1881         return fsetxattr(filedes, name, value, size, flags);
1882 #elif defined(HAVE_EXTATTR_SET_FD)
1883         char *s;
1884         int retval = 0;
1885         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1886                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1887         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1888         if (flags) {
1889                 /* Check attribute existence */
1890                 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
1891                 if (retval < 0) {
1892                         /* REPLACE attribute, that doesn't exist */
1893                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
1894                                 errno = ENOATTR;
1895                                 return -1;
1896                         }
1897                         /* Ignore other errors */
1898                 }
1899                 else {
1900                         /* CREATE attribute, that already exists */
1901                         if (flags & XATTR_CREATE) {
1902                                 errno = EEXIST;
1903                                 return -1;
1904                         }
1905                 }
1906         }
1907         retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
1908         return (retval < 0) ? -1 : 0;
1909 #elif defined(HAVE_ATTR_SETF)
1910         int myflags = 0;
1911         char *attrname = strchr(name,'.') + 1;
1912
1913         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
1914         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
1915         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
1916
1917         return attr_setf(filedes, attrname, (const char *)value, size, myflags);
1918 #else
1919         errno = ENOSYS;
1920         return -1;
1921 #endif
1922 }
1923
1924 /****************************************************************************
1925  Return the major devicenumber for UNIX extensions.
1926 ****************************************************************************/
1927
1928 uint32 unix_dev_major(SMB_DEV_T dev)
1929 {
1930 #if defined(HAVE_DEVICE_MAJOR_FN)
1931         return (uint32)major(dev);
1932 #else
1933         return (uint32)(dev >> 8);
1934 #endif
1935 }
1936
1937 /****************************************************************************
1938  Return the minor devicenumber for UNIX extensions.
1939 ****************************************************************************/
1940
1941 uint32 unix_dev_minor(SMB_DEV_T dev)
1942 {
1943 #if defined(HAVE_DEVICE_MINOR_FN)
1944         return (uint32)minor(dev);
1945 #else
1946         return (uint32)(dev & 0xff);
1947 #endif
1948 }
1949
1950 #if defined(WITH_AIO)
1951
1952 /*******************************************************************
1953  An aio_read wrapper that will deal with 64-bit sizes.
1954 ********************************************************************/
1955
1956 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
1957 {
1958 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
1959         return aio_read64(aiocb);
1960 #elif defined(HAVE_AIO_READ)
1961         return aio_read(aiocb);
1962 #else
1963         errno = ENOSYS;
1964         return -1;
1965 #endif
1966 }
1967
1968 /*******************************************************************
1969  An aio_write wrapper that will deal with 64-bit sizes.
1970 ********************************************************************/
1971
1972 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
1973 {
1974 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
1975         return aio_write64(aiocb);
1976 #elif defined(HAVE_AIO_WRITE)
1977         return aio_write(aiocb);
1978 #else
1979         errno = ENOSYS;
1980         return -1;
1981 #endif
1982 }
1983
1984 /*******************************************************************
1985  An aio_return wrapper that will deal with 64-bit sizes.
1986 ********************************************************************/
1987
1988 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
1989 {
1990 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
1991         return aio_return64(aiocb);
1992 #elif defined(HAVE_AIO_RETURN)
1993         return aio_return(aiocb);
1994 #else
1995         errno = ENOSYS;
1996         return -1;
1997 #endif
1998 }
1999
2000 /*******************************************************************
2001  An aio_cancel wrapper that will deal with 64-bit sizes.
2002 ********************************************************************/
2003
2004 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2005 {
2006 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
2007         return aio_cancel64(fd, aiocb);
2008 #elif defined(HAVE_AIO_CANCEL)
2009         return aio_cancel(fd, aiocb);
2010 #else
2011         errno = ENOSYS;
2012         return -1;
2013 #endif
2014 }
2015
2016 /*******************************************************************
2017  An aio_error wrapper that will deal with 64-bit sizes.
2018 ********************************************************************/
2019
2020 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2021 {
2022 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
2023         return aio_error64(aiocb);
2024 #elif defined(HAVE_AIO_ERROR)
2025         return aio_error(aiocb);
2026 #else
2027         errno = ENOSYS;
2028         return -1;
2029 #endif
2030 }
2031
2032 /*******************************************************************
2033  An aio_fsync wrapper that will deal with 64-bit sizes.
2034 ********************************************************************/
2035
2036 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2037 {
2038 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64)
2039         return aio_fsync64(op, aiocb);
2040 #elif defined(HAVE_AIO_FSYNC)
2041         return aio_fsync(op, aiocb);
2042 #else
2043         errno = ENOSYS;
2044         return -1;
2045 #endif
2046 }
2047
2048 /*******************************************************************
2049  An aio_fsync wrapper that will deal with 64-bit sizes.
2050 ********************************************************************/
2051
2052 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2053 {
2054 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64)
2055         return aio_suspend64(cblist, n, timeout);
2056 #elif defined(HAVE_AIO_FSYNC)
2057         return aio_suspend(cblist, n, timeout);
2058 #else
2059         errno = ENOSYS;
2060         return -1;
2061 #endif
2062 }
2063 #else /* !WITH_AIO */
2064
2065 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2066 {
2067         errno = ENOSYS;
2068         return -1;
2069 }
2070
2071 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2072 {
2073         errno = ENOSYS;
2074         return -1;
2075 }
2076
2077 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2078 {
2079         errno = ENOSYS;
2080         return -1;
2081 }
2082
2083 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2084 {
2085         errno = ENOSYS;
2086         return -1;
2087 }
2088
2089 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2090 {
2091         errno = ENOSYS;
2092         return -1;
2093 }
2094
2095 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2096 {
2097         errno = ENOSYS;
2098         return -1;
2099 }
2100
2101 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2102 {
2103         errno = ENOSYS;
2104         return -1;
2105 }
2106 #endif /* WITH_AIO */