diff options
Diffstat (limited to 'source3/lib/system.c')
| -rw-r--r-- | source3/lib/system.c | 1497 |
1 files changed, 124 insertions, 1373 deletions
diff --git a/source3/lib/system.c b/source3/lib/system.c index 7c0bb3fe5a..d69f1c66f1 100644 --- a/source3/lib/system.c +++ b/source3/lib/system.c @@ -25,6 +25,11 @@ #include "system/capability.h" #include "system/passwd.h" #include "system/filesys.h" +#include "../lib/util/setid.h" + +#ifdef HAVE_SYS_SYSCTL_H +#include <sys/sysctl.h> +#endif #ifdef HAVE_SYS_PRCTL_H #include <sys/prctl.h> @@ -48,76 +53,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 > 999999) { - 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. ********************************************************************/ @@ -183,40 +118,32 @@ ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt) } /******************************************************************* -A pread wrapper that will deal with EINTR and 64-bit file offsets. +A pread wrapper that will deal with EINTR ********************************************************************/ -#if defined(HAVE_PREAD) || defined(HAVE_PREAD64) -ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off) +#if defined(HAVE_PREAD) +ssize_t sys_pread(int fd, void *buf, size_t count, 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); -#else ret = pread(fd, buf, count, off); -#endif } while (ret == -1 && errno == EINTR); return ret; } #endif /******************************************************************* -A write wrapper that will deal with EINTR and 64-bit file offsets. +A write 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) +#if defined(HAVE_PWRITE) +ssize_t sys_pwrite(int fd, const void *buf, size_t count, off_t off) { ssize_t ret; do { -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64) - ret = pwrite64(fd, buf, count, off); -#else ret = pwrite(fd, buf, count, off); -#endif } while (ret == -1 && errno == EINTR); return ret; } @@ -241,42 +168,6 @@ ssize_t sys_send(int s, const void *msg, size_t len, int flags) } /******************************************************************* -A sendto wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK. -********************************************************************/ - -ssize_t sys_sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen) -{ - ssize_t ret; - - do { - ret = sendto(s, msg, len, flags, to, tolen); -#if defined(EWOULDBLOCK) - } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)); -#else - } while (ret == -1 && (errno == EINTR || errno == EAGAIN)); -#endif - return ret; -} - -/******************************************************************* -A recv 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 ret; - - do { - ret = recv(fd, buf, count, flags); -#if defined(EWOULDBLOCK) - } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)); -#else - } while (ret == -1 && (errno == EINTR || errno == EAGAIN)); -#endif - return ret; -} - -/******************************************************************* A recvfrom wrapper that will deal with EINTR. ********************************************************************/ @@ -544,15 +435,9 @@ void update_stat_ex_create_time(struct stat_ex *dst, dst->st_ex_calculated_birthtime = false; } -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64) -static void init_stat_ex_from_stat (struct stat_ex *dst, - const struct stat64 *src, - bool fake_dir_create_times) -#else -static void init_stat_ex_from_stat (struct stat_ex *dst, - const struct stat *src, - bool fake_dir_create_times) -#endif +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; @@ -586,20 +471,15 @@ static void init_stat_ex_from_stat (struct stat_ex *dst, } /******************************************************************* -A stat() wrapper that will deal with 64 bit filesizes. +A stat() wrapper. ********************************************************************/ 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_STAT64) - struct stat64 statbuf; - ret = stat64(fname, &statbuf); -#else struct stat statbuf; ret = stat(fname, &statbuf); -#endif if (ret == 0) { /* we always want directories to appear zero size */ if (S_ISDIR(statbuf.st_mode)) { @@ -611,19 +491,14 @@ int sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf, } /******************************************************************* - An fstat() wrapper that will deal with 64 bit filesizes. + An fstat() wrapper. ********************************************************************/ 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_FSTAT64) - struct stat64 statbuf; - ret = fstat64(fd, &statbuf); -#else struct stat statbuf; ret = fstat(fd, &statbuf); -#endif if (ret == 0) { /* we always want directories to appear zero size */ if (S_ISDIR(statbuf.st_mode)) { @@ -635,20 +510,15 @@ int sys_fstat(int fd, SMB_STRUCT_STAT *sbuf, bool fake_dir_create_times) } /******************************************************************* - An lstat() wrapper that will deal with 64 bit filesizes. + An lstat() wrapper. ********************************************************************/ int sys_lstat(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_LSTAT64) - struct stat64 statbuf; - ret = lstat64(fname, &statbuf); -#else struct stat statbuf; ret = lstat(fname, &statbuf); -#endif if (ret == 0) { /* we always want directories to appear zero size */ if (S_ISDIR(statbuf.st_mode)) { @@ -660,18 +530,16 @@ int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf, } /******************************************************************* - An posix_fallocate() 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) +int sys_posix_fallocate(int fd, off_t offset, off_t len) { -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_POSIX_FALLOCATE64) && !defined(HAVE_BROKEN_POSIX_FALLOCATE) - return posix_fallocate64(fd, offset, len); -#elif defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE) +#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; + off_t new_len = offset + len; int ret; struct stat64 sbuf; @@ -706,7 +574,7 @@ int sys_posix_fallocate(int fd, SMB_OFF_T offset, SMB_OFF_T len) #include <linux/falloc.h> #endif -int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len) +int sys_fallocate(int fd, enum vfs_fallocate_mode mode, off_t offset, off_t len) { #if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE) int lmode; @@ -721,9 +589,7 @@ int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OF errno = EINVAL; return -1; } -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LINUX_FALLOCATE64) - return fallocate64(fd, lmode, offset, len); -#elif defined(HAVE_LINUX_FALLOCATE) +#if defined(HAVE_LINUX_FALLOCATE) return fallocate(fd, lmode, offset, len); #endif #else @@ -733,108 +599,6 @@ int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OF #endif } -/******************************************************************* - An ftruncate() wrapper that will deal with 64 bit filesizes. -********************************************************************/ - -int sys_ftruncate(int fd, SMB_OFF_T offset) -{ -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64) - return ftruncate64(fd, offset); -#else - return ftruncate(fd, offset); -#endif -} - -/******************************************************************* - An lseek() wrapper that will deal with 64 bit filesizes. -********************************************************************/ - -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); -#else - return lseek(fd, offset, whence); -#endif -} - -/******************************************************************* - An fseek() wrapper that will deal with 64 bit filesizes. -********************************************************************/ - -int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence) -{ -#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); -#elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO) - return fseeko(fp, offset, whence); -#else - return fseek(fp, offset, whence); -#endif -} - -/******************************************************************* - An ftell() wrapper that will deal with 64 bit filesizes. -********************************************************************/ - -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. -********************************************************************/ - -int sys_creat(const char *path, mode_t mode) -{ -#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 -} - -/******************************************************************* - An open() wrapper that will deal with 64 bit filesizes. -********************************************************************/ - -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. -********************************************************************/ - -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 */ @@ -869,29 +633,14 @@ void kernel_flock(int fd, uint32 share_mode, uint32 access_mask) /******************************************************************* - 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 -} - -/******************************************************************* - An fdopendir 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_DIR *sys_fdopendir(int fd) +DIR *sys_fdopendir(int fd) { -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FDOPENDIR64) && defined(HAVE_DIRFD) - return fdopendir64(fd); -#elif defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD) +#if defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD) return fdopendir(fd); #else errno = ENOSYS; @@ -900,82 +649,13 @@ SMB_STRUCT_DIR *sys_fdopendir(int fd) } /******************************************************************* - A readdir wrapper that will deal with 64 bit filesizes. -********************************************************************/ - -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. -********************************************************************/ - -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); -#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; @@ -997,18 +677,45 @@ int sys_waitpid(pid_t pid,int *status,int options) } /******************************************************************* - 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) @@ -1250,7 +957,7 @@ static int sys_broken_setgroups(int setlen, gid_t *gidset) for(i = 0; i < setlen; i++) group_list[i] = (GID_T) gidset[i]; - if(setgroups(setlen, group_list) != 0) { + if(samba_setgroups(setlen, group_list) != 0) { int saved_errno = errno; SAFE_FREE(group_list); errno = saved_errno; @@ -1287,7 +994,7 @@ static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset) /* No group list, just make sure we are setting the efective GID. */ if (setlen == 0) { - return setgroups(1, &primary_gid); + return samba_setgroups(1, &primary_gid); } /* If the primary gid is not the first array element, grow the array @@ -1313,7 +1020,7 @@ static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset) #if defined(HAVE_BROKEN_GETGROUPS) ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset); #else - ret = setgroups(setlen, new_gidset ? new_gidset : gidset); + ret = samba_setgroups(setlen, new_gidset ? new_gidset : gidset); #endif if (new_gidset) { @@ -1356,7 +1063,7 @@ int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset) #elif defined(HAVE_BROKEN_GETGROUPS) return sys_broken_setgroups(setlen, gidset); #else - return setgroups(setlen, gidset); + return samba_setgroups(setlen, gidset); #endif } @@ -1393,7 +1100,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; } @@ -1452,33 +1159,45 @@ int sys_popen(const char *command) int pipe_fds[2]; popen_list *entry = NULL; char **argl = NULL; + int ret; + + if (!*command) { + errno = EINVAL; + return -1; + } - if (pipe(pipe_fds) < 0) + ret = pipe(pipe_fds); + if (ret < 0) { + DEBUG(0, ("sys_popen: error opening pipe: %s\n", + strerror(errno))); return -1; + } parent_end = pipe_fds[0]; child_end = pipe_fds[1]; - if (!*command) { - errno = EINVAL; + entry = SMB_MALLOC_P(popen_list); + if (entry == NULL) { + DEBUG(0, ("sys_popen: malloc failed\n")); goto err_exit; } - if((entry = SMB_MALLOC_P(popen_list)) == NULL) - goto err_exit; - ZERO_STRUCTP(entry); /* * Extract the command and args into a NULL terminated array. */ - if(!(argl = extract_args(NULL, command))) + argl = extract_args(NULL, command); + if (argl == NULL) { + DEBUG(0, ("sys_popen: extract_args() failed: %s\n", strerror(errno))); goto err_exit; + } - entry->child_pid = sys_fork(); + entry->child_pid = fork(); if (entry->child_pid == -1) { + DEBUG(0, ("sys_popen: fork failed: %s\n", strerror(errno))); goto err_exit; } @@ -1506,7 +1225,11 @@ int sys_popen(const char *command) for (p = popen_chain; p; p = p->next) close(p->fd); - execv(argl[0], argl); + ret = execv(argl[0], argl); + if (ret == -1) { + DEBUG(0, ("sys_popen: ERROR executing command " + "'%s': %s\n", command, strerror(errno))); + } _exit (127); } @@ -1600,867 +1323,6 @@ int sys_pclose(int fd) SAFE_FREE(msgbuf); } -/******** Solaris EA helper function prototypes ********/ -#ifdef HAVE_ATTROPEN -#define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP -static int solaris_write_xattr(int attrfd, const char *value, size_t size); -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); -static int solaris_unlinkat(int attrdirfd, const char *name); -static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode); -static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode); -#endif - -/************************************************************************** - Wrappers for extented attribute calls. Based on the Linux package with - support for IRIX and (Net|Free)BSD also. Expand as other systems have them. -****************************************************************************/ - -ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size) -{ -#if defined(HAVE_GETXATTR) -#ifndef XATTR_ADD_OPT - return getxattr(path, name, value, size); -#else - int options = 0; - return getxattr(path, name, value, size, 0, options); -#endif -#elif defined(HAVE_GETEA) - return getea(path, name, value, size); -#elif defined(HAVE_EXTATTR_GET_FILE) - char *s; - ssize_t retval; - int attrnamespace = (strncmp(name, "system", 6) == 0) ? - EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER; - const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1; - /* - * The BSD implementation has a nasty habit of silently truncating - * the returned value to the size of the buffer, so we have to check - * that the buffer is large enough to fit the returned value. - */ - if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) { - if(retval > size) { - errno = ERANGE; - return -1; - } - if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0) - return retval; - } - - DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno))); - return -1; -#elif defined(HAVE_ATTR_GET) - int retval, flags = 0; - int valuelength = (int)size; - char *attrname = strchr(name,'.') + 1; - - 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); - if (attrfd >= 0) { - ret = solaris_read_xattr(attrfd, value, size); - close(attrfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size) -{ -#if defined(HAVE_FGETXATTR) -#ifndef XATTR_ADD_OPT - return fgetxattr(filedes, name, value, size); -#else - int options = 0; - return fgetxattr(filedes, name, value, size, 0, options); -#endif -#elif defined(HAVE_FGETEA) - return fgetea(filedes, name, value, size); -#elif defined(HAVE_EXTATTR_GET_FD) - char *s; - ssize_t retval; - int attrnamespace = (strncmp(name, "system", 6) == 0) ? - EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER; - const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1; - - if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) { - if(retval > size) { - errno = ERANGE; - return -1; - } - if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0) - return retval; - } - - DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno))); - return -1; -#elif defined(HAVE_ATTR_GETF) - int retval, flags = 0; - int valuelength = (int)size; - char *attrname = strchr(name,'.') + 1; - - if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT; - - retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags); - - return retval ? retval : valuelength; -#elif defined(HAVE_ATTROPEN) - ssize_t ret = -1; - int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0); - if (attrfd >= 0) { - ret = solaris_read_xattr(attrfd, value, size); - close(attrfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -#if defined(HAVE_EXTATTR_LIST_FILE) - -#define EXTATTR_PREFIX(s) (s), (sizeof((s))-1) - -static struct { - int space; - const char *name; - size_t len; -} -extattr[] = { - { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") }, - { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") }, -}; - -typedef union { - const char *path; - int filedes; -} extattr_arg; - -static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size) -{ - ssize_t list_size, total_size = 0; - int i, t, len; - char *buf; - /* Iterate through extattr(2) namespaces */ - for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) { - switch(type) { -#if defined(HAVE_EXTATTR_LIST_FILE) - case 0: - list_size = extattr_list_file(arg.path, extattr[t].space, list, size); - break; -#endif -#if defined(HAVE_EXTATTR_LIST_LINK) - case 1: - list_size = extattr_list_link(arg.path, extattr[t].space, list, size); - break; -#endif -#if defined(HAVE_EXTATTR_LIST_FD) - case 2: - list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size); - break; -#endif - default: - errno = ENOSYS; - return -1; - } - /* Some error happend. Errno should be set by the previous call */ - if(list_size < 0) - return -1; - /* No attributes */ - if(list_size == 0) - continue; - /* XXX: Call with an empty buffer may be used to calculate - necessary buffer size. Unfortunately, we can't say, how - many attributes were returned, so here is the potential - problem with the emulation. - */ - if(list == NULL) { - /* Take the worse case of one char attribute names - - two bytes per name plus one more for sanity. - */ - total_size += list_size + (list_size/2 + 1)*extattr[t].len; - continue; - } - /* Count necessary offset to fit namespace prefixes */ - len = 0; - for(i = 0; i < list_size; i += list[i] + 1) - len += extattr[t].len; - - total_size += list_size + len; - /* Buffer is too small to fit the results */ - if(total_size > size) { - errno = ERANGE; - return -1; - } - /* Shift results back, so we can prepend prefixes */ - buf = (char *)memmove(list + len, list, list_size); - - for(i = 0; i < list_size; i += len + 1) { - len = buf[i]; - strncpy(list, extattr[t].name, extattr[t].len + 1); - list += extattr[t].len; - strncpy(list, buf + i + 1, len); - list[len] = '\0'; - list += len + 1; - } - size -= total_size; - } - return total_size; -} - -#endif - -#if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H) -static char attr_buffer[ATTR_MAX_VALUELEN]; - -static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags) -{ - int retval = 0, index; - attrlist_cursor_t *cursor = 0; - int total_size = 0; - attrlist_t * al = (attrlist_t *)attr_buffer; - attrlist_ent_t *ae; - size_t ent_size, left = size; - char *bp = list; - - while (True) { - if (filedes) - retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor); - else - retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor); - if (retval) break; - for (index = 0; index < al->al_count; index++) { - ae = ATTR_ENTRY(attr_buffer, index); - ent_size = strlen(ae->a_name) + sizeof("user."); - if (left >= ent_size) { - strncpy(bp, "user.", sizeof("user.")); - strncat(bp, ae->a_name, ent_size - sizeof("user.")); - bp += ent_size; - left -= ent_size; - } else if (size) { - errno = ERANGE; - retval = -1; - break; - } - total_size += ent_size; - } - if (al->al_more == 0) break; - } - if (retval == 0) { - flags |= ATTR_ROOT; - cursor = 0; - while (True) { - if (filedes) - retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor); - else - retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor); - if (retval) break; - for (index = 0; index < al->al_count; index++) { - ae = ATTR_ENTRY(attr_buffer, index); - ent_size = strlen(ae->a_name) + sizeof("system."); - if (left >= ent_size) { - strncpy(bp, "system.", sizeof("system.")); - strncat(bp, ae->a_name, ent_size - sizeof("system.")); - bp += ent_size; - left -= ent_size; - } else if (size) { - errno = ERANGE; - retval = -1; - break; - } - total_size += ent_size; - } - if (al->al_more == 0) break; - } - } - return (ssize_t)(retval ? retval : total_size); -} - -#endif - -ssize_t sys_listxattr (const char *path, char *list, size_t size) -{ -#if defined(HAVE_LISTXATTR) -#ifndef XATTR_ADD_OPT - return listxattr(path, list, size); -#else - int options = 0; - return listxattr(path, list, size, options); -#endif -#elif defined(HAVE_LISTEA) - return listea(path, list, size); -#elif defined(HAVE_EXTATTR_LIST_FILE) - extattr_arg arg; - arg.path = path; - return bsd_attr_list(0, arg, list, size); -#elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H) - return irix_attr_list(path, 0, list, size, 0); -#elif defined(HAVE_ATTROPEN) - ssize_t ret = -1; - int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0); - if (attrdirfd >= 0) { - ret = solaris_list_xattr(attrdirfd, list, size); - close(attrdirfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#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) -#ifndef XATTR_ADD_OPT - return flistxattr(filedes, list, size); -#else - int options = 0; - return flistxattr(filedes, list, size, options); -#endif -#elif defined(HAVE_FLISTEA) - return flistea(filedes, list, size); -#elif defined(HAVE_EXTATTR_LIST_FD) - extattr_arg arg; - arg.filedes = filedes; - return bsd_attr_list(2, arg, list, size); -#elif defined(HAVE_ATTR_LISTF) - return irix_attr_list(NULL, filedes, list, size, 0); -#elif defined(HAVE_ATTROPEN) - ssize_t ret = -1; - int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0); - if (attrdirfd >= 0) { - ret = solaris_list_xattr(attrdirfd, list, size); - close(attrdirfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -int sys_removexattr (const char *path, const char *name) -{ -#if defined(HAVE_REMOVEXATTR) -#ifndef XATTR_ADD_OPT - return removexattr(path, name); -#else - int options = 0; - return removexattr(path, name, options); -#endif -#elif defined(HAVE_REMOVEEA) - return removeea(path, name); -#elif defined(HAVE_EXTATTR_DELETE_FILE) - char *s; - int attrnamespace = (strncmp(name, "system", 6) == 0) ? - EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER; - const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1; - - return extattr_delete_file(path, attrnamespace, attrname); -#elif defined(HAVE_ATTR_REMOVE) - int flags = 0; - char *attrname = strchr(name,'.') + 1; - - if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT; - - return attr_remove(path, attrname, flags); -#elif defined(HAVE_ATTROPEN) - int ret = -1; - int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0); - if (attrdirfd >= 0) { - ret = solaris_unlinkat(attrdirfd, name); - close(attrdirfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -int sys_lremovexattr (const char *path, const char *name) -{ -#if defined(HAVE_LREMOVEXATTR) - return lremovexattr(path, name); -#elif defined(HAVE_REMOVEXATTR) && defined(XATTR_ADD_OPT) - int options = XATTR_NOFOLLOW; - return removexattr(path, name, options); -#elif defined(HAVE_LREMOVEEA) - return lremoveea(path, name); -#elif defined(HAVE_EXTATTR_DELETE_LINK) - char *s; - int attrnamespace = (strncmp(name, "system", 6) == 0) ? - EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER; - const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1; - - return extattr_delete_link(path, attrnamespace, attrname); -#elif defined(HAVE_ATTR_REMOVE) - int flags = ATTR_DONTFOLLOW; - char *attrname = strchr(name,'.') + 1; - - if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT; - - return attr_remove(path, attrname, flags); -#elif defined(HAVE_ATTROPEN) - int ret = -1; - int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0); - if (attrdirfd >= 0) { - ret = solaris_unlinkat(attrdirfd, name); - close(attrdirfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -int sys_fremovexattr (int filedes, const char *name) -{ -#if defined(HAVE_FREMOVEXATTR) -#ifndef XATTR_ADD_OPT - return fremovexattr(filedes, name); -#else - int options = 0; - return fremovexattr(filedes, name, options); -#endif -#elif defined(HAVE_FREMOVEEA) - return fremoveea(filedes, name); -#elif defined(HAVE_EXTATTR_DELETE_FD) - char *s; - int attrnamespace = (strncmp(name, "system", 6) == 0) ? - EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER; - const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1; - - return extattr_delete_fd(filedes, attrnamespace, attrname); -#elif defined(HAVE_ATTR_REMOVEF) - int flags = 0; - char *attrname = strchr(name,'.') + 1; - - if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT; - - return attr_removef(filedes, attrname, flags); -#elif defined(HAVE_ATTROPEN) - int ret = -1; - int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0); - if (attrdirfd >= 0) { - ret = solaris_unlinkat(attrdirfd, name); - close(attrdirfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags) -{ -#if defined(HAVE_SETXATTR) -#ifndef XATTR_ADD_OPT - return setxattr(path, name, value, size, flags); -#else - int options = 0; - return setxattr(path, name, value, size, 0, options); -#endif -#elif defined(HAVE_SETEA) - return setea(path, name, value, size, flags); -#elif defined(HAVE_EXTATTR_SET_FILE) - char *s; - int retval = 0; - int attrnamespace = (strncmp(name, "system", 6) == 0) ? - EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER; - const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1; - if (flags) { - /* Check attribute existence */ - retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0); - if (retval < 0) { - /* REPLACE attribute, that doesn't exist */ - if (flags & XATTR_REPLACE && errno == ENOATTR) { - errno = ENOATTR; - return -1; - } - /* Ignore other errors */ - } - else { - /* CREATE attribute, that already exists */ - if (flags & XATTR_CREATE) { - errno = EEXIST; - return -1; - } - } - } - retval = extattr_set_file(path, attrnamespace, attrname, value, size); - return (retval < 0) ? -1 : 0; -#elif defined(HAVE_ATTR_SET) - int myflags = 0; - char *attrname = strchr(name,'.') + 1; - - if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT; - if (flags & XATTR_CREATE) myflags |= ATTR_CREATE; - if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE; - - return attr_set(path, attrname, (const char *)value, size, myflags); -#elif defined(HAVE_ATTROPEN) - int ret = -1; - int myflags = O_RDWR; - int attrfd; - if (flags & XATTR_CREATE) myflags |= O_EXCL; - if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT; - attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE); - if (attrfd >= 0) { - ret = solaris_write_xattr(attrfd, value, size); - close(attrfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags) -{ -#if defined(HAVE_LSETXATTR) - return lsetxattr(path, name, value, size, flags); -#elif defined(HAVE_SETXATTR) && defined(XATTR_ADD_OPT) - int options = XATTR_NOFOLLOW; - return setxattr(path, name, value, size, 0, options); -#elif defined(LSETEA) - return lsetea(path, name, value, size, flags); -#elif defined(HAVE_EXTATTR_SET_LINK) - char *s; - int retval = 0; - int attrnamespace = (strncmp(name, "system", 6) == 0) ? - EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER; - const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1; - if (flags) { - /* Check attribute existence */ - retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0); - if (retval < 0) { - /* REPLACE attribute, that doesn't exist */ - if (flags & XATTR_REPLACE && errno == ENOATTR) { - errno = ENOATTR; - return -1; - } - /* Ignore other errors */ - } - else { - /* CREATE attribute, that already exists */ - if (flags & XATTR_CREATE) { - errno = EEXIST; - return -1; - } - } - } - - retval = extattr_set_link(path, attrnamespace, attrname, value, size); - return (retval < 0) ? -1 : 0; -#elif defined(HAVE_ATTR_SET) - int myflags = ATTR_DONTFOLLOW; - char *attrname = strchr(name,'.') + 1; - - if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT; - if (flags & XATTR_CREATE) myflags |= ATTR_CREATE; - if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE; - - return attr_set(path, attrname, (const char *)value, size, myflags); -#elif defined(HAVE_ATTROPEN) - int ret = -1; - int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW; - int attrfd; - if (flags & XATTR_CREATE) myflags |= O_EXCL; - if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT; - attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE); - if (attrfd >= 0) { - ret = solaris_write_xattr(attrfd, value, size); - close(attrfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags) -{ -#if defined(HAVE_FSETXATTR) -#ifndef XATTR_ADD_OPT - return fsetxattr(filedes, name, value, size, flags); -#else - int options = 0; - return fsetxattr(filedes, name, value, size, 0, options); -#endif -#elif defined(HAVE_FSETEA) - return fsetea(filedes, name, value, size, flags); -#elif defined(HAVE_EXTATTR_SET_FD) - char *s; - int retval = 0; - int attrnamespace = (strncmp(name, "system", 6) == 0) ? - EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER; - const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1; - if (flags) { - /* Check attribute existence */ - retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0); - if (retval < 0) { - /* REPLACE attribute, that doesn't exist */ - if (flags & XATTR_REPLACE && errno == ENOATTR) { - errno = ENOATTR; - return -1; - } - /* Ignore other errors */ - } - else { - /* CREATE attribute, that already exists */ - if (flags & XATTR_CREATE) { - errno = EEXIST; - return -1; - } - } - } - retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size); - return (retval < 0) ? -1 : 0; -#elif defined(HAVE_ATTR_SETF) - int myflags = 0; - char *attrname = strchr(name,'.') + 1; - - if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT; - if (flags & XATTR_CREATE) myflags |= ATTR_CREATE; - if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE; - - return attr_setf(filedes, attrname, (const char *)value, size, myflags); -#elif defined(HAVE_ATTROPEN) - int ret = -1; - int myflags = O_RDWR | O_XATTR; - int attrfd; - if (flags & XATTR_CREATE) myflags |= O_EXCL; - if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT; - attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE); - if (attrfd >= 0) { - ret = solaris_write_xattr(attrfd, value, size); - close(attrfd); - } - return ret; -#else - errno = ENOSYS; - return -1; -#endif -} - -/************************************************************************** - helper functions for Solaris' EA support -****************************************************************************/ -#ifdef HAVE_ATTROPEN -static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size) -{ - struct stat sbuf; - - if (fstat(attrfd, &sbuf) == -1) { - errno = ENOATTR; - return -1; - } - - /* This is to return the current size of the named extended attribute */ - if (size == 0) { - return sbuf.st_size; - } - - /* check size and read xattr */ - if (sbuf.st_size > size) { - errno = ERANGE; - return -1; - } - - return read(attrfd, value, sbuf.st_size); -} - -static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size) -{ - ssize_t len = 0; - DIR *dirp; - struct dirent *de; - int newfd = dup(attrdirfd); - /* CAUTION: The originating file descriptor should not be - used again following the call to fdopendir(). - For that reason we dup() the file descriptor - here to make things more clear. */ - dirp = fdopendir(newfd); - - while ((de = readdir(dirp))) { - size_t listlen = strlen(de->d_name); - if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) { - /* we don't want "." and ".." here: */ - DEBUG(10,("skipped EA %s\n",de->d_name)); - continue; - } - - if (size == 0) { - /* return the current size of the list of extended attribute names*/ - len += listlen + 1; - } else { - /* check size and copy entrieѕ + nul into list. */ - if ((len + listlen + 1) > size) { - errno = ERANGE; - len = -1; - break; - } else { - safe_strcpy(list + len, de->d_name, listlen); - len += listlen; - list[len] = '\0'; - ++len; - } - } - } - - if (closedir(dirp) == -1) { - DEBUG(0,("closedir dirp failed: %s\n",strerror(errno))); - return -1; - } - return len; -} - -static int solaris_unlinkat(int attrdirfd, const char *name) -{ - if (unlinkat(attrdirfd, name, 0) == -1) { - if (errno == ENOENT) { - errno = ENOATTR; - } - return -1; - } - return 0; -} - -static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode) -{ - int filedes = attropen(path, attrpath, oflag, mode); - if (filedes == -1) { - DEBUG(10,("attropen FAILED: path: %s, name: %s, errno: %s\n",path,attrpath,strerror(errno))); - if (errno == EINVAL) { - errno = ENOTSUP; - } else { - errno = ENOATTR; - } - } - return filedes; -} - -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: %d, path: %s, errno: %s\n",filedes,path,strerror(errno))); - if (errno == EINVAL) { - errno = ENOTSUP; - } else { - errno = ENOATTR; - } - } - return filedes; -} - -static int solaris_write_xattr(int attrfd, const char *value, size_t size) -{ - if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) { - return 0; - } else { - DEBUG(10,("solaris_write_xattr FAILED!\n")); - return -1; - } -} -#endif /*HAVE_ATTROPEN*/ - - /**************************************************************************** Return the major devicenumber for UNIX extensions. ****************************************************************************/ @@ -2487,160 +1349,49 @@ uint32 unix_dev_minor(SMB_DEV_T dev) #endif } -#if defined(WITH_AIO) - +#if 0 /******************************************************************* - An aio_read wrapper that will deal with 64-bit sizes. + Return the number of CPUs. ********************************************************************/ -int sys_aio_read(SMB_STRUCT_AIOCB *aiocb) +int sys_get_number_of_cores(void) { -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64) - return aio_read64(aiocb); -#elif defined(HAVE_AIO_READ) - return aio_read(aiocb); -#else - errno = ENOSYS; - return -1; -#endif -} - -/******************************************************************* - An aio_write wrapper that will deal with 64-bit sizes. -********************************************************************/ + int ret = -1; -int sys_aio_write(SMB_STRUCT_AIOCB *aiocb) -{ -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64) - return aio_write64(aiocb); -#elif defined(HAVE_AIO_WRITE) - return aio_write(aiocb); -#else - errno = ENOSYS; - return -1; +#if defined(HAVE_SYSCONF) +#if defined(_SC_NPROCESSORS_ONLN) + ret = (int)sysconf(_SC_NPROCESSORS_ONLN); #endif -} - -/******************************************************************* - An aio_return wrapper that will deal with 64-bit sizes. -********************************************************************/ - -ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb) -{ -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64) - return aio_return64(aiocb); -#elif defined(HAVE_AIO_RETURN) - return aio_return(aiocb); -#else - errno = ENOSYS; - return -1; +#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); -/******************************************************************* - An aio_cancel wrapper that will deal with 64-bit sizes. -********************************************************************/ + name[0] = CTL_HW; +#if defined(HW_AVAILCPU) + name[1] = HW_AVAILCPU; -int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb) -{ -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64) - return aio_cancel64(fd, aiocb); -#elif defined(HAVE_AIO_CANCEL) - return aio_cancel(fd, aiocb); -#else - errno = ENOSYS; - return -1; + if (sysctl(name, 2, &ret, &len, NULL, 0) == -1) { + ret = -1; + } #endif -} - -/******************************************************************* - An aio_error wrapper that will deal with 64-bit sizes. -********************************************************************/ - -int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb) -{ -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64) - return aio_error64(aiocb); -#elif defined(HAVE_AIO_ERROR) - return aio_error(aiocb); -#else - errno = ENOSYS; - return -1; +#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 -} - -/******************************************************************* - An aio_fsync wrapper that will deal with 64-bit sizes. -********************************************************************/ - -int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb) -{ -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64) - return aio_fsync64(op, aiocb); -#elif defined(HAVE_AIO_FSYNC) - return aio_fsync(op, aiocb); -#else - errno = ENOSYS; - return -1; #endif + if (ret < 1) { + ret = 1; + } + return ret; } - -/******************************************************************* - An aio_fsync wrapper that will deal with 64-bit sizes. -********************************************************************/ - -int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout) -{ -#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64) - return aio_suspend64(cblist, n, timeout); -#elif defined(HAVE_AIO_FSYNC) - return aio_suspend(cblist, n, timeout); -#else - errno = ENOSYS; - return -1; #endif -} -#else /* !WITH_AIO */ - -int sys_aio_read(SMB_STRUCT_AIOCB *aiocb) -{ - errno = ENOSYS; - return -1; -} - -int sys_aio_write(SMB_STRUCT_AIOCB *aiocb) -{ - errno = ENOSYS; - return -1; -} - -ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb) -{ - errno = ENOSYS; - return -1; -} - -int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb) -{ - errno = ENOSYS; - return -1; -} - -int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb) -{ - errno = ENOSYS; - return -1; -} - -int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb) -{ - errno = ENOSYS; - return -1; -} - -int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout) -{ - errno = ENOSYS; - return -1; -} -#endif /* WITH_AIO */ |