Makefile.in: Added maintainer mode fixes.

aclocal.m4: Added AC_LIBTESTFUNC.
configure.in: Fixed -lsecurity -lsec problems.
client.c: dos_ fixes.
groupdb/aliasunix.c: Dead code removal.
include/includes.h: Added default PRINTCAP_NAME.
lib/genrand.c: dos_ fixes.
lib/replace.c: Added strtoul.
lib/system.c: dos_ fixes.
lib/util.c: dos_ fixes.
lib/util_sid.c: Signed/unsigned fixes.
lib/util_str.c: removed bad const.
locking/locking_slow.c: dos_ fixes.
printing/printing.c: dos_ fixes.
rpc_server/srv_samr.c: Dead code removal.
rpc_server/srv_sid.c: global_myworkgroup defined with wrong size AGAIN !
smbd/dir.c: dos_ fixes.
smbd/open.c: dos_ fixes.
smbd/oplock.c: dos_ fixes.
smbd/reply.c smbd/server.c smbd/service.c smbd/uid.c: dos_ fixes.

Jeremy.
(This used to be commit 6acb4b68f68d516e2ac3c47e500f5600d653435e)

7 files changed, 574 insertions, 408 deletions

diff --git a/source3/lib/doscalls.c b/source3/lib/doscalls.c
new file mode 100644
index 0000000000..031effcf52
--- /dev/null
+++ b/source3/lib/doscalls.c
@@ -0,0 +1,471 @@
+/* 
+   Unix SMB/Netbios implementation.
+   Version 1.9.
+   Samba system utilities
+   Copyright (C) Jeremy Allison 1992-1998
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+
+/*
+ * Wrappers for calls that need to translate to
+ * DOS/Windows semantics. Note that the pathnames
+ * in all these functions referred to as 'DOS' names
+ * are actually in UNIX path format (ie. '/' instead of
+ * '\' directory separators etc.), but the codepage they
+ * are in is still the client codepage, hence the 'DOS'
+ * name.
+ */
+
+extern int DEBUGLEVEL;
+
+/*******************************************************************
+ Unlink wrapper that calls dos_to_unix.
+********************************************************************/
+
+int dos_unlink(char *fname)
+{
+  return(unlink(dos_to_unix(fname,False)));
+}
+
+/*******************************************************************
+ Open() wrapper that calls dos_to_unix.
+********************************************************************/
+
+int dos_open(char *fname,int flags,mode_t mode)
+{
+  return(sys_open(dos_to_unix(fname,False),flags,mode));
+}
+
+/*******************************************************************
+ Opendir() wrapper that calls dos_to_unix.
+********************************************************************/
+
+DIR *dos_opendir(char *dname)
+{
+  return(opendir(dos_to_unix(dname,False)));
+}
+
+/*******************************************************************
+ Readdirname() wrapper that calls unix_to_dos.
+********************************************************************/
+
+char *dos_readdirname(DIR *p)
+{
+  char *dname = readdirname(p);
+
+  if (!dname)
+    return(NULL);
+ 
+  unix_to_dos(dname, True);
+  return(dname);
+}
+
+/*******************************************************************
+ A stat() wrapper that calls dos_to_unix.
+********************************************************************/
+
+int dos_stat(char *fname,SMB_STRUCT_STAT *sbuf)
+{
+  return(sys_stat(dos_to_unix(fname,False),sbuf));
+}
+
+/*******************************************************************
+ An lstat() that calls dos_to_unix.
+********************************************************************/
+
+int dos_lstat(char *fname,SMB_STRUCT_STAT *sbuf)
+{
+  return(sys_lstat(dos_to_unix(fname,False),sbuf));
+}
+
+/*******************************************************************
+ Mkdir() that calls dos_to_unix.
+********************************************************************/
+
+int dos_mkdir(char *dname,mode_t mode)
+{
+  return(mkdir(dos_to_unix(dname,False),mode));
+}
+
+/*******************************************************************
+ Rmdir() - call dos_to_unix.
+********************************************************************/
+
+int dos_rmdir(char *dname)
+{
+  return(rmdir(dos_to_unix(dname,False)));
+}
+
+/*******************************************************************
+ chdir() - call dos_to_unix.
+********************************************************************/
+
+int dos_chdir(char *dname)
+{
+  return(chdir(dos_to_unix(dname,False)));
+}
+
+/*******************************************************************
+ Utime() - call dos_to_unix.
+********************************************************************/
+
+int dos_utime(char *fname,struct utimbuf *times)
+{
+  /* if the modtime is 0 or -1 then ignore the call and
+     return success */
+  if (times->modtime == (time_t)0 || times->modtime == (time_t)-1)
+    return 0;
+  
+  /* if the access time is 0 or -1 then set it to the modtime */
+  if (times->actime == (time_t)0 || times->actime == (time_t)-1)
+    times->actime = times->modtime;
+   
+  return(utime(dos_to_unix(fname,False),times));
+}
+
+/*********************************************************
+ For rename across filesystems Patch from Warren Birnbaum 
+ <warrenb@hpcvscdp.cv.hp.com>
+**********************************************************/
+
+static int copy_reg(char *source, const char *dest)
+{
+  SMB_STRUCT_STAT source_stats;
+  int ifd;
+  int ofd;
+  char *buf;
+  int len;                      /* Number of bytes read into `buf'. */
+
+  sys_lstat (source, &source_stats);
+  if (!S_ISREG (source_stats.st_mode))
+    return 1;
+
+  if (unlink (dest) && errno != ENOENT)
+    return 1;
+
+  if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
+    return 1;
+
+  if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0 )
+  {
+    close (ifd);
+    return 1;
+  }
+
+  if((buf = malloc( COPYBUF_SIZE )) == NULL)
+  {
+    close (ifd);  
+    close (ofd);  
+    unlink (dest);
+    return 1;
+  }
+
+  while ((len = read(ifd, buf, COPYBUF_SIZE)) > 0)
+  {
+    if (write_data(ofd, buf, len) < 0)
+    {
+      close (ifd);
+      close (ofd);
+      unlink (dest);
+      free(buf);
+      return 1;
+    }
+  }
+  free(buf);
+  if (len < 0)
+  {
+    close (ifd);
+    close (ofd);
+    unlink (dest);
+    return 1;
+  }
+
+  if (close (ifd) < 0)
+  {
+    close (ofd);
+    return 1;
+  }
+  if (close (ofd) < 0)
+    return 1;
+
+  /* chown turns off set[ug]id bits for non-root,
+     so do the chmod last.  */
+
+  /* Try to copy the old file's modtime and access time.  */
+  {
+    struct utimbuf tv;
+
+    tv.actime = source_stats.st_atime;
+    tv.modtime = source_stats.st_mtime;
+    if (utime (dest, &tv))
+      return 1;
+  }
+
+  /* Try to preserve ownership.  For non-root it might fail, but that's ok.
+     But root probably wants to know, e.g. if NFS disallows it.  */
+  if (chown (dest, source_stats.st_uid, source_stats.st_gid)
+      && (errno != EPERM))
+    return 1;
+
+  if (chmod (dest, source_stats.st_mode & 07777))
+    return 1;
+
+  unlink (source);
+  return 0;
+}
+
+/*******************************************************************
+ Rename() - call dos_to_unix.
+********************************************************************/
+
+int dos_rename(char *from, char *to)
+{
+    int rcode;  
+    pstring zfrom, zto;
+
+    pstrcpy (zfrom, dos_to_unix (from, False));
+    pstrcpy (zto, dos_to_unix (to, False));
+    rcode = rename (zfrom, zto);
+
+    if (errno == EXDEV) 
+    {
+      /* Rename across filesystems needed. */
+      rcode = copy_reg (zfrom, zto);        
+    }
+    return rcode;
+}
+
+/*******************************************************************
+ Chmod - call dos_to_unix.
+********************************************************************/
+
+int dos_chmod(char *fname,mode_t mode)
+{
+  return(chmod(dos_to_unix(fname,False),mode));
+}
+
+/*******************************************************************
+ Getwd - takes a UNIX directory name and returns the name
+ in dos format.
+********************************************************************/
+
+char *dos_getwd(char *unix_path)
+{
+	char *wd;
+	wd = sys_getwd(unix_path);
+	if (wd)
+		unix_to_dos(wd, True);
+	return wd;
+}
+
+/*******************************************************************
+ Check if a DOS file exists.
+********************************************************************/
+
+BOOL dos_file_exist(char *fname,SMB_STRUCT_STAT *sbuf)
+{
+  return file_exist(dos_to_unix(fname, False), sbuf);
+}
+
+/*******************************************************************
+ Check if a DOS directory exists.
+********************************************************************/
+
+BOOL dos_directory_exist(char *dname,SMB_STRUCT_STAT *st)
+{
+  return directory_exist(dos_to_unix(dname, False), st);
+}
+
+/*******************************************************************
+ Return the modtime of a DOS pathname.
+********************************************************************/
+
+time_t dos_file_modtime(char *fname)
+{
+  return file_modtime(dos_to_unix(fname, False));
+}
+
+/*******************************************************************
+ Return the file size of a DOS pathname.
+********************************************************************/
+
+SMB_OFF_T dos_file_size(char *file_name)
+{
+  return file_size(dos_to_unix(file_name, False));
+}
+
+/*******************************************************************
+ A wrapper for dos_chdir().
+********************************************************************/
+
+int dos_ChDir(char *path)
+{
+  int res;
+  static pstring LastDir="";
+
+  if (strcsequal(path,"."))
+    return(0);
+
+  if (*path == '/' && strcsequal(LastDir,path))
+    return(0);
+
+  DEBUG(3,("dos_ChDir to %s\n",path));
+
+  res = dos_chdir(path);
+  if (!res)
+    pstrcpy(LastDir,path);
+  return(res);
+}
+
+/* number of list structures for a caching GetWd function. */
+#define MAX_GETWDCACHE (50)
+
+struct
+{
+  SMB_DEV_T dev; /* These *must* be compatible with the types returned in a stat() call. */
+  SMB_INO_T inode; /* These *must* be compatible with the types returned in a stat() call. */
+  char *dos_path; /* The pathname in DOS format. */
+  BOOL valid;
+} ino_list[MAX_GETWDCACHE];
+
+BOOL use_getwd_cache=True;
+
+/****************************************************************************
+ Prompte a ptr (to make it recently used)
+****************************************************************************/
+
+static void array_promote(char *array,int elsize,int element)
+{
+  char *p;
+  if (element == 0)
+    return;
+
+  p = (char *)malloc(elsize);
+
+  if (!p)
+    {
+      DEBUG(5,("Ahh! Can't malloc\n"));
+      return;
+    }
+  memcpy(p,array + element * elsize, elsize);
+  memmove(array + elsize,array,elsize*element);
+  memcpy(array,p,elsize);
+  free(p);
+}
+
+/*******************************************************************
+ Return the absolute current directory path - given a UNIX pathname.
+ Note that this path is returned in DOS format, not UNIX
+ format.
+********************************************************************/
+
+char *dos_GetWd(char *path)
+{
+  pstring s;
+  static BOOL getwd_cache_init = False;
+  SMB_STRUCT_STAT st, st2;
+  int i;
+
+  *s = 0;
+
+  if (!use_getwd_cache)
+    return(dos_getwd(path));
+
+  /* init the cache */
+  if (!getwd_cache_init)
+  {
+    getwd_cache_init = True;
+    for (i=0;i<MAX_GETWDCACHE;i++)
+    {
+      string_init(&ino_list[i].dos_path,"");
+      ino_list[i].valid = False;
+    }
+  }
+
+  /*  Get the inode of the current directory, if this doesn't work we're
+      in trouble :-) */
+
+  if (sys_stat(".",&st) == -1)
+  {
+    DEBUG(0,("Very strange, couldn't stat \".\"\n"));
+    return(dos_getwd(path));
+  }
+
+
+  for (i=0; i<MAX_GETWDCACHE; i++)
+    if (ino_list[i].valid)
+    {
+
+      /*  If we have found an entry with a matching inode and dev number
+          then find the inode number for the directory in the cached string.
+          If this agrees with that returned by the stat for the current
+          directory then all is o.k. (but make sure it is a directory all
+          the same...) */
+
+      if (st.st_ino == ino_list[i].inode &&
+          st.st_dev == ino_list[i].dev)
+      {
+        if (dos_stat(ino_list[i].dos_path,&st2) == 0)
+        {
+          if (st.st_ino == st2.st_ino &&
+              st.st_dev == st2.st_dev &&
+              (st2.st_mode & S_IFMT) == S_IFDIR)
+          {
+            pstrcpy (path, ino_list[i].dos_path);
+
+            /* promote it for future use */
+            array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
+            return (path);
+          }
+          else
+          {
+            /*  If the inode is different then something's changed,
+                scrub the entry and start from scratch. */
+            ino_list[i].valid = False;
+          }
+        }
+      }
+    }
+
+
+  /*  We don't have the information to hand so rely on traditional methods.
+      The very slow getcwd, which spawns a process on some systems, or the
+      not quite so bad getwd. */
+
+  if (!dos_getwd(s))
+  {
+    DEBUG(0,("dos_GetWd: dos_getwd call failed, errno %s\n",strerror(errno)));
+    return (NULL);
+  }
+
+  pstrcpy(path,s);
+
+  DEBUG(5,("dos_GetWd %s, inode %.0f, dev %.0f\n",s,(double)st.st_ino,(double)st.st_dev));
+
+  /* add it to the cache */
+  i = MAX_GETWDCACHE - 1;
+  string_set(&ino_list[i].dos_path,s);
+  ino_list[i].dev = st.st_dev;
+  ino_list[i].inode = st.st_ino;
+  ino_list[i].valid = True;
+
+  /* put it at the top of the list */
+  array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
+
+  return (path);
+}
diff --git a/source3/lib/genrand.c b/source3/lib/genrand.c
index 8b05b02f94..90e4a3194e 100644
--- a/source3/lib/genrand.c
+++ b/source3/lib/genrand.c
@@ -56,7 +56,7 @@ static void do_filehash(char *fname, unsigned char *hash)
 
 static void do_dirrand(char *name, unsigned char *buf, int buf_len)
 {
-  void *dp = dos_opendir(name);
+  DIR *dp = opendir(name);
   pstring fullname;
   int len_left;
   int fullname_len;
@@ -86,7 +86,7 @@ static void do_dirrand(char *name, unsigned char *buf, int buf_len)
       if(strlen(p) <= len_left)
         pstrcpy(pos, p);
 
-      if(dos_stat(fullname,&st) == 0) {
+      if(sys_stat(fullname,&st) == 0) {
         SIVAL(buf, ((counter * 4)%(buf_len-4)), 
               IVAL(buf,((counter * 4)%(buf_len-4))) ^ st.st_atime);
         counter++;
diff --git a/source3/lib/replace.c b/source3/lib/replace.c
index 2d4ed775a4..a768e9ce47 100644
--- a/source3/lib/replace.c
+++ b/source3/lib/replace.c
@@ -299,3 +299,71 @@ char *rep_inet_ntoa(struct in_addr ip)
 }
 #endif /* REPLACE_INET_NTOA */
 
+#ifndef HAVE_STRTOUL
+#ifndef ULONG_MAX
+#define	ULONG_MAX	((unsigned long)(~0L))		/* 0xFFFFFFFF */
+#endif
+
+/*
+ * Convert a string to an unsigned long integer.
+ * Taken from libg++ - libiberty code.
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+ unsigned long strtoul(const char *nptr, char **endptr, int base)
+{
+	const char *s = nptr;
+	unsigned long acc;
+	int c;
+	unsigned long cutoff;
+	int neg = 0, any, cutlim;
+
+	/*
+	 * See strtol for comments as to the logic used.
+	 */
+	do {
+		c = *s++;
+	} while (isspace(c));
+	if (c == '-') {
+		neg = 1;
+		c = *s++;
+	} else if (c == '+')
+		c = *s++;
+	if ((base == 0 || base == 16) &&
+	    c == '0' && (*s == 'x' || *s == 'X')) {
+		c = s[1];
+		s += 2;
+		base = 16;
+	}
+	if (base == 0)
+		base = c == '0' ? 8 : 10;
+	cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
+	cutlim = (int)((unsigned long)ULONG_MAX % (unsigned long)base);
+	for (acc = 0, any = 0;; c = *s++) {
+		if (isdigit(c))
+			c -= '0';
+		else if (isalpha(c))
+			c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+		else
+			break;
+		if (c >= base)
+			break;
+		if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
+			any = -1;
+		else {
+			any = 1;
+			acc *= base;
+			acc += c;
+		}
+	}
+	if (any < 0) {
+		acc = ULONG_MAX;
+		errno = ERANGE;
+	} else if (neg)
+		acc = -acc;
+	if (endptr != 0)
+		*endptr = (char *) (any ? s - 1 : nptr);
+	return (acc);
+}
+#endif /* HAVE_STRTOUL */
diff --git a/source3/lib/system.c b/source3/lib/system.c
index d07df3faf0..edf8bb9da7 100644
--- a/source3/lib/system.c
+++ b/source3/lib/system.c
@@ -143,7 +143,7 @@ int sys_select(int maxfd, fd_set *fds,struct timeval *tval)
 A stat() wrapper that will deal with 64 bit filesizes.
 ********************************************************************/
 
-int sys_stat(char *fname,SMB_STRUCT_STAT *sbuf)
+int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
 {
 #if defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
   return stat64(fname, sbuf);
@@ -169,7 +169,7 @@ int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
  An lstat() wrapper that will deal with 64 bit filesizes.
 ********************************************************************/
 
-int sys_lstat(char *fname,SMB_STRUCT_STAT *sbuf)
+int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
 {
 #if defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
   return lstat64(fname, sbuf);
@@ -287,42 +287,9 @@ void *sys_mmap(void *addr, size_t len, int prot, int flags, int fd, SMB_OFF_T of
 }
 
 /*******************************************************************
-just a unlink wrapper that calls dos_to_unix.
-********************************************************************/
-int dos_unlink(char *fname)
-{
-  return(unlink(dos_to_unix(fname,False)));
-}
-
-
-/*******************************************************************
-a simple open() wrapper that calls dos_to_unix.
-********************************************************************/
-int dos_open(char *fname,int flags,mode_t mode)
-{
-  return(sys_open(dos_to_unix(fname,False),flags,mode));
-}
-
-
-/*******************************************************************
-a simple opendir() wrapper that calls dos_to_unix
-********************************************************************/
-DIR *dos_opendir(char *dname)
-{
-	return(opendir(dos_to_unix(dname,False)));
-}
-
-/*******************************************************************
-and a stat() wrapper that calls dos_to_unix.
-********************************************************************/
-int dos_stat(char *fname,SMB_STRUCT_STAT *sbuf)
-{
-  return(sys_stat(dos_to_unix(fname,False),sbuf));
-}
-
-/*******************************************************************
 The wait() calls vary between systems
 ********************************************************************/
+
 int sys_waitpid(pid_t pid,int *status,int options)
 {
 #ifdef HAVE_WAITPID
@@ -333,174 +300,6 @@ int sys_waitpid(pid_t pid,int *status,int options)
 }
 
 /*******************************************************************
-don't forget lstat() that calls dos_to_unix.
-********************************************************************/
-int dos_lstat(char *fname,SMB_STRUCT_STAT *sbuf)
-{
-  return(sys_lstat(dos_to_unix(fname,False),sbuf));
-}
-
-/*******************************************************************
-mkdir() gets a wrapper that calls dos_to_unix.
-********************************************************************/
-int dos_mkdir(char *dname,mode_t mode)
-{
-  return(mkdir(dos_to_unix(dname,False),mode));
-}
-
-/*******************************************************************
-do does rmdir() - call dos_to_unix
-********************************************************************/
-int dos_rmdir(char *dname)
-{
-  return(rmdir(dos_to_unix(dname,False)));
-}
-
-/*******************************************************************
-I almost forgot chdir() - call dos_to_unix.
-********************************************************************/
-int dos_chdir(char *dname)
-{
-  return(chdir(dos_to_unix(dname,False)));
-}
-
-/*******************************************************************
-now for utime() - call dos_to_unix.
-********************************************************************/
-int dos_utime(char *fname,struct utimbuf *times)
-{
-  /* if the modtime is 0 or -1 then ignore the call and
-     return success */
-  if (times->modtime == (time_t)0 || times->modtime == (time_t)-1)
-    return 0;
-  
-  /* if the access time is 0 or -1 then set it to the modtime */
-  if (times->actime == (time_t)0 || times->actime == (time_t)-1)
-    times->actime = times->modtime;
-   
-  return(utime(dos_to_unix(fname,False),times));
-}
-
-/*********************************************************
-for rename across filesystems Patch from Warren Birnbaum 
-<warrenb@hpcvscdp.cv.hp.com>
-**********************************************************/
-
-static int copy_reg(char *source, const char *dest)
-{
-  SMB_STRUCT_STAT source_stats;
-  int ifd;
-  int ofd;
-  char *buf;
-  int len;                      /* Number of bytes read into `buf'. */
-
-  sys_lstat (source, &source_stats);
-  if (!S_ISREG (source_stats.st_mode))
-    return 1;
-
-  if (unlink (dest) && errno != ENOENT)
-    return 1;
-
-  if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
-    return 1;
-
-  if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0 )
-  {
-    close (ifd);
-    return 1;
-  }
-
-  if((buf = malloc( COPYBUF_SIZE )) == NULL)
-  {
-    close (ifd);  
-    close (ofd);  
-    unlink (dest);
-    return 1;
-  }
-
-  while ((len = read(ifd, buf, COPYBUF_SIZE)) > 0)
-  {
-    if (write_data(ofd, buf, len) < 0)
-    {
-      close (ifd);
-      close (ofd);
-      unlink (dest);
-      free(buf);
-      return 1;
-    }
-  }
-  free(buf);
-  if (len < 0)
-  {
-    close (ifd);
-    close (ofd);
-    unlink (dest);
-    return 1;
-  }
-
-  if (close (ifd) < 0)
-  {
-    close (ofd);
-    return 1;
-  }
-  if (close (ofd) < 0)
-    return 1;
-
-  /* chown turns off set[ug]id bits for non-root,
-     so do the chmod last.  */
-
-  /* Try to copy the old file's modtime and access time.  */
-  {
-    struct utimbuf tv;
-
-    tv.actime = source_stats.st_atime;
-    tv.modtime = source_stats.st_mtime;
-    if (utime (dest, &tv))
-      return 1;
-  }
-
-  /* Try to preserve ownership.  For non-root it might fail, but that's ok.
-     But root probably wants to know, e.g. if NFS disallows it.  */
-  if (chown (dest, source_stats.st_uid, source_stats.st_gid)
-      && (errno != EPERM))
-    return 1;
-
-  if (chmod (dest, source_stats.st_mode & 07777))
-    return 1;
-
-  unlink (source);
-  return 0;
-}
-
-/*******************************************************************
-for rename() - call dos_to_unix.
-********************************************************************/
-int dos_rename(char *from, char *to)
-{
-    int rcode;  
-    pstring zfrom, zto;
-
-    pstrcpy (zfrom, dos_to_unix (from, False));
-    pstrcpy (zto, dos_to_unix (to, False));
-    rcode = rename (zfrom, zto);
-
-    if (errno == EXDEV) 
-    {
-      /* Rename across filesystems needed. */
-      rcode = copy_reg (zfrom, zto);        
-    }
-    return rcode;
-}
-
-/*******************************************************************
-for chmod - call dos_to_unix.
-********************************************************************/
-int dos_chmod(char *fname,mode_t mode)
-{
-  return(chmod(dos_to_unix(fname,False),mode));
-}
-
-/*******************************************************************
 system wrapper for getwd
 ********************************************************************/
 char *sys_getwd(char *s)
@@ -515,22 +314,9 @@ char *sys_getwd(char *s)
 }
 
 /*******************************************************************
-for getwd - takes a UNIX directory name and returns the name
-in dos format.
-********************************************************************/
-char *dos_getwd(char *s)
-{
-	char *wd;
-	wd = sys_getwd(s);
-	if (wd)
-		unix_to_dos(wd, True);
-	return wd;
-}
-
-/*******************************************************************
 chown isn't used much but OS/2 doesn't have it
 ********************************************************************/
-int sys_chown(char *fname,uid_t uid,gid_t gid)
+int sys_chown(const char *fname,uid_t uid,gid_t gid)
 {
 #ifndef HAVE_CHOWN
 	static int done;
@@ -546,7 +332,7 @@ int sys_chown(char *fname,uid_t uid,gid_t gid)
 /*******************************************************************
 os/2 also doesn't have chroot
 ********************************************************************/
-int sys_chroot(char *dname)
+int sys_chroot(const char *dname)
 {
 #ifndef HAVE_CHROOT
 	static int done;
@@ -564,7 +350,7 @@ 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(char *name)
+struct hostent *sys_gethostbyname(const char *name)
 {
 #ifdef REDUCE_ROOT_DNS_LOOKUPS
   char query[256], hostname[256];
diff --git a/source3/lib/util.c b/source3/lib/util.c
index ad5dbcf106..757abc8175 100644
--- a/source3/lib/util.c
+++ b/source3/lib/util.c
@@ -100,30 +100,6 @@ char *tmpdir(void)
   return "/tmp";
 }
 
-
-
-/****************************************************************************
-prompte a dptr (to make it recently used)
-****************************************************************************/
-static void array_promote(char *array,int elsize,int element)
-{
-  char *p;
-  if (element == 0)
-    return;
-
-  p = (char *)malloc(elsize);
-
-  if (!p)
-    {
-      DEBUG(5,("Ahh! Can't malloc\n"));
-      return;
-    }
-  memcpy(p,array + element * elsize, elsize);
-  memmove(array + elsize,array,elsize*element);
-  memcpy(array,p,elsize);
-  free(p);
-}
-
 /****************************************************************************
 determine whether we are in the specified group
 ****************************************************************************/
@@ -189,7 +165,7 @@ char *Atoic(char *p, int *n, char *c)
 	return p;
 }
 
-int* add_num_to_list(uint32 **num, int *count, int val)
+uint32 *add_num_to_list(uint32 **num, int *count, int val)
 {
 	(*num) = Realloc((*num), ((*count)+1) * sizeof(uint32));
 	if ((*num) == NULL)
@@ -201,6 +177,7 @@ int* add_num_to_list(uint32 **num, int *count, int val)
 
 	return (*num);
 }
+
 /*************************************************************************
  reads a list of numbers
  *************************************************************************/
@@ -383,7 +360,7 @@ BOOL file_exist(char *fname,SMB_STRUCT_STAT *sbuf)
   SMB_STRUCT_STAT st;
   if (!sbuf) sbuf = &st;
   
-  if (dos_stat(fname,sbuf) != 0) 
+  if (sys_stat(fname,sbuf) != 0) 
     return(False);
 
   return(S_ISREG(sbuf->st_mode));
@@ -396,7 +373,7 @@ time_t file_modtime(char *fname)
 {
   SMB_STRUCT_STAT st;
   
-  if (dos_stat(fname,&st) != 0) 
+  if (sys_stat(fname,&st) != 0) 
     return(0);
 
   return(st.st_mtime);
@@ -412,7 +389,7 @@ BOOL directory_exist(char *dname,SMB_STRUCT_STAT *st)
 
   if (!st) st = &st2;
 
-  if (dos_stat(dname,st) != 0) 
+  if (sys_stat(dname,st) != 0) 
     return(False);
 
   ret = S_ISDIR(st->st_mode);
@@ -428,7 +405,8 @@ SMB_OFF_T file_size(char *file_name)
 {
   SMB_STRUCT_STAT buf;
   buf.st_size = 0;
-  dos_stat(file_name,&buf);
+  if(sys_stat(file_name,&buf) != 0)
+    return (SMB_OFF_T)-1;
   return(buf.st_size);
 }
 
@@ -451,8 +429,6 @@ char *attrib_string(uint16 mode)
   return(attrstr);
 }
 
-
-
 /****************************************************************************
   make a file into unix format
 ****************************************************************************/
@@ -667,141 +643,6 @@ void unix_clean_name(char *s)
   trim_string(s,NULL,"/..");
 }
 
-
-/*******************************************************************
-a wrapper for the normal chdir() function
-********************************************************************/
-int ChDir(char *path)
-{
-  int res;
-  static pstring LastDir="";
-
-  if (strcsequal(path,".")) return(0);
-
-  if (*path == '/' && strcsequal(LastDir,path)) return(0);
-  DEBUG(3,("chdir to %s\n",path));
-  res = dos_chdir(path);
-  if (!res)
-    pstrcpy(LastDir,path);
-  return(res);
-}
-
-/* number of list structures for a caching GetWd function. */
-#define MAX_GETWDCACHE (50)
-
-struct
-{
-  SMB_DEV_T dev; /* These *must* be compatible with the types returned in a stat() call. */
-  SMB_INO_T inode; /* These *must* be compatible with the types returned in a stat() call. */
-  char *text; /* The pathname in DOS format. */
-  BOOL valid;
-} ino_list[MAX_GETWDCACHE];
-
-BOOL use_getwd_cache=True;
-
-/*******************************************************************
-  return the absolute current directory path - given a UNIX pathname.
-  Note that this path is returned in DOS format, not UNIX
-  format.
-********************************************************************/
-char *GetWd(char *str)
-{
-  pstring s;
-  static BOOL getwd_cache_init = False;
-  SMB_STRUCT_STAT st, st2;
-  int i;
-
-  *s = 0;
-
-  if (!use_getwd_cache)
-    return(dos_getwd(str));
-
-  /* init the cache */
-  if (!getwd_cache_init)
-  {
-    getwd_cache_init = True;
-    for (i=0;i<MAX_GETWDCACHE;i++)
-    {
-      string_init(&ino_list[i].text,"");
-      ino_list[i].valid = False;
-    }
-  }
-
-  /*  Get the inode of the current directory, if this doesn't work we're
-      in trouble :-) */
-
-  if (dos_stat(".",&st) == -1) 
-  {
-    DEBUG(0,("Very strange, couldn't stat \".\"\n"));
-    return(dos_getwd(str));
-  }
-
-
-  for (i=0; i<MAX_GETWDCACHE; i++)
-    if (ino_list[i].valid)
-    {
-
-      /*  If we have found an entry with a matching inode and dev number
-          then find the inode number for the directory in the cached string.
-          If this agrees with that returned by the stat for the current
-          directory then all is o.k. (but make sure it is a directory all
-          the same...) */
-      
-      if (st.st_ino == ino_list[i].inode &&
-          st.st_dev == ino_list[i].dev)
-      {
-        if (dos_stat(ino_list[i].text,&st2) == 0)
-        {
-          if (st.st_ino == st2.st_ino &&
-              st.st_dev == st2.st_dev &&
-              (st2.st_mode & S_IFMT) == S_IFDIR)
-          {
-            pstrcpy (str, ino_list[i].text);
-
-            /* promote it for future use */
-            array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
-            return (str);
-          }
-          else
-          {
-            /*  If the inode is different then something's changed, 
-                scrub the entry and start from scratch. */
-            ino_list[i].valid = False;
-          }
-        }
-      }
-    }
-
-
-  /*  We don't have the information to hand so rely on traditional methods.
-      The very slow getcwd, which spawns a process on some systems, or the
-      not quite so bad getwd. */
-
-  if (!dos_getwd(s))
-  {
-    DEBUG(0,("Getwd failed, errno %s\n",strerror(errno)));
-    return (NULL);
-  }
-
-  pstrcpy(str,s);
-
-  DEBUG(5,("GetWd %s, inode %d, dev %x\n",s,(int)st.st_ino,(int)st.st_dev));
-
-  /* add it to the cache */
-  i = MAX_GETWDCACHE - 1;
-  string_set(&ino_list[i].text,s);
-  ino_list[i].dev = st.st_dev;
-  ino_list[i].inode = st.st_ino;
-  ino_list[i].valid = True;
-
-  /* put it at the top of the list */
-  array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
-
-  return (str);
-}
-
-
-
 /*******************************************************************
 reduce a file name, removing .. elements and checking that 
 it is below dir in the heirachy. This uses GetWd() and so must be run
@@ -809,6 +650,7 @@ on the system that has the referenced file system.
 
 widelinks are allowed if widelinks is true
 ********************************************************************/
+
 BOOL reduce_name(char *s,char *dir,BOOL widelinks)
 {
 #ifndef REDUCE_PATHS
@@ -850,22 +692,22 @@ BOOL reduce_name(char *s,char *dir,BOOL widelinks)
   if (!p)
     return(True);
 
-  if (!GetWd(wd))
+  if (!dos_GetWd(wd))
     {
       DEBUG(0,("couldn't getwd for %s %s\n",s,dir));
       return(False);
     }
 
-  if (ChDir(dir) != 0)
+  if (dos_ChDir(dir) != 0)
     {
       DEBUG(0,("couldn't chdir to %s\n",dir));
       return(False);
     }
 
-  if (!GetWd(dir2))
+  if (!dos_GetWd(dir2))
     {
       DEBUG(0,("couldn't getwd for %s\n",dir));
-      ChDir(wd);
+      dos_ChDir(wd);
       return(False);
     }
 
@@ -879,16 +721,16 @@ BOOL reduce_name(char *s,char *dir,BOOL widelinks)
 	  *p = '/';
       }
 
-  if (ChDir(base_name) != 0)
+  if (dos_ChDir(base_name) != 0)
     {
-      ChDir(wd);
+      dos_ChDir(wd);
       DEBUG(3,("couldn't chdir for %s %s basename=%s\n",s,dir,base_name));
       return(False);
     }
 
-  if (!GetWd(newname))
+  if (!dos_GetWd(newname))
     {
-      ChDir(wd);
+      dos_ChDir(wd);
       DEBUG(2,("couldn't get wd for %s %s\n",s,dir2));
       return(False);
     }
@@ -900,13 +742,13 @@ BOOL reduce_name(char *s,char *dir,BOOL widelinks)
     }
 
   {
-    int l = strlen(dir2);    
+    size_t l = strlen(dir2);    
     if (dir2[l-1] == '/')
       l--;
 
     if (strncmp(newname,dir2,l) != 0)
       {
-	ChDir(wd);
+	dos_ChDir(wd);
 	DEBUG(2,("Bad access attempt? s=%s dir=%s newname=%s l=%d\n",s,dir2,newname,l));
 	return(False);
       }
@@ -922,7 +764,7 @@ BOOL reduce_name(char *s,char *dir,BOOL widelinks)
       pstrcpy(s,newname);
   }
 
-  ChDir(wd);
+  dos_ChDir(wd);
 
   if (strlen(s) == 0)
     pstrcpy(s,"./");
@@ -2536,7 +2378,7 @@ void smb_panic(char *why)
 /*******************************************************************
 a readdir wrapper which just returns the file name
 ********************************************************************/
-char *readdirname(void *p)
+char *readdirname(DIR *p)
 {
 	struct dirent *ptr;
 	char *dname;
@@ -2560,7 +2402,6 @@ char *readdirname(void *p)
 	{
 		static pstring buf;
 		memcpy(buf, dname, NAMLEN(ptr)+1);
-		unix_to_dos(buf, True);
 		dname = buf;
 	}
 
diff --git a/source3/lib/util_sid.c b/source3/lib/util_sid.c
index a483f85b84..8741479067 100644
--- a/source3/lib/util_sid.c
+++ b/source3/lib/util_sid.c
@@ -39,11 +39,11 @@ char *sid_to_string(pstring sidstr_out, DOM_SID *sid)
               (sid->id_auth[3] << 16) +
               (sid->id_auth[2] << 24);
 
-  slprintf(sidstr_out, sizeof(pstring) - 1, "S-%d-%d", sid->sid_rev_num, ia);
+  slprintf(sidstr_out, sizeof(pstring) - 1, "S-%u-%lu", (unsigned int)sid->sid_rev_num, (unsigned long)ia);
 
   for (i = 0; i < sid->num_auths; i++)
   {
-    slprintf(subauth, sizeof(subauth)-1, "-%u", sid->sub_auths[i]);
+    slprintf(subauth, sizeof(subauth)-1, "-%lu", (unsigned long)sid->sub_auths[i]);
     pstrcat(sidstr_out, subauth);
   }
 
@@ -76,7 +76,7 @@ BOOL string_to_sid(DOM_SID *sidout, char *sidstr)
   }
 
   /* Get the revision number. */
-  sidout->sid_rev_num = atoi(tok);
+  sidout->sid_rev_num = (uint8)strtoul(tok,NULL,10);
 
   if (!next_token(&p, tok, "-", sizeof(tok))) {
     DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
@@ -84,7 +84,7 @@ BOOL string_to_sid(DOM_SID *sidout, char *sidstr)
   }
 
   /* identauth in decimal should be <  2^32 */
-  ia = atoi(tok);
+  ia = (uint32)strtoul(tok,NULL,10);
 
   /* NOTE - the ia value is in big-endian format. */
   sidout->id_auth[0] = 0;
@@ -104,7 +104,7 @@ BOOL string_to_sid(DOM_SID *sidout, char *sidstr)
      * are converted to little-endian when linearized onto the wire.
      */
 	uint32 rid = (uint32)strtoul(tok, NULL, 10);
-	DEBUG(50,("string_to_sid: tok: %s rid 0x%x\n", tok, rid));
+	DEBUG(50,("string_to_sid: tok: %s rid 0x%lx\n", tok, (unsigned long)rid));
 	sid_append_rid(sidout, rid);
   }
 
diff --git a/source3/lib/util_str.c b/source3/lib/util_str.c
index d01e0d8d39..a55d4cd8dc 100644
--- a/source3/lib/util_str.c
+++ b/source3/lib/util_str.c
@@ -458,11 +458,11 @@ void string_replace(char *s,char oldc,char newc)
 /*******************************************************************
 skip past some strings in a buffer
 ********************************************************************/
-char *skip_string(const char *buf,size_t n)
+char *skip_string(char *buf,size_t n)
 {
   while (n--)
     buf += strlen(buf) + 1;
-  return((char *)buf);
+  return(buf);
 }
 
 /*******************************************************************