#include "includes.h"
#ifdef HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#endif
#if defined(HAVE_DARWIN_INITGROUPS)
#include <sys/syscall.h>
#endif
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
#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
}
int sys_usleep(long usecs)
{
#ifndef HAVE_USLEEP
struct timeval tval;
#endif
if(usecs < 0 || usecs > 1000000) {
errno = EINVAL;
return -1;
}
#if HAVE_USLEEP
usleep(usecs);
return 0;
#else
tval.tv_sec = 0;
tval.tv_usec = usecs/1000;
select(0,NULL,NULL,NULL,&tval);
return 0;
#endif
}
ssize_t sys_read(int fd, void *buf, size_t count)
{
ssize_t ret;
do {
ret = read(fd, buf, count);
} while (ret == -1 && errno == EINTR);
return ret;
}
ssize_t sys_write(int fd, const void *buf, size_t count)
{
ssize_t ret;
do {
ret = write(fd, buf, count);
} while (ret == -1 && errno == EINTR);
return ret;
}
#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);
#else
ret = pread(fd, buf, count, off);
#endif
} while (ret == -1 && errno == EINTR);
return ret;
}
#endif
#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 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;
}
#endif
ssize_t sys_send(int s, const void *msg, size_t len, int flags)
{
ssize_t ret;
do {
ret = send(s, msg, len, flags);
} while (ret == -1 && errno == EINTR);
return ret;
}
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);
} while (ret == -1 && errno == EINTR);
return ret;
}
ssize_t sys_recv(int fd, void *buf, size_t count, int flags)
{
ssize_t ret;
do {
ret = recv(fd, buf, count, flags);
} while (ret == -1 && errno == EINTR);
return ret;
}
ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
{
ssize_t ret;
do {
ret = recvfrom(s, buf, len, flags, from, fromlen);
} while (ret == -1 && errno == EINTR);
return ret;
}
int sys_fcntl_ptr(int fd, int cmd, void *arg)
{
int ret;
do {
ret = fcntl(fd, cmd, arg);
} while (ret == -1 && errno == EINTR);
return ret;
}
int sys_fcntl_long(int fd, int cmd, long arg)
{
int ret;
do {
ret = fcntl(fd, cmd, arg);
} while (ret == -1 && errno == EINTR);
return ret;
}
int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
{
int ret;
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
ret = stat64(fname, sbuf);
#else
ret = stat(fname, sbuf);
#endif
if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
return ret;
}
int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
{
int ret;
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
ret = fstat64(fd, sbuf);
#else
ret = fstat(fd, sbuf);
#endif
if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
return ret;
}
int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
{
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
if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
return ret;
}
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
}
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
}
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);
#else
return fseek(fp, offset, whence);
#endif
}
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
}
int sys_creat(const char *path, mode_t mode)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
return creat64(path, mode);
#else
return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
#endif
}
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
}
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
}
void kernel_flock(int fd, uint32 share_mode)
{
#if HAVE_KERNEL_SHARE_MODES
int kernel_mode = 0;
if (share_mode == FILE_SHARE_WRITE) {
kernel_mode = LOCK_MAND|LOCK_WRITE;
} else if (share_mode == FILE_SHARE_READ) {
kernel_mode = LOCK_MAND|LOCK_READ;
} else if (share_mode == FILE_SHARE_NONE) {
kernel_mode = LOCK_MAND;
}
if (kernel_mode) {
flock(fd, kernel_mode);
}
#endif
;
}
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
}
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
}
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
}
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
}
void sys_rewinddir(SMB_STRUCT_DIR *dirp)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
rewinddir64(dirp);
#else
rewinddir(dirp);
#endif
}
int sys_closedir(SMB_STRUCT_DIR *dirp)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
return closedir64(dirp);
#else
return closedir(dirp);
#endif
}
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
return mknod(path, mode, dev);
#endif
#else
errno = ENOSYS;
return -1;
#endif
}
char *sys_realpath(const char *path, char *resolved_path)
{
#if defined(HAVE_REALPATH)
return realpath(path, resolved_path);
#else
errno = EINVAL;
return NULL;
#endif
}
int sys_waitpid(pid_t pid,int *status,int options)
{
#ifdef HAVE_WAITPID
return waitpid(pid,status,options);
#else
return wait4(pid, status, options, NULL);
#endif
}
char *sys_getwd(char *s)
{
char *wd;
#ifdef HAVE_GETCWD
wd = (char *)getcwd(s, sizeof (pstring));
#else
wd = (char *)getwd(s);
#endif
return wd;
}
int sys_symlink(const char *oldpath, const char *newpath)
{
#ifndef HAVE_SYMLINK
errno = ENOSYS;
return -1;
#else
return symlink(oldpath, newpath);
#endif
}
int sys_readlink(const char *path, char *buf, size_t bufsiz)
{
#ifndef HAVE_READLINK
errno = ENOSYS;
return -1;
#else
return readlink(path, buf, bufsiz);
#endif
}
int sys_link(const char *oldpath, const char *newpath)
{
#ifndef HAVE_LINK
errno = ENOSYS;
return -1;
#else
return link(oldpath, newpath);
#endif
}
int sys_chown(const char *fname,uid_t uid,gid_t gid)
{
#ifndef HAVE_CHOWN
static int done;
if (!done) {
DEBUG(1,("WARNING: no chown!\n"));
done=1;
}
errno = ENOSYS;
return -1;
#else
return(chown(fname,uid,gid));
#endif
}
int sys_lchown(const char *fname,uid_t uid,gid_t gid)
{
#ifndef HAVE_LCHOWN
static int done;
if (!done) {
DEBUG(1,("WARNING: no lchown!\n"));
done=1;
}
errno = ENOSYS;
return -1;
#else
return(lchown(fname,uid,gid));
#endif
}
int sys_chroot(const char *dname)
{
#ifndef HAVE_CHROOT
static int done;
if (!done) {
DEBUG(1,("WARNING: no chroot!\n"));
done=1;
}
errno = ENOSYS;
return -1;
#else
return(chroot(dname));
#endif
}
struct hostent *sys_gethostbyname(const char *name)
{
#ifdef REDUCE_ROOT_DNS_LOOKUPS
char query[256], hostname[256];
char *domain;
if (strchr_m(name, '.'))
return(gethostbyname(name));
gethostname(hostname, sizeof(hostname) - 1);
hostname[sizeof(hostname) - 1] = 0;
if ((domain = strchr_m(hostname, '.')) == NULL)
return(gethostbyname(name));
if((strlen(name) + strlen(domain)) >= sizeof(query))
return(gethostbyname(name));
slprintf(query, sizeof(query)-1, "%s%s", name, domain);
return(gethostbyname(query));
#else
return(gethostbyname(name));
#endif
}
#if defined(HAVE_POSIX_CAPABILITIES)
#ifdef HAVE_SYS_CAPABILITY_H
#if defined(BROKEN_REDHAT_7_SYSTEM_HEADERS) && !defined(_I386_STATFS_H) && !defined(_PPC_STATFS_H)
#define _I386_STATFS_H
#define _PPC_STATFS_H
#define BROKEN_REDHAT_7_STATFS_WORKAROUND
#endif
#include <sys/capability.h>
#ifdef BROKEN_REDHAT_7_STATFS_WORKAROUND
#undef _I386_STATFS_H
#undef _PPC_STATFS_H
#undef BROKEN_REDHAT_7_STATFS_WORKAROUND
#endif
#endif
static BOOL set_process_capability(enum smbd_capability capability,
BOOL enable)
{
cap_value_t cap_vals[2] = {0};
int num_cap_vals = 0;
cap_t cap;
#if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
if (!prctl(PR_GET_KEEPCAPS)) {
prctl(PR_SET_KEEPCAPS, 1);
}
#endif
cap = cap_get_proc();
if (cap == NULL) {
DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
strerror(errno)));
return False;
}
switch (capability) {
case KERNEL_OPLOCK_CAPABILITY:
#ifdef CAP_NETWORK_MGT
cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
#endif
break;
case DMAPI_ACCESS_CAPABILITY:
#ifdef CAP_DEVICE_MGT
cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
#elif CAP_MKNOD
cap_vals[num_cap_vals++] = CAP_MKNOD;
#endif
break;
}
SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
if (num_cap_vals == 0) {
cap_free(cap);
return True;
}
cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
enable ? CAP_SET : CAP_CLEAR);
cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
if (cap_set_proc(cap) == -1) {
DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
strerror(errno)));
cap_free(cap);
return False;
}
cap_free(cap);
return True;
}
#endif
void set_effective_capability(enum smbd_capability capability)
{
#if defined(HAVE_POSIX_CAPABILITIES)
set_process_capability(capability, True);
#endif
}
void drop_effective_capability(enum smbd_capability capability)
{
#if defined(HAVE_POSIX_CAPABILITIES)
set_process_capability(capability, False);
#endif
}
long sys_random(void)
{
#if defined(HAVE_RANDOM)
return (long)random();
#elif defined(HAVE_RAND)
return (long)rand();
#else
DEBUG(0,("Error - no random function available !\n"));
exit(1);
#endif
}
void sys_srandom(unsigned int seed)
{
#if defined(HAVE_SRANDOM)
srandom(seed);
#elif defined(HAVE_SRAND)
srand(seed);
#else
DEBUG(0,("Error - no srandom function available !\n"));
exit(1);
#endif
}
int groups_max(void)
{
#if defined(SYSCONF_SC_NGROUPS_MAX)
int ret = sysconf(_SC_NGROUPS_MAX);
return (ret == -1) ? NGROUPS_MAX : ret;
#else
return NGROUPS_MAX;
#endif
}
int sys_getgroups(int setlen, gid_t *gidset)
{
#if !defined(HAVE_BROKEN_GETGROUPS)
return getgroups(setlen, gidset);
#else
GID_T gid;
GID_T *group_list;
int i, ngroups;
if(setlen == 0) {
return getgroups(setlen, &gid);
}
if(setlen < 0) {
errno = EINVAL;
return -1;
}
if (setlen == 0)
setlen = groups_max();
if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
DEBUG(0,("sys_getgroups: Malloc fail.\n"));
return -1;
}
if((ngroups = getgroups(setlen, group_list)) < 0) {
int saved_errno = errno;
SAFE_FREE(group_list);
errno = saved_errno;
return -1;
}
for(i = 0; i < ngroups; i++)
gidset[i] = (gid_t)group_list[i];
SAFE_FREE(group_list);
return ngroups;
#endif
}
int sys_setgroups(uid_t gmuid, int setlen, gid_t *gidset)
{
#if defined(HAVE_DARWIN_INITGROUPS)
int maxgroups = sysconf(_SC_NGROUPS_MAX);
if (setlen > maxgroups) {
setlen = maxgroups;
}
return syscall(SYS_initgroups, setlen, gidset, gmuid);
#elif !defined(HAVE_SETGROUPS)
errno = ENOSYS;
return -1;
#if !defined(HAVE_BROKEN_GETGROUPS)
return setgroups(setlen, gidset);
#else
GID_T *group_list;
int i ;
if (setlen == 0)
return 0 ;
if (setlen < 0 || setlen > groups_max()) {
errno = EINVAL;
return -1;
}
if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
DEBUG(0,("sys_setgroups: Malloc fail.\n"));
return -1;
}
for(i = 0; i < setlen; i++)
group_list[i] = (GID_T) gidset[i];
if(setgroups(setlen, group_list) != 0) {
int saved_errno = errno;
SAFE_FREE(group_list);
errno = saved_errno;
return -1;
}
SAFE_FREE(group_list);
return 0 ;
#endif
#endif
}
void sys_setpwent(void)
{
setpwent();
}
struct passwd *sys_getpwent(void)
{
return getpwent();
}
void sys_endpwent(void)
{
endpwent();
}
#ifdef ENABLE_BUILD_FARM_HACKS
static struct passwd *fake_pwd;
static int num_fake_pwd;
struct passwd *sys_getpwnam(const char *name)
{
int i;
for (i=0; i<num_fake_pwd; i++) {
if (strcmp(fake_pwd[i].pw_name, name) == 0) {
DEBUG(10, ("Returning fake user %s\n", name));
return &fake_pwd[i];
}
}
return getpwnam(name);
}
struct passwd *sys_getpwuid(uid_t uid)
{
int i;
for (i=0; i<num_fake_pwd; i++) {
if (fake_pwd[i].pw_uid == uid) {
DEBUG(10, ("Returning fake user %s\n",
fake_pwd[i].pw_name));
return &fake_pwd[i];
}
}
return getpwuid(uid);
}
void faked_create_user(const char *name)
{
int i;
uid_t uid;
struct passwd new_pwd;
for (i=0; i<10; i++) {
generate_random_buffer((unsigned char *)&uid,
sizeof(uid));
if (getpwuid(uid) == NULL) {
break;
}
}
if (i==10) {
return;
}
new_pwd.pw_name = SMB_STRDUP(name);
new_pwd.pw_passwd = SMB_STRDUP("x");
new_pwd.pw_uid = uid;
new_pwd.pw_gid = 100;
new_pwd.pw_gecos = SMB_STRDUP("faked user");
new_pwd.pw_dir = SMB_STRDUP("/nodir");
new_pwd.pw_shell = SMB_STRDUP("/bin/false");
ADD_TO_ARRAY(NULL, struct passwd, new_pwd, &fake_pwd,
&num_fake_pwd);
DEBUG(10, ("Added fake user %s, have %d fake users\n",
name, num_fake_pwd));
}
#else
struct passwd *sys_getpwnam(const char *name)
{
return getpwnam(name);
}
struct passwd *sys_getpwuid(uid_t uid)
{
return getpwuid(uid);
}
#endif
struct group *sys_getgrnam(const char *name)
{
return getgrnam(name);
}
struct group *sys_getgrgid(gid_t gid)
{
return getgrgid(gid);
}
#if 0
int wsys_stat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf)
{
pstring fname;
return sys_stat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf);
}
int wsys_lstat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf)
{
pstring fname;
return sys_lstat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf);
}
int wsys_creat(const smb_ucs2_t *wfname, mode_t mode)
{
pstring fname;
return sys_creat(unicode_to_unix(fname,wfname,sizeof(fname)), mode);
}
int wsys_open(const smb_ucs2_t *wfname, int oflag, mode_t mode)
{
pstring fname;
return sys_open(unicode_to_unix(fname,wfname,sizeof(fname)), oflag, mode);
}
FILE *wsys_fopen(const smb_ucs2_t *wfname, const char *type)
{
pstring fname;
return sys_fopen(unicode_to_unix(fname,wfname,sizeof(fname)), type);
}
SMB_STRUCT_DIR *wsys_opendir(const smb_ucs2_t *wfname)
{
pstring fname;
return opendir(unicode_to_unix(fname,wfname,sizeof(fname)));
}
SMB_STRUCT_WDIRENT *wsys_readdir(SMB_STRUCT_DIR *dirp)
{
static SMB_STRUCT_WDIRENT retval;
SMB_STRUCT_DIRENT *dirval = sys_readdir(dirp);
if(!dirval)
return NULL;
unix_to_unicode(retval.d_name,dirval->d_name,sizeof(retval.d_name));
return &retval;
}
smb_ucs2_t *wsys_getwd(smb_ucs2_t *s)
{
pstring fname;
char *p = sys_getwd(fname);
if(!p)
return NULL;
return unix_to_unicode(s, p, sizeof(wpstring));
}
int wsys_chown(const smb_ucs2_t *wfname, uid_t uid, gid_t gid)
{
pstring fname;
return chown(unicode_to_unix(fname,wfname,sizeof(fname)), uid, gid);
}
int wsys_chroot(const smb_ucs2_t *wfname)
{
pstring fname;
return chroot(unicode_to_unix(fname,wfname,sizeof(fname)));
}
SMB_STRUCT_WPASSWD *wsys_getpwnam(const smb_ucs2_t *wname)
{
static SMB_STRUCT_WPASSWD retval;
fstring name;
struct passwd *pwret = sys_getpwnam(unicode_to_unix(name,wname,sizeof(name)));
if(!pwret)
return NULL;
unix_to_unicode(retval.pw_name, pwret->pw_name, sizeof(retval.pw_name));
retval.pw_passwd = pwret->pw_passwd;
retval.pw_uid = pwret->pw_uid;
retval.pw_gid = pwret->pw_gid;
unix_to_unicode(retval.pw_gecos, pwret->pw_gecos, sizeof(retval.pw_gecos));
unix_to_unicode(retval.pw_dir, pwret->pw_dir, sizeof(retval.pw_dir));
unix_to_unicode(retval.pw_shell, pwret->pw_shell, sizeof(retval.pw_shell));
return &retval;
}
SMB_STRUCT_WPASSWD *wsys_getpwuid(uid_t uid)
{
static SMB_STRUCT_WPASSWD retval;
struct passwd *pwret = sys_getpwuid(uid);
if(!pwret)
return NULL;
unix_to_unicode(retval.pw_name, pwret->pw_name, sizeof(retval.pw_name));
retval.pw_passwd = pwret->pw_passwd;
retval.pw_uid = pwret->pw_uid;
retval.pw_gid = pwret->pw_gid;
unix_to_unicode(retval.pw_gecos, pwret->pw_gecos, sizeof(retval.pw_gecos));
unix_to_unicode(retval.pw_dir, pwret->pw_dir, sizeof(retval.pw_dir));
unix_to_unicode(retval.pw_shell, pwret->pw_shell, sizeof(retval.pw_shell));
return &retval;
}
#endif
static char **extract_args(const char *command)
{
static pstring trunc_cmd;
char *ptr;
int argcl;
char **argl = NULL;
int i;
pstrcpy(trunc_cmd, command);
if(!(ptr = strtok(trunc_cmd, " \t"))) {
errno = EINVAL;
return NULL;
}
for( argcl = 1; ptr; ptr = strtok(NULL, " \t"))
argcl++;
if((argl = (char **)SMB_MALLOC((argcl + 1) * sizeof(char *))) == NULL)
return NULL;
pstrcpy(trunc_cmd, command);
ptr = strtok(trunc_cmd, " \t");
i = 0;
argl[i++] = ptr;
while((ptr = strtok(NULL, " \t")) != NULL)
argl[i++] = ptr;
argl[i++] = NULL;
return argl;
}
static pid_t mypid = (pid_t)-1;
pid_t sys_fork(void)
{
pid_t forkret = fork();
if (forkret == (pid_t)0)
mypid = (pid_t) -1;
return forkret;
}
pid_t sys_getpid(void)
{
if (mypid == (pid_t)-1)
mypid = getpid();
return mypid;
}
typedef struct _popen_list
{
int fd;
pid_t child_pid;
struct _popen_list *next;
} popen_list;
static popen_list *popen_chain;
int sys_popen(const char *command)
{
int parent_end, child_end;
int pipe_fds[2];
popen_list *entry = NULL;
char **argl = NULL;
if (pipe(pipe_fds) < 0)
return -1;
parent_end = pipe_fds[0];
child_end = pipe_fds[1];
if (!*command) {
errno = EINVAL;
goto err_exit;
}
if((entry = SMB_MALLOC_P(popen_list)) == NULL)
goto err_exit;
ZERO_STRUCTP(entry);
if(!(argl = extract_args(command)))
goto err_exit;
entry->child_pid = sys_fork();
if (entry->child_pid == -1) {
goto err_exit;
}
if (entry->child_pid == 0) {
int child_std_end = STDOUT_FILENO;
popen_list *p;
close(parent_end);
if (child_end != child_std_end) {
dup2 (child_end, child_std_end);
close (child_end);
}
for (p = popen_chain; p; p = p->next)
close(p->fd);
execv(argl[0], argl);
_exit (127);
}
close (child_end);
SAFE_FREE(argl);
entry->next = popen_chain;
popen_chain = entry;
entry->fd = parent_end;
return entry->fd;
err_exit:
SAFE_FREE(entry);
SAFE_FREE(argl);
close(pipe_fds[0]);
close(pipe_fds[1]);
return -1;
}
int sys_pclose(int fd)
{
int wstatus;
popen_list **ptr = &popen_chain;
popen_list *entry = NULL;
pid_t wait_pid;
int status = -1;
for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
if ((*ptr)->fd == fd) {
entry = *ptr;
*ptr = (*ptr)->next;
status = 0;
break;
}
}
if (status < 0 || close(entry->fd) < 0)
return -1;
do {
wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
} while (wait_pid == -1 && errno == EINTR);
SAFE_FREE(entry);
if (wait_pid == -1)
return -1;
return wstatus;
}
void *sys_dlopen(const char *name, int flags)
{
#if defined(HAVE_DLOPEN)
return dlopen(name, flags);
#else
return NULL;
#endif
}
void *sys_dlsym(void *handle, const char *symbol)
{
#if defined(HAVE_DLSYM)
return dlsym(handle, symbol);
#else
return NULL;
#endif
}
int sys_dlclose (void *handle)
{
#if defined(HAVE_DLCLOSE)
return dlclose(handle);
#else
return 0;
#endif
}
const char *sys_dlerror(void)
{
#if defined(HAVE_DLERROR)
return dlerror();
#else
return NULL;
#endif
}
int sys_dup2(int oldfd, int newfd)
{
#if defined(HAVE_DUP2)
return dup2(oldfd, newfd);
#else
errno = ENOSYS;
return -1;
#endif
}
void sys_adminlog(int priority, const char *format_str, ...)
{
va_list ap;
int ret;
char *msgbuf = NULL;
va_start( ap, format_str );
ret = vasprintf( &msgbuf, format_str, ap );
va_end( ap );
if (ret == -1)
return;
#if defined(HAVE_SYSLOG)
syslog( priority, "%s", msgbuf );
#else
DEBUG(0,("%s", msgbuf ));
#endif
SAFE_FREE(msgbuf);
}
#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
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;
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;
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;
}
if(list_size < 0)
return -1;
if(list_size == 0)
continue;
if(list == NULL) {
total_size += list_size + (list_size/2 + 1)*extattr[t].len;
continue;
}
len = 0;
for(i = 0; i < list_size; i += list[i] + 1)
len += extattr[t].len;
total_size += list_size + len;
if(total_size > size) {
errno = ERANGE;
return -1;
}
buf = memmove(list + len, list, list_size);
for(i = 0; i < list_size; i += len + 1) {
len = buf[i];
strncpy(list, extattr[t].name, extattr[t].len + 1);
list += extattr[t].len;
strncpy(list, buf + i + 1, len);
list[len] = '\0';
list += len + 1;
}
size -= total_size;
}
return total_size;
}
#endif
#if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
static char attr_buffer[ATTR_MAX_VALUELEN];
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
}
#if !defined(HAVE_SETXATTR)
#define XATTR_CREATE 0x1
#define XATTR_REPLACE 0x2
#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) {
retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
if (retval < 0) {
if (flags & XATTR_REPLACE && errno == ENOATTR) {
errno = ENOATTR;
return -1;
}
}
else {
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) {
retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
if (retval < 0) {
if (flags & XATTR_REPLACE && errno == ENOATTR) {
errno = ENOATTR;
return -1;
}
}
else {
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) {
retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
if (retval < 0) {
if (flags & XATTR_REPLACE && errno == ENOATTR) {
errno = ENOATTR;
return -1;
}
}
else {
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
}
#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;
}
if (size == 0) {
return sbuf.st_size;
}
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;
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);
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
DEBUG(10,("skipped EA %s\n",de->d_name));
continue;
}
if (size == 0) {
len += listlen + 1;
} else {
if ((len + listlen + 1) > size) {
errno = ERANGE;
len = -1;
break;
} else {
safe_strcpy(list + len, de->d_name, listlen);
pstrcpy(list + len, de->d_name);
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: %s, 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
uint32 unix_dev_major(SMB_DEV_T dev)
{
#if defined(HAVE_DEVICE_MAJOR_FN)
return (uint32)major(dev);
#else
return (uint32)(dev >> 8);
#endif
}
uint32 unix_dev_minor(SMB_DEV_T dev)
{
#if defined(HAVE_DEVICE_MINOR_FN)
return (uint32)minor(dev);
#else
return (uint32)(dev & 0xff);
#endif
}
#if defined(WITH_AIO)
int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
return aio_read64(aiocb);
#elif defined(HAVE_AIO_READ)
return aio_read(aiocb);
#else
errno = ENOSYS;
return -1;
#endif
}
int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
return aio_write64(aiocb);
#elif defined(HAVE_AIO_WRITE)
return aio_write(aiocb);
#else
errno = ENOSYS;
return -1;
#endif
}
ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
return aio_return64(aiocb);
#elif defined(HAVE_AIO_RETURN)
return aio_return(aiocb);
#else
errno = ENOSYS;
return -1;
#endif
}
int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
return aio_cancel64(fd, aiocb);
#elif defined(HAVE_AIO_CANCEL)
return aio_cancel(fd, aiocb);
#else
errno = ENOSYS;
return -1;
#endif
}
int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
return aio_error64(aiocb);
#elif defined(HAVE_AIO_ERROR)
return aio_error(aiocb);
#else
errno = ENOSYS;
return -1;
#endif
}
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
}
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
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
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
}