Getting ready to add UNIX extensions in HEAD also.

Jeremy
(This used to be commit 6210d4aa196c944e47076e316980f76ac9c6b02d)

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;