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