source3/lib/system.c

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