r23658: One pstring a day....
[ira/wip.git] / source3 / lib / system.c
index 7434cbe35eea878021fa5bc3b7430b21629ebfc4..79d37d702450a4a57fb0aba4f82b202670719067 100644 (file)
@@ -2,7 +2,8 @@
    Unix SMB/CIFS implementation.
    Samba system utilities
    Copyright (C) Andrew Tridgell 1992-1998
-   Copyright (C) Jeremy Allison 1998-2002
+   Copyright (C) Jeremy Allison  1998-2005
+   Copyright (C) Timur Bakeyev        2005
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
 #include "includes.h"
 
+#ifdef HAVE_SYS_PRCTL_H
+#include <sys/prctl.h>
+#endif
+
 /*
    The idea is that this file will eventually have wrappers around all
    important system calls in samba. The aims are:
 
 
 
+/*******************************************************************
+ A wrapper for memalign
+********************************************************************/
+
+void *sys_memalign( size_t align, size_t size )
+{
+#if defined(HAVE_POSIX_MEMALIGN)
+       void *p = NULL;
+       int ret = posix_memalign( &p, align, size );
+       if ( ret == 0 )
+               return p;
+               
+       return NULL;
+#elif defined(HAVE_MEMALIGN)
+       return memalign( align, size );
+#else
+       /* On *BSD systems memaligns doesn't exist, but memory will
+        * be aligned on allocations of > pagesize. */
+#if defined(SYSCONF_SC_PAGESIZE)
+       size_t pagesize = (size_t)sysconf(_SC_PAGESIZE);
+#elif defined(HAVE_GETPAGESIZE)
+       size_t pagesize = (size_t)getpagesize();
+#else
+       size_t pagesize = (size_t)-1;
+#endif
+       if (pagesize == (size_t)-1) {
+               DEBUG(0,("memalign functionalaity not available on this platform!\n"));
+               return NULL;
+       }
+       if (size < pagesize) {
+               size = pagesize;
+       }
+       return SMB_MALLOC(size);
+#endif
+}
+
 /*******************************************************************
  A wrapper for usleep in case we don't have one.
 ********************************************************************/
@@ -100,7 +141,6 @@ ssize_t sys_write(int fd, const void *buf, size_t count)
        return ret;
 }
 
-
 /*******************************************************************
 A pread wrapper that will deal with EINTR and 64-bit file offsets.
 ********************************************************************/
@@ -169,6 +209,20 @@ ssize_t sys_sendto(int s,  const void *msg, size_t len, int flags, const struct
        return ret;
 }
 
+/*******************************************************************
+A recv wrapper that will deal with EINTR.
+********************************************************************/
+
+ssize_t sys_recv(int fd, void *buf, size_t count, int flags)
+{
+       ssize_t ret;
+
+       do {
+               ret = recv(fd, buf, count, flags);
+       } while (ret == -1 && errno == EINTR);
+       return ret;
+}
+
 /*******************************************************************
 A recvfrom wrapper that will deal with EINTR.
 ********************************************************************/
@@ -361,11 +415,36 @@ FILE *sys_fopen(const char *path, const char *type)
 #endif
 }
 
+
+/*******************************************************************
+ A flock() wrapper that will perform the kernel flock.
+********************************************************************/
+
+void kernel_flock(int fd, uint32 share_mode)
+{
+#if HAVE_KERNEL_SHARE_MODES
+       int kernel_mode = 0;
+       if (share_mode == FILE_SHARE_WRITE) {
+               kernel_mode = LOCK_MAND|LOCK_WRITE;
+       } else if (share_mode == FILE_SHARE_READ) {
+               kernel_mode = LOCK_MAND|LOCK_READ;
+       } else if (share_mode == FILE_SHARE_NONE) {
+               kernel_mode = LOCK_MAND;
+       }
+       if (kernel_mode) {
+               flock(fd, kernel_mode);
+       }
+#endif
+       ;
+}
+
+
+
 /*******************************************************************
  An opendir wrapper that will deal with 64 bit filesizes.
 ********************************************************************/
 
-DIR *sys_opendir(const char *name)
+SMB_STRUCT_DIR *sys_opendir(const char *name)
 {
 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
        return opendir64(name);
@@ -378,7 +457,7 @@ DIR *sys_opendir(const char *name)
  A readdir wrapper that will deal with 64 bit filesizes.
 ********************************************************************/
 
-SMB_STRUCT_DIRENT *sys_readdir(DIR *dirp)
+SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
 {
 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
        return readdir64(dirp);
@@ -391,7 +470,7 @@ SMB_STRUCT_DIRENT *sys_readdir(DIR *dirp)
  A seekdir wrapper that will deal with 64 bit filesizes.
 ********************************************************************/
 
-void sys_seekdir(DIR *dirp, long offset)
+void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset)
 {
 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_SEEKDIR64)
        seekdir64(dirp, offset);
@@ -404,7 +483,7 @@ void sys_seekdir(DIR *dirp, long offset)
  A telldir wrapper that will deal with 64 bit filesizes.
 ********************************************************************/
 
-long sys_telldir(DIR *dirp)
+long sys_telldir(SMB_STRUCT_DIR *dirp)
 {
 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_TELLDIR64)
        return (long)telldir64(dirp);
@@ -417,7 +496,7 @@ long sys_telldir(DIR *dirp)
  A rewinddir wrapper that will deal with 64 bit filesizes.
 ********************************************************************/
 
-void sys_rewinddir(DIR *dirp)
+void sys_rewinddir(SMB_STRUCT_DIR *dirp)
 {
 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
        rewinddir64(dirp);
@@ -430,7 +509,7 @@ void sys_rewinddir(DIR *dirp)
  A close wrapper that will deal with 64 bit filesizes.
 ********************************************************************/
 
-int sys_closedir(DIR *dirp)
+int sys_closedir(SMB_STRUCT_DIR *dirp)
 {
 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
        return closedir64(dirp);
@@ -562,6 +641,25 @@ int sys_chown(const char *fname,uid_t uid,gid_t gid)
 #endif
 }
 
+/*******************************************************************
+ Wrapper for lchown.
+********************************************************************/
+
+int sys_lchown(const char *fname,uid_t uid,gid_t gid)
+{
+#ifndef HAVE_LCHOWN
+       static int done;
+       if (!done) {
+               DEBUG(1,("WARNING: no lchown!\n"));
+               done=1;
+       }
+       errno = ENOSYS;
+       return -1;
+#else
+       return(lchown(fname,uid,gid));
+#endif
+}
+
 /*******************************************************************
 os/2 also doesn't have chroot
 ********************************************************************/
@@ -623,85 +721,125 @@ struct hostent *sys_gethostbyname(const char *name)
 }
 
 
-#if defined(HAVE_IRIX_SPECIFIC_CAPABILITIES)
-/**************************************************************************
- Try and abstract process capabilities (for systems that have them).
-****************************************************************************/
-static BOOL set_process_capability( uint32 cap_flag, BOOL enable )
-{
-       if(cap_flag == KERNEL_OPLOCK_CAPABILITY) {
-               cap_t cap = cap_get_proc();
+#if defined(HAVE_POSIX_CAPABILITIES)
 
-               if (cap == NULL) {
-                       DEBUG(0,("set_process_capability: cap_get_proc failed. Error was %s\n",
-                               strerror(errno)));
-                       return False;
-               }
+#ifdef HAVE_SYS_CAPABILITY_H
 
-               if(enable)
-                       cap->cap_effective |= CAP_NETWORK_MGT;
-               else
-                       cap->cap_effective &= ~CAP_NETWORK_MGT;
+#if defined(BROKEN_REDHAT_7_SYSTEM_HEADERS) && !defined(_I386_STATFS_H) && !defined(_PPC_STATFS_H)
+#define _I386_STATFS_H
+#define _PPC_STATFS_H
+#define BROKEN_REDHAT_7_STATFS_WORKAROUND
+#endif
 
-               if (cap_set_proc(cap) == -1) {
-                       DEBUG(0,("set_process_capability: cap_set_proc failed. Error was %s\n",
-                               strerror(errno)));
-                       cap_free(cap);
-                       return False;
-               }
+#include <sys/capability.h>
 
-               cap_free(cap);
+#ifdef BROKEN_REDHAT_7_STATFS_WORKAROUND
+#undef _I386_STATFS_H
+#undef _PPC_STATFS_H
+#undef BROKEN_REDHAT_7_STATFS_WORKAROUND
+#endif
 
-               DEBUG(10,("set_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
-       }
-       return True;
-}
+#endif /* HAVE_SYS_CAPABILITY_H */
 
 /**************************************************************************
- Try and abstract inherited process capabilities (for systems that have them).
+ Try and abstract process capabilities (for systems that have them).
 ****************************************************************************/
 
-static BOOL set_inherited_process_capability( uint32 cap_flag, BOOL enable )
-{
-       if(cap_flag == KERNEL_OPLOCK_CAPABILITY) {
-               cap_t cap = cap_get_proc();
+/* Set the POSIX capabilities needed for the given purpose into the effective
+ * capability set of the current process. Make sure they are always removed
+ * from the inheritable set, because there is no circumstance in which our
+ * children should inherit our elevated privileges.
+ */
+static BOOL set_process_capability(enum smbd_capability capability,
+                                  BOOL enable)
+{
+       cap_value_t cap_vals[2] = {0};
+       int num_cap_vals = 0;
+
+       cap_t cap;
+
+#if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
+       /* On Linux, make sure that any capabilities we grab are sticky
+        * across UID changes. We expect that this would allow us to keep both
+        * the effective and permitted capability sets, but as of circa 2.6.16,
+        * only the permitted set is kept. It is a bug (which we work around)
+        * that the effective set is lost, but we still require the effective
+        * set to be kept.
+        */
+       if (!prctl(PR_GET_KEEPCAPS)) {
+               prctl(PR_SET_KEEPCAPS, 1);
+       }
+#endif
 
-               if (cap == NULL) {
-                       DEBUG(0,("set_inherited_process_capability: cap_get_proc failed. Error was %s\n",
-                               strerror(errno)));
-                       return False;
-               }
+       cap = cap_get_proc();
+       if (cap == NULL) {
+               DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
+                       strerror(errno)));
+               return False;
+       }
 
-               if(enable)
-                       cap->cap_inheritable |= CAP_NETWORK_MGT;
-               else
-                       cap->cap_inheritable &= ~CAP_NETWORK_MGT;
+       switch (capability) {
+               case KERNEL_OPLOCK_CAPABILITY:
+#ifdef CAP_NETWORK_MGT
+                       /* IRIX has CAP_NETWORK_MGT for oplocks. */
+                       cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
+#endif
+                       break;
+               case DMAPI_ACCESS_CAPABILITY:
+#ifdef CAP_DEVICE_MGT
+                       /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
+                       cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
+#elif CAP_MKNOD
+                       /* Linux has CAP_MKNOD for DMAPI access. */
+                       cap_vals[num_cap_vals++] = CAP_MKNOD;
+#endif
+                       break;
+       }
 
-               if (cap_set_proc(cap) == -1) {
-                       DEBUG(0,("set_inherited_process_capability: cap_set_proc failed. Error was %s\n", 
-                               strerror(errno)));
-                       cap_free(cap);
-                       return False;
-               }
+       SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
 
+       if (num_cap_vals == 0) {
                cap_free(cap);
+               return True;
+       }
+
+       cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
+               enable ? CAP_SET : CAP_CLEAR);
 
-               DEBUG(10,("set_inherited_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
+       /* We never want to pass capabilities down to our children, so make
+        * sure they are not inherited.
+        */
+       cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
+
+       if (cap_set_proc(cap) == -1) {
+               DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
+                       strerror(errno)));
+               cap_free(cap);
+               return False;
        }
+
+       cap_free(cap);
        return True;
 }
-#endif
+
+#endif /* HAVE_POSIX_CAPABILITIES */
 
 /****************************************************************************
  Gain the oplock capability from the kernel if possible.
 ****************************************************************************/
 
-void oplock_set_capability(BOOL this_process, BOOL inherit)
+void set_effective_capability(enum smbd_capability capability)
 {
-#if HAVE_KERNEL_OPLOCKS_IRIX
-       set_process_capability(KERNEL_OPLOCK_CAPABILITY,this_process);
-       set_inherited_process_capability(KERNEL_OPLOCK_CAPABILITY,inherit);
-#endif
+#if defined(HAVE_POSIX_CAPABILITIES)
+       set_process_capability(capability, True);
+#endif /* HAVE_POSIX_CAPABILITIES */
+}
+
+void drop_effective_capability(enum smbd_capability capability)
+{
+#if defined(HAVE_POSIX_CAPABILITIES)
+       set_process_capability(capability, False);
+#endif /* HAVE_POSIX_CAPABILITIES */
 }
 
 /**************************************************************************
@@ -751,15 +889,13 @@ int groups_max(void)
 }
 
 /**************************************************************************
- Wrapper for getgroups. Deals with broken (int) case.
+ Wrap setgroups and getgroups for systems that declare getgroups() as
+ returning an array of gid_t, but actuall return an array of int.
 ****************************************************************************/
 
-int sys_getgroups(int setlen, gid_t *gidset)
+#if defined(HAVE_BROKEN_GETGROUPS)
+static int sys_broken_getgroups(int setlen, gid_t *gidset)
 {
-#if !defined(HAVE_BROKEN_GETGROUPS)
-       return getgroups(setlen, gidset);
-#else
-
        GID_T gid;
        GID_T *group_list;
        int i, ngroups;
@@ -781,7 +917,7 @@ int sys_getgroups(int setlen, gid_t *gidset)
        if (setlen == 0)
                setlen = groups_max();
 
-       if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
+       if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
                DEBUG(0,("sys_getgroups: Malloc fail.\n"));
                return -1;
        }
@@ -798,26 +934,10 @@ int sys_getgroups(int setlen, gid_t *gidset)
 
        SAFE_FREE(group_list);
        return ngroups;
-#endif /* HAVE_BROKEN_GETGROUPS */
 }
 
-
-/**************************************************************************
- Wrapper for setgroups. Deals with broken (int) case. Automatically used
- if we have broken getgroups.
-****************************************************************************/
-
-int sys_setgroups(int setlen, gid_t *gidset)
+static int sys_broken_setgroups(int setlen, gid_t *gidset)
 {
-#if !defined(HAVE_SETGROUPS)
-       errno = ENOSYS;
-       return -1;
-#endif /* HAVE_SETGROUPS */
-
-#if !defined(HAVE_BROKEN_GETGROUPS)
-       return setgroups(setlen, gidset);
-#else
-
        GID_T *group_list;
        int i ; 
 
@@ -834,7 +954,7 @@ int sys_setgroups(int setlen, gid_t *gidset)
         * GID_T array of size setlen.
         */
 
-       if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
+       if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
                DEBUG(0,("sys_setgroups: Malloc fail.\n"));
                return -1;    
        }
@@ -851,7 +971,105 @@ int sys_setgroups(int setlen, gid_t *gidset)
  
        SAFE_FREE(group_list);
        return 0 ;
+}
+
 #endif /* HAVE_BROKEN_GETGROUPS */
+
+/* This is a list of systems that require the first GID passed to setgroups(2)
+ * to be the effective GID. If your system is one of these, add it here.
+ */
+#if defined (FREEBSD) || defined (DARWINOS)
+#define USE_BSD_SETGROUPS
+#endif
+
+#if defined(USE_BSD_SETGROUPS)
+/* Depending on the particular BSD implementation, the first GID that is
+ * passed to setgroups(2) will either be ignored or will set the credential's
+ * effective GID. In either case, the right thing to do is to guarantee that
+ * gidset[0] is the effective GID.
+ */
+static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
+{
+       gid_t *new_gidset = NULL;
+       int max;
+       int ret;
+
+       /* setgroups(2) will fail with EINVAL if we pass too many groups. */
+       max = groups_max();
+
+       /* No group list, just make sure we are setting the efective GID. */
+       if (setlen == 0) {
+               return setgroups(1, &primary_gid);
+       }
+
+       /* If the primary gid is not the first array element, grow the array
+        * and insert it at the front.
+        */
+       if (gidset[0] != primary_gid) {
+               new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
+               if (new_gidset == NULL) {
+                       return -1;
+               }
+
+               memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
+               new_gidset[0] = primary_gid;
+               setlen++;
+       }
+
+       if (setlen > max) {
+               DEBUG(3, ("forced to truncate group list from %d to %d\n",
+                       setlen, max));
+               setlen = max;
+       }
+
+#if defined(HAVE_BROKEN_GETGROUPS)
+       ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
+#else
+       ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
+#endif
+
+       if (new_gidset) {
+               int errsav = errno;
+               SAFE_FREE(new_gidset);
+               errno = errsav;
+       }
+
+       return ret;
+}
+
+#endif /* USE_BSD_SETGROUPS */
+
+/**************************************************************************
+ Wrapper for getgroups. Deals with broken (int) case.
+****************************************************************************/
+
+int sys_getgroups(int setlen, gid_t *gidset)
+{
+#if defined(HAVE_BROKEN_GETGROUPS)
+       return sys_broken_getgroups(setlen, gidset);
+#else
+       return getgroups(setlen, gidset);
+#endif
+}
+
+/**************************************************************************
+ Wrapper for setgroups. Deals with broken (int) case and BSD case.
+****************************************************************************/
+
+int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
+{
+#if !defined(HAVE_SETGROUPS)
+       errno = ENOSYS;
+       return -1;
+#endif /* HAVE_SETGROUPS */
+
+#if defined(USE_BSD_SETGROUPS)
+       return sys_bsd_setgroups(primary_gid, setlen, gidset);
+#elif defined(HAVE_BROKEN_GETGROUPS)
+       return sys_broken_setgroups(setlen, gidset);
+#else
+       return setgroups(setlen, gidset);
+#endif
 }
 
 /**************************************************************************
@@ -877,6 +1095,82 @@ void sys_endpwent(void)
  Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
 ****************************************************************************/
 
+#ifdef ENABLE_BUILD_FARM_HACKS
+
+/*
+ * In the build farm we want to be able to join machines to the domain. As we
+ * don't have root access, we need to bypass direct access to /etc/passwd
+ * after a user has been created via samr. Fake those users.
+ */
+
+static struct passwd *fake_pwd;
+static int num_fake_pwd;
+
+struct passwd *sys_getpwnam(const char *name)
+{
+       int i;
+
+       for (i=0; i<num_fake_pwd; i++) {
+               if (strcmp(fake_pwd[i].pw_name, name) == 0) {
+                       DEBUG(10, ("Returning fake user %s\n", name));
+                       return &fake_pwd[i];
+               }
+       }
+
+       return getpwnam(name);
+}
+
+struct passwd *sys_getpwuid(uid_t uid)
+{
+       int i;
+
+       for (i=0; i<num_fake_pwd; i++) {
+               if (fake_pwd[i].pw_uid == uid) {
+                       DEBUG(10, ("Returning fake user %s\n",
+                                  fake_pwd[i].pw_name));
+                       return &fake_pwd[i];
+               }
+       }
+
+       return getpwuid(uid);
+}
+
+void faked_create_user(const char *name)
+{
+       int i;
+       uid_t uid;
+       struct passwd new_pwd;
+
+       for (i=0; i<10; i++) {
+               generate_random_buffer((unsigned char *)&uid,
+                                      sizeof(uid));
+               if (getpwuid(uid) == NULL) {
+                       break;
+               }
+       }
+
+       if (i==10) {
+               /* Weird. No free uid found... */
+               return;
+       }
+
+       new_pwd.pw_name = SMB_STRDUP(name);
+       new_pwd.pw_passwd = SMB_STRDUP("x");
+       new_pwd.pw_uid = uid;
+       new_pwd.pw_gid = 100;
+       new_pwd.pw_gecos = SMB_STRDUP("faked user");
+       new_pwd.pw_dir = SMB_STRDUP("/nodir");
+       new_pwd.pw_shell = SMB_STRDUP("/bin/false");
+
+       ADD_TO_ARRAY(NULL, struct passwd, new_pwd, &fake_pwd,
+                    &num_fake_pwd);
+
+       DEBUG(10, ("Added fake user %s, have %d fake users\n",
+                  name, num_fake_pwd));
+}
+
+#else
+
 struct passwd *sys_getpwnam(const char *name)
 {
        return getpwnam(name);
@@ -887,6 +1181,8 @@ struct passwd *sys_getpwuid(uid_t uid)
        return getpwuid(uid);
 }
 
+#endif
+
 struct group *sys_getgrnam(const char *name)
 {
        return getgrnam(name);
@@ -959,7 +1255,7 @@ FILE *wsys_fopen(const smb_ucs2_t *wfname, const char *type)
  Wide opendir. Just narrow and call sys_xxx.
 ****************************************************************************/
 
-DIR *wsys_opendir(const smb_ucs2_t *wfname)
+SMB_STRUCT_DIR *wsys_opendir(const smb_ucs2_t *wfname)
 {
        pstring fname;
        return opendir(unicode_to_unix(fname,wfname,sizeof(fname)));
@@ -969,7 +1265,7 @@ DIR *wsys_opendir(const smb_ucs2_t *wfname)
  Wide readdir. Return a structure pointer containing a wide filename.
 ****************************************************************************/
 
-SMB_STRUCT_WDIRENT *wsys_readdir(DIR *dirp)
+SMB_STRUCT_WDIRENT *wsys_readdir(SMB_STRUCT_DIR *dirp)
 {
        static SMB_STRUCT_WDIRENT retval;
        SMB_STRUCT_DIRENT *dirval = sys_readdir(dirp);
@@ -1070,21 +1366,25 @@ SMB_STRUCT_WPASSWD *wsys_getpwuid(uid_t uid)
 #endif /* NOT CURRENTLY USED - JRA */
 
 /**************************************************************************
- Extract a command into an arg list. Uses a static pstring for storage.
- Caller frees returned arg list (which contains pointers into the static pstring).
+ Extract a command into an arg list.
 ****************************************************************************/
 
-static char **extract_args(const char *command)
+static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
 {
-       static pstring trunc_cmd;
+       char *trunc_cmd;
+       char *saveptr;
        char *ptr;
        int argcl;
        char **argl = NULL;
        int i;
 
-       pstrcpy(trunc_cmd, command);
+       if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
+               DEBUG(0, ("talloc failed\n"));
+               goto nomem;
+       }
 
-       if(!(ptr = strtok(trunc_cmd, " \t"))) {
+       if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
+               TALLOC_FREE(trunc_cmd);
                errno = EINVAL;
                return NULL;
        }
@@ -1093,27 +1393,46 @@ static char **extract_args(const char *command)
         * Count the args.
         */
 
-       for( argcl = 1; ptr; ptr = strtok(NULL, " \t"))
+       for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
                argcl++;
 
-       if((argl = (char **)SMB_MALLOC((argcl + 1) * sizeof(char *))) == NULL)
-               return NULL;
+       TALLOC_FREE(trunc_cmd);
+
+       if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
+               goto nomem;
+       }
 
        /*
         * Now do the extraction.
         */
 
-       pstrcpy(trunc_cmd, command);
+       if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
+               goto nomem;
+       }
 
-       ptr = strtok(trunc_cmd, " \t");
+       ptr = strtok_r(trunc_cmd, " \t", &saveptr);
        i = 0;
-       argl[i++] = ptr;
 
-       while((ptr = strtok(NULL, " \t")) != NULL)
-               argl[i++] = ptr;
+       if (!(argl[i++] = talloc_strdup(argl, ptr))) {
+               goto nomem;
+       }
+
+       while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
+
+               if (!(argl[i++] = talloc_strdup(argl, ptr))) {
+                       goto nomem;
+               }
+       }
 
        argl[i++] = NULL;
        return argl;
+
+ nomem:
+       DEBUG(0, ("talloc failed\n"));
+       TALLOC_FREE(trunc_cmd);
+       TALLOC_FREE(argl);
+       errno = ENOMEM;
+       return NULL;
 }
 
 /**************************************************************************
@@ -1187,7 +1506,7 @@ int sys_popen(const char *command)
         * Extract the command and args into a NULL terminated array.
         */
 
-       if(!(argl = extract_args(command)))
+       if(!(argl = extract_args(NULL, command)))
                goto err_exit;
 
        entry->child_pid = sys_fork();
@@ -1229,7 +1548,7 @@ int sys_popen(const char *command)
         */
 
        close (child_end);
-       SAFE_FREE(argl);
+       TALLOC_FREE(argl);
 
        /* Link into popen_chain. */
        entry->next = popen_chain;
@@ -1366,17 +1685,46 @@ int sys_dup2(int oldfd, int newfd)
 
 /**************************************************************************
  Wrappers for extented attribute calls. Based on the Linux package with
- support for IRIX also. Expand as other systems have them.
+ support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
 ****************************************************************************/
 
 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
 {
 #if defined(HAVE_GETXATTR)
+#ifndef XATTR_ADD_OPT
        return getxattr(path, name, value, size);
+#else
+       int options = 0;
+       return getxattr(path, name, value, size, 0, options);
+#endif
+#elif defined(HAVE_GETEA)
+       return getea(path, name, value, size);
+#elif defined(HAVE_EXTATTR_GET_FILE)
+       char *s;
+       ssize_t retval;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+       /*
+        * The BSD implementation has a nasty habit of silently truncating
+        * the returned value to the size of the buffer, so we have to check
+        * that the buffer is large enough to fit the returned value.
+        */
+       if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
+               if(retval > size) {
+                       errno = ERANGE;
+                       return -1;
+               }
+               if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
+                       return retval;
+       }
+
+       DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
+       return -1;
 #elif defined(HAVE_ATTR_GET)
        int retval, flags = 0;
        int valuelength = (int)size;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
@@ -1393,10 +1741,33 @@ ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t s
 {
 #if defined(HAVE_LGETXATTR)
        return lgetxattr(path, name, value, size);
+#elif defined(HAVE_GETXATTR) && defined(XATTR_ADD_OPT)
+       int options = XATTR_NOFOLLOW;
+       return getxattr(path, name, value, size, 0, options);
+#elif defined(HAVE_LGETEA)
+       return lgetea(path, name, value, size);
+#elif defined(HAVE_EXTATTR_GET_LINK)
+       char *s;
+       ssize_t retval;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+
+       if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
+               if(retval > size) {
+                       errno = ERANGE;
+                       return -1;
+               }
+               if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
+                       return retval;
+       }
+       
+       DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
+       return -1;
 #elif defined(HAVE_ATTR_GET)
        int retval, flags = ATTR_DONTFOLLOW;
        int valuelength = (int)size;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
@@ -1412,11 +1783,36 @@ ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t s
 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
 {
 #if defined(HAVE_FGETXATTR)
+#ifndef XATTR_ADD_OPT
        return fgetxattr(filedes, name, value, size);
+#else
+       int options = 0;
+       return fgetxattr(filedes, name, value, size, 0, options);
+#endif
+#elif defined(HAVE_FGETEA)
+       return fgetea(filedes, name, value, size);
+#elif defined(HAVE_EXTATTR_GET_FD)
+       char *s;
+       ssize_t retval;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+
+       if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
+               if(retval > size) {
+                       errno = ERANGE;
+                       return -1;
+               }
+               if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
+                       return retval;
+       }
+       
+       DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
+       return -1;
 #elif defined(HAVE_ATTR_GETF)
        int retval, flags = 0;
        int valuelength = (int)size;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
@@ -1429,6 +1825,99 @@ ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
 #endif
 }
 
+#if defined(HAVE_EXTATTR_LIST_FILE)
+
+#define EXTATTR_PREFIX(s)      (s), (sizeof((s))-1)
+
+static struct {
+        int space;
+       const char *name;
+       size_t len;
+} 
+extattr[] = {
+       { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
+        { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
+};
+
+typedef union {
+       const char *path;
+       int filedes;
+} extattr_arg;
+
+static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
+{
+       ssize_t list_size, total_size = 0;
+       int i, t, len;
+       char *buf;
+       /* Iterate through extattr(2) namespaces */
+       for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
+               switch(type) {
+#if defined(HAVE_EXTATTR_LIST_FILE)
+                       case 0:
+                               list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
+                               break;
+#endif
+#if defined(HAVE_EXTATTR_LIST_LINK)
+                       case 1:
+                               list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
+                               break;
+#endif
+#if defined(HAVE_EXTATTR_LIST_FD)
+                       case 2:
+                               list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
+                               break;
+#endif
+                       default:
+                               errno = ENOSYS;
+                               return -1;
+               }
+               /* Some error happend. Errno should be set by the previous call */
+               if(list_size < 0)
+                       return -1;
+               /* No attributes */
+               if(list_size == 0)
+                       continue;
+               /* XXX: Call with an empty buffer may be used to calculate
+                  necessary buffer size. Unfortunately, we can't say, how
+                  many attributes were returned, so here is the potential
+                  problem with the emulation.
+               */
+               if(list == NULL) {
+                       /* Take the worse case of one char attribute names - 
+                          two bytes per name plus one more for sanity.
+                       */
+                       total_size += list_size + (list_size/2 + 1)*extattr[t].len;
+                       continue;
+               }
+               /* Count necessary offset to fit namespace prefixes */
+               len = 0;
+               for(i = 0; i < list_size; i += list[i] + 1)
+                       len += extattr[t].len;
+
+               total_size += list_size + len;
+               /* Buffer is too small to fit the results */
+               if(total_size > size) {
+                       errno = ERANGE;
+                       return -1;
+               }
+               /* Shift results back, so we can prepend prefixes */
+               buf = memmove(list + len, list, list_size);
+
+               for(i = 0; i < list_size; i += len + 1) {
+                       len = buf[i];
+                       strncpy(list, extattr[t].name, extattr[t].len + 1);
+                       list += extattr[t].len;
+                       strncpy(list, buf + i + 1, len);
+                       list[len] = '\0';
+                       list += len + 1;
+               }
+               size -= total_size;
+       }
+       return total_size;
+}
+
+#endif
+
 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
 static char attr_buffer[ATTR_MAX_VALUELEN];
 
@@ -1500,7 +1989,18 @@ static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t
 ssize_t sys_listxattr (const char *path, char *list, size_t size)
 {
 #if defined(HAVE_LISTXATTR)
+#ifndef XATTR_ADD_OPT
        return listxattr(path, list, size);
+#else
+       int options = 0;
+       return listxattr(path, list, size, options);
+#endif
+#elif defined(HAVE_LISTEA)
+       return listea(path, list, size);
+#elif defined(HAVE_EXTATTR_LIST_FILE)
+       extattr_arg arg;
+       arg.path = path;
+       return bsd_attr_list(0, arg, list, size);
 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
        return irix_attr_list(path, 0, list, size, 0);
 #else
@@ -1513,6 +2013,15 @@ ssize_t sys_llistxattr (const char *path, char *list, size_t size)
 {
 #if defined(HAVE_LLISTXATTR)
        return llistxattr(path, list, size);
+#elif defined(HAVE_LISTXATTR) && defined(XATTR_ADD_OPT)
+       int options = XATTR_NOFOLLOW;
+       return listxattr(path, list, size, options);
+#elif defined(HAVE_LLISTEA)
+       return llistea(path, list, size);
+#elif defined(HAVE_EXTATTR_LIST_LINK)
+       extattr_arg arg;
+       arg.path = path;
+       return bsd_attr_list(1, arg, list, size);
 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
        return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW);
 #else
@@ -1524,7 +2033,18 @@ ssize_t sys_llistxattr (const char *path, char *list, size_t size)
 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
 {
 #if defined(HAVE_FLISTXATTR)
+#ifndef XATTR_ADD_OPT
        return flistxattr(filedes, list, size);
+#else
+       int options = 0;
+       return flistxattr(filedes, list, size, options);
+#endif
+#elif defined(HAVE_FLISTEA)
+       return flistea(filedes, list, size);
+#elif defined(HAVE_EXTATTR_LIST_FD)
+       extattr_arg arg;
+       arg.filedes = filedes;
+       return bsd_attr_list(2, arg, list, size);
 #elif defined(HAVE_ATTR_LISTF)
        return irix_attr_list(NULL, filedes, list, size, 0);
 #else
@@ -1536,10 +2056,24 @@ ssize_t sys_flistxattr (int filedes, char *list, size_t size)
 int sys_removexattr (const char *path, const char *name)
 {
 #if defined(HAVE_REMOVEXATTR)
+#ifndef XATTR_ADD_OPT
        return removexattr(path, name);
+#else
+       int options = 0;
+       return removexattr(path, name, options);
+#endif
+#elif defined(HAVE_REMOVEEA)
+       return removeea(path, name);
+#elif defined(HAVE_EXTATTR_DELETE_FILE)
+       char *s;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+
+       return extattr_delete_file(path, attrnamespace, attrname);
 #elif defined(HAVE_ATTR_REMOVE)
        int flags = 0;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
@@ -1554,9 +2088,21 @@ int sys_lremovexattr (const char *path, const char *name)
 {
 #if defined(HAVE_LREMOVEXATTR)
        return lremovexattr(path, name);
+#elif defined(HAVE_REMOVEXATTR) && defined(XATTR_ADD_OPT)
+       int options = XATTR_NOFOLLOW;
+       return removexattr(path, name, options);
+#elif defined(HAVE_LREMOVEEA)
+       return lremoveea(path, name);
+#elif defined(HAVE_EXTATTR_DELETE_LINK)
+       char *s;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+
+       return extattr_delete_link(path, attrnamespace, attrname);
 #elif defined(HAVE_ATTR_REMOVE)
        int flags = ATTR_DONTFOLLOW;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
@@ -1570,10 +2116,24 @@ int sys_lremovexattr (const char *path, const char *name)
 int sys_fremovexattr (int filedes, const char *name)
 {
 #if defined(HAVE_FREMOVEXATTR)
+#ifndef XATTR_ADD_OPT
        return fremovexattr(filedes, name);
+#else
+       int options = 0;
+       return fremovexattr(filedes, name, options);
+#endif
+#elif defined(HAVE_FREMOVEEA)
+       return fremoveea(filedes, name);
+#elif defined(HAVE_EXTATTR_DELETE_FD)
+       char *s;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+
+       return extattr_delete_fd(filedes, attrnamespace, attrname);
 #elif defined(HAVE_ATTR_REMOVEF)
        int flags = 0;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
@@ -1592,10 +2152,44 @@ int sys_fremovexattr (int filedes, const char *name)
 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
 {
 #if defined(HAVE_SETXATTR)
+#ifndef XATTR_ADD_OPT
        return setxattr(path, name, value, size, flags);
+#else
+       int options = 0;
+       return setxattr(path, name, value, size, 0, options);
+#endif
+#elif defined(HAVE_SETEA)
+       return setea(path, name, value, size, flags);
+#elif defined(HAVE_EXTATTR_SET_FILE)
+       char *s;
+       int retval = 0;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+       if (flags) {
+               /* Check attribute existence */
+               retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
+               if (retval < 0) {
+                       /* REPLACE attribute, that doesn't exist */
+                       if (flags & XATTR_REPLACE && errno == ENOATTR) {
+                               errno = ENOATTR;
+                               return -1;
+                       }
+                       /* Ignore other errors */
+               }
+               else {
+                       /* CREATE attribute, that already exists */
+                       if (flags & XATTR_CREATE) {
+                               errno = EEXIST;
+                               return -1;
+                       }
+               }
+       }
+       retval = extattr_set_file(path, attrnamespace, attrname, value, size);
+       return (retval < 0) ? -1 : 0;
 #elif defined(HAVE_ATTR_SET)
        int myflags = 0;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
        if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
@@ -1612,9 +2206,42 @@ int sys_lsetxattr (const char *path, const char *name, const void *value, size_t
 {
 #if defined(HAVE_LSETXATTR)
        return lsetxattr(path, name, value, size, flags);
+#elif defined(HAVE_SETXATTR) && defined(XATTR_ADD_OPT)
+       int options = XATTR_NOFOLLOW;
+       return setxattr(path, name, value, size, 0, options);
+#elif defined(LSETEA)
+       return lsetea(path, name, value, size, flags);
+#elif defined(HAVE_EXTATTR_SET_LINK)
+       char *s;
+       int retval = 0;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+       if (flags) {
+               /* Check attribute existence */
+               retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
+               if (retval < 0) {
+                       /* REPLACE attribute, that doesn't exist */
+                       if (flags & XATTR_REPLACE && errno == ENOATTR) {
+                               errno = ENOATTR;
+                               return -1;
+                       }
+                       /* Ignore other errors */
+               }
+               else {
+                       /* CREATE attribute, that already exists */
+                       if (flags & XATTR_CREATE) {
+                               errno = EEXIST;
+                               return -1;
+                       }
+               }
+       }
+
+       retval = extattr_set_link(path, attrnamespace, attrname, value, size);
+       return (retval < 0) ? -1 : 0;
 #elif defined(HAVE_ATTR_SET)
        int myflags = ATTR_DONTFOLLOW;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
        if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
@@ -1630,10 +2257,44 @@ int sys_lsetxattr (const char *path, const char *name, const void *value, size_t
 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
 {
 #if defined(HAVE_FSETXATTR)
+#ifndef XATTR_ADD_OPT
        return fsetxattr(filedes, name, value, size, flags);
+#else
+       int options = 0;
+       return fsetxattr(filedes, name, value, size, 0, options);
+#endif
+#elif defined(HAVE_FSETEA)
+       return fsetea(filedes, name, value, size, flags);
+#elif defined(HAVE_EXTATTR_SET_FD)
+       char *s;
+       int retval = 0;
+       int attrnamespace = (strncmp(name, "system", 6) == 0) ? 
+               EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
+       const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
+       if (flags) {
+               /* Check attribute existence */
+               retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
+               if (retval < 0) {
+                       /* REPLACE attribute, that doesn't exist */
+                       if (flags & XATTR_REPLACE && errno == ENOATTR) {
+                               errno = ENOATTR;
+                               return -1;
+                       }
+                       /* Ignore other errors */
+               }
+               else {
+                       /* CREATE attribute, that already exists */
+                       if (flags & XATTR_CREATE) {
+                               errno = EEXIST;
+                               return -1;
+                       }
+               }
+       }
+       retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
+       return (retval < 0) ? -1 : 0;
 #elif defined(HAVE_ATTR_SETF)
        int myflags = 0;
-       char *attrname = strchr(name,'.') +1;
+       char *attrname = strchr(name,'.') + 1;
        
        if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
        if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
@@ -1671,3 +2332,186 @@ uint32 unix_dev_minor(SMB_DEV_T dev)
         return (uint32)(dev & 0xff);
 #endif
 }
+
+#if defined(WITH_AIO)
+
+/*******************************************************************
+ An aio_read wrapper that will deal with 64-bit sizes.
+********************************************************************/
+                                                                                                                                           
+int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
+{
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
+        return aio_read64(aiocb);
+#elif defined(HAVE_AIO_READ)
+        return aio_read(aiocb);
+#else
+       errno = ENOSYS;
+       return -1;
+#endif
+}
+
+/*******************************************************************
+ An aio_write wrapper that will deal with 64-bit sizes.
+********************************************************************/
+                                                                                                                                           
+int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
+{
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
+        return aio_write64(aiocb);
+#elif defined(HAVE_AIO_WRITE)
+        return aio_write(aiocb);
+#else
+       errno = ENOSYS;
+       return -1;
+#endif
+}
+
+/*******************************************************************
+ An aio_return wrapper that will deal with 64-bit sizes.
+********************************************************************/
+                                                                                                                                           
+ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
+{
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
+        return aio_return64(aiocb);
+#elif defined(HAVE_AIO_RETURN)
+        return aio_return(aiocb);
+#else
+       errno = ENOSYS;
+       return -1;
+#endif
+}
+
+/*******************************************************************
+ An aio_cancel wrapper that will deal with 64-bit sizes.
+********************************************************************/
+
+int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
+{
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
+        return aio_cancel64(fd, aiocb);
+#elif defined(HAVE_AIO_CANCEL)
+        return aio_cancel(fd, aiocb);
+#else
+       errno = ENOSYS;
+       return -1;
+#endif
+}
+
+/*******************************************************************
+ An aio_error wrapper that will deal with 64-bit sizes.
+********************************************************************/
+
+int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
+{
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
+        return aio_error64(aiocb);
+#elif defined(HAVE_AIO_ERROR)
+        return aio_error(aiocb);
+#else
+       errno = ENOSYS;
+       return -1;
+#endif
+}
+
+/*******************************************************************
+ An aio_fsync wrapper that will deal with 64-bit sizes.
+********************************************************************/
+
+int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
+{
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64)
+        return aio_fsync64(op, aiocb);
+#elif defined(HAVE_AIO_FSYNC)
+        return aio_fsync(op, aiocb);
+#else
+       errno = ENOSYS;
+       return -1;
+#endif
+}
+
+/*******************************************************************
+ An aio_fsync wrapper that will deal with 64-bit sizes.
+********************************************************************/
+
+int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
+{
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64)
+        return aio_suspend64(cblist, n, timeout);
+#elif defined(HAVE_AIO_FSYNC)
+        return aio_suspend(cblist, n, timeout);
+#else
+       errno = ENOSYS;
+       return -1;
+#endif
+}
+#else /* !WITH_AIO */
+
+int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
+{
+       errno = ENOSYS;
+       return -1;
+}
+
+int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
+{
+       errno = ENOSYS;
+       return -1;
+}
+
+ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
+{
+       errno = ENOSYS;
+       return -1;
+}
+
+int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
+{
+       errno = ENOSYS;
+       return -1;
+}
+
+int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
+{
+       errno = ENOSYS;
+       return -1;
+}
+
+int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
+{
+       errno = ENOSYS;
+       return -1;
+}
+
+int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
+{
+       errno = ENOSYS;
+       return -1;
+}
+#endif /* WITH_AIO */
+
+int sys_getpeereid( int s, uid_t *uid)
+{
+#if defined(HAVE_PEERCRED)
+       struct ucred cred;
+       socklen_t cred_len = sizeof(struct ucred);
+       int ret;
+
+       ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
+       if (ret != 0) {
+               return -1;
+       }
+
+       if (cred_len != sizeof(struct ucred)) {
+               errno = EINVAL;
+               return -1;
+       }
+
+       *uid = cred.uid;
+       return 0;
+#else
+       errno = ENOSYS;
+       return -1;
+#endif
+}