summaryrefslogtreecommitdiff
path: root/source3/lib
diff options
context:
space:
mode:
authorJeremy Allison <jra@samba.org>2002-01-10 00:28:09 +0000
committerJeremy Allison <jra@samba.org>2002-01-10 00:28:09 +0000
commit3454945146bdef0108f3a55fb32456cccf15f188 (patch)
treea8f95d74555b8f68edc577d2d0308e0af9186b3d /source3/lib
parent3375267106fb0af332a516c6403700acbd1133ab (diff)
downloadsamba-3454945146bdef0108f3a55fb32456cccf15f188.tar.gz
samba-3454945146bdef0108f3a55fb32456cccf15f188.tar.bz2
samba-3454945146bdef0108f3a55fb32456cccf15f188.zip
Getting ready to add UNIX extensions in HEAD also.
Jeremy (This used to be commit 6210d4aa196c944e47076e316980f76ac9c6b02d)
Diffstat (limited to 'source3/lib')
-rw-r--r--source3/lib/system.c576
1 files changed, 392 insertions, 184 deletions
diff --git a/source3/lib/system.c b/source3/lib/system.c
index 4114ce456c..417f5ad6e2 100644
--- a/source3/lib/system.c
+++ b/source3/lib/system.c
@@ -3,6 +3,7 @@
Version 1.9.
Samba system utilities
Copyright (C) Andrew Tridgell 1992-1998
+ Copyright (C) Jeremy Allison 1998-2002
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -45,30 +46,30 @@
int sys_usleep(long usecs)
{
#ifndef HAVE_USLEEP
- struct timeval tval;
+ struct timeval tval;
#endif
- /*
- * We need this braindamage as the glibc usleep
- * is not SPEC1170 complient... grumble... JRA.
- */
+ /*
+ * We need this braindamage as the glibc usleep
+ * is not SPEC1170 complient... grumble... JRA.
+ */
- if(usecs < 0 || usecs > 1000000) {
- errno = EINVAL;
- return -1;
- }
+ if(usecs < 0 || usecs > 1000000) {
+ errno = EINVAL;
+ return -1;
+ }
#if HAVE_USLEEP
- usleep(usecs);
- return 0;
+ 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;
+ /*
+ * Fake it with select...
+ */
+ tval.tv_sec = 0;
+ tval.tv_usec = usecs/1000;
+ select(0,NULL,NULL,NULL,&tval);
+ return 0;
#endif /* HAVE_USLEEP */
}
@@ -130,9 +131,9 @@ int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
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);
+ return ftruncate64(fd, offset);
#else
- return ftruncate(fd, offset);
+ return ftruncate(fd, offset);
#endif
}
@@ -143,9 +144,9 @@ int sys_ftruncate(int fd, SMB_OFF_T offset)
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);
+ return lseek64(fd, offset, whence);
#else
- return lseek(fd, offset, whence);
+ return lseek(fd, offset, whence);
#endif
}
@@ -156,11 +157,11 @@ SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
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);
+ return fseek64(fp, offset, whence);
#elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
- return fseeko64(fp, offset, whence);
+ return fseeko64(fp, offset, whence);
#else
- return fseek(fp, offset, whence);
+ return fseek(fp, offset, whence);
#endif
}
@@ -171,11 +172,11 @@ int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
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);
+ 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);
+ return (SMB_OFF_T)ftello64(fp);
#else
- return (SMB_OFF_T)ftell(fp);
+ return (SMB_OFF_T)ftell(fp);
#endif
}
@@ -186,13 +187,13 @@ SMB_OFF_T sys_ftell(FILE *fp)
int sys_creat(const char *path, mode_t mode)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
- return creat64(path, mode);
+ 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);
+ /*
+ * 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
}
@@ -203,9 +204,9 @@ int sys_creat(const char *path, mode_t mode)
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);
+ return open64(path, oflag, mode);
#else
- return open(path, oflag, mode);
+ return open(path, oflag, mode);
#endif
}
@@ -216,9 +217,9 @@ int sys_open(const char *path, int oflag, mode_t mode)
FILE *sys_fopen(const char *path, const char *type)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
- return fopen64(path, type);
+ return fopen64(path, type);
#else
- return fopen(path, type);
+ return fopen(path, type);
#endif
}
@@ -229,9 +230,28 @@ FILE *sys_fopen(const char *path, const char *type)
SMB_STRUCT_DIRENT *sys_readdir(DIR *dirp)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
- return readdir64(dirp);
+ return readdir64(dirp);
+#else
+ return readdir(dirp);
+#endif
+}
+
+/*******************************************************************
+ An mknod() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+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 readdir(dirp);
+ return mknod(path, mode, dev);
+#endif
+#else
+ /* No mknod system call. */
+ errno = ENOSYS;
+ return -1;
#endif
}
@@ -242,24 +262,25 @@ The wait() calls vary between systems
int sys_waitpid(pid_t pid,int *status,int options)
{
#ifdef HAVE_WAITPID
- return waitpid(pid,status,options);
+ return waitpid(pid,status,options);
#else /* HAVE_WAITPID */
- return wait4(pid, status, options, NULL);
+ return wait4(pid, status, options, NULL);
#endif /* HAVE_WAITPID */
}
/*******************************************************************
-system wrapper for getwd
+ System wrapper for getwd
********************************************************************/
+
char *sys_getwd(char *s)
{
- char *wd;
+ char *wd;
#ifdef HAVE_GETCWD
- wd = (char *)getcwd(s, sizeof (pstring));
+ wd = (char *)getcwd(s, sizeof (pstring));
#else
- wd = (char *)getwd(s);
+ wd = (char *)getwd(s);
#endif
- return wd;
+ return wd;
}
/*******************************************************************
@@ -291,6 +312,20 @@ int sys_readlink(const char *path, char *buf, size_t bufsiz)
}
/*******************************************************************
+system wrapper for link
+********************************************************************/
+
+int sys_link(const char *oldpath, const char *newpath)
+{
+#ifndef HAVE_LINK
+ errno = ENOSYS;
+ return -1;
+#else
+ return link(oldpath, newpath);
+#endif
+}
+
+/*******************************************************************
chown isn't used much but OS/2 doesn't have it
********************************************************************/
@@ -330,39 +365,40 @@ A wrapper for gethostbyname() that tries avoids looking up hostnames
in the root domain, which can cause dial-on-demand links to come up for no
apparent reason.
****************************************************************************/
+
struct hostent *sys_gethostbyname(const char *name)
{
#ifdef REDUCE_ROOT_DNS_LOOKUPS
- char query[256], hostname[256];
- char *domain;
+ char query[256], hostname[256];
+ char *domain;
- /* Does this name have any dots in it? If so, make no change */
+ /* Does this name have any dots in it? If so, make no change */
- if (strchr_m(name, '.'))
- return(gethostbyname(name));
+ if (strchr_m(name, '.'))
+ return(gethostbyname(name));
- /* Get my hostname, which should have domain name
- attached. If not, just do the gethostname on the
- original string.
- */
+ /* Get my hostname, which should have domain name
+ attached. If not, just do the gethostname on the
+ original string.
+ */
- gethostname(hostname, sizeof(hostname) - 1);
- hostname[sizeof(hostname) - 1] = 0;
- if ((domain = strchr_m(hostname, '.')) == NULL)
- return(gethostbyname(name));
+ gethostname(hostname, sizeof(hostname) - 1);
+ hostname[sizeof(hostname) - 1] = 0;
+ if ((domain = strchr_m(hostname, '.')) == NULL)
+ return(gethostbyname(name));
- /* Attach domain name to query and do modified query.
- If names too large, just do gethostname on the
- original string.
- */
+ /* Attach domain name to query and do modified query.
+ If names too large, just do gethostname on the
+ original string.
+ */
- if((strlen(name) + strlen(domain)) >= sizeof(query))
- 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));
+ slprintf(query, sizeof(query)-1, "%s%s", name, domain);
+ return(gethostbyname(query));
#else /* REDUCE_ROOT_DNS_LOOKUPS */
- return(gethostbyname(name));
+ return(gethostbyname(name));
#endif /* REDUCE_ROOT_DNS_LOOKUPS */
}
@@ -373,33 +409,32 @@ struct hostent *sys_gethostbyname(const char *name)
****************************************************************************/
static BOOL set_process_capability( uint32 cap_flag, BOOL enable )
{
- if(cap_flag == KERNEL_OPLOCK_CAPABILITY)
- {
- cap_t cap = cap_get_proc();
+ if(cap_flag == KERNEL_OPLOCK_CAPABILITY) {
+ cap_t cap = cap_get_proc();
- if (cap == NULL) {
- DEBUG(0,("set_process_capability: cap_get_proc failed. Error was %s\n",
- strerror(errno)));
- return False;
- }
+ if (cap == NULL) {
+ DEBUG(0,("set_process_capability: cap_get_proc failed. Error was %s\n",
+ strerror(errno)));
+ return False;
+ }
- if(enable)
- cap->cap_effective |= CAP_NETWORK_MGT;
- else
- cap->cap_effective &= ~CAP_NETWORK_MGT;
+ if(enable)
+ cap->cap_effective |= CAP_NETWORK_MGT;
+ else
+ cap->cap_effective &= ~CAP_NETWORK_MGT;
- if (cap_set_proc(cap) == -1) {
- DEBUG(0,("set_process_capability: cap_set_proc failed. Error was %s\n",
- strerror(errno)));
- cap_free(cap);
- return False;
- }
+ if (cap_set_proc(cap) == -1) {
+ DEBUG(0,("set_process_capability: cap_set_proc failed. Error was %s\n",
+ strerror(errno)));
+ cap_free(cap);
+ return False;
+ }
- cap_free(cap);
+ cap_free(cap);
- DEBUG(10,("set_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
- }
- return True;
+ DEBUG(10,("set_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
+ }
+ return True;
}
/**************************************************************************
@@ -408,39 +443,39 @@ static BOOL set_process_capability( uint32 cap_flag, BOOL enable )
static BOOL set_inherited_process_capability( uint32 cap_flag, BOOL enable )
{
- if(cap_flag == KERNEL_OPLOCK_CAPABILITY)
- {
- cap_t cap = cap_get_proc();
+ if(cap_flag == KERNEL_OPLOCK_CAPABILITY) {
+ cap_t cap = cap_get_proc();
- if (cap == NULL) {
- DEBUG(0,("set_inherited_process_capability: cap_get_proc failed. Error was %s\n",
- strerror(errno)));
- return False;
- }
+ if (cap == NULL) {
+ DEBUG(0,("set_inherited_process_capability: cap_get_proc failed. Error was %s\n",
+ strerror(errno)));
+ return False;
+ }
- if(enable)
- cap->cap_inheritable |= CAP_NETWORK_MGT;
- else
- cap->cap_inheritable &= ~CAP_NETWORK_MGT;
+ if(enable)
+ cap->cap_inheritable |= CAP_NETWORK_MGT;
+ else
+ cap->cap_inheritable &= ~CAP_NETWORK_MGT;
- if (cap_set_proc(cap) == -1) {
- DEBUG(0,("set_inherited_process_capability: cap_set_proc failed. Error was %s\n",
- strerror(errno)));
- cap_free(cap);
- return False;
- }
+ if (cap_set_proc(cap) == -1) {
+ DEBUG(0,("set_inherited_process_capability: cap_set_proc failed. Error was %s\n",
+ strerror(errno)));
+ cap_free(cap);
+ return False;
+ }
- cap_free(cap);
+ cap_free(cap);
- DEBUG(10,("set_inherited_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
- }
- return True;
+ DEBUG(10,("set_inherited_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
+ }
+ return True;
}
#endif
/****************************************************************************
-gain the oplock capability from the kernel if possible
+ Gain the oplock capability from the kernel if possible.
****************************************************************************/
+
void oplock_set_capability(BOOL this_process, BOOL inherit)
{
#if HAVE_KERNEL_OPLOCKS_IRIX
@@ -456,12 +491,12 @@ void oplock_set_capability(BOOL this_process, BOOL inherit)
long sys_random(void)
{
#if defined(HAVE_RANDOM)
- return (long)random();
+ return (long)random();
#elif defined(HAVE_RAND)
- return (long)rand();
+ return (long)rand();
#else
- DEBUG(0,("Error - no random function available !\n"));
- exit(1);
+ DEBUG(0,("Error - no random function available !\n"));
+ exit(1);
#endif
}
@@ -472,12 +507,12 @@ long sys_random(void)
void sys_srandom(unsigned int seed)
{
#if defined(HAVE_SRANDOM)
- srandom(seed);
+ srandom(seed);
#elif defined(HAVE_SRAND)
- srand(seed);
+ srand(seed);
#else
- DEBUG(0,("Error - no srandom function available !\n"));
- exit(1);
+ DEBUG(0,("Error - no srandom function available !\n"));
+ exit(1);
#endif
}
@@ -488,10 +523,10 @@ void sys_srandom(unsigned int seed)
int groups_max(void)
{
#if defined(SYSCONF_SC_NGROUPS_MAX)
- int ret = sysconf(_SC_NGROUPS_MAX);
- return (ret == -1) ? NGROUPS_MAX : ret;
+ int ret = sysconf(_SC_NGROUPS_MAX);
+ return (ret == -1) ? NGROUPS_MAX : ret;
#else
- return NGROUPS_MAX;
+ return NGROUPS_MAX;
#endif
}
@@ -502,47 +537,47 @@ int groups_max(void)
int sys_getgroups(int setlen, gid_t *gidset)
{
#if !defined(HAVE_BROKEN_GETGROUPS)
- return getgroups(setlen, gidset);
+ return getgroups(setlen, gidset);
#else
- GID_T gid;
- GID_T *group_list;
- int i, ngroups;
+ GID_T gid;
+ GID_T *group_list;
+ int i, ngroups;
- if(setlen == 0) {
- return getgroups(setlen, &gid);
- }
+ if(setlen == 0) {
+ return getgroups(setlen, &gid);
+ }
- /*
- * Broken case. We need to allocate a
- * GID_T array of size setlen.
- */
+ /*
+ * Broken case. We need to allocate a
+ * GID_T array of size setlen.
+ */
- if(setlen < 0) {
- errno = EINVAL;
- return -1;
- }
+ if(setlen < 0) {
+ errno = EINVAL;
+ return -1;
+ }
- if (setlen == 0)
- setlen = groups_max();
+ 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((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;
- }
+ 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];
+ for(i = 0; i < ngroups; i++)
+ gidset[i] = (gid_t)group_list[i];
- SAFE_FREE(group_list);
- return ngroups;
+ SAFE_FREE(group_list);
+ return ngroups;
#endif /* HAVE_BROKEN_GETGROUPS */
}
@@ -556,42 +591,42 @@ int sys_getgroups(int setlen, gid_t *gidset)
int sys_setgroups(int setlen, gid_t *gidset)
{
#if !defined(HAVE_BROKEN_GETGROUPS)
- return setgroups(setlen, gidset);
+ return setgroups(setlen, gidset);
#else
- GID_T *group_list;
- int i ;
+ GID_T *group_list;
+ int i ;
- if (setlen == 0)
- return 0 ;
+ if (setlen == 0)
+ return 0 ;
- if (setlen < 0 || setlen > groups_max()) {
- errno = EINVAL;
- return -1;
- }
+ if (setlen < 0 || setlen > groups_max()) {
+ errno = EINVAL;
+ return -1;
+ }
- /*
- * Broken case. We need to allocate a
- * GID_T array of size setlen.
- */
+ /*
+ * Broken case. We need to allocate a
+ * GID_T array of size setlen.
+ */
- if((group_list = (GID_T *)malloc(setlen * sizeof(GID_T))) == NULL) {
- DEBUG(0,("sys_setgroups: Malloc fail.\n"));
- 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;
- }
+ 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 ;
+ SAFE_FREE(group_list);
+ return 0 ;
#endif /* HAVE_BROKEN_GETGROUPS */
}
@@ -724,6 +759,178 @@ struct passwd *sys_getpwuid(uid_t uid)
return setup_pwret(getpwuid(uid));
}
+#if 0 /* NOT CURRENTLY USED - JRA */
+/**************************************************************************
+ The following are the UNICODE versions of *all* system interface functions
+ called within Samba. Ok, ok, the exceptions are the gethostbyXX calls,
+ which currently are left as ascii as they are not used other than in name
+ resolution.
+****************************************************************************/
+
+/**************************************************************************
+ Wide stat. Just narrow and call sys_xxx.
+****************************************************************************/
+
+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);
+}
+
+/**************************************************************************
+ Wide lstat. Just narrow and call sys_xxx.
+****************************************************************************/
+
+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);
+}
+
+/**************************************************************************
+ Wide creat. Just narrow and call sys_xxx.
+****************************************************************************/
+
+int wsys_creat(const smb_ucs2_t *wfname, mode_t mode)
+{
+ pstring fname;
+ return sys_creat(unicode_to_unix(fname,wfname,sizeof(fname)), mode);
+}
+
+/**************************************************************************
+ Wide open. Just narrow and call sys_xxx.
+****************************************************************************/
+
+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);
+}
+
+/**************************************************************************
+ Wide fopen. Just narrow and call sys_xxx.
+****************************************************************************/
+
+FILE *wsys_fopen(const smb_ucs2_t *wfname, const char *type)
+{
+ pstring fname;
+ return sys_fopen(unicode_to_unix(fname,wfname,sizeof(fname)), type);
+}
+
+/**************************************************************************
+ Wide opendir. Just narrow and call sys_xxx.
+****************************************************************************/
+
+DIR *wsys_opendir(const smb_ucs2_t *wfname)
+{
+ pstring fname;
+ return opendir(unicode_to_unix(fname,wfname,sizeof(fname)));
+}
+
+/**************************************************************************
+ Wide readdir. Return a structure pointer containing a wide filename.
+****************************************************************************/
+
+SMB_STRUCT_WDIRENT *wsys_readdir(DIR *dirp)
+{
+ static SMB_STRUCT_WDIRENT retval;
+ SMB_STRUCT_DIRENT *dirval = sys_readdir(dirp);
+
+ if(!dirval)
+ return NULL;
+
+ /*
+ * The only POSIX defined member of this struct is d_name.
+ */
+
+ unix_to_unicode(retval.d_name,dirval->d_name,sizeof(retval.d_name));
+
+ return &retval;
+}
+
+/**************************************************************************
+ Wide getwd. Call sys_xxx and widen. Assumes s points to a wpstring.
+****************************************************************************/
+
+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));
+}
+
+/**************************************************************************
+ Wide chown. Just narrow and call sys_xxx.
+****************************************************************************/
+
+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);
+}
+
+/**************************************************************************
+ Wide chroot. Just narrow and call sys_xxx.
+****************************************************************************/
+
+int wsys_chroot(const smb_ucs2_t *wfname)
+{
+ pstring fname;
+ return chroot(unicode_to_unix(fname,wfname,sizeof(fname)));
+}
+
+/**************************************************************************
+ Wide getpwnam. Return a structure pointer containing wide names.
+****************************************************************************/
+
+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;
+}
+
+/**************************************************************************
+ Wide getpwuid. Return a structure pointer containing wide names.
+****************************************************************************/
+
+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 /* NOT CURRENTLY USED - JRA */
+
/**************************************************************************
Extract a command into an arg list. Uses a static pstring for storage.
Caller frees returned arg list (which contains pointers into the static pstring).
@@ -905,6 +1112,7 @@ err_exit:
/**************************************************************************
Wrapper for pclose. Modified from the glibc sources.
****************************************************************************/
+
int sys_pclose(int fd)
{
int wstatus;