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>
-/*******************************************************************
- 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.
********************************************************************/
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;
}
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;
}
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;
}
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.
-********************************************************************/
-
-int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
+static struct timespec get_mtimespec(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_mtime;
+ ret.tv_nsec = 0;
+ return ret;
#else
- ret = stat(fname, sbuf);
-#endif
- /* we always want directories to appear zero size */
- if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
+#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
}
-/*******************************************************************
- An fstat() wrapper that will deal with 64 bit filesizes.
-********************************************************************/
-
-int sys_fstat(int fd,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_FSTAT64)
- ret = fstat64(fd, 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 = fstat(fd, 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;
}
-/*******************************************************************
- An lstat() wrapper that will deal with 64 bit filesizes.
-********************************************************************/
+/****************************************************************************
+ Return the best approximation to a 'create time' under UNIX from a stat_ex
+ structure.
+****************************************************************************/
-int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
+static struct timespec calc_create_time_stat_ex(const struct stat_ex *st)
{
- 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 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;
}
-/*******************************************************************
- An ftruncate() wrapper that will deal with 64 bit filesizes.
-********************************************************************/
+/****************************************************************************
+ Return the 'create time' from a stat struct if it exists (birthtime) or else
+ use the best approximation.
+****************************************************************************/
-int sys_ftruncate(int fd, SMB_OFF_T offset)
+static void make_create_timespec(const struct stat *pst, struct stat_ex *dst,
+ bool fake_dir_create_times)
{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
- return ftruncate64(fd, offset);
+ 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
- return ftruncate(fd, offset);
+ 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;
+ }
}
-/*******************************************************************
- An lseek() wrapper that will deal with 64 bit filesizes.
-********************************************************************/
+/****************************************************************************
+ 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;
+}
-SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
+void init_stat_ex_from_stat (struct stat_ex *dst,
+ const struct stat *src,
+ bool fake_dir_create_times)
{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
- return lseek64(fd, offset, whence);
+ 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
- return lseek(fd, offset, whence);
+ 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 fseek() wrapper that will deal with 64 bit filesizes.
+A stat() wrapper.
********************************************************************/
-int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
+int sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf,
+ bool fake_dir_create_times)
{
-#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);
-#else
- return fseek(fp, offset, whence);
-#endif
+ int ret;
+ 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 ftell() wrapper that will deal with 64 bit filesizes.
+ An fstat() wrapper.
********************************************************************/
-SMB_OFF_T sys_ftell(FILE *fp)
+int sys_fstat(int fd, SMB_STRUCT_STAT *sbuf, bool fake_dir_create_times)
{
-#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
+ int ret;
+ 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;
}
/*******************************************************************
- A creat() wrapper that will deal with 64 bit filesizes.
+ An lstat() wrapper.
********************************************************************/
-int sys_creat(const char *path, mode_t mode)
+int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
+ bool fake_dir_create_times)
{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
- return creat64(path, mode);
-#else
- /*
- * If creat64 isn't defined then ensure we call a potential open64.
- * JRA.
- */
- return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
-#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 open() 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;
-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);
+ /* 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 open(path, oflag, mode);
+ return ENOSYS;
#endif
}
/*******************************************************************
- An fopen() wrapper that will deal with 64 bit filesizes.
+ An fallocate() function that matches the semantics of the Linux one.
********************************************************************/
-FILE *sys_fopen(const char *path, const char *type)
+#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(HAVE_FOPEN64)
- return fopen64(path, type);
+#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 fopen(path, type);
+ /* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
+ errno = ENOSYS;
+ return -1;
#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;
/*******************************************************************
- An opendir wrapper that will deal with 64 bit filesizes.
-********************************************************************/
-
-SMB_STRUCT_DIR *sys_opendir(const char *name)
-{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
- return opendir64(name);
-#else
- return opendir(name);
-#endif
-}
-
-/*******************************************************************
- A readdir wrapper that will deal with 64 bit filesizes.
+ An fdopendir wrapper.
+ Ugly hack - we need dirfd for this to work correctly in the
+ calling code.. JRA.
********************************************************************/
-SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
+DIR *sys_fdopendir(int fd)
{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
- return readdir64(dirp);
+#if defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD)
+ return fdopendir(fd);
#else
- return readdir(dirp);
-#endif
-}
-
-/*******************************************************************
- A seekdir wrapper that will deal with 64 bit filesizes.
-********************************************************************/
-
-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.
-********************************************************************/
-
-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.
-********************************************************************/
-
-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.
-********************************************************************/
-
-int sys_closedir(SMB_STRUCT_DIR *dirp)
-{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
- return closedir64(dirp);
-#else
- return closedir(dirp);
+ errno = ENOSYS;
+ return NULL;
#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;
}
/*******************************************************************
- System wrapper for getwd
+ System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
+ on error (malloc fail usually).
********************************************************************/
-char *sys_getwd(char *s)
+char *sys_getwd(void)
{
- char *wd;
-#ifdef HAVE_GETCWD
- wd = (char *)getcwd(s, PATH_MAX);
+#ifdef GETCWD_TAKES_NULL
+ return getcwd(NULL, 0);
+#elif HAVE_GETCWD
+ char *wd = NULL, *s = NULL;
+ size_t allocated = PATH_MAX;
+
+ 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;
+ }
+ }
+ return wd;
#else
- wd = (char *)getwd(s);
+ char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
+ if (s == NULL) {
+ return NULL;
+ }
+ return getwd(s);
#endif
- return wd;
}
#if defined(HAVE_POSIX_CAPABILITIES)
#endif
}
+#ifndef NGROUPS_MAX
+#define NGROUPS_MAX 32 /* Guess... */
+#endif
+
/**************************************************************************
Returns equivalent to NGROUPS_MAX - using sysconf if needed.
****************************************************************************/
****************************************************************************/
#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;
DEBUG(0,("sys_setgroups: Malloc fail.\n"));
return -1;
}
-
+
for(i = 0; i < setlen; i++)
group_list[i] = (GID_T) gidset[i];
errno = saved_errno;
return -1;
}
-
+
SAFE_FREE(group_list);
return 0 ;
}
#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.
****************************************************************************/
TALLOC_FREE(trunc_cmd);
- if (!(argl = TALLOC_ARRAY(mem_ctx, char *, argcl + 1))) {
+ if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
goto nomem;
}
}
argl[i++] = NULL;
+ TALLOC_FREE(trunc_cmd);
return argl;
nomem:
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.
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;
err_exit:
SAFE_FREE(entry);
- SAFE_FREE(argl);
+ TALLOC_FREE(argl);
close(pipe_fds[0]);
close(pipe_fds[1]);
return -1;
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);
-
- return retval ? retval : valuelength;
-#elif defined(HAVE_ATTROPEN)
- ssize_t ret = -1;
- int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
- if (attrfd >= 0) {
- ret = solaris_read_xattr(attrfd, value, size);
- close(attrfd);
- }
- return ret;
-#else
- errno = ENOSYS;
- return -1;
-#endif
-}
-
-ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
-{
-#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;
-
if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
return retval ? retval : valuelength;
#elif defined(HAVE_ATTROPEN)
ssize_t ret = -1;
- int attrfd = solaris_attropen(path, name, O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
+ int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
if (attrfd >= 0) {
ret = solaris_read_xattr(attrfd, value, size);
close(attrfd);
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);
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:
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];
#endif
}
-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);
-#elif defined(HAVE_ATTROPEN)
- ssize_t ret = -1;
- int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
- if (attrdirfd >= 0) {
- ret = solaris_list_xattr(attrdirfd, list, size);
- close(attrdirfd);
- }
- return ret;
-#else
- errno = ENOSYS;
- return -1;
-#endif
-}
-
ssize_t sys_flistxattr (int filedes, char *list, size_t size)
{
#if defined(HAVE_FLISTXATTR)
#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);
#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);
#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);
#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;
#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;
#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;
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);
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));
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;
}
}
}
{
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 {
/****************************************************************************
Return the major devicenumber for UNIX extensions.
****************************************************************************/
-
+
uint32 unix_dev_major(SMB_DEV_T dev)
{
#if defined(HAVE_DEVICE_MAJOR_FN)
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)
#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;
}
/*******************************************************************
- 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;
}
/*******************************************************************
- 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;
}
/*******************************************************************
- 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;
}
/*******************************************************************
- 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;
}
/*******************************************************************
- 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;
}
/*******************************************************************
- 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;
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);
-}
git.samba.org / kai / samba.git / blobdiff