Ignore:
Timestamp:
Nov 24, 2016, 1:14:11 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to version 4.4.3

File:
1 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/source3/lib/system.c

    r871 r988  
    2626#include "system/passwd.h"
    2727#include "system/filesys.h"
     28#include "../lib/util/setid.h"
     29
     30#ifdef HAVE_SYS_SYSCTL_H
     31#include <sys/sysctl.h>
     32#endif
    2833
    2934#ifdef HAVE_SYS_PRCTL_H
    … …  
    4651*/
    4752
    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 
    22553/*******************************************************************
    22654A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
    … …  
    23361        do {
    23462                ret = send(s, msg, len, flags);
    235 #if defined(EWOULDBLOCK)
    23663        } 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
     64
    27665        return ret;
    27766}
    … …  
    335124#else
    336125#if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
    337         return pst->st_atim;
     126        struct timespec ret;
     127        ret.tv_sec = pst->st_atim.tv_sec;
     128        ret.tv_nsec = pst->st_atim.tv_nsec;
     129        return ret;
    338130#elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
    339131        struct timespec ret;
    … …  
    370162#else
    371163#if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
    372         return pst->st_mtim;
     164        struct timespec ret;
     165        ret.tv_sec = pst->st_mtim.tv_sec;
     166        ret.tv_nsec = pst->st_mtim.tv_nsec;
     167        return ret;
    373168#elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
    374169        struct timespec ret;
    … …  
    405200#else
    406201#if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
    407         return pst->st_ctim;
     202        struct timespec ret;
     203        ret.tv_sec = pst->st_ctim.tv_sec;
     204        ret.tv_nsec = pst->st_ctim.tv_nsec;
     205        return ret;
    408206#elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
    409207        struct timespec ret;
    … …  
    542340}
    543341
    544 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
    545 static void init_stat_ex_from_stat (struct stat_ex *dst,
    546                                     const struct stat64 *src,
    547                                     bool fake_dir_create_times)
    548 #else
    549 static void init_stat_ex_from_stat (struct stat_ex *dst,
    550                                     const struct stat *src,
    551                                     bool fake_dir_create_times)
    552 #endif
     342void init_stat_ex_from_stat (struct stat_ex *dst,
     343                            const struct stat *src,
     344                            bool fake_dir_create_times)
    553345{
    554346        dst->st_ex_dev = src->st_dev;
    … …  
    584376
    585377/*******************************************************************
    586 A stat() wrapper that will deal with 64 bit filesizes.
     378A stat() wrapper.
    587379********************************************************************/
    588380
    … …  
    591383{
    592384        int ret;
    593 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
    594         struct stat64 statbuf;
    595         ret = stat64(fname, &statbuf);
    596 #else
    597385        struct stat statbuf;
    598386        ret = stat(fname, &statbuf);
    599 #endif
    600387        if (ret == 0) {
    601388                /* we always want directories to appear zero size */
    … …  
    609396
    610397/*******************************************************************
    611  An fstat() wrapper that will deal with 64 bit filesizes.
     398 An fstat() wrapper.
    612399********************************************************************/
    613400
    … …  
    615402{
    616403        int ret;
    617 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
    618         struct stat64 statbuf;
    619         ret = fstat64(fd, &statbuf);
    620 #else
    621404        struct stat statbuf;
    622405        ret = fstat(fd, &statbuf);
    623 #endif
    624406        if (ret == 0) {
    625407                /* we always want directories to appear zero size */
    … …  
    633415
    634416/*******************************************************************
    635  An lstat() wrapper that will deal with 64 bit filesizes.
     417 An lstat() wrapper.
    636418********************************************************************/
    637419
    … …  
    640422{
    641423        int ret;
    642 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
    643         struct stat64 statbuf;
    644         ret = lstat64(fname, &statbuf);
    645 #else
    646424        struct stat statbuf;
    647425        ret = lstat(fname, &statbuf);
    648 #endif
    649426        if (ret == 0) {
    650427                /* we always want directories to appear zero size */
    … …  
    658435
    659436/*******************************************************************
    660  An posix_fallocate() wrapper that will deal with 64 bit filesizes.
    661 ********************************************************************/
    662 int sys_posix_fallocate(int fd, SMB_OFF_T offset, SMB_OFF_T len)
    663 {
    664 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_POSIX_FALLOCATE64) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
    665         return posix_fallocate64(fd, offset, len);
    666 #elif defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
     437 An posix_fallocate() wrapper.
     438********************************************************************/
     439int sys_posix_fallocate(int fd, off_t offset, off_t len)
     440{
     441#if defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
    667442        return posix_fallocate(fd, offset, len);
    668443#elif defined(F_RESVSP64)
    669444        /* this handles XFS on IRIX */
    670445        struct flock64 fl;
    671         SMB_OFF_T new_len = offset + len;
     446        off_t new_len = offset + len;
    672447        int ret;
    673448        struct stat64 sbuf;
    … …  
    704479#endif
    705480
    706 int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len)
    707 {
    708 #if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE)
    709         int lmode;
    710         switch (mode) {
    711         case VFS_FALLOCATE_EXTEND_SIZE:
    712                 lmode = 0;
    713                 break;
    714         case VFS_FALLOCATE_KEEP_SIZE:
    715                 lmode = FALLOC_FL_KEEP_SIZE;
    716                 break;
    717         default:
     481int sys_fallocate(int fd, uint32_t mode, off_t offset, off_t len)
     482{
     483#if defined(HAVE_LINUX_FALLOCATE)
     484        int lmode = 0;
     485
     486        if (mode & VFS_FALLOCATE_FL_KEEP_SIZE) {
     487                lmode |= FALLOC_FL_KEEP_SIZE;
     488                mode &= ~VFS_FALLOCATE_FL_KEEP_SIZE;
     489        }
     490
     491#if defined(HAVE_FALLOC_FL_PUNCH_HOLE)
     492        if (mode & VFS_FALLOCATE_FL_PUNCH_HOLE) {
     493                lmode |= FALLOC_FL_PUNCH_HOLE;
     494                mode &= ~VFS_FALLOCATE_FL_PUNCH_HOLE;
     495        }
     496#endif  /* HAVE_FALLOC_FL_PUNCH_HOLE */
     497
     498        if (mode != 0) {
     499                DEBUG(2, ("unmapped fallocate flags: %lx\n",
     500                      (unsigned long)mode));
    718501                errno = EINVAL;
    719502                return -1;
    720503        }
    721 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LINUX_FALLOCATE64)
    722         return fallocate64(fd, lmode, offset, len);
    723 #elif defined(HAVE_LINUX_FALLOCATE)
    724504        return fallocate(fd, lmode, offset, len);
    725 #endif
    726 #else
     505#else   /* HAVE_LINUX_FALLOCATE */
    727506        /* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
    728507        errno = ENOSYS;
    729508        return -1;
    730 #endif
    731 }
    732 
    733 /*******************************************************************
    734  An ftruncate() wrapper that will deal with 64 bit filesizes.
    735 ********************************************************************/
    736 
    737 int sys_ftruncate(int fd, SMB_OFF_T offset)
    738 {
    739 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
    740         return ftruncate64(fd, offset);
    741 #else
    742         return ftruncate(fd, offset);
    743 #endif
    744 }
    745 
    746 /*******************************************************************
    747  An lseek() wrapper that will deal with 64 bit filesizes.
    748 ********************************************************************/
    749 
    750 SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
    751 {
    752 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
    753         return lseek64(fd, offset, whence);
    754 #else
    755         return lseek(fd, offset, whence);
    756 #endif
    757 }
    758 
    759 /*******************************************************************
    760  An fseek() wrapper that will deal with 64 bit filesizes.
    761 ********************************************************************/
    762 
    763 int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
    764 {
    765 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
    766         return fseek64(fp, offset, whence);
    767 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
    768         return fseeko64(fp, offset, whence);
    769 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO)
    770         return fseeko(fp, offset, whence);
    771 #else
    772         return fseek(fp, offset, whence);
    773 #endif
    774 }
    775 
    776 /*******************************************************************
    777  An ftell() wrapper that will deal with 64 bit filesizes.
    778 ********************************************************************/
    779 
    780 SMB_OFF_T sys_ftell(FILE *fp)
    781 {
    782 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
    783         return (SMB_OFF_T)ftell64(fp);
    784 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
    785         return (SMB_OFF_T)ftello64(fp);
    786 #else
    787         return (SMB_OFF_T)ftell(fp);
    788 #endif
    789 }
    790 
    791 /*******************************************************************
    792  A creat() wrapper that will deal with 64 bit filesizes.
    793 ********************************************************************/
    794 
    795 int sys_creat(const char *path, mode_t mode)
    796 {
    797 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
    798         return creat64(path, mode);
    799 #else
    800         /*
    801          * If creat64 isn't defined then ensure we call a potential open64.
    802          * JRA.
    803          */
    804         return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
    805 #endif
    806 }
    807 
    808 /*******************************************************************
    809  An open() wrapper that will deal with 64 bit filesizes.
    810 ********************************************************************/
    811 
    812 int sys_open(const char *path, int oflag, mode_t mode)
    813 {
    814 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
    815         return open64(path, oflag, mode);
    816 #else
    817         return open(path, oflag, mode);
    818 #endif
    819 }
    820 
    821 /*******************************************************************
    822  An fopen() wrapper that will deal with 64 bit filesizes.
    823 ********************************************************************/
    824 
    825 FILE *sys_fopen(const char *path, const char *type)
    826 {
    827 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
    828         return fopen64(path, type);
    829 #else
    830         return fopen(path, type);
    831 #endif
    832 }
    833 
     509#endif  /* HAVE_LINUX_FALLOCATE */
     510}
    834511
    835512#if HAVE_KERNEL_SHARE_MODES
    … …  
    846523********************************************************************/
    847524
    848 void kernel_flock(int fd, uint32 share_mode, uint32 access_mask)
     525void kernel_flock(int fd, uint32_t share_mode, uint32_t access_mask)
    849526{
    850527#if HAVE_KERNEL_SHARE_MODES
    … …  
    867544
    868545/*******************************************************************
    869  An opendir wrapper that will deal with 64 bit filesizes.
    870 ********************************************************************/
    871 
    872 SMB_STRUCT_DIR *sys_opendir(const char *name)
    873 {
    874 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
    875         return opendir64(name);
    876 #else
    877         return opendir(name);
    878 #endif
    879 }
    880 
    881 /*******************************************************************
    882546 An fdopendir wrapper.
    883547********************************************************************/
    884548
    885 SMB_STRUCT_DIR *sys_fdopendir(int fd)
    886 {
    887 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FDOPENDIR64)
    888         return fdopendir64(fd);
    889 #elif defined(HAVE_FDOPENDIR)
     549DIR *sys_fdopendir(int fd)
     550{
     551#if defined(HAVE_FDOPENDIR)
    890552        return fdopendir(fd);
    891553#else
    … …  
    896558
    897559/*******************************************************************
    898  A readdir wrapper that will deal with 64 bit filesizes.
    899 ********************************************************************/
    900 
    901 SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
    902 {
    903 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
    904         return readdir64(dirp);
    905 #else
    906         return readdir(dirp);
    907 #endif
    908 }
    909 
    910 /*******************************************************************
    911  A seekdir wrapper that will deal with 64 bit filesizes.
    912 ********************************************************************/
    913 
    914 void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset)
    915 {
    916 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_SEEKDIR64)
    917         seekdir64(dirp, offset);
    918 #else
    919         seekdir(dirp, offset);
    920 #endif
    921 }
    922 
    923 /*******************************************************************
    924  A telldir wrapper that will deal with 64 bit filesizes.
    925 ********************************************************************/
    926 
    927 long sys_telldir(SMB_STRUCT_DIR *dirp)
    928 {
    929 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_TELLDIR64)
    930         return (long)telldir64(dirp);
    931 #else
    932         return (long)telldir(dirp);
    933 #endif
    934 }
    935 
    936 /*******************************************************************
    937  A rewinddir wrapper that will deal with 64 bit filesizes.
    938 ********************************************************************/
    939 
    940 void sys_rewinddir(SMB_STRUCT_DIR *dirp)
    941 {
    942 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
    943         rewinddir64(dirp);
    944 #else
    945         rewinddir(dirp);
    946 #endif
    947 }
    948 
    949 /*******************************************************************
    950  A close wrapper that will deal with 64 bit filesizes.
    951 ********************************************************************/
    952 
    953 int sys_closedir(SMB_STRUCT_DIR *dirp)
    954 {
    955 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
    956         return closedir64(dirp);
    957 #else
    958         return closedir(dirp);
    959 #endif
    960 }
    961 
    962 /*******************************************************************
    963  An mknod() wrapper that will deal with 64 bit filesizes.
     560 An mknod() wrapper.
    964561********************************************************************/
    965562
    966563int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
    967564{
    968 #if defined(HAVE_MKNOD) || defined(HAVE_MKNOD64)
    969 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_MKNOD64) && defined(HAVE_DEV64_T)
    970         return mknod64(path, mode, dev);
    971 #else
     565#if defined(HAVE_MKNOD)
    972566        return mknod(path, mode, dev);
    973 #endif
    974567#else
    975568        /* No mknod system call. */
    … …  
    993586
    994587/*******************************************************************
    995  System wrapper for getwd
    996 ********************************************************************/
    997 
    998 char *sys_getwd(char *s)
    999 {
    1000         char *wd;
    1001 #ifdef HAVE_GETCWD
    1002         wd = (char *)getcwd(s, PATH_MAX);
    1003 #else
    1004         wd = (char *)getwd(s);
    1005 #endif
     588 System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
     589 on error (malloc fail usually).
     590********************************************************************/
     591
     592char *sys_getwd(void)
     593{
     594#ifdef GETCWD_TAKES_NULL
     595        return getcwd(NULL, 0);
     596#elif HAVE_GETCWD
     597        char *wd = NULL, *s = NULL;
     598        size_t allocated = PATH_MAX;
     599
     600        while (1) {
     601                s = SMB_REALLOC_ARRAY(s, char, allocated);
     602                if (s == NULL) {
     603                        return NULL;
     604                }
     605                wd = getcwd(s, allocated);
     606                if (wd) {
     607                        break;
     608                }
     609                if (errno != ERANGE) {
     610                        SAFE_FREE(s);
     611                        break;
     612                }
     613                allocated *= 2;
     614                if (allocated < PATH_MAX) {
     615                        SAFE_FREE(s);
     616                        break;
     617                }
     618        }
    1006619        return wd;
     620#else
     621        char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
     622        if (s == NULL) {
     623                return NULL;
     624        }
     625        return getwd(s);
     626#endif
    1007627}
    1008628
    … …  
    1067687#endif
    1068688                        break;
     689                case DAC_OVERRIDE_CAPABILITY:
     690#ifdef CAP_DAC_OVERRIDE
     691                        cap_vals[num_cap_vals++] = CAP_DAC_OVERRIDE;
     692#endif
    1069693        }
    1070694
    … …  
    1246870                group_list[i] = (GID_T) gidset[i];
    1247871
    1248         if(setgroups(setlen, group_list) != 0) {
     872        if(samba_setgroups(setlen, group_list) != 0) {
    1249873                int saved_errno = errno;
    1250874                SAFE_FREE(group_list);
    … …  
    1283907        /* No group list, just make sure we are setting the efective GID. */
    1284908        if (setlen == 0) {
    1285                 return setgroups(1, &primary_gid);
     909                return samba_setgroups(1, &primary_gid);
    1286910        }
    1287911
    … …  
    1309933        ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
    1310934#else
    1311         ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
     935        ret = samba_setgroups(setlen, new_gidset ? new_gidset : gidset);
    1312936#endif
    1313937
    … …  
    1352976        return sys_broken_setgroups(setlen, gidset);
    1353977#else
    1354         return setgroups(setlen, gidset);
     978        return samba_setgroups(setlen, gidset);
    1355979#endif
    1356980}
    … …  
    13891013        TALLOC_FREE(trunc_cmd);
    13901014
    1391         if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
     1015        if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
    13921016                goto nomem;
    13931017        }
    … …  
    14481072        popen_list *entry = NULL;
    14491073        char **argl = NULL;
    1450 
    1451         if (pipe(pipe_fds) < 0)
     1074        int ret;
     1075
     1076        if (!*command) {
     1077                errno = EINVAL;
    14521078                return -1;
     1079        }
     1080
     1081        ret = pipe(pipe_fds);
     1082        if (ret < 0) {
     1083                DEBUG(0, ("sys_popen: error opening pipe: %s\n",
     1084                          strerror(errno)));
     1085                return -1;
     1086        }
    14531087
    14541088        parent_end = pipe_fds[0];
    14551089        child_end = pipe_fds[1];
    14561090
    1457         if (!*command) {
    1458                 errno = EINVAL;
     1091        entry = SMB_MALLOC_P(popen_list);
     1092        if (entry == NULL) {
     1093                DEBUG(0, ("sys_popen: malloc failed\n"));
    14591094                goto err_exit;
    14601095        }
    1461 
    1462         if((entry = SMB_MALLOC_P(popen_list)) == NULL)
    1463                 goto err_exit;
    14641096
    14651097        ZERO_STRUCTP(entry);
    … …  
    14691101         */
    14701102
    1471         if(!(argl = extract_args(NULL, command)))
     1103        argl = extract_args(NULL, command);
     1104        if (argl == NULL) {
     1105                DEBUG(0, ("sys_popen: extract_args() failed: %s\n", strerror(errno)));
    14721106                goto err_exit;
    1473 
    1474         entry->child_pid = sys_fork();
     1107        }
     1108
     1109        entry->child_pid = fork();
    14751110
    14761111        if (entry->child_pid == -1) {
     1112                DEBUG(0, ("sys_popen: fork failed: %s\n", strerror(errno)));
    14771113                goto err_exit;
    14781114        }
    … …  
    15021138                        close(p->fd);
    15031139
    1504                 execv(argl[0], argl);
     1140                ret = execv(argl[0], argl);
     1141                if (ret == -1) {
     1142                        DEBUG(0, ("sys_popen: ERROR executing command "
     1143                                  "'%s': %s\n", command, strerror(errno)));
     1144                }
    15051145                _exit (127);
    15061146        }
    … …  
    15711211}
    15721212
    1573 /**************************************************************************
    1574  Wrapper for Admin Logs.
    1575 ****************************************************************************/
    1576 
    1577  void sys_adminlog(int priority, const char *format_str, ...)
    1578 {
    1579         va_list ap;
    1580         int ret;
    1581         char *msgbuf = NULL;
    1582 
    1583         va_start( ap, format_str );
    1584         ret = vasprintf( &msgbuf, format_str, ap );
    1585         va_end( ap );
    1586 
    1587         if (ret == -1)
    1588                 return;
    1589 
    1590 #if defined(HAVE_SYSLOG)
    1591         syslog( priority, "%s", msgbuf );
    1592 #else
    1593         DEBUG(0,("%s", msgbuf ));
    1594 #endif
    1595         SAFE_FREE(msgbuf);
    1596 }
    1597 
    1598 /******** Solaris EA helper function prototypes ********/
    1599 #ifdef HAVE_ATTROPEN
    1600 #define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP
    1601 static int solaris_write_xattr(int attrfd, const char *value, size_t size);
    1602 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size);
    1603 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size);
    1604 static int solaris_unlinkat(int attrdirfd, const char *name);
    1605 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode);
    1606 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode);
    1607 #endif
    1608 
    1609 /**************************************************************************
    1610  Wrappers for extented attribute calls. Based on the Linux package with
    1611  support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
    1612 ****************************************************************************/
    1613 
    1614 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
    1615 {
    1616 #if defined(HAVE_GETXATTR)
    1617 #ifndef XATTR_ADD_OPT
    1618         return getxattr(path, name, value, size);
    1619 #else
    1620         int options = 0;
    1621         return getxattr(path, name, value, size, 0, options);
    1622 #endif
    1623 #elif defined(HAVE_GETEA)
    1624         return getea(path, name, value, size);
    1625 #elif defined(HAVE_EXTATTR_GET_FILE)
    1626         char *s;
    1627         ssize_t retval;
    1628         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    1629                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    1630         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    1631         /*
    1632          * The BSD implementation has a nasty habit of silently truncating
    1633          * the returned value to the size of the buffer, so we have to check
    1634          * that the buffer is large enough to fit the returned value.
    1635          */
    1636         if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
    1637                 if(retval > size) {
    1638                         errno = ERANGE;
    1639                         return -1;
    1640                 }
    1641                 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
    1642                         return retval;
    1643         }
    1644 
    1645         DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
    1646         return -1;
    1647 #elif defined(HAVE_ATTR_GET)
    1648         int retval, flags = 0;
    1649         int valuelength = (int)size;
    1650         char *attrname = strchr(name,'.') + 1;
    1651 
    1652         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
    1653 
    1654         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
    1655 
    1656         return retval ? retval : valuelength;
    1657 #elif defined(HAVE_ATTROPEN)
    1658         ssize_t ret = -1;
    1659         int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
    1660         if (attrfd >= 0) {
    1661                 ret = solaris_read_xattr(attrfd, value, size);
    1662                 close(attrfd);
    1663         }
    1664         return ret;
    1665 #else
    1666         errno = ENOSYS;
    1667         return -1;
    1668 #endif
    1669 }
    1670 
    1671 ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
    1672 {
    1673 #if defined(HAVE_LGETXATTR)
    1674         return lgetxattr(path, name, value, size);
    1675 #elif defined(HAVE_GETXATTR) && defined(XATTR_ADD_OPT)
    1676         int options = XATTR_NOFOLLOW;
    1677         return getxattr(path, name, value, size, 0, options);
    1678 #elif defined(HAVE_LGETEA)
    1679         return lgetea(path, name, value, size);
    1680 #elif defined(HAVE_EXTATTR_GET_LINK)
    1681         char *s;
    1682         ssize_t retval;
    1683         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    1684                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    1685         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    1686 
    1687         if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
    1688                 if(retval > size) {
    1689                         errno = ERANGE;
    1690                         return -1;
    1691                 }
    1692                 if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
    1693                         return retval;
    1694         }
    1695 
    1696         DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
    1697         return -1;
    1698 #elif defined(HAVE_ATTR_GET)
    1699         int retval, flags = ATTR_DONTFOLLOW;
    1700         int valuelength = (int)size;
    1701         char *attrname = strchr(name,'.') + 1;
    1702 
    1703         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
    1704 
    1705         retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
    1706 
    1707         return retval ? retval : valuelength;
    1708 #elif defined(HAVE_ATTROPEN)
    1709         ssize_t ret = -1;
    1710         int attrfd = solaris_attropen(path, name, O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
    1711         if (attrfd >= 0) {
    1712                 ret = solaris_read_xattr(attrfd, value, size);
    1713                 close(attrfd);
    1714         }
    1715         return ret;
    1716 #else
    1717         errno = ENOSYS;
    1718         return -1;
    1719 #endif
    1720 }
    1721 
    1722 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
    1723 {
    1724 #if defined(HAVE_FGETXATTR)
    1725 #ifndef XATTR_ADD_OPT
    1726         return fgetxattr(filedes, name, value, size);
    1727 #else
    1728         int options = 0;
    1729         return fgetxattr(filedes, name, value, size, 0, options);
    1730 #endif
    1731 #elif defined(HAVE_FGETEA)
    1732         return fgetea(filedes, name, value, size);
    1733 #elif defined(HAVE_EXTATTR_GET_FD)
    1734         char *s;
    1735         ssize_t retval;
    1736         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    1737                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    1738         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    1739 
    1740         if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
    1741                 if(retval > size) {
    1742                         errno = ERANGE;
    1743                         return -1;
    1744                 }
    1745                 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
    1746                         return retval;
    1747         }
    1748 
    1749         DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
    1750         return -1;
    1751 #elif defined(HAVE_ATTR_GETF)
    1752         int retval, flags = 0;
    1753         int valuelength = (int)size;
    1754         char *attrname = strchr(name,'.') + 1;
    1755 
    1756         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
    1757 
    1758         retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
    1759 
    1760         return retval ? retval : valuelength;
    1761 #elif defined(HAVE_ATTROPEN)
    1762         ssize_t ret = -1;
    1763         int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
    1764         if (attrfd >= 0) {
    1765                 ret = solaris_read_xattr(attrfd, value, size);
    1766                 close(attrfd);
    1767         }
    1768         return ret;
    1769 #else
    1770         errno = ENOSYS;
    1771         return -1;
    1772 #endif
    1773 }
    1774 
    1775 #if defined(HAVE_EXTATTR_LIST_FILE)
    1776 
    1777 #define EXTATTR_PREFIX(s)       (s), (sizeof((s))-1)
    1778 
    1779 static struct {
    1780         int space;
    1781         const char *name;
    1782         size_t len;
    1783 }
    1784 extattr[] = {
    1785         { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
    1786         { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
    1787 };
    1788 
    1789 typedef union {
    1790         const char *path;
    1791         int filedes;
    1792 } extattr_arg;
    1793 
    1794 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
    1795 {
    1796         ssize_t list_size, total_size = 0;
    1797         int i, t, len;
    1798         char *buf;
    1799         /* Iterate through extattr(2) namespaces */
    1800         for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
    1801                 if (t != EXTATTR_NAMESPACE_USER && geteuid() != 0) {
    1802                         /* ignore all but user namespace when we are not root, see bug 10247 */
    1803                         continue;
    1804                 }
    1805                 switch(type) {
    1806 #if defined(HAVE_EXTATTR_LIST_FILE)
    1807                         case 0:
    1808                                 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
    1809                                 break;
    1810 #endif
    1811 #if defined(HAVE_EXTATTR_LIST_LINK)
    1812                         case 1:
    1813                                 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
    1814                                 break;
    1815 #endif
    1816 #if defined(HAVE_EXTATTR_LIST_FD)
    1817                         case 2:
    1818                                 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
    1819                                 break;
    1820 #endif
    1821                         default:
    1822                                 errno = ENOSYS;
    1823                                 return -1;
    1824                 }
    1825                 /* Some error happend. Errno should be set by the previous call */
    1826                 if(list_size < 0)
    1827                         return -1;
    1828                 /* No attributes */
    1829                 if(list_size == 0)
    1830                         continue;
    1831                 /* XXX: Call with an empty buffer may be used to calculate
    1832                    necessary buffer size. Unfortunately, we can't say, how
    1833                    many attributes were returned, so here is the potential
    1834                    problem with the emulation.
    1835                 */
    1836                 if(list == NULL) {
    1837                         /* Take the worse case of one char attribute names -
    1838                            two bytes per name plus one more for sanity.
    1839                         */
    1840                         total_size += list_size + (list_size/2 + 1)*extattr[t].len;
    1841                         continue;
    1842                 }
    1843                 /* Count necessary offset to fit namespace prefixes */
    1844                 len = 0;
    1845                 for(i = 0; i < list_size; i += list[i] + 1)
    1846                         len += extattr[t].len;
    1847 
    1848                 total_size += list_size + len;
    1849                 /* Buffer is too small to fit the results */
    1850                 if(total_size > size) {
    1851                         errno = ERANGE;
    1852                         return -1;
    1853                 }
    1854                 /* Shift results back, so we can prepend prefixes */
    1855                 buf = (char *)memmove(list + len, list, list_size);
    1856 
    1857                 for(i = 0; i < list_size; i += len + 1) {
    1858                         len = buf[i];
    1859                         strncpy(list, extattr[t].name, extattr[t].len + 1);
    1860                         list += extattr[t].len;
    1861                         strncpy(list, buf + i + 1, len);
    1862                         list[len] = '\0';
    1863                         list += len + 1;
    1864                 }
    1865                 size -= total_size;
    1866         }
    1867         return total_size;
    1868 }
    1869 
    1870 #endif
    1871 
    1872 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
    1873 static char attr_buffer[ATTR_MAX_VALUELEN];
    1874 
    1875 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
    1876 {
    1877         int retval = 0, index;
    1878         attrlist_cursor_t *cursor = 0;
    1879         int total_size = 0;
    1880         attrlist_t * al = (attrlist_t *)attr_buffer;
    1881         attrlist_ent_t *ae;
    1882         size_t ent_size, left = size;
    1883         char *bp = list;
    1884 
    1885         while (True) {
    1886             if (filedes)
    1887                 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
    1888             else
    1889                 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
    1890             if (retval) break;
    1891             for (index = 0; index < al->al_count; index++) {
    1892                 ae = ATTR_ENTRY(attr_buffer, index);
    1893                 ent_size = strlen(ae->a_name) + sizeof("user.");
    1894                 if (left >= ent_size) {
    1895                     strncpy(bp, "user.", sizeof("user."));
    1896                     strncat(bp, ae->a_name, ent_size - sizeof("user."));
    1897                     bp += ent_size;
    1898                     left -= ent_size;
    1899                 } else if (size) {
    1900                     errno = ERANGE;
    1901                     retval = -1;
    1902                     break;
    1903                 }
    1904                 total_size += ent_size;
    1905             }
    1906             if (al->al_more == 0) break;
    1907         }
    1908         if (retval == 0) {
    1909             flags |= ATTR_ROOT;
    1910             cursor = 0;
    1911             while (True) {
    1912                 if (filedes)
    1913                     retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
    1914                 else
    1915                     retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
    1916                 if (retval) break;
    1917                 for (index = 0; index < al->al_count; index++) {
    1918                     ae = ATTR_ENTRY(attr_buffer, index);
    1919                     ent_size = strlen(ae->a_name) + sizeof("system.");
    1920                     if (left >= ent_size) {
    1921                         strncpy(bp, "system.", sizeof("system."));
    1922                         strncat(bp, ae->a_name, ent_size - sizeof("system."));
    1923                         bp += ent_size;
    1924                         left -= ent_size;
    1925                     } else if (size) {
    1926                         errno = ERANGE;
    1927                         retval = -1;
    1928                         break;
    1929                     }
    1930                     total_size += ent_size;
    1931                 }
    1932                 if (al->al_more == 0) break;
    1933             }
    1934         }
    1935         return (ssize_t)(retval ? retval : total_size);
    1936 }
    1937 
    1938 #endif
    1939 
    1940 ssize_t sys_listxattr (const char *path, char *list, size_t size)
    1941 {
    1942 #if defined(HAVE_LISTXATTR)
    1943 #ifndef XATTR_ADD_OPT
    1944         return listxattr(path, list, size);
    1945 #else
    1946         int options = 0;
    1947         return listxattr(path, list, size, options);
    1948 #endif
    1949 #elif defined(HAVE_LISTEA)
    1950         return listea(path, list, size);
    1951 #elif defined(HAVE_EXTATTR_LIST_FILE)
    1952         extattr_arg arg;
    1953         arg.path = path;
    1954         return bsd_attr_list(0, arg, list, size);
    1955 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
    1956         return irix_attr_list(path, 0, list, size, 0);
    1957 #elif defined(HAVE_ATTROPEN)
    1958         ssize_t ret = -1;
    1959         int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
    1960         if (attrdirfd >= 0) {
    1961                 ret = solaris_list_xattr(attrdirfd, list, size);
    1962                 close(attrdirfd);
    1963         }
    1964         return ret;
    1965 #else
    1966         errno = ENOSYS;
    1967         return -1;
    1968 #endif
    1969 }
    1970 
    1971 ssize_t sys_llistxattr (const char *path, char *list, size_t size)
    1972 {
    1973 #if defined(HAVE_LLISTXATTR)
    1974         return llistxattr(path, list, size);
    1975 #elif defined(HAVE_LISTXATTR) && defined(XATTR_ADD_OPT)
    1976         int options = XATTR_NOFOLLOW;
    1977         return listxattr(path, list, size, options);
    1978 #elif defined(HAVE_LLISTEA)
    1979         return llistea(path, list, size);
    1980 #elif defined(HAVE_EXTATTR_LIST_LINK)
    1981         extattr_arg arg;
    1982         arg.path = path;
    1983         return bsd_attr_list(1, arg, list, size);
    1984 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
    1985         return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW);
    1986 #elif defined(HAVE_ATTROPEN)
    1987         ssize_t ret = -1;
    1988         int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
    1989         if (attrdirfd >= 0) {
    1990                 ret = solaris_list_xattr(attrdirfd, list, size);
    1991                 close(attrdirfd);
    1992         }
    1993         return ret;
    1994 #else
    1995         errno = ENOSYS;
    1996         return -1;
    1997 #endif
    1998 }
    1999 
    2000 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
    2001 {
    2002 #if defined(HAVE_FLISTXATTR)
    2003 #ifndef XATTR_ADD_OPT
    2004         return flistxattr(filedes, list, size);
    2005 #else
    2006         int options = 0;
    2007         return flistxattr(filedes, list, size, options);
    2008 #endif
    2009 #elif defined(HAVE_FLISTEA)
    2010         return flistea(filedes, list, size);
    2011 #elif defined(HAVE_EXTATTR_LIST_FD)
    2012         extattr_arg arg;
    2013         arg.filedes = filedes;
    2014         return bsd_attr_list(2, arg, list, size);
    2015 #elif defined(HAVE_ATTR_LISTF)
    2016         return irix_attr_list(NULL, filedes, list, size, 0);
    2017 #elif defined(HAVE_ATTROPEN)
    2018         ssize_t ret = -1;
    2019         int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
    2020         if (attrdirfd >= 0) {
    2021                 ret = solaris_list_xattr(attrdirfd, list, size);
    2022                 close(attrdirfd);
    2023         }
    2024         return ret;
    2025 #else
    2026         errno = ENOSYS;
    2027         return -1;
    2028 #endif
    2029 }
    2030 
    2031 int sys_removexattr (const char *path, const char *name)
    2032 {
    2033 #if defined(HAVE_REMOVEXATTR)
    2034 #ifndef XATTR_ADD_OPT
    2035         return removexattr(path, name);
    2036 #else
    2037         int options = 0;
    2038         return removexattr(path, name, options);
    2039 #endif
    2040 #elif defined(HAVE_REMOVEEA)
    2041         return removeea(path, name);
    2042 #elif defined(HAVE_EXTATTR_DELETE_FILE)
    2043         char *s;
    2044         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    2045                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    2046         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    2047 
    2048         return extattr_delete_file(path, attrnamespace, attrname);
    2049 #elif defined(HAVE_ATTR_REMOVE)
    2050         int flags = 0;
    2051         char *attrname = strchr(name,'.') + 1;
    2052 
    2053         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
    2054 
    2055         return attr_remove(path, attrname, flags);
    2056 #elif defined(HAVE_ATTROPEN)
    2057         int ret = -1;
    2058         int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
    2059         if (attrdirfd >= 0) {
    2060                 ret = solaris_unlinkat(attrdirfd, name);
    2061                 close(attrdirfd);
    2062         }
    2063         return ret;
    2064 #else
    2065         errno = ENOSYS;
    2066         return -1;
    2067 #endif
    2068 }
    2069 
    2070 int sys_lremovexattr (const char *path, const char *name)
    2071 {
    2072 #if defined(HAVE_LREMOVEXATTR)
    2073         return lremovexattr(path, name);
    2074 #elif defined(HAVE_REMOVEXATTR) && defined(XATTR_ADD_OPT)
    2075         int options = XATTR_NOFOLLOW;
    2076         return removexattr(path, name, options);
    2077 #elif defined(HAVE_LREMOVEEA)
    2078         return lremoveea(path, name);
    2079 #elif defined(HAVE_EXTATTR_DELETE_LINK)
    2080         char *s;
    2081         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    2082                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    2083         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    2084 
    2085         return extattr_delete_link(path, attrnamespace, attrname);
    2086 #elif defined(HAVE_ATTR_REMOVE)
    2087         int flags = ATTR_DONTFOLLOW;
    2088         char *attrname = strchr(name,'.') + 1;
    2089 
    2090         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
    2091 
    2092         return attr_remove(path, attrname, flags);
    2093 #elif defined(HAVE_ATTROPEN)
    2094         int ret = -1;
    2095         int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
    2096         if (attrdirfd >= 0) {
    2097                 ret = solaris_unlinkat(attrdirfd, name);
    2098                 close(attrdirfd);
    2099         }
    2100         return ret;
    2101 #else
    2102         errno = ENOSYS;
    2103         return -1;
    2104 #endif
    2105 }
    2106 
    2107 int sys_fremovexattr (int filedes, const char *name)
    2108 {
    2109 #if defined(HAVE_FREMOVEXATTR)
    2110 #ifndef XATTR_ADD_OPT
    2111         return fremovexattr(filedes, name);
    2112 #else
    2113         int options = 0;
    2114         return fremovexattr(filedes, name, options);
    2115 #endif
    2116 #elif defined(HAVE_FREMOVEEA)
    2117         return fremoveea(filedes, name);
    2118 #elif defined(HAVE_EXTATTR_DELETE_FD)
    2119         char *s;
    2120         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    2121                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    2122         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    2123 
    2124         return extattr_delete_fd(filedes, attrnamespace, attrname);
    2125 #elif defined(HAVE_ATTR_REMOVEF)
    2126         int flags = 0;
    2127         char *attrname = strchr(name,'.') + 1;
    2128 
    2129         if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
    2130 
    2131         return attr_removef(filedes, attrname, flags);
    2132 #elif defined(HAVE_ATTROPEN)
    2133         int ret = -1;
    2134         int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
    2135         if (attrdirfd >= 0) {
    2136                 ret = solaris_unlinkat(attrdirfd, name);
    2137                 close(attrdirfd);
    2138         }
    2139         return ret;
    2140 #else
    2141         errno = ENOSYS;
    2142         return -1;
    2143 #endif
    2144 }
    2145 
    2146 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
    2147 {
    2148 #if defined(HAVE_SETXATTR)
    2149 #ifndef XATTR_ADD_OPT
    2150         return setxattr(path, name, value, size, flags);
    2151 #else
    2152         int options = 0;
    2153         return setxattr(path, name, value, size, 0, options);
    2154 #endif
    2155 #elif defined(HAVE_SETEA)
    2156         return setea(path, name, value, size, flags);
    2157 #elif defined(HAVE_EXTATTR_SET_FILE)
    2158         char *s;
    2159         int retval = 0;
    2160         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    2161                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    2162         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    2163         if (flags) {
    2164                 /* Check attribute existence */
    2165                 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
    2166                 if (retval < 0) {
    2167                         /* REPLACE attribute, that doesn't exist */
    2168                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
    2169                                 errno = ENOATTR;
    2170                                 return -1;
    2171                         }
    2172                         /* Ignore other errors */
    2173                 }
    2174                 else {
    2175                         /* CREATE attribute, that already exists */
    2176                         if (flags & XATTR_CREATE) {
    2177                                 errno = EEXIST;
    2178                                 return -1;
    2179                         }
    2180                 }
    2181         }
    2182         retval = extattr_set_file(path, attrnamespace, attrname, value, size);
    2183         return (retval < 0) ? -1 : 0;
    2184 #elif defined(HAVE_ATTR_SET)
    2185         int myflags = 0;
    2186         char *attrname = strchr(name,'.') + 1;
    2187 
    2188         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
    2189         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
    2190         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
    2191 
    2192         return attr_set(path, attrname, (const char *)value, size, myflags);
    2193 #elif defined(HAVE_ATTROPEN)
    2194         int ret = -1;
    2195         int myflags = O_RDWR;
    2196         int attrfd;
    2197         if (flags & XATTR_CREATE) myflags |= O_EXCL;
    2198         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
    2199         attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
    2200         if (attrfd >= 0) {
    2201                 ret = solaris_write_xattr(attrfd, value, size);
    2202                 close(attrfd);
    2203         }
    2204         return ret;
    2205 #else
    2206         errno = ENOSYS;
    2207         return -1;
    2208 #endif
    2209 }
    2210 
    2211 int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags)
    2212 {
    2213 #if defined(HAVE_LSETXATTR)
    2214         return lsetxattr(path, name, value, size, flags);
    2215 #elif defined(HAVE_SETXATTR) && defined(XATTR_ADD_OPT)
    2216         int options = XATTR_NOFOLLOW;
    2217         return setxattr(path, name, value, size, 0, options);
    2218 #elif defined(LSETEA)
    2219         return lsetea(path, name, value, size, flags);
    2220 #elif defined(HAVE_EXTATTR_SET_LINK)
    2221         char *s;
    2222         int retval = 0;
    2223         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    2224                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    2225         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    2226         if (flags) {
    2227                 /* Check attribute existence */
    2228                 retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
    2229                 if (retval < 0) {
    2230                         /* REPLACE attribute, that doesn't exist */
    2231                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
    2232                                 errno = ENOATTR;
    2233                                 return -1;
    2234                         }
    2235                         /* Ignore other errors */
    2236                 }
    2237                 else {
    2238                         /* CREATE attribute, that already exists */
    2239                         if (flags & XATTR_CREATE) {
    2240                                 errno = EEXIST;
    2241                                 return -1;
    2242                         }
    2243                 }
    2244         }
    2245 
    2246         retval = extattr_set_link(path, attrnamespace, attrname, value, size);
    2247         return (retval < 0) ? -1 : 0;
    2248 #elif defined(HAVE_ATTR_SET)
    2249         int myflags = ATTR_DONTFOLLOW;
    2250         char *attrname = strchr(name,'.') + 1;
    2251 
    2252         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
    2253         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
    2254         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
    2255 
    2256         return attr_set(path, attrname, (const char *)value, size, myflags);
    2257 #elif defined(HAVE_ATTROPEN)
    2258         int ret = -1;
    2259         int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW;
    2260         int attrfd;
    2261         if (flags & XATTR_CREATE) myflags |= O_EXCL;
    2262         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
    2263         attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
    2264         if (attrfd >= 0) {
    2265                 ret = solaris_write_xattr(attrfd, value, size);
    2266                 close(attrfd);
    2267         }
    2268         return ret;
    2269 #else
    2270         errno = ENOSYS;
    2271         return -1;
    2272 #endif
    2273 }
    2274 
    2275 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
    2276 {
    2277 #if defined(HAVE_FSETXATTR)
    2278 #ifndef XATTR_ADD_OPT
    2279         return fsetxattr(filedes, name, value, size, flags);
    2280 #else
    2281         int options = 0;
    2282         return fsetxattr(filedes, name, value, size, 0, options);
    2283 #endif
    2284 #elif defined(HAVE_FSETEA)
    2285         return fsetea(filedes, name, value, size, flags);
    2286 #elif defined(HAVE_EXTATTR_SET_FD)
    2287         char *s;
    2288         int retval = 0;
    2289         int attrnamespace = (strncmp(name, "system", 6) == 0) ?
    2290                 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
    2291         const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
    2292         if (flags) {
    2293                 /* Check attribute existence */
    2294                 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
    2295                 if (retval < 0) {
    2296                         /* REPLACE attribute, that doesn't exist */
    2297                         if (flags & XATTR_REPLACE && errno == ENOATTR) {
    2298                                 errno = ENOATTR;
    2299                                 return -1;
    2300                         }
    2301                         /* Ignore other errors */
    2302                 }
    2303                 else {
    2304                         /* CREATE attribute, that already exists */
    2305                         if (flags & XATTR_CREATE) {
    2306                                 errno = EEXIST;
    2307                                 return -1;
    2308                         }
    2309                 }
    2310         }
    2311         retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
    2312         return (retval < 0) ? -1 : 0;
    2313 #elif defined(HAVE_ATTR_SETF)
    2314         int myflags = 0;
    2315         char *attrname = strchr(name,'.') + 1;
    2316 
    2317         if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
    2318         if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
    2319         if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
    2320 
    2321         return attr_setf(filedes, attrname, (const char *)value, size, myflags);
    2322 #elif defined(HAVE_ATTROPEN)
    2323         int ret = -1;
    2324         int myflags = O_RDWR | O_XATTR;
    2325         int attrfd;
    2326         if (flags & XATTR_CREATE) myflags |= O_EXCL;
    2327         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
    2328         attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
    2329         if (attrfd >= 0) {
    2330                 ret = solaris_write_xattr(attrfd, value, size);
    2331                 close(attrfd);
    2332         }
    2333         return ret;
    2334 #else
    2335         errno = ENOSYS;
    2336         return -1;
    2337 #endif
    2338 }
    2339 
    2340 /**************************************************************************
    2341  helper functions for Solaris' EA support
    2342 ****************************************************************************/
    2343 #ifdef HAVE_ATTROPEN
    2344 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
    2345 {
    2346         struct stat sbuf;
    2347 
    2348         if (fstat(attrfd, &sbuf) == -1) {
    2349                 errno = ENOATTR;
    2350                 return -1;
    2351         }
    2352 
    2353         /* This is to return the current size of the named extended attribute */
    2354         if (size == 0) {
    2355                 return sbuf.st_size;
    2356         }
    2357 
    2358         /* check size and read xattr */
    2359         if (sbuf.st_size > size) {
    2360                 errno = ERANGE;
    2361                 return -1;
    2362         }
    2363 
    2364         return read(attrfd, value, sbuf.st_size);
    2365 }
    2366 
    2367 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
    2368 {
    2369         ssize_t len = 0;
    2370         DIR *dirp;
    2371         struct dirent *de;
    2372         int newfd = dup(attrdirfd);
    2373         /* CAUTION: The originating file descriptor should not be
    2374                     used again following the call to fdopendir().
    2375                     For that reason we dup() the file descriptor
    2376                     here to make things more clear. */
    2377         dirp = fdopendir(newfd);
    2378 
    2379         while ((de = readdir(dirp))) {
    2380                 size_t listlen = strlen(de->d_name);
    2381                 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
    2382                         /* we don't want "." and ".." here: */
    2383                         DEBUG(10,("skipped EA %s\n",de->d_name));
    2384                         continue;
    2385                 }
    2386 
    2387                 if (size == 0) {
    2388                         /* return the current size of the list of extended attribute names*/
    2389                         len += listlen + 1;
    2390                 } else {
    2391                         /* check size and copy entrieѕ + nul into list. */
    2392                         if ((len + listlen + 1) > size) {
    2393                                 errno = ERANGE;
    2394                                 len = -1;
    2395                                 break;
    2396                         } else {
    2397                                 safe_strcpy(list + len, de->d_name, listlen);
    2398                                 len += listlen;
    2399                                 list[len] = '\0';
    2400                                 ++len;
    2401                         }
    2402                 }
    2403         }
    2404 
    2405         if (closedir(dirp) == -1) {
    2406                 DEBUG(0,("closedir dirp failed: %s\n",strerror(errno)));
    2407                 return -1;
    2408         }
    2409         return len;
    2410 }
    2411 
    2412 static int solaris_unlinkat(int attrdirfd, const char *name)
    2413 {
    2414         if (unlinkat(attrdirfd, name, 0) == -1) {
    2415                 if (errno == ENOENT) {
    2416                         errno = ENOATTR;
    2417                 }
    2418                 return -1;
    2419         }
    2420         return 0;
    2421 }
    2422 
    2423 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
    2424 {
    2425         int filedes = attropen(path, attrpath, oflag, mode);
    2426         if (filedes == -1) {
    2427                 DEBUG(10,("attropen FAILED: path: %s, name: %s, errno: %s\n",path,attrpath,strerror(errno)));
    2428                 if (errno == EINVAL) {
    2429                         errno = ENOTSUP;
    2430                 } else {
    2431                         errno = ENOATTR;
    2432                 }
    2433         }
    2434         return filedes;
    2435 }
    2436 
    2437 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
    2438 {
    2439         int filedes = openat(fildes, path, oflag, mode);
    2440         if (filedes == -1) {
    2441                 DEBUG(10,("openat FAILED: fd: %d, path: %s, errno: %s\n",filedes,path,strerror(errno)));
    2442                 if (errno == EINVAL) {
    2443                         errno = ENOTSUP;
    2444                 } else {
    2445                         errno = ENOATTR;
    2446                 }
    2447         }
    2448         return filedes;
    2449 }
    2450 
    2451 static int solaris_write_xattr(int attrfd, const char *value, size_t size)
    2452 {
    2453         if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
    2454                 return 0;
    2455         } else {
    2456                 DEBUG(10,("solaris_write_xattr FAILED!\n"));
    2457                 return -1;
    2458         }
    2459 }
    2460 #endif /*HAVE_ATTROPEN*/
    2461 
    2462 
    24631213/****************************************************************************
    24641214 Return the major devicenumber for UNIX extensions.
    24651215****************************************************************************/
    24661216
    2467 uint32 unix_dev_major(SMB_DEV_T dev)
     1217uint32_t unix_dev_major(SMB_DEV_T dev)
    24681218{
    24691219#if defined(HAVE_DEVICE_MAJOR_FN)
    2470         return (uint32)major(dev);
    2471 #else
    2472         return (uint32)(dev >> 8);
     1220        return (uint32_t)major(dev);
     1221#else
     1222        return (uint32_t)(dev >> 8);
    24731223#endif
    24741224}
    … …  
    24781228****************************************************************************/
    24791229
    2480 uint32 unix_dev_minor(SMB_DEV_T dev)
     1230uint32_t unix_dev_minor(SMB_DEV_T dev)
    24811231{
    24821232#if defined(HAVE_DEVICE_MINOR_FN)
    2483         return (uint32)minor(dev);
    2484 #else
    2485         return (uint32)(dev & 0xff);
    2486 #endif
    2487 }
    2488 
    2489 #if defined(WITH_AIO)
    2490 
    2491 /*******************************************************************
    2492  An aio_read wrapper that will deal with 64-bit sizes.
    2493 ********************************************************************/
    2494 
    2495 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
    2496 {
    2497 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
    2498         return aio_read64(aiocb);
    2499 #elif defined(HAVE_AIO_READ)
    2500         return aio_read(aiocb);
    2501 #else
    2502         errno = ENOSYS;
    2503         return -1;
    2504 #endif
    2505 }
    2506 
    2507 /*******************************************************************
    2508  An aio_write wrapper that will deal with 64-bit sizes.
    2509 ********************************************************************/
    2510 
    2511 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
    2512 {
    2513 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
    2514         return aio_write64(aiocb);
    2515 #elif defined(HAVE_AIO_WRITE)
    2516         return aio_write(aiocb);
    2517 #else
    2518         errno = ENOSYS;
    2519         return -1;
    2520 #endif
    2521 }
    2522 
    2523 /*******************************************************************
    2524  An aio_return wrapper that will deal with 64-bit sizes.
    2525 ********************************************************************/
    2526 
    2527 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
    2528 {
    2529 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
    2530         return aio_return64(aiocb);
    2531 #elif defined(HAVE_AIO_RETURN)
    2532         return aio_return(aiocb);
    2533 #else
    2534         errno = ENOSYS;
    2535         return -1;
    2536 #endif
    2537 }
    2538 
    2539 /*******************************************************************
    2540  An aio_cancel wrapper that will deal with 64-bit sizes.
    2541 ********************************************************************/
    2542 
    2543 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
    2544 {
    2545 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
    2546         return aio_cancel64(fd, aiocb);
    2547 #elif defined(HAVE_AIO_CANCEL)
    2548         return aio_cancel(fd, aiocb);
    2549 #else
    2550         errno = ENOSYS;
    2551         return -1;
    2552 #endif
    2553 }
    2554 
    2555 /*******************************************************************
    2556  An aio_error wrapper that will deal with 64-bit sizes.
    2557 ********************************************************************/
    2558 
    2559 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
    2560 {
    2561 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
    2562         return aio_error64(aiocb);
    2563 #elif defined(HAVE_AIO_ERROR)
    2564         return aio_error(aiocb);
    2565 #else
    2566         errno = ENOSYS;
    2567         return -1;
    2568 #endif
    2569 }
    2570 
    2571 /*******************************************************************
    2572  An aio_fsync wrapper that will deal with 64-bit sizes.
    2573 ********************************************************************/
    2574 
    2575 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
    2576 {
    2577 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64)
    2578         return aio_fsync64(op, aiocb);
    2579 #elif defined(HAVE_AIO_FSYNC)
    2580         return aio_fsync(op, aiocb);
    2581 #else
    2582         errno = ENOSYS;
    2583         return -1;
    2584 #endif
    2585 }
    2586 
    2587 /*******************************************************************
    2588  An aio_fsync wrapper that will deal with 64-bit sizes.
    2589 ********************************************************************/
    2590 
    2591 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
    2592 {
    2593 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64)
    2594         return aio_suspend64(cblist, n, timeout);
    2595 #elif defined(HAVE_AIO_FSYNC)
    2596         return aio_suspend(cblist, n, timeout);
    2597 #else
    2598         errno = ENOSYS;
    2599         return -1;
    2600 #endif
    2601 }
    2602 #else /* !WITH_AIO */
    2603 
    2604 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
    2605 {
    2606         errno = ENOSYS;
    2607         return -1;
    2608 }
    2609 
    2610 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
    2611 {
    2612         errno = ENOSYS;
    2613         return -1;
    2614 }
    2615 
    2616 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
    2617 {
    2618         errno = ENOSYS;
    2619         return -1;
    2620 }
    2621 
    2622 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
    2623 {
    2624         errno = ENOSYS;
    2625         return -1;
    2626 }
    2627 
    2628 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
    2629 {
    2630         errno = ENOSYS;
    2631         return -1;
    2632 }
    2633 
    2634 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
    2635 {
    2636         errno = ENOSYS;
    2637         return -1;
    2638 }
    2639 
    2640 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
    2641 {
    2642         errno = ENOSYS;
    2643         return -1;
    2644 }
    2645 #endif /* WITH_AIO */
     1233        return (uint32_t)minor(dev);
     1234#else
     1235        return (uint32_t)(dev & 0xff);
     1236#endif
     1237}
     1238
     1239#if 0
     1240/*******************************************************************
     1241 Return the number of CPUs.
     1242********************************************************************/
     1243
     1244int sys_get_number_of_cores(void)
     1245{
     1246        int ret = -1;
     1247
     1248#if defined(HAVE_SYSCONF)
     1249#if defined(_SC_NPROCESSORS_ONLN)
     1250        ret = (int)sysconf(_SC_NPROCESSORS_ONLN);
     1251#endif
     1252#if defined(_SC_NPROCESSORS_CONF)
     1253        if (ret < 1) {
     1254                ret = (int)sysconf(_SC_NPROCESSORS_CONF);
     1255        }
     1256#endif
     1257#elif defined(HAVE_SYSCTL) && defined(CTL_HW)
     1258        int name[2];
     1259        unsigned int len = sizeof(ret);
     1260
     1261        name[0] = CTL_HW;
     1262#if defined(HW_AVAILCPU)
     1263        name[1] = HW_AVAILCPU;
     1264
     1265        if (sysctl(name, 2, &ret, &len, NULL, 0) == -1) {
     1266                ret = -1;
     1267        }
     1268#endif
     1269#if defined(HW_NCPU)
     1270        if(ret < 1) {
     1271                name[0] = CTL_HW;
     1272                name[1] = HW_NCPU;
     1273                if (sysctl(nm, 2, &count, &len, NULL, 0) == -1) {
     1274                        ret = -1;
     1275                }
     1276        }
     1277#endif
     1278#endif
     1279        if (ret < 1) {
     1280                ret = 1;
     1281        }
     1282        return ret;
     1283}
     1284#endif
Note: See TracChangeset for help on using the changeset viewer.