X-Git-Url: http://git.samba.org/?a=blobdiff_plain;f=source3%2Flib%2Fsystem.c;h=08d13e6f2bff0682d5b296151c80c831b77d6934;hb=43e9be8894a2eaf883453de78acbade7b391a53e;hp=fa50955ef64cedee89a0d247fd78d74736617e74;hpb=c4fbe2846231a6b322c1094c6a1dbf93b7305768;p=samba.git

diff --git a/source3/lib/system.c b/source3/lib/system.c
index fa50955ef64..08d13e6f2bf 100644
--- a/source3/lib/system.c
+++ b/source3/lib/system.c
@@ -5,22 +5,30 @@
    Copyright (C) Jeremy Allison  1998-2005
    Copyright (C) Timur Bakeyev        2005
    Copyright (C) Bjoern Jacke    2006-2007
-   
+
    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
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
+#include "system/syslog.h"
+#include "system/capability.h"
+#include "system/passwd.h"
+#include "system/filesys.h"
+
+#ifdef HAVE_SYS_SYSCTL_H
+#include <sys/sysctl.h>
+#endif
 
 #ifdef HAVE_SYS_PRCTL_H
 #include <sys/prctl.h>
@@ -43,76 +51,6 @@
 
 
 
-/*******************************************************************
- 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.
-********************************************************************/
-
-int sys_usleep(long usecs)
-{
-#ifndef HAVE_USLEEP
-	struct timeval tval;
-#endif
-
-	/*
-	 * We need this braindamage as the glibc usleep
-	 * is not SPEC1170 complient... grumble... JRA.
-	 */
-
-	if(usecs < 0 || usecs > 1000000) {
-		errno = EINVAL;
-		return -1;
-	}
-
-#if HAVE_USLEEP
-	usleep(usecs);
-	return 0;
-#else /* HAVE_USLEEP */
-	/*
-	 * Fake it with select...
-	 */
-	tval.tv_sec = 0;
-	tval.tv_usec = usecs/1000;
-	select(0,NULL,NULL,NULL,&tval);
-	return 0;
-#endif /* HAVE_USLEEP */
-}
-
 /*******************************************************************
 A read wrapper that will deal with EINTR.
 ********************************************************************/
@@ -123,7 +61,11 @@ ssize_t sys_read(int fd, void *buf, size_t count)
 
 	do {
 		ret = read(fd, buf, count);
-	} while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
 	return ret;
 }
 
@@ -137,89 +79,90 @@ ssize_t sys_write(int fd, const void *buf, size_t count)
 
 	do {
 		ret = write(fd, buf, count);
-	} while (ret == -1 && errno == EINTR);
-	return ret;
-}
-
-/*******************************************************************
-A pread wrapper that will deal with EINTR and 64-bit file offsets.
-********************************************************************/
-
-#if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
-ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
-{
-	ssize_t ret;
-
-	do {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PREAD64)
-		ret = pread64(fd, buf, count, off);
+#if defined(EWOULDBLOCK)
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
 #else
-		ret = pread(fd, buf, count, off);
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 #endif
-	} while (ret == -1 && errno == EINTR);
 	return ret;
 }
-#endif
 
 /*******************************************************************
-A write wrapper that will deal with EINTR and 64-bit file offsets.
+A writev wrapper that will deal with EINTR.
 ********************************************************************/
 
-#if defined(HAVE_PWRITE) || defined(HAVE_PWRITE64)
-ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off)
+ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt)
 {
 	ssize_t ret;
 
+#if 0
+	/* Try to confuse write_data_iov a bit */
+	if ((random() % 5) == 0) {
+		return sys_write(fd, iov[0].iov_base, iov[0].iov_len);
+	}
+	if (iov[0].iov_len > 1) {
+		return sys_write(fd, iov[0].iov_base,
+				 (random() % (iov[0].iov_len-1)) + 1);
+	}
+#endif
+
 	do {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64)
-		ret = pwrite64(fd, buf, count, off);
+		ret = writev(fd, iov, iovcnt);
+#if defined(EWOULDBLOCK)
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
 #else
-		ret = pwrite(fd, buf, count, off);
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 #endif
-	} while (ret == -1 && errno == EINTR);
 	return ret;
 }
-#endif
 
 /*******************************************************************
-A send wrapper that will deal with EINTR.
+A pread wrapper that will deal with EINTR
 ********************************************************************/
 
-ssize_t sys_send(int s, const void *msg, size_t len, int flags)
+#if defined(HAVE_PREAD)
+ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
 {
 	ssize_t ret;
 
 	do {
-		ret = send(s, msg, len, flags);
+		ret = pread(fd, buf, count, off);
 	} while (ret == -1 && errno == EINTR);
 	return ret;
 }
+#endif
 
 /*******************************************************************
-A sendto wrapper that will deal with EINTR.
+A write wrapper that will deal with EINTR
 ********************************************************************/
 
-ssize_t sys_sendto(int s,  const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
+#if defined(HAVE_PWRITE)
+ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off)
 {
 	ssize_t ret;
 
 	do {
-		ret = sendto(s, msg, len, flags, to, tolen);
+		ret = pwrite(fd, buf, count, off);
 	} while (ret == -1 && errno == EINTR);
 	return ret;
 }
+#endif
 
 /*******************************************************************
-A recv wrapper that will deal with EINTR.
+A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
 ********************************************************************/
 
-ssize_t sys_recv(int fd, void *buf, size_t count, int flags)
+ssize_t sys_send(int s, const void *msg, size_t len, int flags)
 {
 	ssize_t ret;
 
 	do {
-		ret = recv(fd, buf, count, flags);
-	} while (ret == -1 && errno == EINTR);
+		ret = send(s, msg, len, flags);
+#if defined(EWOULDBLOCK)
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
 	return ret;
 }
 
@@ -233,7 +176,11 @@ ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *f
 
 	do {
 		ret = recvfrom(s, buf, len, flags, from, fromlen);
-	} while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+	} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
 	return ret;
 }
 
@@ -251,176 +198,451 @@ int sys_fcntl_ptr(int fd, int cmd, void *arg)
 	return ret;
 }
 
-/*******************************************************************
-A fcntl wrapper that will deal with EINTR.
-********************************************************************/
+/****************************************************************************
+ Get/Set all the possible time fields from a stat struct as a timespec.
+****************************************************************************/
 
-int sys_fcntl_long(int fd, int cmd, long arg)
+static struct timespec get_atimespec(const struct stat *pst)
 {
-	int ret;
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+	struct timespec ret;
 
-	do {
-		ret = fcntl(fd, cmd, arg);
-	} while (ret == -1 && errno == EINTR);
+	/* Old system - no ns timestamp. */
+	ret.tv_sec = pst->st_atime;
+	ret.tv_nsec = 0;
+	return ret;
+#else
+#if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
+	return pst->st_atim;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
+	struct timespec ret;
+	ret.tv_sec = pst->st_atime;
+	ret.tv_nsec = pst->st_atimensec;
+	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
+	struct timespec ret;
+	ret.tv_sec = pst->st_atime;
+	ret.tv_nsec = pst->st_atime_n;
 	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
+	struct timespec ret;
+	ret.tv_sec = pst->st_atime;
+	ret.tv_nsec = pst->st_uatime * 1000;
+	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
+	return pst->st_atimespec;
+#else
+#error	CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
 }
 
-/*******************************************************************
-A stat() wrapper that will deal with 64 bit filesizes.
-********************************************************************/
+static struct timespec get_mtimespec(const struct stat *pst)
+{
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+	struct timespec ret;
+
+	/* Old system - no ns timestamp. */
+	ret.tv_sec = pst->st_mtime;
+	ret.tv_nsec = 0;
+	return ret;
+#else
+#if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
+	return pst->st_mtim;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
+	struct timespec ret;
+	ret.tv_sec = pst->st_mtime;
+	ret.tv_nsec = pst->st_mtimensec;
+	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
+	struct timespec ret;
+	ret.tv_sec = pst->st_mtime;
+	ret.tv_nsec = pst->st_mtime_n;
+	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
+	struct timespec ret;
+	ret.tv_sec = pst->st_mtime;
+	ret.tv_nsec = pst->st_umtime * 1000;
+	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
+	return pst->st_mtimespec;
+#else
+#error	CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
+}
 
-int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
+static struct timespec get_ctimespec(const struct stat *pst)
 {
-	int ret;
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
-	ret = stat64(fname, sbuf);
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+	struct timespec ret;
+
+	/* Old system - no ns timestamp. */
+	ret.tv_sec = pst->st_ctime;
+	ret.tv_nsec = 0;
+	return ret;
 #else
-	ret = stat(fname, sbuf);
+#if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
+	return pst->st_ctim;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
+	struct timespec ret;
+	ret.tv_sec = pst->st_ctime;
+	ret.tv_nsec = pst->st_ctimensec;
+	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
+	struct timespec ret;
+	ret.tv_sec = pst->st_ctime;
+	ret.tv_nsec = pst->st_ctime_n;
+	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
+	struct timespec ret;
+	ret.tv_sec = pst->st_ctime;
+	ret.tv_nsec = pst->st_uctime * 1000;
+	return ret;
+#elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
+	return pst->st_ctimespec;
+#else
+#error	CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
 #endif
-	/* we always want directories to appear zero size */
-	if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
+}
+
+/****************************************************************************
+ Return the best approximation to a 'create time' under UNIX from a stat
+ structure.
+****************************************************************************/
+
+static struct timespec calc_create_time_stat(const struct stat *st)
+{
+	struct timespec ret, ret1;
+	struct timespec c_time = get_ctimespec(st);
+	struct timespec m_time = get_mtimespec(st);
+	struct timespec a_time = get_atimespec(st);
+
+	ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
+	ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
+
+	if(!null_timespec(ret1)) {
+		return ret1;
+	}
+
+	/*
+	 * One of ctime, mtime or atime was zero (probably atime).
+	 * Just return MIN(ctime, mtime).
+	 */
+	return ret;
+}
+
+/****************************************************************************
+ Return the best approximation to a 'create time' under UNIX from a stat_ex
+ structure.
+****************************************************************************/
+
+static struct timespec calc_create_time_stat_ex(const struct stat_ex *st)
+{
+	struct timespec ret, ret1;
+	struct timespec c_time = st->st_ex_ctime;
+	struct timespec m_time = st->st_ex_mtime;
+	struct timespec a_time = st->st_ex_atime;
+
+	ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
+	ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
+
+	if(!null_timespec(ret1)) {
+		return ret1;
+	}
+
+	/*
+	 * One of ctime, mtime or atime was zero (probably atime).
+	 * Just return MIN(ctime, mtime).
+	 */
 	return ret;
 }
 
+/****************************************************************************
+ Return the 'create time' from a stat struct if it exists (birthtime) or else
+ use the best approximation.
+****************************************************************************/
+
+static void make_create_timespec(const struct stat *pst, struct stat_ex *dst,
+				 bool fake_dir_create_times)
+{
+	if (S_ISDIR(pst->st_mode) && fake_dir_create_times) {
+		dst->st_ex_btime.tv_sec = 315493200L;          /* 1/1/1980 */
+		dst->st_ex_btime.tv_nsec = 0;
+	}
+
+	dst->st_ex_calculated_birthtime = false;
+
+#if defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
+	dst->st_ex_btime = pst->st_birthtimespec;
+#elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC)
+	dst->st_ex_btime.tv_sec = pst->st_birthtime;
+	dst->st_ex_btime.tv_nsec = pst->st_birthtimenspec;
+#elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIME)
+	dst->st_ex_btime.tv_sec = pst->st_birthtime;
+	dst->st_ex_btime.tv_nsec = 0;
+#else
+	dst->st_ex_btime = calc_create_time_stat(pst);
+	dst->st_ex_calculated_birthtime = true;
+#endif
+
+	/* Deal with systems that don't initialize birthtime correctly.
+	 * Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
+	 */
+	if (null_timespec(dst->st_ex_btime)) {
+		dst->st_ex_btime = calc_create_time_stat(pst);
+		dst->st_ex_calculated_birthtime = true;
+	}
+}
+
+/****************************************************************************
+ If we update a timestamp in a stat_ex struct we may have to recalculate
+ the birthtime. For now only implement this for write time, but we may
+ also need to do it for atime and ctime. JRA.
+****************************************************************************/
+
+void update_stat_ex_mtime(struct stat_ex *dst,
+				struct timespec write_ts)
+{
+	dst->st_ex_mtime = write_ts;
+
+	/* We may have to recalculate btime. */
+	if (dst->st_ex_calculated_birthtime) {
+		dst->st_ex_btime = calc_create_time_stat_ex(dst);
+	}
+}
+
+void update_stat_ex_create_time(struct stat_ex *dst,
+                                struct timespec create_time)
+{
+	dst->st_ex_btime = create_time;
+	dst->st_ex_calculated_birthtime = false;
+}
+
+void init_stat_ex_from_stat (struct stat_ex *dst,
+			    const struct stat *src,
+			    bool fake_dir_create_times)
+{
+	dst->st_ex_dev = src->st_dev;
+	dst->st_ex_ino = src->st_ino;
+	dst->st_ex_mode = src->st_mode;
+	dst->st_ex_nlink = src->st_nlink;
+	dst->st_ex_uid = src->st_uid;
+	dst->st_ex_gid = src->st_gid;
+	dst->st_ex_rdev = src->st_rdev;
+	dst->st_ex_size = src->st_size;
+	dst->st_ex_atime = get_atimespec(src);
+	dst->st_ex_mtime = get_mtimespec(src);
+	dst->st_ex_ctime = get_ctimespec(src);
+	make_create_timespec(src, dst, fake_dir_create_times);
+#ifdef HAVE_STAT_ST_BLKSIZE
+	dst->st_ex_blksize = src->st_blksize;
+#else
+	dst->st_ex_blksize = STAT_ST_BLOCKSIZE;
+#endif
+
+#ifdef HAVE_STAT_ST_BLOCKS
+	dst->st_ex_blocks = src->st_blocks;
+#else
+	dst->st_ex_blocks = src->st_size / dst->st_ex_blksize + 1;
+#endif
+
+#ifdef HAVE_STAT_ST_FLAGS
+	dst->st_ex_flags = src->st_flags;
+#else
+	dst->st_ex_flags = 0;
+#endif
+}
+
 /*******************************************************************
- An fstat() wrapper that will deal with 64 bit filesizes.
+A stat() wrapper.
 ********************************************************************/
 
-int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
+int sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf,
+	     bool fake_dir_create_times)
 {
 	int ret;
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
-	ret = fstat64(fd, sbuf);
-#else
-	ret = fstat(fd, sbuf);
-#endif
-	/* we always want directories to appear zero size */
-	if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
+	struct stat statbuf;
+	ret = stat(fname, &statbuf);
+	if (ret == 0) {
+		/* we always want directories to appear zero size */
+		if (S_ISDIR(statbuf.st_mode)) {
+			statbuf.st_size = 0;
+		}
+		init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
+	}
 	return ret;
 }
 
 /*******************************************************************
- An lstat() wrapper that will deal with 64 bit filesizes.
+ An fstat() wrapper.
 ********************************************************************/
 
-int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
+int sys_fstat(int fd, SMB_STRUCT_STAT *sbuf, bool fake_dir_create_times)
 {
 	int ret;
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
-	ret = lstat64(fname, sbuf);
-#else
-	ret = lstat(fname, sbuf);
-#endif
-	/* we always want directories to appear zero size */
-	if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
+	struct stat statbuf;
+	ret = fstat(fd, &statbuf);
+	if (ret == 0) {
+		/* we always want directories to appear zero size */
+		if (S_ISDIR(statbuf.st_mode)) {
+			statbuf.st_size = 0;
+		}
+		init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
+	}
 	return ret;
 }
 
 /*******************************************************************
- An ftruncate() wrapper that will deal with 64 bit filesizes.
+ An lstat() wrapper.
 ********************************************************************/
 
-int sys_ftruncate(int fd, SMB_OFF_T offset)
+int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
+	      bool fake_dir_create_times)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
-	return ftruncate64(fd, offset);
-#else
-	return ftruncate(fd, offset);
-#endif
+	int ret;
+	struct stat statbuf;
+	ret = lstat(fname, &statbuf);
+	if (ret == 0) {
+		/* we always want directories to appear zero size */
+		if (S_ISDIR(statbuf.st_mode)) {
+			statbuf.st_size = 0;
+		}
+		init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
+	}
+	return ret;
 }
 
 /*******************************************************************
- An lseek() wrapper that will deal with 64 bit filesizes.
+ An posix_fallocate() wrapper.
 ********************************************************************/
+int sys_posix_fallocate(int fd, SMB_OFF_T offset, SMB_OFF_T len)
+{
+#if defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
+	return posix_fallocate(fd, offset, len);
+#elif defined(F_RESVSP64)
+	/* this handles XFS on IRIX */
+	struct flock64 fl;
+	SMB_OFF_T new_len = offset + len;
+	int ret;
+	struct stat64 sbuf;
 
-SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
-{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
-	return lseek64(fd, offset, whence);
+	/* unlikely to get a too large file on a 64bit system but ... */
+	if (new_len < 0)
+		return EFBIG;
+
+	fl.l_whence = SEEK_SET;
+	fl.l_start = offset;
+	fl.l_len = len;
+
+	ret=fcntl(fd, F_RESVSP64, &fl);
+
+	if (ret != 0)
+		return errno;
+
+	/* Make sure the file gets enlarged after we allocated space: */
+	fstat64(fd, &sbuf);
+	if (new_len > sbuf.st_size)
+		ftruncate64(fd, new_len);
+	return 0;
 #else
-	return lseek(fd, offset, whence);
+	return ENOSYS;
 #endif
 }
 
 /*******************************************************************
- An fseek() wrapper that will deal with 64 bit filesizes.
+ An fallocate() function that matches the semantics of the Linux one.
 ********************************************************************/
 
-int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
+#ifdef HAVE_LINUX_FALLOC_H
+#include <linux/falloc.h>
+#endif
+
+int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
-	return fseek64(fp, offset, whence);
-#elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
-	return fseeko64(fp, offset, whence);
+#if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE)
+	int lmode;
+	switch (mode) {
+	case VFS_FALLOCATE_EXTEND_SIZE:
+		lmode = 0;
+		break;
+	case VFS_FALLOCATE_KEEP_SIZE:
+		lmode = FALLOC_FL_KEEP_SIZE;
+		break;
+	default:
+		errno = EINVAL;
+		return -1;
+	}
+#if defined(HAVE_LINUX_FALLOCATE)
+	return fallocate(fd, lmode, offset, len);
+#endif
 #else
-	return fseek(fp, offset, whence);
+	/* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
+	errno = ENOSYS;
+	return -1;
 #endif
 }
 
 /*******************************************************************
- An ftell() wrapper that will deal with 64 bit filesizes.
+ An ftell() wrapper.
 ********************************************************************/
 
 SMB_OFF_T sys_ftell(FILE *fp)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
-	return (SMB_OFF_T)ftell64(fp);
-#elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
-	return (SMB_OFF_T)ftello64(fp);
-#else
 	return (SMB_OFF_T)ftell(fp);
-#endif
 }
 
 /*******************************************************************
- A creat() wrapper that will deal with 64 bit filesizes.
+ A creat() wrapper.
 ********************************************************************/
 
 int sys_creat(const char *path, mode_t mode)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
-	return creat64(path, mode);
+#if defined(HAVE_CREAT)
+	return creat(path, mode);
 #else
 	/*
-	 * If creat64 isn't defined then ensure we call a potential open64.
-	 * JRA.
+	 * If creat isn't defined then ensure we call open with the expected flags.
+	 *
 	 */
 	return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
 #endif
 }
 
 /*******************************************************************
- An open() wrapper that will deal with 64 bit filesizes.
+ An open() wrapper.
 ********************************************************************/
 
 int sys_open(const char *path, int oflag, mode_t mode)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
-	return open64(path, oflag, mode);
-#else
 	return open(path, oflag, mode);
-#endif
 }
 
 /*******************************************************************
- An fopen() wrapper that will deal with 64 bit filesizes.
+ An fopen() wrapper.
 ********************************************************************/
 
 FILE *sys_fopen(const char *path, const char *type)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
-	return fopen64(path, type);
-#else
 	return fopen(path, type);
-#endif
 }
 
 
+#if HAVE_KERNEL_SHARE_MODES
+#ifndef LOCK_MAND
+#define LOCK_MAND	32	/* This is a mandatory flock */
+#define LOCK_READ	64	/* ... Which allows concurrent read operations */
+#define LOCK_WRITE	128	/* ... Which allows concurrent write operations */
+#define LOCK_RW		192	/* ... Which allows concurrent read & write ops */
+#endif
+#endif
+
 /*******************************************************************
  A flock() wrapper that will perform the kernel flock.
 ********************************************************************/
 
-void kernel_flock(int fd, uint32 share_mode)
+void kernel_flock(int fd, uint32 share_mode, uint32 access_mask)
 {
 #if HAVE_KERNEL_SHARE_MODES
 	int kernel_mode = 0;
@@ -441,95 +663,83 @@ void kernel_flock(int fd, uint32 share_mode)
 
 
 /*******************************************************************
- An opendir wrapper that will deal with 64 bit filesizes.
+ An opendir wrapper.
 ********************************************************************/
 
 SMB_STRUCT_DIR *sys_opendir(const char *name)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
-	return opendir64(name);
-#else
 	return opendir(name);
+}
+
+/*******************************************************************
+ An fdopendir wrapper.
+ Ugly hack - we need dirfd for this to work correctly in the
+ calling code.. JRA.
+********************************************************************/
+
+SMB_STRUCT_DIR *sys_fdopendir(int fd)
+{
+#if defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD)
+	return fdopendir(fd);
+#else
+	errno = ENOSYS;
+	return NULL;
 #endif
 }
 
 /*******************************************************************
- A readdir wrapper that will deal with 64 bit filesizes.
+ A readdir wrapper.
 ********************************************************************/
 
 SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
-	return readdir64(dirp);
-#else
 	return readdir(dirp);
-#endif
 }
 
 /*******************************************************************
- A seekdir wrapper that will deal with 64 bit filesizes.
+ A seekdir wrapper.
 ********************************************************************/
 
 void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_SEEKDIR64)
-	seekdir64(dirp, offset);
-#else
 	seekdir(dirp, offset);
-#endif
 }
 
 /*******************************************************************
- A telldir wrapper that will deal with 64 bit filesizes.
+ A telldir wrapper.
 ********************************************************************/
 
 long sys_telldir(SMB_STRUCT_DIR *dirp)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_TELLDIR64)
-	return (long)telldir64(dirp);
-#else
 	return (long)telldir(dirp);
-#endif
 }
 
 /*******************************************************************
- A rewinddir wrapper that will deal with 64 bit filesizes.
+ A rewinddir wrapper.
 ********************************************************************/
 
 void sys_rewinddir(SMB_STRUCT_DIR *dirp)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
-	rewinddir64(dirp);
-#else
 	rewinddir(dirp);
-#endif
 }
 
 /*******************************************************************
- A close wrapper that will deal with 64 bit filesizes.
+ A close wrapper.
 ********************************************************************/
 
 int sys_closedir(SMB_STRUCT_DIR *dirp)
 {
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
-	return closedir64(dirp);
-#else
 	return closedir(dirp);
-#endif
 }
 
 /*******************************************************************
- An mknod() wrapper that will deal with 64 bit filesizes.
+ An mknod() wrapper.
 ********************************************************************/
 
 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
 {
-#if defined(HAVE_MKNOD) || defined(HAVE_MKNOD64)
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_MKNOD64) && defined(HAVE_DEV64_T)
-	return mknod64(path, mode, dev);
-#else
+#if defined(HAVE_MKNOD)
 	return mknod(path, mode, dev);
-#endif
 #else
 	/* No mknod system call. */
 	errno = ENOSYS;
@@ -537,21 +747,6 @@ int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
 #endif
 }
 
-/*******************************************************************
- Wrapper for realpath.
-********************************************************************/
-
-char *sys_realpath(const char *path, char *resolved_path)
-{
-#if defined(HAVE_REALPATH)
-	return realpath(path, resolved_path);
-#else
-	/* As realpath is not a system call we can't return ENOSYS. */
-	errno = EINVAL;
-	return NULL;
-#endif
-}
-
 /*******************************************************************
 The wait() calls vary between systems
 ********************************************************************/
@@ -566,115 +761,44 @@ int sys_waitpid(pid_t pid,int *status,int options)
 }
 
 /*******************************************************************
- System wrapper for getwd
-********************************************************************/
-
-char *sys_getwd(char *s)
-{
-	char *wd;
-#ifdef HAVE_GETCWD
-	wd = (char *)getcwd(s, PATH_MAX);
-#else
-	wd = (char *)getwd(s);
-#endif
-	return wd;
-}
-
-/*******************************************************************
-system wrapper for symlink
-********************************************************************/
-
-int sys_symlink(const char *oldpath, const char *newpath)
-{
-#ifndef HAVE_SYMLINK
-	errno = ENOSYS;
-	return -1;
-#else
-	return symlink(oldpath, newpath);
-#endif
-}
-
-/*******************************************************************
-system wrapper for readlink
-********************************************************************/
-
-int sys_readlink(const char *path, char *buf, size_t bufsiz)
-{
-#ifndef HAVE_READLINK
-	errno = ENOSYS;
-	return -1;
-#else
-	return readlink(path, buf, bufsiz);
-#endif
-}
-
-/*******************************************************************
-system wrapper for link
-********************************************************************/
-
-int sys_link(const char *oldpath, const char *newpath)
-{
-#ifndef HAVE_LINK
-	errno = ENOSYS;
-	return -1;
-#else
-	return link(oldpath, newpath);
-#endif
-}
-
-/*******************************************************************
-chown isn't used much but OS/2 doesn't have it
+ System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
+ on error (malloc fail usually).
 ********************************************************************/
 
-int sys_chown(const char *fname,uid_t uid,gid_t gid)
+char *sys_getwd(void)
 {
-#ifndef HAVE_CHOWN
-	static int done;
-	if (!done) {
-		DEBUG(1,("WARNING: no chown!\n"));
-		done=1;
-	}
-	errno = ENOSYS;
-	return -1;
-#else
-	return(chown(fname,uid,gid));
-#endif
-}
+#ifdef GETCWD_TAKES_NULL
+	return getcwd(NULL, 0);
+#elif HAVE_GETCWD
+	char *wd = NULL, *s = NULL;
+	size_t allocated = PATH_MAX;
 
-/*******************************************************************
- 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;
+	while (1) {
+		s = SMB_REALLOC_ARRAY(s, char, allocated);
+		if (s == NULL) {
+			return NULL;
+		}
+		wd = getcwd(s, allocated);
+		if (wd) {
+			break;
+		}
+		if (errno != ERANGE) {
+			SAFE_FREE(s);
+			break;
+		}
+		allocated *= 2;
+		if (allocated < PATH_MAX) {
+			SAFE_FREE(s);
+			break;
+		}
 	}
-	errno = ENOSYS;
-	return -1;
+	return wd;
 #else
-	return(lchown(fname,uid,gid));
-#endif
-}
-
-/*******************************************************************
-os/2 also doesn't have chroot
-********************************************************************/
-int sys_chroot(const char *dname)
-{
-#ifndef HAVE_CHROOT
-	static int done;
-	if (!done) {
-		DEBUG(1,("WARNING: no chroot!\n"));
-		done=1;
+	char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
+	if (s == NULL) {
+		return NULL;
 	}
-	errno = ENOSYS;
-	return -1;
-#else
-	return(chroot(dname));
+	return getwd(s);
 #endif
 }
 
@@ -731,6 +855,11 @@ static bool set_process_capability(enum smbd_capability capability,
 #elif CAP_MKNOD
 			/* Linux has CAP_MKNOD for DMAPI access. */
 			cap_vals[num_cap_vals++] = CAP_MKNOD;
+#endif
+			break;
+		case LEASE_CAPABILITY:
+#ifdef CAP_LEASE
+			cap_vals[num_cap_vals++] = CAP_LEASE;
 #endif
 			break;
 	}
@@ -813,6 +942,10 @@ void sys_srandom(unsigned int seed)
 #endif
 }
 
+#ifndef NGROUPS_MAX
+#define NGROUPS_MAX 32 /* Guess... */
+#endif
+
 /**************************************************************************
  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
 ****************************************************************************/
@@ -833,6 +966,13 @@ int groups_max(void)
 ****************************************************************************/
 
 #if defined(HAVE_BROKEN_GETGROUPS)
+
+#ifdef HAVE_BROKEN_GETGROUPS
+#define GID_T int
+#else
+#define GID_T gid_t
+#endif
+
 static int sys_broken_getgroups(int setlen, gid_t *gidset)
 {
 	GID_T gid;
@@ -897,7 +1037,7 @@ static int sys_broken_setgroups(int setlen, gid_t *gidset)
 		DEBUG(0,("sys_setgroups: Malloc fail.\n"));
 		return -1;    
 	}
- 
+
 	for(i = 0; i < setlen; i++) 
 		group_list[i] = (GID_T) gidset[i]; 
 
@@ -907,7 +1047,7 @@ static int sys_broken_setgroups(int setlen, gid_t *gidset)
 		errno = saved_errno;
 		return -1;
 	}
- 
+
 	SAFE_FREE(group_list);
 	return 0 ;
 }
@@ -1011,50 +1151,6 @@ int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
 #endif
 }
 
-/**************************************************************************
- Wrappers for setpwent(), getpwent() and endpwent()
-****************************************************************************/
-
-void sys_setpwent(void)
-{
-	setpwent();
-}
-
-struct passwd *sys_getpwent(void)
-{
-	return getpwent();
-}
-
-void sys_endpwent(void)
-{
-	endpwent();
-}
-
-/**************************************************************************
- Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
-****************************************************************************/
-
-
-struct passwd *sys_getpwnam(const char *name)
-{
-	return getpwnam(name);
-}
-
-struct passwd *sys_getpwuid(uid_t uid)
-{
-	return getpwuid(uid);
-}
-
-struct group *sys_getgrnam(const char *name)
-{
-	return getgrnam(name);
-}
-
-struct group *sys_getgrgid(gid_t gid)
-{
-	return getgrgid(gid);
-}
-
 /**************************************************************************
  Extract a command into an arg list.
 ****************************************************************************/
@@ -1088,7 +1184,7 @@ static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
 
 	TALLOC_FREE(trunc_cmd);
 
-	if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
+	if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
 		goto nomem;
 	}
 
@@ -1115,6 +1211,7 @@ static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
 	}
 
 	argl[i++] = NULL;
+	TALLOC_FREE(trunc_cmd);
 	return argl;
 
  nomem:
@@ -1125,35 +1222,6 @@ static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
 	return NULL;
 }
 
-/**************************************************************************
- Wrapper for fork. Ensures that mypid is reset. Used so we can write
- a sys_getpid() that only does a system call *once*.
-****************************************************************************/
-
-static pid_t mypid = (pid_t)-1;
-
-pid_t sys_fork(void)
-{
-	pid_t forkret = fork();
-
-	if (forkret == (pid_t)0) /* Child - reset mypid so sys_getpid does a system call. */
-		mypid = (pid_t) -1;
-
-	return forkret;
-}
-
-/**************************************************************************
- Wrapper for getpid. Ensures we only do a system call *once*.
-****************************************************************************/
-
-pid_t sys_getpid(void)
-{
-	if (mypid == (pid_t)-1)
-		mypid = getpid();
-
-	return mypid;
-}
-
 /**************************************************************************
  Wrapper for popen. Safer as it doesn't search a path.
  Modified from the glibc sources.
@@ -1199,7 +1267,7 @@ int sys_popen(const char *command)
 	if(!(argl = extract_args(NULL, command)))
 		goto err_exit;
 
-	entry->child_pid = sys_fork();
+	entry->child_pid = fork();
 
 	if (entry->child_pid == -1) {
 		goto err_exit;
@@ -1250,7 +1318,7 @@ int sys_popen(const char *command)
 err_exit:
 
 	SAFE_FREE(entry);
-	SAFE_FREE(argl);
+	TALLOC_FREE(argl);
 	close(pipe_fds[0]);
 	close(pipe_fds[1]);
 	return -1;
@@ -1298,56 +1366,6 @@ int sys_pclose(int fd)
 	return wstatus;
 }
 
-/**************************************************************************
- Wrappers for dlopen, dlsym, dlclose.
-****************************************************************************/
-
-void *sys_dlopen(const char *name, int flags)
-{
-#if defined(HAVE_DLOPEN)
-	return dlopen(name, flags);
-#else
-	return NULL;
-#endif
-}
-
-void *sys_dlsym(void *handle, const char *symbol)
-{
-#if defined(HAVE_DLSYM)
-    return dlsym(handle, symbol);
-#else
-    return NULL;
-#endif
-}
-
-int sys_dlclose (void *handle)
-{
-#if defined(HAVE_DLCLOSE)
-	return dlclose(handle);
-#else
-	return 0;
-#endif
-}
-
-const char *sys_dlerror(void)
-{
-#if defined(HAVE_DLERROR)
-	return dlerror();
-#else
-	return NULL;
-#endif
-}
-
-int sys_dup2(int oldfd, int newfd) 
-{
-#if defined(HAVE_DUP2)
-	return dup2(oldfd, newfd);
-#else
-	errno = ENOSYS;
-	return -1;
-#endif
-}
-
 /**************************************************************************
  Wrapper for Admin Logs.
 ****************************************************************************/
@@ -1426,7 +1444,7 @@ ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t si
 	int retval, flags = 0;
 	int valuelength = (int)size;
 	char *attrname = strchr(name,'.') + 1;
-	
+
 	if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
 	retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
@@ -1470,14 +1488,14 @@ ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t s
 		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;
-	
+
 	if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
 	retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
@@ -1523,14 +1541,14 @@ ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
 		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;
-	
+
 	if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
 	retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
@@ -1575,7 +1593,7 @@ static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size
 	int i, t, len;
 	char *buf;
 	/* Iterate through extattr(2) namespaces */
-	for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
+	for(t = 0; t < ARRAY_SIZE(extattr); t++) {
 		switch(type) {
 #if defined(HAVE_EXTATTR_LIST_FILE)
 			case 0:
@@ -1626,7 +1644,7 @@ static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size
 			return -1;
 		}
 		/* Shift results back, so we can prepend prefixes */
-		buf = memmove(list + len, list, list_size);
+		buf = (char *)memmove(list + len, list, list_size);
 
 		for(i = 0; i < list_size; i += len + 1) {
 			len = buf[i];
@@ -1823,7 +1841,7 @@ int sys_removexattr (const char *path, const char *name)
 #elif defined(HAVE_ATTR_REMOVE)
 	int flags = 0;
 	char *attrname = strchr(name,'.') + 1;
-	
+
 	if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
 	return attr_remove(path, attrname, flags);
@@ -1860,7 +1878,7 @@ int sys_lremovexattr (const char *path, const char *name)
 #elif defined(HAVE_ATTR_REMOVE)
 	int flags = ATTR_DONTFOLLOW;
 	char *attrname = strchr(name,'.') + 1;
-	
+
 	if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
 	return attr_remove(path, attrname, flags);
@@ -1899,7 +1917,7 @@ int sys_fremovexattr (int filedes, const char *name)
 #elif defined(HAVE_ATTR_REMOVEF)
 	int flags = 0;
 	char *attrname = strchr(name,'.') + 1;
-	
+
 	if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
 
 	return attr_removef(filedes, attrname, flags);
@@ -1958,7 +1976,7 @@ int sys_setxattr (const char *path, const char *name, const void *value, size_t
 #elif defined(HAVE_ATTR_SET)
 	int myflags = 0;
 	char *attrname = strchr(name,'.') + 1;
-	
+
 	if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
 	if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
 	if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
@@ -2022,7 +2040,7 @@ int sys_lsetxattr (const char *path, const char *name, const void *value, size_t
 #elif defined(HAVE_ATTR_SET)
 	int myflags = ATTR_DONTFOLLOW;
 	char *attrname = strchr(name,'.') + 1;
-	
+
 	if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
 	if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
 	if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
@@ -2087,7 +2105,7 @@ int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size
 #elif defined(HAVE_ATTR_SETF)
 	int myflags = 0;
 	char *attrname = strchr(name,'.') + 1;
-	
+
 	if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
 	if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
 	if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
@@ -2141,7 +2159,6 @@ static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
 {
 	ssize_t len = 0;
-	int stop = 0;
 	DIR *dirp;
 	struct dirent *de;
 	int newfd = dup(attrdirfd);
@@ -2152,7 +2169,7 @@ static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
 	dirp = fdopendir(newfd);
 
 	while ((de = readdir(dirp))) {
-		size_t listlen = strlen(de->d_name);
+		size_t listlen = strlen(de->d_name) + 1;
 		if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
 			/* we don't want "." and ".." here: */
 			DEBUG(10,("skipped EA %s\n",de->d_name));
@@ -2161,18 +2178,16 @@ static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
 
 		if (size == 0) {
 			/* return the current size of the list of extended attribute names*/
-			len += listlen + 1;
+			len += listlen;
 		} else {
 			/* check size and copy entrieѕ + nul into list. */
-			if ((len + listlen + 1) > size) {
+			if ((len + listlen) > size) {
 				errno = ERANGE;
 				len = -1;
 				break;
 			} else {
-				safe_strcpy(list + len, de->d_name, listlen);
+				strlcpy(list + len, de->d_name, listlen);
 				len += listlen;
-				list[len] = '\0';
-				++len;
 			}
 		}
 	}
@@ -2213,7 +2228,7 @@ static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
 {
 	int filedes = openat(fildes, path, oflag, mode);
 	if (filedes == -1) {
-		DEBUG(10,("openat FAILED: fd: %s, path: %s, errno: %s\n",filedes,path,strerror(errno)));
+		DEBUG(10,("openat FAILED: fd: %d, path: %s, errno: %s\n",filedes,path,strerror(errno)));
 		if (errno == EINVAL) {
 			errno = ENOTSUP;
 		} else {
@@ -2238,7 +2253,7 @@ static int solaris_write_xattr(int attrfd, const char *value, size_t size)
 /****************************************************************************
  Return the major devicenumber for UNIX extensions.
 ****************************************************************************/
-                                                                                                                
+
 uint32 unix_dev_major(SMB_DEV_T dev)
 {
 #if defined(HAVE_DEVICE_MAJOR_FN)
@@ -2247,11 +2262,11 @@ uint32 unix_dev_major(SMB_DEV_T dev)
         return (uint32)(dev >> 8);
 #endif
 }
-                                                                                                                
+
 /****************************************************************************
  Return the minor devicenumber for UNIX extensions.
 ****************************************************************************/
-                                                                                                                
+
 uint32 unix_dev_minor(SMB_DEV_T dev)
 {
 #if defined(HAVE_DEVICE_MINOR_FN)
@@ -2261,17 +2276,62 @@ uint32 unix_dev_minor(SMB_DEV_T dev)
 #endif
 }
 
+#if 0
+/*******************************************************************
+ Return the number of CPUs.
+********************************************************************/
+
+int sys_get_number_of_cores(void)
+{
+	int ret = -1;
+
+#if defined(HAVE_SYSCONF)
+#if defined(_SC_NPROCESSORS_ONLN)
+	ret = (int)sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+#if defined(_SC_NPROCESSORS_CONF)
+	if (ret < 1) {
+		ret = (int)sysconf(_SC_NPROCESSORS_CONF);
+	}
+#endif
+#elif defined(HAVE_SYSCTL) && defined(CTL_HW)
+	int name[2];
+	unsigned int len = sizeof(ret);
+
+	name[0] = CTL_HW;
+#if defined(HW_AVAILCPU)
+	name[1] = HW_AVAILCPU;
+
+	if (sysctl(name, 2, &ret, &len, NULL, 0) == -1) {
+		ret = -1;
+	}
+#endif
+#if defined(HW_NCPU)
+	if(ret < 1) {
+		name[0] = CTL_HW;
+		name[1] = HW_NCPU;
+		if (sysctl(nm, 2, &count, &len, NULL, 0) == -1) {
+			ret = -1;
+		}
+	}
+#endif
+#endif
+	if (ret < 1) {
+		ret = 1;
+	}
+	return ret;
+}
+#endif
+
 #if defined(WITH_AIO)
 
 /*******************************************************************
- An aio_read wrapper that will deal with 64-bit sizes.
+ An aio_read wrapper.
 ********************************************************************/
-                                                                                                                                           
+
 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)
+#if defined(HAVE_AIO_READ)
         return aio_read(aiocb);
 #else
 	errno = ENOSYS;
@@ -2280,14 +2340,12 @@ int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
 }
 
 /*******************************************************************
- An aio_write wrapper that will deal with 64-bit sizes.
+ An aio_write wrapper.
 ********************************************************************/
-                                                                                                                                           
+
 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)
+#if defined(HAVE_AIO_WRITE)
         return aio_write(aiocb);
 #else
 	errno = ENOSYS;
@@ -2296,14 +2354,12 @@ int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
 }
 
 /*******************************************************************
- An aio_return wrapper that will deal with 64-bit sizes.
+ An aio_return wrapper.
 ********************************************************************/
-                                                                                                                                           
+
 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)
+#if defined(HAVE_AIO_RETURN)
         return aio_return(aiocb);
 #else
 	errno = ENOSYS;
@@ -2312,14 +2368,12 @@ ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
 }
 
 /*******************************************************************
- An aio_cancel wrapper that will deal with 64-bit sizes.
+ An aio_cancel wrapper.
 ********************************************************************/
 
 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)
+#if defined(HAVE_AIO_CANCEL)
         return aio_cancel(fd, aiocb);
 #else
 	errno = ENOSYS;
@@ -2328,14 +2382,12 @@ int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
 }
 
 /*******************************************************************
- An aio_error wrapper that will deal with 64-bit sizes.
+ An aio_error wrapper.
 ********************************************************************/
 
 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)
+#if defined(HAVE_AIO_ERROR)
         return aio_error(aiocb);
 #else
 	errno = ENOSYS;
@@ -2344,14 +2396,12 @@ int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
 }
 
 /*******************************************************************
- An aio_fsync wrapper that will deal with 64-bit sizes.
+ An aio_fsync wrapper.
 ********************************************************************/
 
 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)
+#if defined(HAVE_AIO_FSYNC)
         return aio_fsync(op, aiocb);
 #else
 	errno = ENOSYS;
@@ -2360,14 +2410,12 @@ int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
 }
 
 /*******************************************************************
- An aio_fsync wrapper that will deal with 64-bit sizes.
+ An aio_fsync wrapper.
 ********************************************************************/
 
 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)
+#if defined(HAVE_AIO_FSYNC)
         return aio_suspend(cblist, n, timeout);
 #else
 	errno = ENOSYS;
@@ -2418,70 +2466,3 @@ int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct
 	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
-}
-
-int sys_getnameinfo(const struct sockaddr *psa,
-			socklen_t salen,
-			char *host,
-			size_t hostlen,
-			char *service,
-			size_t servlen,
-			int flags)
-{
-	/*
-	 * For Solaris we must make sure salen is the
-	 * correct length for the incoming sa_family.
-	 */
-
-	if (salen == sizeof(struct sockaddr_storage)) {
-		salen = sizeof(struct sockaddr_in);
-#if defined(HAVE_IPV6)
-		if (psa->sa_family == AF_INET6) {
-			salen = sizeof(struct sockaddr_in6);
-		}
-#endif
-	}
-	return getnameinfo(psa, salen, host, hostlen, service, servlen, flags);
-}
-
-int sys_connect(int fd, const struct sockaddr * addr)
-{
-	socklen_t salen = -1;
-
-	if (addr->sa_family == AF_INET) {
-	    salen = sizeof(struct sockaddr_in);
-	} else if (addr->sa_family == AF_UNIX) {
-	    salen = sizeof(struct sockaddr_un);
-	}
-#if defined(HAVE_IPV6)
-	else if (addr->sa_family == AF_INET6) {
-	    salen = sizeof(struct sockaddr_in6);
-	}
-#endif
-
-	return connect(fd, addr, salen);
-}