2 Unix SMB/CIFS implementation.
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
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.
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.
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/>.
24 #include "system/syslog.h"
25 #include "system/capability.h"
26 #include "system/passwd.h"
27 #include "system/filesys.h"
29 #ifdef HAVE_SYS_PRCTL_H
30 #include <sys/prctl.h>
34 The idea is that this file will eventually have wrappers around all
35 important system calls in samba. The aims are:
37 - to enable easier porting by putting OS dependent stuff in here
39 - to allow for hooks into other "pseudo-filesystems"
41 - to allow easier integration of things like the japanese extensions
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.
50 /*******************************************************************
51 A wrapper for memalign
52 ********************************************************************/
54 void *sys_memalign( size_t align, size_t size )
56 #if defined(HAVE_POSIX_MEMALIGN)
58 int ret = posix_memalign( &p, align, size );
63 #elif defined(HAVE_MEMALIGN)
64 return memalign( align, size );
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();
73 size_t pagesize = (size_t)-1;
75 if (pagesize == (size_t)-1) {
76 DEBUG(0,("memalign functionalaity not available on this platform!\n"));
79 if (size < pagesize) {
82 return SMB_MALLOC(size);
86 /*******************************************************************
87 A wrapper for usleep in case we don't have one.
88 ********************************************************************/
90 int sys_usleep(long usecs)
97 * We need this braindamage as the glibc usleep
98 * is not SPEC1170 complient... grumble... JRA.
101 if(usecs < 0 || usecs > 999999) {
109 #else /* HAVE_USLEEP */
111 * Fake it with select...
114 tval.tv_usec = usecs/1000;
115 select(0,NULL,NULL,NULL,&tval);
117 #endif /* HAVE_USLEEP */
120 /*******************************************************************
121 A read wrapper that will deal with EINTR.
122 ********************************************************************/
124 ssize_t sys_read(int fd, void *buf, size_t count)
129 ret = read(fd, buf, count);
130 #if defined(EWOULDBLOCK)
131 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
133 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
138 /*******************************************************************
139 A write wrapper that will deal with EINTR.
140 ********************************************************************/
142 ssize_t sys_write(int fd, const void *buf, size_t count)
147 ret = write(fd, buf, count);
148 #if defined(EWOULDBLOCK)
149 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
151 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
156 /*******************************************************************
157 A writev wrapper that will deal with EINTR.
158 ********************************************************************/
160 ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt)
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);
169 if (iov[0].iov_len > 1) {
170 return sys_write(fd, iov[0].iov_base,
171 (random() % (iov[0].iov_len-1)) + 1);
176 ret = writev(fd, iov, iovcnt);
177 #if defined(EWOULDBLOCK)
178 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
180 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
185 /*******************************************************************
186 A pread wrapper that will deal with EINTR and 64-bit file offsets.
187 ********************************************************************/
189 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
190 ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
195 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PREAD64)
196 ret = pread64(fd, buf, count, off);
198 ret = pread(fd, buf, count, off);
200 } while (ret == -1 && errno == EINTR);
205 /*******************************************************************
206 A write wrapper that will deal with EINTR and 64-bit file offsets.
207 ********************************************************************/
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)
215 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64)
216 ret = pwrite64(fd, buf, count, off);
218 ret = pwrite(fd, buf, count, off);
220 } while (ret == -1 && errno == EINTR);
225 /*******************************************************************
226 A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
227 ********************************************************************/
229 ssize_t sys_send(int s, const void *msg, size_t len, int flags)
234 ret = send(s, msg, len, flags);
235 #if defined(EWOULDBLOCK)
236 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
238 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
243 /*******************************************************************
244 A sendto wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
245 ********************************************************************/
247 ssize_t sys_sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
252 ret = sendto(s, msg, len, flags, to, tolen);
253 #if defined(EWOULDBLOCK)
254 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
256 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
261 /*******************************************************************
262 A recv wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
263 ********************************************************************/
265 ssize_t sys_recv(int fd, void *buf, size_t count, int flags)
270 ret = recv(fd, buf, count, flags);
271 #if defined(EWOULDBLOCK)
272 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
274 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
279 /*******************************************************************
280 A recvfrom wrapper that will deal with EINTR.
281 ********************************************************************/
283 ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
288 ret = recvfrom(s, buf, len, flags, from, fromlen);
289 #if defined(EWOULDBLOCK)
290 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
292 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
297 /*******************************************************************
298 A fcntl wrapper that will deal with EINTR.
299 ********************************************************************/
301 int sys_fcntl_ptr(int fd, int cmd, void *arg)
306 ret = fcntl(fd, cmd, arg);
307 } while (ret == -1 && errno == EINTR);
311 /*******************************************************************
312 A fcntl wrapper that will deal with EINTR.
313 ********************************************************************/
315 int sys_fcntl_long(int fd, int cmd, long arg)
320 ret = fcntl(fd, cmd, arg);
321 } while (ret == -1 && errno == EINTR);
325 /****************************************************************************
326 Get/Set all the possible time fields from a stat struct as a timespec.
327 ****************************************************************************/
329 static struct timespec get_atimespec(const struct stat *pst)
331 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
334 /* Old system - no ns timestamp. */
335 ret.tv_sec = pst->st_atime;
339 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
341 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
343 ret.tv_sec = pst->st_atime;
344 ret.tv_nsec = pst->st_atimensec;
346 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
348 ret.tv_sec = pst->st_atime;
349 ret.tv_nsec = pst->st_atime_n;
351 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
353 ret.tv_sec = pst->st_atime;
354 ret.tv_nsec = pst->st_uatime * 1000;
356 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
357 return pst->st_atimespec;
359 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
364 static struct timespec get_mtimespec(const struct stat *pst)
366 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
369 /* Old system - no ns timestamp. */
370 ret.tv_sec = pst->st_mtime;
374 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
376 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
378 ret.tv_sec = pst->st_mtime;
379 ret.tv_nsec = pst->st_mtimensec;
381 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
383 ret.tv_sec = pst->st_mtime;
384 ret.tv_nsec = pst->st_mtime_n;
386 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
388 ret.tv_sec = pst->st_mtime;
389 ret.tv_nsec = pst->st_umtime * 1000;
391 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
392 return pst->st_mtimespec;
394 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
399 static struct timespec get_ctimespec(const struct stat *pst)
401 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
404 /* Old system - no ns timestamp. */
405 ret.tv_sec = pst->st_ctime;
409 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
411 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
413 ret.tv_sec = pst->st_ctime;
414 ret.tv_nsec = pst->st_ctimensec;
416 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
418 ret.tv_sec = pst->st_ctime;
419 ret.tv_nsec = pst->st_ctime_n;
421 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
423 ret.tv_sec = pst->st_ctime;
424 ret.tv_nsec = pst->st_uctime * 1000;
426 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
427 return pst->st_ctimespec;
429 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
434 /****************************************************************************
435 Return the best approximation to a 'create time' under UNIX from a stat
437 ****************************************************************************/
439 static struct timespec calc_create_time_stat(const struct stat *st)
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);
446 ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
447 ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
449 if(!null_timespec(ret1)) {
454 * One of ctime, mtime or atime was zero (probably atime).
455 * Just return MIN(ctime, mtime).
460 /****************************************************************************
461 Return the best approximation to a 'create time' under UNIX from a stat_ex
463 ****************************************************************************/
465 static struct timespec calc_create_time_stat_ex(const struct stat_ex *st)
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;
472 ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
473 ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
475 if(!null_timespec(ret1)) {
480 * One of ctime, mtime or atime was zero (probably atime).
481 * Just return MIN(ctime, mtime).
486 /****************************************************************************
487 Return the 'create time' from a stat struct if it exists (birthtime) or else
488 use the best approximation.
489 ****************************************************************************/
491 static void make_create_timespec(const struct stat *pst, struct stat_ex *dst,
492 bool fake_dir_create_times)
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;
499 dst->st_ex_calculated_birthtime = false;
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;
510 dst->st_ex_btime = calc_create_time_stat(pst);
511 dst->st_ex_calculated_birthtime = true;
514 /* Deal with systems that don't initialize birthtime correctly.
515 * Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
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;
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 ****************************************************************************/
529 void update_stat_ex_mtime(struct stat_ex *dst,
530 struct timespec write_ts)
532 dst->st_ex_mtime = write_ts;
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);
540 void update_stat_ex_create_time(struct stat_ex *dst,
541 struct timespec create_time)
543 dst->st_ex_btime = create_time;
544 dst->st_ex_calculated_birthtime = false;
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)
552 static void init_stat_ex_from_stat (struct stat_ex *dst,
553 const struct stat *src,
554 bool fake_dir_create_times)
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;
572 dst->st_ex_blksize = STAT_ST_BLOCKSIZE;
575 #ifdef HAVE_STAT_ST_BLOCKS
576 dst->st_ex_blocks = src->st_blocks;
578 dst->st_ex_blocks = src->st_size / dst->st_ex_blksize + 1;
581 #ifdef HAVE_STAT_ST_FLAGS
582 dst->st_ex_flags = src->st_flags;
584 dst->st_ex_flags = 0;
588 /*******************************************************************
589 A stat() wrapper that will deal with 64 bit filesizes.
590 ********************************************************************/
592 int sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf,
593 bool fake_dir_create_times)
596 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
597 struct stat64 statbuf;
598 ret = stat64(fname, &statbuf);
601 ret = stat(fname, &statbuf);
604 /* we always want directories to appear zero size */
605 if (S_ISDIR(statbuf.st_mode)) {
608 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
613 /*******************************************************************
614 An fstat() wrapper that will deal with 64 bit filesizes.
615 ********************************************************************/
617 int sys_fstat(int fd, SMB_STRUCT_STAT *sbuf, bool fake_dir_create_times)
620 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
621 struct stat64 statbuf;
622 ret = fstat64(fd, &statbuf);
625 ret = fstat(fd, &statbuf);
628 /* we always want directories to appear zero size */
629 if (S_ISDIR(statbuf.st_mode)) {
632 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
637 /*******************************************************************
638 An lstat() wrapper that will deal with 64 bit filesizes.
639 ********************************************************************/
641 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
642 bool fake_dir_create_times)
645 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
646 struct stat64 statbuf;
647 ret = lstat64(fname, &statbuf);
650 ret = lstat(fname, &statbuf);
653 /* we always want directories to appear zero size */
654 if (S_ISDIR(statbuf.st_mode)) {
657 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
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)
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 */
674 SMB_OFF_T new_len = offset + len;
678 /* unlikely to get a too large file on a 64bit system but ... */
682 fl.l_whence = SEEK_SET;
686 ret=fcntl(fd, F_RESVSP64, &fl);
691 /* Make sure the file gets enlarged after we allocated space: */
693 if (new_len > sbuf.st_size)
694 ftruncate64(fd, new_len);
701 /*******************************************************************
702 An fallocate() function that matches the semantics of the Linux one.
703 ********************************************************************/
705 #ifdef HAVE_LINUX_FALLOC_H
706 #include <linux/falloc.h>
709 int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len)
711 #if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE)
714 case VFS_FALLOCATE_EXTEND_SIZE:
717 case VFS_FALLOCATE_KEEP_SIZE:
718 lmode = FALLOC_FL_KEEP_SIZE;
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);
730 /* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
736 /*******************************************************************
737 An ftruncate() wrapper that will deal with 64 bit filesizes.
738 ********************************************************************/
740 int sys_ftruncate(int fd, SMB_OFF_T offset)
742 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
743 return ftruncate64(fd, offset);
745 return ftruncate(fd, offset);
749 /*******************************************************************
750 An lseek() wrapper that will deal with 64 bit filesizes.
751 ********************************************************************/
753 SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
755 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
756 return lseek64(fd, offset, whence);
758 return lseek(fd, offset, whence);
762 /*******************************************************************
763 An fseek() wrapper that will deal with 64 bit filesizes.
764 ********************************************************************/
766 int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
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);
773 return fseek(fp, offset, whence);
777 /*******************************************************************
778 An ftell() wrapper that will deal with 64 bit filesizes.
779 ********************************************************************/
781 SMB_OFF_T sys_ftell(FILE *fp)
783 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
784 return (SMB_OFF_T)ftell64(fp);
785 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
786 return (SMB_OFF_T)ftello64(fp);
788 return (SMB_OFF_T)ftell(fp);
792 /*******************************************************************
793 A creat() wrapper that will deal with 64 bit filesizes.
794 ********************************************************************/
796 int sys_creat(const char *path, mode_t mode)
798 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
799 return creat64(path, mode);
802 * If creat64 isn't defined then ensure we call a potential open64.
805 return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
809 /*******************************************************************
810 An open() wrapper that will deal with 64 bit filesizes.
811 ********************************************************************/
813 int sys_open(const char *path, int oflag, mode_t mode)
815 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
816 return open64(path, oflag, mode);
818 return open(path, oflag, mode);
822 /*******************************************************************
823 An fopen() wrapper that will deal with 64 bit filesizes.
824 ********************************************************************/
826 FILE *sys_fopen(const char *path, const char *type)
828 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
829 return fopen64(path, type);
831 return fopen(path, type);
836 #if HAVE_KERNEL_SHARE_MODES
838 #define LOCK_MAND 32 /* This is a mandatory flock */
839 #define LOCK_READ 64 /* ... Which allows concurrent read operations */
840 #define LOCK_WRITE 128 /* ... Which allows concurrent write operations */
841 #define LOCK_RW 192 /* ... Which allows concurrent read & write ops */
845 /*******************************************************************
846 A flock() wrapper that will perform the kernel flock.
847 ********************************************************************/
849 void kernel_flock(int fd, uint32 share_mode, uint32 access_mask)
851 #if HAVE_KERNEL_SHARE_MODES
853 if (share_mode == FILE_SHARE_WRITE) {
854 kernel_mode = LOCK_MAND|LOCK_WRITE;
855 } else if (share_mode == FILE_SHARE_READ) {
856 kernel_mode = LOCK_MAND|LOCK_READ;
857 } else if (share_mode == FILE_SHARE_NONE) {
858 kernel_mode = LOCK_MAND;
861 flock(fd, kernel_mode);
869 /*******************************************************************
870 An opendir wrapper that will deal with 64 bit filesizes.
871 ********************************************************************/
873 SMB_STRUCT_DIR *sys_opendir(const char *name)
875 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
876 return opendir64(name);
878 return opendir(name);
882 /*******************************************************************
883 An fdopendir wrapper that will deal with 64 bit filesizes.
884 Ugly hack - we need dirfd for this to work correctly in the
886 ********************************************************************/
888 SMB_STRUCT_DIR *sys_fdopendir(int fd)
890 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FDOPENDIR64) && defined(HAVE_DIRFD)
891 return fdopendir64(fd);
892 #elif defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD)
893 return fdopendir(fd);
900 /*******************************************************************
901 A readdir wrapper that will deal with 64 bit filesizes.
902 ********************************************************************/
904 SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
906 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
907 return readdir64(dirp);
909 return readdir(dirp);
913 /*******************************************************************
914 A seekdir wrapper that will deal with 64 bit filesizes.
915 ********************************************************************/
917 void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset)
919 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_SEEKDIR64)
920 seekdir64(dirp, offset);
922 seekdir(dirp, offset);
926 /*******************************************************************
927 A telldir wrapper that will deal with 64 bit filesizes.
928 ********************************************************************/
930 long sys_telldir(SMB_STRUCT_DIR *dirp)
932 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_TELLDIR64)
933 return (long)telldir64(dirp);
935 return (long)telldir(dirp);
939 /*******************************************************************
940 A rewinddir wrapper that will deal with 64 bit filesizes.
941 ********************************************************************/
943 void sys_rewinddir(SMB_STRUCT_DIR *dirp)
945 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
952 /*******************************************************************
953 A close wrapper that will deal with 64 bit filesizes.
954 ********************************************************************/
956 int sys_closedir(SMB_STRUCT_DIR *dirp)
958 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
959 return closedir64(dirp);
961 return closedir(dirp);
965 /*******************************************************************
966 An mknod() wrapper that will deal with 64 bit filesizes.
967 ********************************************************************/
969 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
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);
975 return mknod(path, mode, dev);
978 /* No mknod system call. */
984 /*******************************************************************
985 The wait() calls vary between systems
986 ********************************************************************/
988 int sys_waitpid(pid_t pid,int *status,int options)
991 return waitpid(pid,status,options);
992 #else /* HAVE_WAITPID */
993 return wait4(pid, status, options, NULL);
994 #endif /* HAVE_WAITPID */
997 /*******************************************************************
998 System wrapper for getwd
999 ********************************************************************/
1001 char *sys_getwd(char *s)
1005 wd = (char *)getcwd(s, PATH_MAX);
1007 wd = (char *)getwd(s);
1012 #if defined(HAVE_POSIX_CAPABILITIES)
1014 /**************************************************************************
1015 Try and abstract process capabilities (for systems that have them).
1016 ****************************************************************************/
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.
1023 static bool set_process_capability(enum smbd_capability capability,
1026 cap_value_t cap_vals[2] = {0};
1027 int num_cap_vals = 0;
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
1039 if (!prctl(PR_GET_KEEPCAPS)) {
1040 prctl(PR_SET_KEEPCAPS, 1);
1044 cap = cap_get_proc();
1046 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
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;
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;
1063 /* Linux has CAP_MKNOD for DMAPI access. */
1064 cap_vals[num_cap_vals++] = CAP_MKNOD;
1067 case LEASE_CAPABILITY:
1069 cap_vals[num_cap_vals++] = CAP_LEASE;
1074 SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
1076 if (num_cap_vals == 0) {
1081 cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
1082 enable ? CAP_SET : CAP_CLEAR);
1084 /* We never want to pass capabilities down to our children, so make
1085 * sure they are not inherited.
1087 cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
1089 if (cap_set_proc(cap) == -1) {
1090 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
1100 #endif /* HAVE_POSIX_CAPABILITIES */
1102 /****************************************************************************
1103 Gain the oplock capability from the kernel if possible.
1104 ****************************************************************************/
1106 void set_effective_capability(enum smbd_capability capability)
1108 #if defined(HAVE_POSIX_CAPABILITIES)
1109 set_process_capability(capability, True);
1110 #endif /* HAVE_POSIX_CAPABILITIES */
1113 void drop_effective_capability(enum smbd_capability capability)
1115 #if defined(HAVE_POSIX_CAPABILITIES)
1116 set_process_capability(capability, False);
1117 #endif /* HAVE_POSIX_CAPABILITIES */
1120 /**************************************************************************
1121 Wrapper for random().
1122 ****************************************************************************/
1124 long sys_random(void)
1126 #if defined(HAVE_RANDOM)
1127 return (long)random();
1128 #elif defined(HAVE_RAND)
1129 return (long)rand();
1131 DEBUG(0,("Error - no random function available !\n"));
1136 /**************************************************************************
1137 Wrapper for srandom().
1138 ****************************************************************************/
1140 void sys_srandom(unsigned int seed)
1142 #if defined(HAVE_SRANDOM)
1144 #elif defined(HAVE_SRAND)
1147 DEBUG(0,("Error - no srandom function available !\n"));
1153 #define NGROUPS_MAX 32 /* Guess... */
1156 /**************************************************************************
1157 Returns equivalent to NGROUPS_MAX - using sysconf if needed.
1158 ****************************************************************************/
1160 int groups_max(void)
1162 #if defined(SYSCONF_SC_NGROUPS_MAX)
1163 int ret = sysconf(_SC_NGROUPS_MAX);
1164 return (ret == -1) ? NGROUPS_MAX : ret;
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 ****************************************************************************/
1175 #if defined(HAVE_BROKEN_GETGROUPS)
1177 #ifdef HAVE_BROKEN_GETGROUPS
1183 static int sys_broken_getgroups(int setlen, gid_t *gidset)
1190 return getgroups(setlen, &gid);
1194 * Broken case. We need to allocate a
1195 * GID_T array of size setlen.
1204 setlen = groups_max();
1206 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
1207 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
1211 if((ngroups = getgroups(setlen, group_list)) < 0) {
1212 int saved_errno = errno;
1213 SAFE_FREE(group_list);
1214 errno = saved_errno;
1218 for(i = 0; i < ngroups; i++)
1219 gidset[i] = (gid_t)group_list[i];
1221 SAFE_FREE(group_list);
1225 static int sys_broken_setgroups(int setlen, gid_t *gidset)
1233 if (setlen < 0 || setlen > groups_max()) {
1239 * Broken case. We need to allocate a
1240 * GID_T array of size setlen.
1243 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
1244 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
1248 for(i = 0; i < setlen; i++)
1249 group_list[i] = (GID_T) gidset[i];
1251 if(setgroups(setlen, group_list) != 0) {
1252 int saved_errno = errno;
1253 SAFE_FREE(group_list);
1254 errno = saved_errno;
1258 SAFE_FREE(group_list);
1262 #endif /* HAVE_BROKEN_GETGROUPS */
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.
1267 #if defined (FREEBSD) || defined (DARWINOS)
1268 #define USE_BSD_SETGROUPS
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.
1277 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
1279 gid_t *new_gidset = NULL;
1283 /* setgroups(2) will fail with EINVAL if we pass too many groups. */
1286 /* No group list, just make sure we are setting the efective GID. */
1288 return setgroups(1, &primary_gid);
1291 /* If the primary gid is not the first array element, grow the array
1292 * and insert it at the front.
1294 if (gidset[0] != primary_gid) {
1295 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
1296 if (new_gidset == NULL) {
1300 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
1301 new_gidset[0] = primary_gid;
1306 DEBUG(3, ("forced to truncate group list from %d to %d\n",
1311 #if defined(HAVE_BROKEN_GETGROUPS)
1312 ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
1314 ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
1319 SAFE_FREE(new_gidset);
1326 #endif /* USE_BSD_SETGROUPS */
1328 /**************************************************************************
1329 Wrapper for getgroups. Deals with broken (int) case.
1330 ****************************************************************************/
1332 int sys_getgroups(int setlen, gid_t *gidset)
1334 #if defined(HAVE_BROKEN_GETGROUPS)
1335 return sys_broken_getgroups(setlen, gidset);
1337 return getgroups(setlen, gidset);
1341 /**************************************************************************
1342 Wrapper for setgroups. Deals with broken (int) case and BSD case.
1343 ****************************************************************************/
1345 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
1347 #if !defined(HAVE_SETGROUPS)
1350 #endif /* HAVE_SETGROUPS */
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);
1357 return setgroups(setlen, gidset);
1361 /**************************************************************************
1362 Extract a command into an arg list.
1363 ****************************************************************************/
1365 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
1374 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1375 DEBUG(0, ("talloc failed\n"));
1379 if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1380 TALLOC_FREE(trunc_cmd);
1389 for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1392 TALLOC_FREE(trunc_cmd);
1394 if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
1399 * Now do the extraction.
1402 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1406 ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1409 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1413 while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1415 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1421 TALLOC_FREE(trunc_cmd);
1425 DEBUG(0, ("talloc failed\n"));
1426 TALLOC_FREE(trunc_cmd);
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 ****************************************************************************/
1438 typedef struct _popen_list
1442 struct _popen_list *next;
1445 static popen_list *popen_chain;
1447 int sys_popen(const char *command)
1449 int parent_end, child_end;
1451 popen_list *entry = NULL;
1454 if (pipe(pipe_fds) < 0)
1457 parent_end = pipe_fds[0];
1458 child_end = pipe_fds[1];
1465 if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1468 ZERO_STRUCTP(entry);
1471 * Extract the command and args into a NULL terminated array.
1474 if(!(argl = extract_args(NULL, command)))
1477 entry->child_pid = sys_fork();
1479 if (entry->child_pid == -1) {
1483 if (entry->child_pid == 0) {
1489 int child_std_end = STDOUT_FILENO;
1493 if (child_end != child_std_end) {
1494 dup2 (child_end, child_std_end);
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."
1504 for (p = popen_chain; p; p = p->next)
1507 execv(argl[0], argl);
1518 /* Link into popen_chain. */
1519 entry->next = popen_chain;
1520 popen_chain = entry;
1521 entry->fd = parent_end;
1534 /**************************************************************************
1535 Wrapper for pclose. Modified from the glibc sources.
1536 ****************************************************************************/
1538 int sys_pclose(int fd)
1541 popen_list **ptr = &popen_chain;
1542 popen_list *entry = NULL;
1546 /* Unlink from popen_chain. */
1547 for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1548 if ((*ptr)->fd == fd) {
1550 *ptr = (*ptr)->next;
1556 if (status < 0 || close(entry->fd) < 0)
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.
1566 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1567 } while (wait_pid == -1 && errno == EINTR);
1576 /**************************************************************************
1577 Wrapper for Admin Logs.
1578 ****************************************************************************/
1580 void sys_adminlog(int priority, const char *format_str, ...)
1584 char *msgbuf = NULL;
1586 va_start( ap, format_str );
1587 ret = vasprintf( &msgbuf, format_str, ap );
1593 #if defined(HAVE_SYSLOG)
1594 syslog( priority, "%s", msgbuf );
1596 DEBUG(0,("%s", msgbuf ));
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);
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 ****************************************************************************/
1617 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
1619 #if defined(HAVE_GETXATTR)
1620 #ifndef XATTR_ADD_OPT
1621 return getxattr(path, name, value, size);
1624 return getxattr(path, name, value, size, 0, options);
1626 #elif defined(HAVE_GETEA)
1627 return getea(path, name, value, size);
1628 #elif defined(HAVE_EXTATTR_GET_FILE)
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;
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.
1639 if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1644 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
1648 DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
1650 #elif defined(HAVE_ATTR_GET)
1651 int retval, flags = 0;
1652 int valuelength = (int)size;
1653 char *attrname = strchr(name,'.') + 1;
1655 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1657 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1659 return retval ? retval : valuelength;
1660 #elif defined(HAVE_ATTROPEN)
1662 int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
1664 ret = solaris_read_xattr(attrfd, value, size);
1674 ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
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)
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;
1690 if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1695 if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
1699 DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
1701 #elif defined(HAVE_ATTR_GET)
1702 int retval, flags = ATTR_DONTFOLLOW;
1703 int valuelength = (int)size;
1704 char *attrname = strchr(name,'.') + 1;
1706 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1708 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1710 return retval ? retval : valuelength;
1711 #elif defined(HAVE_ATTROPEN)
1713 int attrfd = solaris_attropen(path, name, O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1715 ret = solaris_read_xattr(attrfd, value, size);
1725 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
1727 #if defined(HAVE_FGETXATTR)
1728 #ifndef XATTR_ADD_OPT
1729 return fgetxattr(filedes, name, value, size);
1732 return fgetxattr(filedes, name, value, size, 0, options);
1734 #elif defined(HAVE_FGETEA)
1735 return fgetea(filedes, name, value, size);
1736 #elif defined(HAVE_EXTATTR_GET_FD)
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;
1743 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
1748 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
1752 DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
1754 #elif defined(HAVE_ATTR_GETF)
1755 int retval, flags = 0;
1756 int valuelength = (int)size;
1757 char *attrname = strchr(name,'.') + 1;
1759 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1761 retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
1763 return retval ? retval : valuelength;
1764 #elif defined(HAVE_ATTROPEN)
1766 int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
1768 ret = solaris_read_xattr(attrfd, value, size);
1778 #if defined(HAVE_EXTATTR_LIST_FILE)
1780 #define EXTATTR_PREFIX(s) (s), (sizeof((s))-1)
1788 { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
1789 { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
1797 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
1799 ssize_t list_size, total_size = 0;
1802 /* Iterate through extattr(2) namespaces */
1803 for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
1805 #if defined(HAVE_EXTATTR_LIST_FILE)
1807 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
1810 #if defined(HAVE_EXTATTR_LIST_LINK)
1812 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
1815 #if defined(HAVE_EXTATTR_LIST_FD)
1817 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
1824 /* Some error happend. Errno should be set by the previous call */
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.
1836 /* Take the worse case of one char attribute names -
1837 two bytes per name plus one more for sanity.
1839 total_size += list_size + (list_size/2 + 1)*extattr[t].len;
1842 /* Count necessary offset to fit namespace prefixes */
1844 for(i = 0; i < list_size; i += list[i] + 1)
1845 len += extattr[t].len;
1847 total_size += list_size + len;
1848 /* Buffer is too small to fit the results */
1849 if(total_size > size) {
1853 /* Shift results back, so we can prepend prefixes */
1854 buf = (char *)memmove(list + len, list, list_size);
1856 for(i = 0; i < list_size; i += len + 1) {
1858 strncpy(list, extattr[t].name, extattr[t].len + 1);
1859 list += extattr[t].len;
1860 strncpy(list, buf + i + 1, len);
1871 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1872 static char attr_buffer[ATTR_MAX_VALUELEN];
1874 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
1876 int retval = 0, index;
1877 attrlist_cursor_t *cursor = 0;
1879 attrlist_t * al = (attrlist_t *)attr_buffer;
1881 size_t ent_size, left = size;
1886 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1888 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
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."));
1903 total_size += ent_size;
1905 if (al->al_more == 0) break;
1912 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1914 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
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."));
1929 total_size += ent_size;
1931 if (al->al_more == 0) break;
1934 return (ssize_t)(retval ? retval : total_size);
1939 ssize_t sys_listxattr (const char *path, char *list, size_t size)
1941 #if defined(HAVE_LISTXATTR)
1942 #ifndef XATTR_ADD_OPT
1943 return listxattr(path, list, size);
1946 return listxattr(path, list, size, options);
1948 #elif defined(HAVE_LISTEA)
1949 return listea(path, list, size);
1950 #elif defined(HAVE_EXTATTR_LIST_FILE)
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)
1958 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1959 if (attrdirfd >= 0) {
1960 ret = solaris_list_xattr(attrdirfd, list, size);
1970 ssize_t sys_llistxattr (const char *path, char *list, size_t size)
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)
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)
1987 int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1988 if (attrdirfd >= 0) {
1989 ret = solaris_list_xattr(attrdirfd, list, size);
1999 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
2001 #if defined(HAVE_FLISTXATTR)
2002 #ifndef XATTR_ADD_OPT
2003 return flistxattr(filedes, list, size);
2006 return flistxattr(filedes, list, size, options);
2008 #elif defined(HAVE_FLISTEA)
2009 return flistea(filedes, list, size);
2010 #elif defined(HAVE_EXTATTR_LIST_FD)
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)
2018 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
2019 if (attrdirfd >= 0) {
2020 ret = solaris_list_xattr(attrdirfd, list, size);
2030 int sys_removexattr (const char *path, const char *name)
2032 #if defined(HAVE_REMOVEXATTR)
2033 #ifndef XATTR_ADD_OPT
2034 return removexattr(path, name);
2037 return removexattr(path, name, options);
2039 #elif defined(HAVE_REMOVEEA)
2040 return removeea(path, name);
2041 #elif defined(HAVE_EXTATTR_DELETE_FILE)
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;
2047 return extattr_delete_file(path, attrnamespace, attrname);
2048 #elif defined(HAVE_ATTR_REMOVE)
2050 char *attrname = strchr(name,'.') + 1;
2052 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
2054 return attr_remove(path, attrname, flags);
2055 #elif defined(HAVE_ATTROPEN)
2057 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
2058 if (attrdirfd >= 0) {
2059 ret = solaris_unlinkat(attrdirfd, name);
2069 int sys_lremovexattr (const char *path, const char *name)
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)
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;
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;
2089 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
2091 return attr_remove(path, attrname, flags);
2092 #elif defined(HAVE_ATTROPEN)
2094 int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
2095 if (attrdirfd >= 0) {
2096 ret = solaris_unlinkat(attrdirfd, name);
2106 int sys_fremovexattr (int filedes, const char *name)
2108 #if defined(HAVE_FREMOVEXATTR)
2109 #ifndef XATTR_ADD_OPT
2110 return fremovexattr(filedes, name);
2113 return fremovexattr(filedes, name, options);
2115 #elif defined(HAVE_FREMOVEEA)
2116 return fremoveea(filedes, name);
2117 #elif defined(HAVE_EXTATTR_DELETE_FD)
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;
2123 return extattr_delete_fd(filedes, attrnamespace, attrname);
2124 #elif defined(HAVE_ATTR_REMOVEF)
2126 char *attrname = strchr(name,'.') + 1;
2128 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
2130 return attr_removef(filedes, attrname, flags);
2131 #elif defined(HAVE_ATTROPEN)
2133 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
2134 if (attrdirfd >= 0) {
2135 ret = solaris_unlinkat(attrdirfd, name);
2145 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
2147 #if defined(HAVE_SETXATTR)
2148 #ifndef XATTR_ADD_OPT
2149 return setxattr(path, name, value, size, flags);
2152 return setxattr(path, name, value, size, 0, options);
2154 #elif defined(HAVE_SETEA)
2155 return setea(path, name, value, size, flags);
2156 #elif defined(HAVE_EXTATTR_SET_FILE)
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;
2163 /* Check attribute existence */
2164 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
2166 /* REPLACE attribute, that doesn't exist */
2167 if (flags & XATTR_REPLACE && errno == ENOATTR) {
2171 /* Ignore other errors */
2174 /* CREATE attribute, that already exists */
2175 if (flags & XATTR_CREATE) {
2181 retval = extattr_set_file(path, attrnamespace, attrname, value, size);
2182 return (retval < 0) ? -1 : 0;
2183 #elif defined(HAVE_ATTR_SET)
2185 char *attrname = strchr(name,'.') + 1;
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;
2191 return attr_set(path, attrname, (const char *)value, size, myflags);
2192 #elif defined(HAVE_ATTROPEN)
2194 int myflags = O_RDWR;
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);
2200 ret = solaris_write_xattr(attrfd, value, size);
2210 int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags)
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)
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;
2226 /* Check attribute existence */
2227 retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
2229 /* REPLACE attribute, that doesn't exist */
2230 if (flags & XATTR_REPLACE && errno == ENOATTR) {
2234 /* Ignore other errors */
2237 /* CREATE attribute, that already exists */
2238 if (flags & XATTR_CREATE) {
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;
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;
2255 return attr_set(path, attrname, (const char *)value, size, myflags);
2256 #elif defined(HAVE_ATTROPEN)
2258 int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW;
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);
2264 ret = solaris_write_xattr(attrfd, value, size);
2274 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
2276 #if defined(HAVE_FSETXATTR)
2277 #ifndef XATTR_ADD_OPT
2278 return fsetxattr(filedes, name, value, size, flags);
2281 return fsetxattr(filedes, name, value, size, 0, options);
2283 #elif defined(HAVE_FSETEA)
2284 return fsetea(filedes, name, value, size, flags);
2285 #elif defined(HAVE_EXTATTR_SET_FD)
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;
2292 /* Check attribute existence */
2293 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
2295 /* REPLACE attribute, that doesn't exist */
2296 if (flags & XATTR_REPLACE && errno == ENOATTR) {
2300 /* Ignore other errors */
2303 /* CREATE attribute, that already exists */
2304 if (flags & XATTR_CREATE) {
2310 retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
2311 return (retval < 0) ? -1 : 0;
2312 #elif defined(HAVE_ATTR_SETF)
2314 char *attrname = strchr(name,'.') + 1;
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;
2320 return attr_setf(filedes, attrname, (const char *)value, size, myflags);
2321 #elif defined(HAVE_ATTROPEN)
2323 int myflags = O_RDWR | O_XATTR;
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);
2329 ret = solaris_write_xattr(attrfd, value, size);
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)
2347 if (fstat(attrfd, &sbuf) == -1) {
2352 /* This is to return the current size of the named extended attribute */
2354 return sbuf.st_size;
2357 /* check size and read xattr */
2358 if (sbuf.st_size > size) {
2363 return read(attrfd, value, sbuf.st_size);
2366 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
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);
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));
2387 /* return the current size of the list of extended attribute names*/
2390 /* check size and copy entrieѕ + nul into list. */
2391 if ((len + listlen + 1) > size) {
2396 safe_strcpy(list + len, de->d_name, listlen);
2404 if (closedir(dirp) == -1) {
2405 DEBUG(0,("closedir dirp failed: %s\n",strerror(errno)));
2411 static int solaris_unlinkat(int attrdirfd, const char *name)
2413 if (unlinkat(attrdirfd, name, 0) == -1) {
2414 if (errno == ENOENT) {
2422 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
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) {
2436 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
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) {
2450 static int solaris_write_xattr(int attrfd, const char *value, size_t size)
2452 if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
2455 DEBUG(10,("solaris_write_xattr FAILED!\n"));
2459 #endif /*HAVE_ATTROPEN*/
2462 /****************************************************************************
2463 Return the major devicenumber for UNIX extensions.
2464 ****************************************************************************/
2466 uint32 unix_dev_major(SMB_DEV_T dev)
2468 #if defined(HAVE_DEVICE_MAJOR_FN)
2469 return (uint32)major(dev);
2471 return (uint32)(dev >> 8);
2475 /****************************************************************************
2476 Return the minor devicenumber for UNIX extensions.
2477 ****************************************************************************/
2479 uint32 unix_dev_minor(SMB_DEV_T dev)
2481 #if defined(HAVE_DEVICE_MINOR_FN)
2482 return (uint32)minor(dev);
2484 return (uint32)(dev & 0xff);
2488 #if defined(WITH_AIO)
2490 /*******************************************************************
2491 An aio_read wrapper that will deal with 64-bit sizes.
2492 ********************************************************************/
2494 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
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);
2506 /*******************************************************************
2507 An aio_write wrapper that will deal with 64-bit sizes.
2508 ********************************************************************/
2510 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
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);
2522 /*******************************************************************
2523 An aio_return wrapper that will deal with 64-bit sizes.
2524 ********************************************************************/
2526 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
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);
2538 /*******************************************************************
2539 An aio_cancel wrapper that will deal with 64-bit sizes.
2540 ********************************************************************/
2542 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
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);
2554 /*******************************************************************
2555 An aio_error wrapper that will deal with 64-bit sizes.
2556 ********************************************************************/
2558 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
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);
2570 /*******************************************************************
2571 An aio_fsync wrapper that will deal with 64-bit sizes.
2572 ********************************************************************/
2574 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
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);
2586 /*******************************************************************
2587 An aio_fsync wrapper that will deal with 64-bit sizes.
2588 ********************************************************************/
2590 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
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);
2601 #else /* !WITH_AIO */
2603 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2609 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2615 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2621 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2627 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2633 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2639 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2644 #endif /* WITH_AIO */