source3/lib/system.c

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