r853: remove a real big bunch of unused code

I really think that this is needed to get a better overview of what is currently used
Also this stuff is really out of date

so if we really ever need some of this stuff back,
a 'svn copy' from the SAMBA_3_0 branch should be no big problem...

metze
(This used to be commit 972598d511c64f29bdc849fe58c9c82fbcf6a4a2)

13 files changed, 0 insertions, 4341 deletions

diff --git a/source4/smbwrapper/PORTING b/source4/smbwrapper/PORTING
deleted file mode 100644
index 884246d078..0000000000
--- a/source4/smbwrapper/PORTING
+++ /dev/null
@@ -1,77 +0,0 @@
-This describes how to port the smbwrapper portion of Samba to a new
-unix-like platform. Note that porting smbwrapper is considerably
-harder than porting Samba, for Samba you generally just need to run
-configure and recompile whereas for smbwrapper some extra effort is
-generally required.
-
-
-STEP 1
-------
-
-The first step is to work out how to create a shared library on your
-OS and how to compile C code to produce position independent object
-files (PIC files). You shoud be able to find this information in the
-man pages for your compiler and loader (ld). Then modify configure.in
-to give that information to Samba.
-
-
-STEP 2
-------
-
-The next step is to work out how to preload shared objects. On many
-systems this is done using a LD_PRELOAD environment variable. On
-others (shc as IRIX) it may use a _RTL_LIST variable.
-
-To make sure it works I suggest you create two C files like this:
-
-/* first C file */
-main()
-{
- unlink("foo.txt");
-}
-
-/* second C file */
-#include <stdio.h>
-
-int unlink(char *fname)
-{
-	fprintf(stderr,"unlink(%s) called\n",fname);
-}
-
-
-then compile the first as an ordinary C program and the second as a
-shared library. Then use LD_PRELOAD to preload the resulting shared
-library. Then run the first program. It should print "unlink(foo.txt)
-called". If it doesn't then consult your man pages till you get it
-right.
-
-Once you work this out then edit smbwrapper/smbsh.in and add a section
-if necessary to correctly set the necessary preload options for your
-OS. 
-
-
-STEP 3
-------
-
-The next step is to work out how to make direct system calls. On most
-machines this will work without any source code changes to
-smbwrapper. To test that it does work create the following C program:
-
-#include <sys/syscall.h>
-main()
-{
- syscall(SYS_write, 1, "hello world\n", 12);
-}
-
-and try to compile/run it. If it produces "hello world" then syscall()
-works as expected. If not then work out what needs to be changed and
-then make that change in realcalls.h. For example, on IRIX 6.4 the
-system call numbers are wrong and need to be fixed up by getting an
-offset right.
-
-
-STEP 4
-------
-
-Try compiling smbwrapper! Then test it. Then debug it. Simple really :)
-
diff --git a/source4/smbwrapper/README b/source4/smbwrapper/README
deleted file mode 100644
index 8d5c376f82..0000000000
--- a/source4/smbwrapper/README
+++ /dev/null
@@ -1,94 +0,0 @@
-This is a prelodable shared library that provides SMB client services
-for existing executables. Using this you can simulate a smb
-filesystem.
-
-*** This is code under development. Some things don't work yet ***
-
-Currently this code has been tested on:
-
-- Linux 2.0 with glibc2 (RH5.1)
-- Linux 2.1 with glibc2
-- Solaris 2.5.1 with gcc
-- Solaris 2.6 with gcc
-- SunOS 4.1.3 with gcc
-- IRIX 6.4 with cc
-- OSF1 with gcc
-
-
-It probably won't run on other systems without some porting. If you
-have a different system then see the file PORTING.
-
-To use it you need to do this:
-
-1) build smbwrapper.so using the command "make smbwrapper"
-3) run smbsh
-
-You will be asked for a username and password. After that you will be
-returned to a shell prompt. It is actually a subshell running with
-smbwrapper enabled. 
-
-Now try to access /smb/SERVER for some SMB server name and see what
-happens. If you use the -W option to set your workgroup or have
-workgroup set in your smb.conf then listing /smb/ should list all SMB
-servers in your workgroup.
-
-
-OPTIONS
--------
-
--U username
-   specify the username and optional password (as user%password)
-
--d debug level
- This is an integer that controls the internal debug level of smbw. It
- defaults to 0, which means no debug info.
-
--l logfile
- The place where smbw debug logs are put. If this is not set then
- stderr is used.
-
--P prefix
- The root of the SMB filesystem. This defaults to /smb/ but you can
- set it to any name you like.
-
--W workgroup
- This is the workgroup used for browsing (ie. listing machines in the
- /smb/ directory). It defaults to the one set in smb.conf.
-
--R resolve order
- This allows you to override the setting of the name resolve order
- from smb.conf
-
-
-ATTRIBUTE MAPPING
------------------
-
-smbwrapper does an inverse attribute maping to what Samba does. This
-means that the archive bit appears as the user execute bit, the system
-bit appears as the group execute bit and the hidden bit appears as the
-other execute bit. You can control these with chmod. The mapping can
-be enabled an disabled using the normal smb.conf controls (ie. "map
-archive", "map system" and "map hidden").
-
-Read-only files appear as non-writeable by everyone. Writeable files
-appear as writeable by the current user.
-
-
-WHAT WORKS
-----------
-
-Things that I have tried and do seem to work include:
-
-  emacs, tar, ls, cmp, cp, rsync, du, cat, rm, mv, less, more, wc, head,
-  tail, bash, tcsh, mkdir, rmdir, vim, xedit, diff
-
-things that I know don't work:
- 
- anything executing from the share
- anything that uses mmap
- redirection within shells to smbsh files
-
-If you want to help with the development of this code then join the
-samba-technical mailing list.
-
-
diff --git a/source4/smbwrapper/realcalls.c b/source4/smbwrapper/realcalls.c
deleted file mode 100644
index b64f4a43db..0000000000
--- a/source4/smbwrapper/realcalls.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper functions for calls that syscall() can't do
-   Copyright (C) Andrew Tridgell 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"
-#include "realcalls.h"
-
-#ifdef REPLACE_UTIME
-int real_utime(const char *name, struct utimbuf *buf)
-{
-	struct timeval tv[2];
-	
-	tv[0].tv_sec = buf->actime;
-	tv[0].tv_usec = 0;
-	tv[1].tv_sec = buf->modtime;
-	tv[1].tv_usec = 0;
-	
-	return real_utimes(name, &tv[0]);
-}
-#endif
-
-#ifdef REPLACE_UTIMES
-int real_utimes(const char *name, struct timeval tv[2])
-{
-	struct utimbuf buf;
-
-	buf.actime = tv[0].tv_sec;
-	buf.modtime = tv[1].tv_sec;
-	
-	return real_utime(name, &buf);
-}
-#endif
diff --git a/source4/smbwrapper/realcalls.h b/source4/smbwrapper/realcalls.h
deleted file mode 100644
index 6c230dba05..0000000000
--- a/source4/smbwrapper/realcalls.h
+++ /dev/null
@@ -1,263 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   defintions of syscall entries
-   Copyright (C) Andrew Tridgell 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.
-*/
-
-#if HAVE_SYS_SYSCALL_H
-#include <sys/syscall.h>
-#elif HAVE_SYSCALL_H
-#include <syscall.h>
-#endif
-
-#ifdef IRIX
-/* amazingly, IRIX gets its own syscall numbers wrong! */
-#ifdef SYSVoffset
-#if (SYSVoffset == 1)
-#undef SYSVoffset
-#define SYSVoffset 1000
-#endif
-#endif
-#endif
-
-/* this file is partly derived from zlibc by Alain Knaff */
-
-#define real_access(fn, mode)		(syscall(SYS_access, (fn), (mode)))
-#define real_chdir(fn)		        (syscall(SYS_chdir, (fn)))
-#define real_chmod(fn, mode)		(syscall(SYS_chmod,(fn), (mode)))
-#define real_chown(fn, owner, group)	(syscall(SYS_chown,(fn),(owner),(group)))
-
-#ifdef SYS_getdents
-#define real_getdents(fd, dirp, count)	(syscall(SYS_getdents, (fd), (dirp), (count)))
-#endif
-
-#define real_link(fn1, fn2)		(syscall(SYS_link, (fn1), (fn2)))
-
-#define real_open(fn,flags,mode)	(syscall(SYS_open, (fn), (flags), (mode)))
-
-#ifdef SYS_open64
-#define real_open64(fn,flags,mode)	(syscall(SYS_open64, (fn), (flags), (mode)))
-#elif HAVE__OPEN64
-#define real_open64(fn,flags,mode)    	(_open64(fn,flags,mode))
-#define NO_OPEN64_ALIAS
-#elif HAVE___OPEN64
-#define real_open64(fn,flags,mode)    	(__open64(fn,flags,mode))
-#define NO_OPEN64_ALIAS
-#endif
-
-#ifdef HAVE__FORK
-#define real_fork()            	(_fork())
-#elif HAVE___FORK
-#define real_fork()            	(__fork())
-#elif SYS_fork
-#define real_fork()		(syscall(SYS_fork))
-#endif
-
-#ifdef HAVE__OPENDIR
-#define real_opendir(fn)            	(_opendir(fn))
-#elif SYS_opendir
-#define real_opendir(fn)		(syscall(SYS_opendir,(fn)))
-#elif HAVE___OPENDIR
-#define real_opendir(fn)            	(__opendir(fn))
-#endif
-
-#ifdef HAVE__READDIR
-#define real_readdir(d)            	(_readdir(d))
-#elif HAVE___READDIR
-#define real_readdir(d)            	(__readdir(d))
-#elif SYS_readdir
-#define real_readdir(d)		(syscall(SYS_readdir,(d)))
-#endif
-
-#ifdef HAVE__CLOSEDIR
-#define real_closedir(d)            	(_closedir(d))
-#elif SYS_closedir
-#define real_closedir(d)		(syscall(SYS_closedir,(d)))
-#elif HAVE___CLOSEDIR
-#define real_closedir(d)            	(__closedir(d))
-#endif
-
-#ifdef HAVE__SEEKDIR
-#define real_seekdir(d,l)            	(_seekdir(d,l))
-#elif SYS_seekdir
-#define real_seekdir(d,l)		(syscall(SYS_seekdir,(d),(l)))
-#elif HAVE___SEEKDIR
-#define real_seekdir(d,l)            	(__seekdir(d,l))
-#else
-#define NO_SEEKDIR_WRAPPER
-#endif
-
-#ifdef HAVE__TELLDIR
-#define real_telldir(d)            	(_telldir(d))
-#elif SYS_telldir
-#define real_telldir(d)		(syscall(SYS_telldir,(d)))
-#elif HAVE___TELLDIR
-#define real_telldir(d)            	(__telldir(d))
-#endif
-
-#ifdef HAVE__DUP
-#define real_dup(d)            	(_dup(d))
-#elif SYS_dup
-#define real_dup(d)		(syscall(SYS_dup,(d)))
-#elif HAVE___DUP
-#define real_dup(d)            	(__dup(d))
-#endif
-
-#ifdef HAVE__DUP2
-#define real_dup2(d1,d2)            	(_dup2(d1,d2))
-#elif SYS_dup2
-#define real_dup2(d1,d2)		(syscall(SYS_dup2,(d1),(d2)))
-#elif HAVE___DUP2
-#define real_dup2(d1,d2)            	(__dup2(d1,d2))
-#endif
-
-#ifdef HAVE__GETCWD
-#define real_getcwd(b,s)            	((char *)_getcwd(b,s))
-#elif SYS_getcwd
-#define real_getcwd(b,s)		((char *)syscall(SYS_getcwd,(b),(s)))
-#elif HAVE___GETCWD
-#define real_getcwd(b,s)            	((char *)__getcwd(b,s))
-#endif
-
-#ifdef HAVE__STAT
-#define real_stat(fn,st)            	(_stat(fn,st))
-#elif SYS_stat
-#define real_stat(fn,st)		(syscall(SYS_stat,(fn),(st)))
-#elif HAVE___STAT
-#define real_stat(fn,st)            	(__stat(fn,st))
-#endif
-
-#ifdef HAVE__LSTAT
-#define real_lstat(fn,st)            	(_lstat(fn,st))
-#elif SYS_lstat
-#define real_lstat(fn,st)		(syscall(SYS_lstat,(fn),(st)))
-#elif HAVE___LSTAT
-#define real_lstat(fn,st)            	(__lstat(fn,st))
-#endif
-
-#ifdef HAVE__FSTAT
-#define real_fstat(fd,st)            	(_fstat(fd,st))
-#elif SYS_fstat
-#define real_fstat(fd,st)		(syscall(SYS_fstat,(fd),(st)))
-#elif HAVE___FSTAT
-#define real_fstat(fd,st)            	(__fstat(fd,st))
-#endif
-
-#if defined(HAVE_SYS_ACL_H) && defined(HAVE__ACL)
-#define real_acl(fn,cmd,n,buf)            	(_acl(fn,cmd,n,buf))
-#elif SYS_acl
-#define real_acl(fn,cmd,n,buf)		(syscall(SYS_acl,(fn),(cmd),(n),(buf)))
-#elif HAVE___ACL
-#define real_acl(fn,cmd,n,buf)            	(__acl(fn,cmd,n,buf))
-#else
-#define NO_ACL_WRAPPER
-#endif
-
-#ifdef HAVE__FACL
-#define real_facl(fd,cmd,n,buf)            	(_facl(fd,cmd,n,buf))
-#elif SYS_facl
-#define real_facl(fd,cmd,n,buf)		(syscall(SYS_facl,(fd),(cmd),(n),(buf)))
-#elif HAVE___FACL
-#define real_facl(fd,cmd,n,buf)            	(__facl(fd,cmd,n,buf))
-#else
-#define NO_FACL_WRAPPER
-#endif
-
-
-#ifdef HAVE__STAT64
-#define real_stat64(fn,st)            	(_stat64(fn,st))
-#elif HAVE___STAT64
-#define real_stat64(fn,st)            	(__stat64(fn,st))
-#endif
-
-#ifdef HAVE__LSTAT64
-#define real_lstat64(fn,st)            	(_lstat64(fn,st))
-#elif HAVE___LSTAT64
-#define real_lstat64(fn,st)            	(__lstat64(fn,st))
-#endif
-
-#ifdef HAVE__FSTAT64
-#define real_fstat64(fd,st)            	(_fstat64(fd,st))
-#elif HAVE___FSTAT64
-#define real_fstat64(fd,st)            	(__fstat64(fd,st))
-#endif
-
-#ifdef HAVE__READDIR64
-#define real_readdir64(d)            	(_readdir64(d))
-#elif HAVE___READDIR64
-#define real_readdir64(d)            	(__readdir64(d))
-#endif
-
-#ifdef HAVE__LLSEEK
-#define real_llseek(fd,ofs,whence)            	(_llseek(fd,ofs,whence))
-#elif HAVE___LLSEEK
-#define real_llseek(fd,ofs,whence)            	(__llseek(fd,ofs,whence))
-#elif HAVE___SYS_LLSEEK
-#define real_llseek(fd,ofs,whence)            	(__sys_llseek(fd,ofs,whence))
-#endif
-
-
-#ifdef HAVE__PREAD
-#define real_pread(fd,buf,size,ofs)            	(_pread(fd,buf,size,ofs))
-#elif HAVE___PREAD
-#define real_pread(fd,buf,size,ofs)            	(__pread(fd,buf,size,ofs))
-#endif
-
-#ifdef HAVE__PREAD64
-#define real_pread64(fd,buf,size,ofs)            	(_pread64(fd,buf,size,ofs))
-#elif HAVE___PREAD64
-#define real_pread64(fd,buf,size,ofs)            	(__pread64(fd,buf,size,ofs))
-#endif
-
-#ifdef HAVE__PWRITE
-#define real_pwrite(fd,buf,size,ofs)            	(_pwrite(fd,buf,size,ofs))
-#elif HAVE___PWRITE
-#define real_pwrite(fd,buf,size,ofs)            	(__pwrite(fd,buf,size,ofs))
-#endif
-
-#ifdef HAVE__PWRITE64
-#define real_pwrite64(fd,buf,size,ofs)            	(_pwrite64(fd,buf,size,ofs))
-#elif HAVE___PWRITE64
-#define real_pwrite64(fd,buf,size,ofs)            	(__pwrite64(fd,buf,size,ofs))
-#endif
-
-
-#define real_readlink(fn,buf,len)	(syscall(SYS_readlink, (fn), (buf), (len)))
-#define real_rename(fn1, fn2)		(syscall(SYS_rename, (fn1), (fn2)))
-#define real_symlink(fn1, fn2)		(syscall(SYS_symlink, (fn1), (fn2)))
-#define real_read(fd, buf, count )	(syscall(SYS_read, (fd), (buf), (count)))
-#define real_lseek(fd, offset, whence)	(syscall(SYS_lseek, (fd), (offset), (whence)))
-#define real_write(fd, buf, count )	(syscall(SYS_write, (fd), (buf), (count)))
-#define real_close(fd)	                (syscall(SYS_close, (fd)))
-#define real_fchdir(fd)	                (syscall(SYS_fchdir, (fd)))
-#define real_fcntl(fd,cmd,arg)	        (syscall(SYS_fcntl, (fd), (cmd), (arg)))
-#define real_symlink(fn1, fn2)		(syscall(SYS_symlink, (fn1), (fn2)))
-#define real_unlink(fn)			(syscall(SYS_unlink, (fn)))
-#define real_rmdir(fn)			(syscall(SYS_rmdir, (fn)))
-#define real_mkdir(fn, mode)		(syscall(SYS_mkdir, (fn), (mode)))
-
-#ifdef SYS_utime
-#define real_utime(fn, buf)		(syscall(SYS_utime, (fn), (buf)))
-#else
-#define REPLACE_UTIME 1
-#endif
-
-#ifdef SYS_utimes
-#define real_utimes(fn, buf)		(syscall(SYS_utimes, (fn), (buf)))
-#else
-#define REPLACE_UTIMES 1
-#endif
diff --git a/source4/smbwrapper/shared.c b/source4/smbwrapper/shared.c
deleted file mode 100644
index b4cfcf7148..0000000000
--- a/source4/smbwrapper/shared.c
+++ /dev/null
@@ -1,203 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper functions - shared variables
-   Copyright (C) Andrew Tridgell 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"
-
-static int shared_fd;
-static char *variables;
-static int shared_size;
-
-/***************************************************** 
-setup the shared area 
-*******************************************************/
-void smbw_setup_shared(void)
-{
-	int fd;
-	pstring name, s;
-
-	slprintf(name,sizeof(name)-1, "%s/smbw.XXXXXX",tmpdir());
-
-	fd = smb_mkstemp(name);
-
-	if (fd == -1) goto failed;
-
-	unlink(name);
-
-	shared_fd = set_maxfiles(SMBW_MAX_OPEN);
-	
-	while (shared_fd && dup2(fd, shared_fd) != shared_fd) shared_fd--;
-
-	if (shared_fd == 0) goto failed;
-
-	close(fd);
-
-	DEBUG(4,("created shared_fd=%d\n", shared_fd));
-
-	slprintf(s,sizeof(s)-1,"%d", shared_fd);
-
-	setenv("SMBW_HANDLE", s, 1);
-
-	return;
-
- failed:
-	perror("Failed to setup shared variable area ");
-	exit(1);
-}
-
-static int locked;
-
-/***************************************************** 
-lock the shared variable area
-*******************************************************/
-static void lockit(void)
-{
-	if (shared_fd == 0) {
-		char *p = getenv("SMBW_HANDLE");
-		if (!p) {
-			DEBUG(0,("ERROR: can't get smbw shared handle\n"));
-			exit(1);
-		}
-		shared_fd = atoi(p);
-	}
-	if (locked==0 && 
-	    fcntl_lock(shared_fd,SMB_F_SETLKW,0,1,F_WRLCK)==False) {
-		DEBUG(0,("ERROR: can't get smbw shared lock (%s)\n", strerror(errno)));
-		exit(1);
-	}
-	locked++;
-}
-
-/***************************************************** 
-unlock the shared variable area
-*******************************************************/
-static void unlockit(void)
-{
-	locked--;
-	if (locked == 0) {
-		fcntl_lock(shared_fd,SMB_F_SETLK,0,1,F_UNLCK);
-	}
-}
-
-
-/***************************************************** 
-get a variable from the shared area
-*******************************************************/
-char *smbw_getshared(const char *name)
-{
-	int i;
-	struct stat st;
-	char *var;
-
-	lockit();
-
-	/* maybe the area has changed */
-	if (fstat(shared_fd, &st)) goto failed;
-
-	if (st.st_size != shared_size) {
-		var = (char *)Realloc(variables, st.st_size);
-		if (!var) goto failed;
-		else variables = var;
-		shared_size = st.st_size;
-		lseek(shared_fd, 0, SEEK_SET);
-		if (read(shared_fd, variables, shared_size) != shared_size) {
-			goto failed;
-		}
-	}
-
-	unlockit();
-
-	i=0;
-	while (i < shared_size) {
-		char *n, *v;
-		int l1, l2;
-
-		l1 = SVAL(&variables[i], 0);
-		l2 = SVAL(&variables[i], 2);
-
-		n = &variables[i+4];
-		v = &variables[i+4+l1];
-		i += 4+l1+l2;
-
-		if (strcmp(name,n)) {
-			continue;
-		}
-		return v;
-	}
-
-	return NULL;
-
- failed:
-	DEBUG(0,("smbw: shared variables corrupt (%s)\n", strerror(errno)));
-	exit(1);
-	return NULL;
-}
-
-
-
-/***************************************************** 
-set a variable in the shared area
-*******************************************************/
-void smbw_setshared(const char *name, const char *val)
-{
-	int l1, l2;
-	char *var;
-
-	/* we don't allow variable overwrite */
-	if (smbw_getshared(name)) return;
-
-	lockit();
-
-	l1 = strlen(name)+1;
-	l2 = strlen(val)+1;
-
-	var = (char *)Realloc(variables, shared_size + l1+l2+4);
-
-	if (!var) {
-		DEBUG(0,("out of memory in smbw_setshared\n"));
-		exit(1);
-	}
-	
-	variables = var;
-
-	SSVAL(&variables[shared_size], 0, l1);
-	SSVAL(&variables[shared_size], 2, l2);
-
-	pstrcpy(&variables[shared_size] + 4, name);
-	pstrcpy(&variables[shared_size] + 4 + l1, val);
-
-	shared_size += l1+l2+4;
-
-	lseek(shared_fd, 0, SEEK_SET);
-	if (write(shared_fd, variables, shared_size) != shared_size) {
-		DEBUG(0,("smbw_setshared failed (%s)\n", strerror(errno)));
-		exit(1);
-	}
-
-	unlockit();
-}
-
-
-/*****************************************************************
-return true if the passed fd is the SMBW_HANDLE
-*****************************************************************/  
-int smbw_shared_fd(int fd)
-{
-	return (shared_fd && shared_fd == fd);
-}
diff --git a/source4/smbwrapper/smbsh.c b/source4/smbwrapper/smbsh.c
deleted file mode 100644
index 221c6d87c2..0000000000
--- a/source4/smbwrapper/smbsh.c
+++ /dev/null
@@ -1,127 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper functions - frontend
-   Copyright (C) Andrew Tridgell 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"
-
-static void smbsh_usage(void)
-{
-	printf("smbsh [options]\n\n");
-	printf(" -W workgroup\n");
-	printf(" -U username\n");
-	printf(" -P prefix\n");
-	printf(" -R resolve order\n");
-	printf(" -d debug level\n");
-	printf(" -l logfile\n");
-	printf(" -L libdir\n");
-	exit(0);
-}
-
-int main(int argc, char *argv[])
-{
-	char *p, *u;
-	const char *libd = dyn_BINDIR;
-	pstring line, wd;
-	int opt;
-	extern char *optarg;
-	extern int optind;
-
-	dbf = x_stdout;
-	smbw_setup_shared();
-
-	while ((opt = getopt(argc, argv, "W:U:R:d:P:l:hL:")) != EOF) {
-		switch (opt) {
-		case 'L':
-			libd = optarg;
-			break;
-		case 'W':
-			smbw_setshared("WORKGROUP", optarg);
-			break;
-		case 'l':
-			smbw_setshared("LOGFILE", optarg);
-			break;
-		case 'P':
-			smbw_setshared("PREFIX", optarg);
-			break;
-		case 'd':
-			smbw_setshared("DEBUG", optarg);
-			break;
-		case 'U':
-			p = strchr_m(optarg,'%');
-			if (p) {
-				*p=0;
-				smbw_setshared("PASSWORD",p+1);
-			}
-			smbw_setshared("USER", optarg);
-			break;
-		case 'R':
-			smbw_setshared("RESOLVE_ORDER",optarg);
-			break;
-
-		case 'h':
-		default:
-			smbsh_usage();
-		}
-	}
-
-
-	if (!smbw_getshared("USER")) {
-		printf("Username: ");
-		u = fgets_slash(line, sizeof(line)-1, x_stdin);
-		smbw_setshared("USER", u);
-	}
-
-	if (!smbw_getshared("PASSWORD")) {
-		p = getpass("Password: ");
-		smbw_setshared("PASSWORD", p);
-	}
-
-	setenv("PS1", "smbsh$ ", 1);
-
-	sys_getwd(wd);
-
-	slprintf(line,sizeof(line)-1,"PWD_%d", (int)getpid());
-
-	smbw_setshared(line, wd);
-
-	slprintf(line,sizeof(line)-1,"%s/smbwrapper.so", libd);
-	setenv("LD_PRELOAD", line, 1);
-
-	slprintf(line,sizeof(line)-1,"%s/smbwrapper.32.so", libd);
-
-	if (file_exist(line, NULL)) {
-		slprintf(line,sizeof(line)-1,"%s/smbwrapper.32.so:DEFAULT", libd);
-		setenv("_RLD_LIST", line, 1);
-		slprintf(line,sizeof(line)-1,"%s/smbwrapper.so:DEFAULT", libd);
-		setenv("_RLDN32_LIST", line, 1);
-	} else {
-		slprintf(line,sizeof(line)-1,"%s/smbwrapper.so:DEFAULT", libd);
-		setenv("_RLD_LIST", line, 1);
-	}
-
-	{
-    	char *shellpath = getenv("SHELL");
-		if(shellpath)
-			execl(shellpath,"smbsh",NULL);
-		else
-			execl("/bin/sh","smbsh",NULL);
-	}
-	printf("launch failed!\n");
-	return 1;
-}	
diff --git a/source4/smbwrapper/smbsh.in b/source4/smbwrapper/smbsh.in
deleted file mode 100644
index 323f091699..0000000000
--- a/source4/smbwrapper/smbsh.in
+++ /dev/null
@@ -1,54 +0,0 @@
-#! /bin/sh
-
-SMBW_LIBDIR=${SMBW_LIBDIR-@builddir@/smbwrapper}
-
-if [ ! -f ${SMBW_LIBDIR}/smbwrapper.so ]; then
-    echo You need to set LIBDIR in smbsh
-    exit
-fi
-
-# a simple launcher for the smbwrapper.so preloadde library
-
-if [ x"${SMBW_USER+set}" != x"set" ]; then
-    echo username?
-    read user
-    SMBW_USER=$user
-    export SMBW_USER
-fi
-
-# this doesn't hide the password - we need a proper launch app for that
-if [ x"${SMBW_PASSWORD+set}" != x"set" ]; then
-    echo password?
-    read pass
-    SMBW_PASSWORD=$pass
-    export SMBW_PASSWORD
-fi
-
-PWD=`pwd`
-export PWD
-PS1='smbsh$ '
-export PS1
-
-
-host_os=@HOST_OS@
-
-case "$host_os" in
-        *irix*)
-		_RLDN32_LIST=$SMBW_LIBDIR/smbwrapper.so:DEFAULT
-		_RLD_LIST=$SMBW_LIBDIR/smbwrapper.32.so:DEFAULT
-		export _RLDN32_LIST
-		export _RLD_LIST
-		;;
-	*osf*)
-		_RLD_LIST=$SMBW_LIBDIR/smbwrapper.so:DEFAULT
-		export _RLD_LIST
-		;;	        
-	*) 
-		LD_PRELOAD=$SMBW_LIBDIR/smbwrapper.so
-		export LD_PRELOAD
-		;;
-esac
-
-echo starting smbwrapper on $host_os
-
-exec ${SMBW_SHELL-${SHELL-/bin/sh}} ${1+"$@"}
diff --git a/source4/smbwrapper/smbw.c b/source4/smbwrapper/smbw.c
deleted file mode 100644
index c62533dc2a..0000000000
--- a/source4/smbwrapper/smbw.c
+++ /dev/null
@@ -1,1554 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper functions
-   Copyright (C) Andrew Tridgell 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"
-#include "realcalls.h"
-
-pstring smbw_cwd;
-
-static struct smbw_file *smbw_files;
-static struct smbw_server *smbw_srvs;
-
-struct bitmap *smbw_file_bmap;
-
-fstring smbw_prefix = SMBW_PREFIX;
-
-int smbw_busy=0;
-
-/* needs to be here because of dumb include files on some systems */
-int creat_bits = O_WRONLY|O_CREAT|O_TRUNC;
-
-
-/***************************************************** 
-initialise structures
-*******************************************************/
-void smbw_init(void)
-{
-	extern BOOL in_client;
-	static int initialised;
-	char *p;
-	int eno;
-	pstring line;
-
-	if (initialised) return;
-	initialised = 1;
-
-	eno = errno;
-
-	smbw_busy++;
-
-	DEBUGLEVEL = 0;
-	setup_logging("smbsh", DEBUG_STDOUT);
-
-	dbf = x_stderr;
-
-	if ((p=smbw_getshared("LOGFILE"))) {
-		dbf = sys_fopen(p, "a");
-	}
-
-	smbw_file_bmap = bitmap_allocate(SMBW_MAX_OPEN);
-	if (!smbw_file_bmap) {
-		exit(1);
-	}
-
-	in_client = True;
-
-	load_interfaces();
-
-	if ((p=smbw_getshared("SERVICESF"))) {
-		pstrcpy(dyn_CONFIGFILE, p);
-	}
-
-	lp_load(dyn_CONFIGFILE,True,False,False);
-
-	if (!init_names())
-		exit(1);
-
-	if ((p=smbw_getshared("DEBUG"))) {
-		DEBUGLEVEL = atoi(p);
-	}
-
-	if ((p=smbw_getshared("RESOLVE_ORDER"))) {
-		lp_set_name_resolve_order(p);
-	}
-
-	if ((p=smbw_getshared("PREFIX"))) {
-		slprintf(smbw_prefix,sizeof(fstring)-1, "/%s/", p);
-		all_string_sub(smbw_prefix,"//", "/", 0);
-		DEBUG(2,("SMBW_PREFIX is %s\n", smbw_prefix));
-	}
-
-	slprintf(line,sizeof(line)-1,"PWD_%d", (int)getpid());
-	
-	p = smbw_getshared(line);
-	if (!p) {
-		sys_getwd(smbw_cwd);
-	}
-	pstrcpy(smbw_cwd, p);
-	DEBUG(4,("Initial cwd is %s\n", smbw_cwd));
-
-	smbw_busy--;
-
-	set_maxfiles(SMBW_MAX_OPEN);
-
-	BlockSignals(True,SIGPIPE);
-
-	errno = eno;
-}
-
-/***************************************************** 
-determine if a file descriptor is a smb one
-*******************************************************/
-int smbw_fd(int fd)
-{
-	if (smbw_busy) return 0;
-	return smbw_file_bmap && bitmap_query(smbw_file_bmap, fd);
-}
-
-/***************************************************** 
-determine if a file descriptor is an internal smbw fd
-*******************************************************/
-int smbw_local_fd(int fd)
-{
-	struct smbw_server *srv;
-	
-	smbw_init();
-
-	if (smbw_busy) return 0;
-	if (smbw_shared_fd(fd)) return 1;
-
-	for (srv=smbw_srvs;srv;srv=srv->next) {
-		if (srv->cli.fd == fd) return 1;
-	}
-
-	return 0;
-}
-
-/***************************************************** 
-a crude inode number generator
-*******************************************************/
-ino_t smbw_inode(const char *name)
-{
-	if (!*name) return 2;
-	return (ino_t)str_checksum(name);
-}
-
-/***************************************************** 
-remove redundent stuff from a filename
-*******************************************************/
-void clean_fname(char *name)
-{
-	char *p, *p2;
-	int l;
-	int modified = 1;
-
-	if (!name) return;
-
-	while (modified) {
-		modified = 0;
-
-		DEBUG(5,("cleaning %s\n", name));
-
-		if ((p=strstr(name,"/./"))) {
-			modified = 1;
-			while (*p) {
-				p[0] = p[2];
-				p++;
-			}
-		}
-
-		if ((p=strstr(name,"//"))) {
-			modified = 1;
-			while (*p) {
-				p[0] = p[1];
-				p++;
-			}
-		}
-
-		if (strcmp(name,"/../")==0) {
-			modified = 1;
-			name[1] = 0;
-		}
-
-		if ((p=strstr(name,"/../"))) {
-			modified = 1;
-			for (p2=(p>name?p-1:p);p2>name;p2--) {
-				if (p2[0] == '/') break;
-			}
-			while (*p2) {
-				p2[0] = p2[3];
-				p2++;
-			}
-		}
-
-		if (strcmp(name,"/..")==0) {
-			modified = 1;
-			name[1] = 0;
-		}
-
-		l = strlen(name);
-		p = l>=3?(name+l-3):name;
-		if (strcmp(p,"/..")==0) {
-			modified = 1;
-			for (p2=p-1;p2>name;p2--) {
-				if (p2[0] == '/') break;
-			}
-			if (p2==name) {
-				p[0] = '/';
-				p[1] = 0;
-			} else {
-				p2[0] = 0;
-			}
-		}
-
-		l = strlen(name);
-		p = l>=2?(name+l-2):name;
-		if (strcmp(p,"/.")==0) {
-			if (p == name) {
-				p[1] = 0;
-			} else {
-				p[0] = 0;
-			}
-		}
-
-		if (strncmp(p=name,"./",2) == 0) {      
-			modified = 1;
-			do {
-				p[0] = p[2];
-			} while (*p++);
-		}
-
-		l = strlen(p=name);
-		if (l > 1 && p[l-1] == '/') {
-			modified = 1;
-			p[l-1] = 0;
-		}
-	}
-}
-
-
-
-/***************************************************** 
-find a workgroup (any workgroup!) that has a master 
-browser on the local network
-*******************************************************/
-static char *smbw_find_workgroup(void)
-{
-	fstring server;
-	char *p;
-	struct in_addr *ip_list = NULL;
-	int count = 0;
-	int i;
-
-	/* first off see if an existing workgroup name exists */
-	p = smbw_getshared("WORKGROUP");
-	if (!p) p = lp_workgroup();
-	
-	slprintf(server, sizeof(server), "%s#1D", p);
-	if (smbw_server(server, "IPC$")) return p;
-
-	/* go looking for workgroups */
-	if (!name_resolve_bcast(MSBROWSE, 1, &ip_list, &count)) {
-		DEBUG(1,("No workgroups found!"));
-		return p;
-	}
-
-	for (i=0;i<count;i++) {
-		static fstring name;
-		if (name_status_find("*", 0, 0x1d, ip_list[i], name)) {
-			slprintf(server, sizeof(server), "%s#1D", name);
-			if (smbw_server(server, "IPC$")) {
-				smbw_setshared("WORKGROUP", name);
-				SAFE_FREE(ip_list);
-				return name;
-			}
-		}
-	}
-
-	SAFE_FREE(ip_list);
-
-	return p;
-}
-
-/***************************************************** 
-parse a smb path into its components. 
-server is one of
-  1) the name of the SMB server
-  2) WORKGROUP#1D for share listing
-  3) WORKGROUP#__ for workgroup listing
-share is the share on the server to query
-path is the SMB path on the server
-return the full path (ie. add cwd if needed)
-*******************************************************/
-char *smbw_parse_path(const char *fname, char *server, char *share, char *path)
-{
-	static pstring s;
-	char *p;
-	int len;
-	fstring workgroup;
-
-	/* add cwd if necessary */
-	if (fname[0] != '/') {
-		slprintf(s, sizeof(s), "%s/%s", smbw_cwd, fname);
-	} else {
-		pstrcpy(s, fname);
-	}
-	clean_fname(s);
-
-	/* see if it has the right prefix */
-	len = strlen(smbw_prefix)-1;
-	if (strncmp(s,smbw_prefix,len) || 
-	    (s[len] != '/' && s[len] != 0)) return s;
-
-	/* ok, its for us. Now parse out the workgroup, share etc. */
-	p = s+len;
-	if (*p == '/') p++;
-	if (!next_token(&p, workgroup, "/", sizeof(fstring))) {
-		/* we're in /smb - give a list of workgroups */
-		slprintf(server,sizeof(fstring), "%s#01", smbw_find_workgroup());
-		fstrcpy(share,"IPC$");
-		pstrcpy(path,"");
-		return s;
-	}
-
-	if (!next_token(&p, server, "/", sizeof(fstring))) {
-		/* we are in /smb/WORKGROUP */
-		slprintf(server,sizeof(fstring), "%s#1D", workgroup);
-		fstrcpy(share,"IPC$");
-		pstrcpy(path,"");
-	}
-
-	if (!next_token(&p, share, "/", sizeof(fstring))) {
-		/* we are in /smb/WORKGROUP/SERVER */
-		fstrcpy(share,"IPC$");
-		pstrcpy(path,"");
-	}
-
-	pstrcpy(path, p);
-
-	all_string_sub(path, "/", "\\", 0);
-
-	return s;
-}
-
-/***************************************************** 
-determine if a path name (possibly relative) is in the 
-smb name space
-*******************************************************/
-int smbw_path(const char *path)
-{
-	fstring server, share;
-	pstring s;
-	char *cwd;
-	int len;
-
-	if(!path)
-		return 0;
-
-	/* this is needed to prevent recursion with the BSD malloc which
-	   opens /etc/malloc.conf on the first call */
-	if (strncmp(path,"/etc/", 5) == 0) {
-		return 0;
-	}
-
-	smbw_init();
-
-	len = strlen(smbw_prefix)-1;
-
-	if (path[0] == '/' && strncmp(path,smbw_prefix,len)) {
-		return 0;
-	}
-
-	if (smbw_busy) return 0;
-
-	DEBUG(3,("smbw_path(%s)\n", path));
-
-	cwd = smbw_parse_path(path, server, share, s);
-
-	if (strncmp(cwd,smbw_prefix,len) == 0 &&
-	    (cwd[len] == '/' || cwd[len] == 0)) {
-		return 1;
-	}
-
-	return 0;
-}
-
-/***************************************************** 
-return a unix errno from a SMB error pair
-*******************************************************/
-int smbw_errno(struct cli_state *c)
-{
-	return cli_errno(c);
-}
-
-/* Return a username and password given a server and share name */
-
-void get_envvar_auth_data(char *server, char *share, char **workgroup,
-			  char **username, char **password)
-{
-	/* Fall back to shared memory/environment variables */
-
-	*username = smbw_getshared("USER");
-	if (!*username) *username = getenv("USER");
-	if (!*username) *username = "guest";
-
-	*workgroup = smbw_getshared("WORKGROUP");
-	if (!*workgroup) *workgroup = lp_workgroup();
-
-	*password = smbw_getshared("PASSWORD");
-	if (!*password) *password = "";
-}
-
-static smbw_get_auth_data_fn get_auth_data_fn = get_envvar_auth_data;
-
-/*****************************************************
-set the get auth data function
-******************************************************/
-void smbw_set_auth_data_fn(smbw_get_auth_data_fn fn)
-{
-	get_auth_data_fn = fn;
-}
-
-/***************************************************** 
-return a connection to a server (existing or new)
-*******************************************************/
-struct smbw_server *smbw_server(char *server, char *share)
-{
-	struct smbw_server *srv=NULL;
-	struct cli_state c;
-	char *username;
-	char *password;
-	char *workgroup;
-	struct nmb_name called, calling;
-	char *p, *server_n = server;
-	fstring group;
-	pstring ipenv;
-	struct in_addr ip;
-
-        zero_ip(&ip);
-	ZERO_STRUCT(c);
-
-	get_auth_data_fn(server, share, &workgroup, &username, &password);
-
-	/* try to use an existing connection */
-	for (srv=smbw_srvs;srv;srv=srv->next) {
-		if (strcmp(server,srv->server_name)==0 &&
-		    strcmp(share,srv->share_name)==0 &&
-		    strcmp(workgroup,srv->workgroup)==0 &&
-		    strcmp(username, srv->username) == 0) 
-			return srv;
-	}
-
-	if (server[0] == 0) {
-		errno = EPERM;
-		return NULL;
-	}
-
-	make_nmb_name(&calling, lp_netbios_name(), 0x0);
-	make_nmb_name(&called , server, 0x20);
-
-	DEBUG(4,("server_n=[%s] server=[%s]\n", server_n, server));
-
-	if ((p=strchr_m(server_n,'#')) && 
-	    (strcmp(p+1,"1D")==0 || strcmp(p+1,"01")==0)) {
-		struct in_addr sip;
-		pstring s;
-
-		fstrcpy(group, server_n);
-		p = strchr_m(group,'#');
-		*p = 0;
-		
-		/* cache the workgroup master lookup */
-		slprintf(s,sizeof(s)-1,"MASTER_%s", group);
-		if (!(server_n = smbw_getshared(s))) {
-			if (!find_master_ip(group, &sip)) {
-				errno = ENOENT;
-				return NULL;
-			}
-			fstrcpy(group, inet_ntoa(sip));
-			server_n = group;
-			smbw_setshared(s,server_n);
-		}
-	}
-
-	DEBUG(4,(" -> server_n=[%s] server=[%s]\n", server_n, server));
-
- again:
-	slprintf(ipenv,sizeof(ipenv)-1,"HOST_%s", server_n);
-
-        zero_ip(&ip);
-	if ((p=smbw_getshared(ipenv))) {
-		ip = *(interpret_addr2(p));
-	}
-
-	/* have to open a new connection */
-	if (!cli_initialise(&c) || !cli_connect(&c, server_n, &ip)) {
-		errno = ENOENT;
-		return NULL;
-	}
-
-	if (!cli_session_request(&c, &calling, &called)) {
-		cli_shutdown(&c);
-		if (strcmp(called.name, "*SMBSERVER")) {
-			make_nmb_name(&called , "*SMBSERVER", 0x20);
-			goto again;
-		}
-		errno = ENOENT;
-		return NULL;
-	}
-
-	DEBUG(4,(" session request ok\n"));
-
-	if (!cli_negprot(&c)) {
-		cli_shutdown(&c);
-		errno = ENOENT;
-		return NULL;
-	}
-
-	if (!cli_session_setup(&c, username, 
-			       password, strlen(password),
-			       password, strlen(password),
-			       workgroup) &&
-	    /* try an anonymous login if it failed */
-	    !cli_session_setup(&c, "", "", 1,"", 0, workgroup)) {
-		cli_shutdown(&c);
-		errno = EPERM;
-		return NULL;
-	}
-
-	DEBUG(4,(" session setup ok\n"));
-
-	if (!cli_send_tconX(&c, share, "?????",
-			    password, strlen(password)+1)) {
-		errno = smbw_errno(&c);
-		cli_shutdown(&c);
-		return NULL;
-	}
-
-	smbw_setshared(ipenv,inet_ntoa(ip));
-	
-	DEBUG(4,(" tconx ok\n"));
-
-	srv = (struct smbw_server *)malloc(sizeof(*srv));
-	if (!srv) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	ZERO_STRUCTP(srv);
-
-	srv->cli = c;
-
-	srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
-
-	srv->server_name = strdup(server);
-	if (!srv->server_name) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	srv->share_name = strdup(share);
-	if (!srv->share_name) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	srv->workgroup = strdup(workgroup);
-	if (!srv->workgroup) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	srv->username = strdup(username);
-	if (!srv->username) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	/* some programs play with file descriptors fairly intimately. We
-	   try to get out of the way by duping to a high fd number */
-	if (fcntl(SMBW_CLI_FD + srv->cli.fd, F_GETFD) && errno == EBADF) {
-		if (dup2(srv->cli.fd,SMBW_CLI_FD+srv->cli.fd) == 
-		    srv->cli.fd+SMBW_CLI_FD) {
-			close(srv->cli.fd);
-			srv->cli.fd += SMBW_CLI_FD;
-		}
-	}
-
-	DLIST_ADD(smbw_srvs, srv);
-
-	return srv;
-
- failed:
-	cli_shutdown(&c);
-	if (!srv) return NULL;
-
-	SAFE_FREE(srv->server_name);
-	SAFE_FREE(srv->share_name);
-	SAFE_FREE(srv);
-	return NULL;
-}
-
-
-/***************************************************** 
-map a fd to a smbw_file structure
-*******************************************************/
-struct smbw_file *smbw_file(int fd)
-{
-	struct smbw_file *file;
-
-	for (file=smbw_files;file;file=file->next) {
-		if (file->fd == fd) return file;
-	}
-	return NULL;
-}
-
-/***************************************************** 
-a wrapper for open()
-*******************************************************/
-int smbw_open(const char *fname, int flags, mode_t mode)
-{
-	fstring server, share;
-	pstring path;
-	struct smbw_server *srv=NULL;
-	int eno=0, fd = -1;
-	struct smbw_file *file=NULL;
-
-	smbw_init();
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_busy++;	
-
-	/* work out what server they are after */
-	smbw_parse_path(fname, server, share, path);
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	if (path[strlen(path)-1] == '\\') {
-		fd = -1;
-	} else {
-		fd = cli_open(&srv->cli, path, flags, DENY_NONE);
-	}
-	if (fd == -1) {
-		/* it might be a directory. Maybe we should use chkpath? */
-		eno = smbw_errno(&srv->cli);
-		fd = smbw_dir_open(fname);
-		if (fd == -1) errno = eno;
-		smbw_busy--;
-		return fd;
-	}
-
-	file = (struct smbw_file *)malloc(sizeof(*file));
-	if (!file) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	ZERO_STRUCTP(file);
-
-	file->f = (struct smbw_filedes *)malloc(sizeof(*(file->f)));
-	if (!file->f) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	ZERO_STRUCTP(file->f);
-
-	file->f->cli_fd = fd;
-	file->f->fname = strdup(path);
-	if (!file->f->fname) {
-		errno = ENOMEM;
-		goto failed;
-	}
-	file->srv = srv;
-	file->fd = open(SMBW_DUMMY, O_WRONLY);
-	if (file->fd == -1) {
-		errno = EMFILE;
-		goto failed;
-	}
-
-	if (bitmap_query(smbw_file_bmap, file->fd)) {
-		DEBUG(0,("ERROR: fd used in smbw_open\n"));
-		errno = EIO;
-		goto failed;
-	}
-
-	file->f->ref_count=1;
-
-	bitmap_set(smbw_file_bmap, file->fd);
-
-	DLIST_ADD(smbw_files, file);
-
-	DEBUG(4,("opened %s\n", fname));
-
-	smbw_busy--;
-	return file->fd;
-
- failed:
-	if (fd != -1) {
-		cli_close(&srv->cli, fd);
-	}
-	if (file) {
-		if (file->f) {
-			SAFE_FREE(file->f->fname);
-			SAFE_FREE(file->f);
-		}
-		SAFE_FREE(file);
-	}
-	smbw_busy--;
-	return -1;
-}
-
-
-/***************************************************** 
-a wrapper for pread()
-*******************************************************/
-ssize_t smbw_pread(int fd, void *buf, size_t count, off_t ofs)
-{
-	struct smbw_file *file;
-	int ret;
-
-	smbw_busy++;
-
-	file = smbw_file(fd);
-	if (!file) {
-		errno = EBADF;
-		smbw_busy--;
-		return -1;
-	}
-	
-	ret = cli_read(&file->srv->cli, file->f->cli_fd, buf, ofs, count);
-
-	if (ret == -1) {
-		errno = smbw_errno(&file->srv->cli);
-		smbw_busy--;
-		return -1;
-	}
-
-	smbw_busy--;
-	return ret;
-}
-
-/***************************************************** 
-a wrapper for read()
-*******************************************************/
-ssize_t smbw_read(int fd, void *buf, size_t count)
-{
-	struct smbw_file *file;
-	int ret;
-
-	DEBUG(4,("smbw_read(%d, %d)\n", fd, (int)count));
-
-	smbw_busy++;
-
-	file = smbw_file(fd);
-	if (!file) {
-		errno = EBADF;
-		smbw_busy--;
-		return -1;
-	}
-	
-	ret = cli_read(&file->srv->cli, file->f->cli_fd, buf, 
-		       file->f->offset, count);
-
-	if (ret == -1) {
-		errno = smbw_errno(&file->srv->cli);
-		smbw_busy--;
-		return -1;
-	}
-
-	file->f->offset += ret;
-	
-	DEBUG(4,(" -> %d\n", ret));
-
-	smbw_busy--;
-	return ret;
-}
-
-	
-
-/***************************************************** 
-a wrapper for write()
-*******************************************************/
-ssize_t smbw_write(int fd, void *buf, size_t count)
-{
-	struct smbw_file *file;
-	int ret;
-
-	smbw_busy++;
-
-	file = smbw_file(fd);
-	if (!file) {
-		errno = EBADF;
-		smbw_busy--;
-		return -1;
-	}
-	
-	ret = cli_write(&file->srv->cli, file->f->cli_fd, 0, buf, file->f->offset, count);
-
-	if (ret == -1) {
-		errno = smbw_errno(&file->srv->cli);
-		smbw_busy--;
-		return -1;
-	}
-
-	file->f->offset += ret;
-
-	smbw_busy--;
-	return ret;
-}
-
-/***************************************************** 
-a wrapper for pwrite()
-*******************************************************/
-ssize_t smbw_pwrite(int fd, void *buf, size_t count, off_t ofs)
-{
-	struct smbw_file *file;
-	int ret;
-
-	smbw_busy++;
-
-	file = smbw_file(fd);
-	if (!file) {
-		errno = EBADF;
-		smbw_busy--;
-		return -1;
-	}
-	
-	ret = cli_write(&file->srv->cli, file->f->cli_fd, 0, buf, ofs, count);
-
-	if (ret == -1) {
-		errno = smbw_errno(&file->srv->cli);
-		smbw_busy--;
-		return -1;
-	}
-
-	smbw_busy--;
-	return ret;
-}
-
-/***************************************************** 
-a wrapper for close()
-*******************************************************/
-int smbw_close(int fd)
-{
-	struct smbw_file *file;
-
-	smbw_busy++;
-
-	file = smbw_file(fd);
-	if (!file) {
-		int ret = smbw_dir_close(fd);
-		smbw_busy--;
-		return ret;
-	}
-	
-	if (file->f->ref_count == 1 &&
-	    !cli_close(&file->srv->cli, file->f->cli_fd)) {
-		errno = smbw_errno(&file->srv->cli);
-		smbw_busy--;
-		return -1;
-	}
-
-
-	bitmap_clear(smbw_file_bmap, file->fd);
-	close(file->fd);
-	
-	DLIST_REMOVE(smbw_files, file);
-
-	file->f->ref_count--;
-	if (file->f->ref_count == 0) {
-		SAFE_FREE(file->f->fname);
-		SAFE_FREE(file->f);
-	}
-	ZERO_STRUCTP(file);
-	SAFE_FREE(file);
-	
-	smbw_busy--;
-
-	return 0;
-}
-
-
-/***************************************************** 
-a wrapper for fcntl()
-*******************************************************/
-int smbw_fcntl(int fd, int cmd, long arg)
-{
-	return 0;
-}
-
-
-/***************************************************** 
-a wrapper for access()
-*******************************************************/
-int smbw_access(const char *name, int mode)
-{
-	struct stat st;
-
-	DEBUG(4,("smbw_access(%s, 0x%x)\n", name, mode));
-
-	if (smbw_stat(name, &st)) return -1;
-
-	if (((mode & R_OK) && !(st.st_mode & S_IRUSR)) ||
-	    ((mode & W_OK) && !(st.st_mode & S_IWUSR)) ||
-	    ((mode & X_OK) && !(st.st_mode & S_IXUSR))) {
-		errno = EACCES;
-		return -1;
-	}
-	
-	return 0;
-}
-
-/***************************************************** 
-a wrapper for realink() - needed for correct errno setting
-*******************************************************/
-int smbw_readlink(const char *path, char *buf, size_t bufsize)
-{
-	struct stat st;
-	int ret;
-
-	ret = smbw_stat(path, &st);
-	if (ret != 0) {
-		DEBUG(4,("readlink(%s) failed\n", path));
-		return -1;
-	}
-	
-	/* it exists - say it isn't a link */
-	DEBUG(4,("readlink(%s) not a link\n", path));
-
-	errno = EINVAL;
-	return -1;
-}
-
-
-/***************************************************** 
-a wrapper for unlink()
-*******************************************************/
-int smbw_unlink(const char *fname)
-{
-	struct smbw_server *srv;
-	fstring server, share;
-	pstring path;
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_init();
-
-	smbw_busy++;
-
-	/* work out what server they are after */
-	smbw_parse_path(fname, server, share, path);
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
-		int job = smbw_stat_printjob(srv, path, NULL, NULL);
-		if (job == -1) {
-			goto failed;
-		}
-		if (cli_printjob_del(&srv->cli, job) != 0) {
-			goto failed;
-		}
-	} else if (!cli_unlink(&srv->cli, path)) {
-		errno = smbw_errno(&srv->cli);
-		goto failed;
-	}
-
-	smbw_busy--;
-	return 0;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-
-/***************************************************** 
-a wrapper for rename()
-*******************************************************/
-int smbw_rename(const char *oldname, const char *newname)
-{
-	struct smbw_server *srv;
-	fstring server1, share1;
-	pstring path1;
-	fstring server2, share2;
-	pstring path2;
-
-	if (!oldname || !newname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_init();
-
-	DEBUG(4,("smbw_rename(%s,%s)\n", oldname, newname));
-
-	smbw_busy++;
-
-	/* work out what server they are after */
-	smbw_parse_path(oldname, server1, share1, path1);
-	smbw_parse_path(newname, server2, share2, path2);
-
-	if (strcmp(server1, server2) || strcmp(share1, share2)) {
-		/* can't cross filesystems */
-		errno = EXDEV;
-		return -1;
-	}
-
-	/* get a connection to the server */
-	srv = smbw_server(server1, share1);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	if (!cli_rename(&srv->cli, path1, path2)) {
-		int eno = smbw_errno(&srv->cli);
-		if (eno != EEXIST ||
-		    !cli_unlink(&srv->cli, path2) ||
-		    !cli_rename(&srv->cli, path1, path2)) {
-			errno = eno;
-			goto failed;
-		}
-	}
-
-	smbw_busy--;
-	return 0;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-
-/***************************************************** 
-a wrapper for utime and utimes
-*******************************************************/
-static int smbw_settime(const char *fname, time_t t)
-{
-	struct smbw_server *srv;
-	fstring server, share;
-	pstring path;
-	uint16 mode;
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_init();
-
-	smbw_busy++;
-
-	/* work out what server they are after */
-	smbw_parse_path(fname, server, share, path);
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	if (!cli_getatr(&srv->cli, path, &mode, NULL, NULL)) {
-		errno = smbw_errno(&srv->cli);
-		goto failed;
-	}
-
-	if (!cli_setatr(&srv->cli, path, mode, t)) {
-		/* some servers always refuse directory changes */
-		if (!(mode & aDIR)) {
-			errno = smbw_errno(&srv->cli);
-			goto failed;
-		}
-	}
-
-	smbw_busy--;
-	return 0;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-/***************************************************** 
-a wrapper for utime 
-*******************************************************/
-int smbw_utime(const char *fname, void *buf)
-{
-	struct utimbuf *tbuf = (struct utimbuf *)buf;
-	return smbw_settime(fname, tbuf?tbuf->modtime:time(NULL));
-}
-
-/***************************************************** 
-a wrapper for utime 
-*******************************************************/
-int smbw_utimes(const char *fname, void *buf)
-{
-	struct timeval *tbuf = (struct timeval *)buf;
-	return smbw_settime(fname, tbuf?tbuf->tv_sec:time(NULL));
-}
-
-
-/***************************************************** 
-a wrapper for chown()
-*******************************************************/
-int smbw_chown(const char *fname, uid_t owner, gid_t group)
-{
-	struct smbw_server *srv;
-	fstring server, share;
-	pstring path;
-	uint16 mode;
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_init();
-
-	smbw_busy++;
-
-	/* work out what server they are after */
-	smbw_parse_path(fname, server, share, path);
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	if (!cli_getatr(&srv->cli, path, &mode, NULL, NULL)) {
-		errno = smbw_errno(&srv->cli);
-		goto failed;
-	}
-	
-	/* assume success */
-
-	smbw_busy--;
-	return 0;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-/***************************************************** 
-a wrapper for chmod()
-*******************************************************/
-int smbw_chmod(const char *fname, mode_t newmode)
-{
-	struct smbw_server *srv;
-	fstring server, share;
-	pstring path;
-	uint32 mode;
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_init();
-
-	smbw_busy++;
-
-	/* work out what server they are after */
-	smbw_parse_path(fname, server, share, path);
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	mode = 0;
-
-	if (!(newmode & (S_IWUSR | S_IWGRP | S_IWOTH))) mode |= aRONLY;
-	if ((newmode & S_IXUSR) && lp_map_archive(-1)) mode |= aARCH;
-	if ((newmode & S_IXGRP) && lp_map_system(-1)) mode |= aSYSTEM;
-	if ((newmode & S_IXOTH) && lp_map_hidden(-1)) mode |= aHIDDEN;
-
-	if (!cli_setatr(&srv->cli, path, mode, 0)) {
-		errno = smbw_errno(&srv->cli);
-		goto failed;
-	}
-	
-	smbw_busy--;
-	return 0;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-/***************************************************** 
-a wrapper for lseek()
-*******************************************************/
-off_t smbw_lseek(int fd, off_t offset, int whence)
-{
-	struct smbw_file *file;
-	size_t size;
-
-	smbw_busy++;
-
-	file = smbw_file(fd);
-	if (!file) {
-		off_t ret = smbw_dir_lseek(fd, offset, whence);
-		smbw_busy--;
-		return ret;
-	}
-
-	switch (whence) {
-	case SEEK_SET:
-		file->f->offset = offset;
-		break;
-	case SEEK_CUR:
-		file->f->offset += offset;
-		break;
-	case SEEK_END:
-		if (!cli_qfileinfo(&file->srv->cli, file->f->cli_fd, 
-				   NULL, &size, NULL, NULL, NULL, 
-				   NULL, NULL) &&
-		    !cli_getattrE(&file->srv->cli, file->f->cli_fd, 
-				  NULL, &size, NULL, NULL, NULL)) {
-			errno = EINVAL;
-			smbw_busy--;
-			return -1;
-		}
-		file->f->offset = size + offset;
-		break;
-	}
-
-	smbw_busy--;
-	return file->f->offset;
-}
-
-
-/***************************************************** 
-a wrapper for dup()
-*******************************************************/
-int smbw_dup(int fd)
-{
-	int fd2;
-	struct smbw_file *file, *file2;
-
-	smbw_busy++;
-
-	file = smbw_file(fd);
-	if (!file) {
-		errno = EBADF;
-		goto failed;
-	}
-
-	fd2 = dup(file->fd);
-	if (fd2 == -1) {
-		goto failed;
-	}
-
-	if (bitmap_query(smbw_file_bmap, fd2)) {
-		DEBUG(0,("ERROR: fd already open in dup!\n"));
-		errno = EIO;
-		goto failed;
-	}
-
-	file2 = (struct smbw_file *)malloc(sizeof(*file2));
-	if (!file2) {
-		close(fd2);
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	ZERO_STRUCTP(file2);
-
-	*file2 = *file;
-	file2->fd = fd2;
-
-	file->f->ref_count++;
-
-	bitmap_set(smbw_file_bmap, fd2);
-	
-	DLIST_ADD(smbw_files, file2);
-	
-	smbw_busy--;
-	return fd2;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-
-/***************************************************** 
-a wrapper for dup2()
-*******************************************************/
-int smbw_dup2(int fd, int fd2)
-{
-	struct smbw_file *file, *file2;
-
-	smbw_busy++;
-
-	file = smbw_file(fd);
-	if (!file) {
-		errno = EBADF;
-		goto failed;
-	}
-
-	if (bitmap_query(smbw_file_bmap, fd2)) {
-		DEBUG(0,("ERROR: fd already open in dup2!\n"));
-		errno = EIO;
-		goto failed;
-	}
-
-	if (dup2(file->fd, fd2) != fd2) {
-		goto failed;
-	}
-
-	file2 = (struct smbw_file *)malloc(sizeof(*file2));
-	if (!file2) {
-		close(fd2);
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	ZERO_STRUCTP(file2);
-
-	*file2 = *file;
-	file2->fd = fd2;
-
-	file->f->ref_count++;
-
-	bitmap_set(smbw_file_bmap, fd2);
-	
-	DLIST_ADD(smbw_files, file2);
-	
-	smbw_busy--;
-	return fd2;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-
-/***************************************************** 
-close a connection to a server
-*******************************************************/
-static void smbw_srv_close(struct smbw_server *srv)
-{
-	smbw_busy++;
-
-	cli_shutdown(&srv->cli);
-
-	SAFE_FREE(srv->server_name);
-	SAFE_FREE(srv->share_name);
-
-	DLIST_REMOVE(smbw_srvs, srv);
-
-	ZERO_STRUCTP(srv);
-
-	SAFE_FREE(srv);
-	
-	smbw_busy--;
-}
-
-/***************************************************** 
-when we fork we have to close all connections and files
-in the child
-*******************************************************/
-int smbw_fork(void)
-{
-	pid_t child;
-	int p[2];
-	char c=0;
-	pstring line;
-
-	struct smbw_file *file, *next_file;
-	struct smbw_server *srv, *next_srv;
-
-	if (pipe(p)) return real_fork();
-
-	child = real_fork();
-
-	if (child) {
-		/* block the parent for a moment until the sockets are
-                   closed */
-		close(p[1]);
-		read(p[0], &c, 1);
-		close(p[0]);
-		return child;
-	}
-
-	close(p[0]);
-
-	/* close all files */
-	for (file=smbw_files;file;file=next_file) {
-		next_file = file->next;
-		close(file->fd);
-	}
-
-	/* close all server connections */
-	for (srv=smbw_srvs;srv;srv=next_srv) {
-		next_srv = srv->next;
-		smbw_srv_close(srv);
-	}
-
-	slprintf(line,sizeof(line)-1,"PWD_%d", (int)getpid());
-	smbw_setshared(line,smbw_cwd);
-
-	/* unblock the parent */
-	write(p[1], &c, 1);
-	close(p[1]);
-
-	/* and continue in the child */
-	return 0;
-}
-
-#ifndef NO_ACL_WRAPPER
-/***************************************************** 
-say no to acls
-*******************************************************/
- int smbw_acl(const char *pathp, int cmd, int nentries, aclent_t *aclbufp)
-{
-	if (cmd == GETACL || cmd == GETACLCNT) return 0;
-	errno = ENOSYS;
-	return -1;
-}
-#endif
-
-#ifndef NO_FACL_WRAPPER
-/***************************************************** 
-say no to acls
-*******************************************************/
- int smbw_facl(int fd, int cmd, int nentries, aclent_t *aclbufp)
-{
-	if (cmd == GETACL || cmd == GETACLCNT) return 0;
-	errno = ENOSYS;
-	return -1;
-}
-#endif
-
-#ifdef HAVE_EXPLICIT_LARGEFILE_SUPPORT
-#ifdef HAVE_STAT64
-/* this can't be in wrapped.c because of include conflicts */
- void stat64_convert(struct stat *st, struct stat64 *st64)
-{
-	st64->st_size = st->st_size;
-	st64->st_mode = st->st_mode;
-	st64->st_ino = st->st_ino;
-	st64->st_dev = st->st_dev;
-	st64->st_rdev = st->st_rdev;
-	st64->st_nlink = st->st_nlink;
-	st64->st_uid = st->st_uid;
-	st64->st_gid = st->st_gid;
-	st64->st_atime = st->st_atime;
-	st64->st_mtime = st->st_mtime;
-	st64->st_ctime = st->st_ctime;
-	st64->st_blksize = st->st_blksize;
-	st64->st_blocks = st->st_blocks;
-}
-#endif
-
-#ifdef HAVE_READDIR64
- void dirent64_convert(struct dirent *d, struct dirent64 *d64)
-{
-	d64->d_ino = d->d_ino;
-	d64->d_off = d->d_off;
-	d64->d_reclen = d->d_reclen;
-	pstrcpy(d64->d_name, d->d_name);
-}
-#endif
-#endif
-
-
-#ifdef HAVE___XSTAT
-/* Definition of `struct stat' used in the linux kernel..  */
-struct kernel_stat {
-	unsigned short int st_dev;
-	unsigned short int __pad1;
-	unsigned long int st_ino;
-	unsigned short int st_mode;
-	unsigned short int st_nlink;
-	unsigned short int st_uid;
-	unsigned short int st_gid;
-	unsigned short int st_rdev;
-	unsigned short int __pad2;
-	unsigned long int st_size;
-	unsigned long int st_blksize;
-	unsigned long int st_blocks;
-	unsigned long int st_atime;
-	unsigned long int __unused1;
-	unsigned long int st_mtime;
-	unsigned long int __unused2;
-	unsigned long int st_ctime;
-	unsigned long int __unused3;
-	unsigned long int __unused4;
-	unsigned long int __unused5;
-};
-
-/*
- * Prototype for gcc in 'fussy' mode.
- */
- void xstat_convert(int vers, struct stat *st, struct kernel_stat *kbuf);
- void xstat_convert(int vers, struct stat *st, struct kernel_stat *kbuf)
-{
-#ifdef _STAT_VER_LINUX_OLD
-	if (vers == _STAT_VER_LINUX_OLD) {
-		memcpy(st, kbuf, sizeof(*st));
-		return;
-	}
-#endif
-
-	ZERO_STRUCTP(st);
-
-	st->st_dev = kbuf->st_dev;
-	st->st_ino = kbuf->st_ino;
-	st->st_mode = kbuf->st_mode;
-	st->st_nlink = kbuf->st_nlink;
-	st->st_uid = kbuf->st_uid;
-	st->st_gid = kbuf->st_gid;
-	st->st_rdev = kbuf->st_rdev;
-	st->st_size = kbuf->st_size;
-	st->st_blksize = kbuf->st_blksize;
-	st->st_blocks = kbuf->st_blocks;
-	st->st_atime = kbuf->st_atime;
-	st->st_mtime = kbuf->st_mtime;
-	st->st_ctime = kbuf->st_ctime;
-}
-#endif
diff --git a/source4/smbwrapper/smbw.h b/source4/smbwrapper/smbw.h
deleted file mode 100644
index 3f0b1cbb44..0000000000
--- a/source4/smbwrapper/smbw.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper functions - definitions
-   Copyright (C) Andrew Tridgell 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.
-*/
-
-#ifndef _SMBW_H
-#define _SMBW_H
-
-#define SMBW_PREFIX "/smb/"
-#define SMBW_DUMMY "/dev/null"
-
-#define SMBW_CLI_FD 512
-#define SMBW_MAX_OPEN 8192
-
-#define SMBW_FILE_MODE (S_IFREG | 0444)
-#define SMBW_DIR_MODE (S_IFDIR | 0555)
-
-struct smbw_server {
-	struct smbw_server *next, *prev;
-	struct cli_state cli;
-	char *server_name;
-	char *share_name;
-	char *workgroup;
-	char *username;
-	dev_t dev;
-	BOOL no_pathinfo2;
-};
-
-struct smbw_filedes {
-	int cli_fd;
-	int ref_count;
-	char *fname;
-	off_t offset;
-};
-
-struct smbw_file {
-	struct smbw_file *next, *prev;
-	struct smbw_filedes *f;
-	int fd;
-	struct smbw_server *srv;
-};
-
-struct smbw_dir {
-	struct smbw_dir *next, *prev;
-	int fd;
-	int offset, count, malloced;
-	struct smbw_server *srv;
-	struct file_info *list;
-	char *path;
-};
-
-typedef void (*smbw_get_auth_data_fn)(char *server, char *share,
-				      char **workgroup, char **username,
-				      char **password);
-
-#endif /* _SMBW_H */
diff --git a/source4/smbwrapper/smbw_cache.c b/source4/smbwrapper/smbw_cache.c
deleted file mode 100644
index fcb0eda805..0000000000
--- a/source4/smbwrapper/smbw_cache.c
+++ /dev/null
@@ -1,207 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper directory functions
-   Copyright (C) Tim Potter 2000
-   
-   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"
-
-/* We cache lists of workgroups, lists of servers in workgroups, and lists
-   of shares exported by servers. */
-
-#define CACHE_TIMEOUT 30
-
-struct name_list {
-	struct name_list *prev, *next;
-	char *name;
-	uint32 stype;
-	char *comment;
-};
-
-struct cached_names {
-	struct cached_names *prev, *next;
-	char *key;
-	struct name_list *name_list;
-	time_t cache_timeout;
-	int result;
-};
-
-static struct cached_names *cached_names = NULL;
-
-/* Find a list of cached name for a workgroup, server or share list */
-
-static struct cached_names *find_cached_names(char *key)
-{
-	struct cached_names *tmp;
-
-	for (tmp = cached_names; tmp; tmp = tmp->next) {
-		if (strequal(tmp->key, key)) {
-			return tmp;
-		}
-	}
-
-	return NULL;
-}
-
-/* Add a name to a list stored in the state variable */
-
-static void add_cached_names(const char *name, uint32 stype, 
-			     const char *comment, void *state)
-{
-	struct name_list **name_list = (struct name_list **)state;
-	struct name_list *new_name;
-
-	new_name = (struct name_list *)malloc(sizeof(struct name_list));
-	if (!new_name) return;
-
-	ZERO_STRUCTP(new_name);
-
-	new_name->name = strdup(name);
-	new_name->stype = stype;
-	new_name->comment = strdup(comment);
-
-	DLIST_ADD(*name_list, new_name);
-}
-
-static void free_name_list(struct name_list *name_list)
-{
-	struct name_list *tmp = name_list;
-
-	while(tmp) {
-		struct name_list *next;
-
-		next = tmp->next;
-
-		SAFE_FREE(tmp->name);
-		SAFE_FREE(tmp->comment);
-		SAFE_FREE(tmp);
-		
-		tmp = next;
-	}
-}
-
-/* Wrapper for NetServerEnum function */
-
-BOOL smbw_NetServerEnum(struct cli_state *cli, char *workgroup, uint32 stype,
-			void (*fn)(const char *, uint32, const char *, void *),
-			void *state)
-{
-	struct cached_names *names;
-	struct name_list *tmp;
-	time_t now = time(NULL);
-	char key[PATH_MAX];
-	BOOL result = True;
-
-	slprintf(key, PATH_MAX - 1, "%s/%s#%s", cli->desthost, 
-		 workgroup, (stype == SV_TYPE_DOMAIN_ENUM ? "DOM" : "SRV"));
-
-	names = find_cached_names(key);
-
-	if (names == NULL || (now - names->cache_timeout) > CACHE_TIMEOUT) {
-		struct cached_names *new_names = NULL;
-
-		/* No names cached for this workgroup */
-
-		if (names == NULL) {
-			new_names = (struct cached_names *)
-				malloc(sizeof(struct cached_names));
-
-			ZERO_STRUCTP(new_names);
-			DLIST_ADD(cached_names, new_names);
-
-		} else {
-
-			/* Dispose of out of date name list */
-
-			free_name_list(names->name_list);
-			names->name_list = NULL;
-
-			new_names = names;
-		}		
-
-		result = cli_NetServerEnum(cli, workgroup, stype, 
-					   add_cached_names, 
-					   &new_names->name_list);
-					   
-		new_names->cache_timeout = now;
-		new_names->result = result;
-		new_names->key = strdup(key);
-
-		names = new_names;
-	}
-
-	/* Return names by running callback function. */
-
-	for (tmp = names->name_list; tmp; tmp = tmp->next)
-		fn(tmp->name, stype, tmp->comment, state);
-	
-	return names->result;
-}
-
-/* Wrapper for RNetShareEnum function */
-
-int smbw_RNetShareEnum(struct cli_state *cli, 
-		       void (*fn)(const char *, uint32, const char *, void *), 
-		       void *state)
-{
-	struct cached_names *names;
-	struct name_list *tmp;
-	time_t now = time(NULL);
-	char key[PATH_MAX];
-
-	slprintf(key, PATH_MAX - 1, "SHARE/%s", cli->desthost);
-
-	names = find_cached_names(key);
-
-	if (names == NULL || (now - names->cache_timeout) > CACHE_TIMEOUT) {
-		struct cached_names *new_names = NULL;
-
-		/* No names cached for this server */
-
-		if (names == NULL) {
-			new_names = (struct cached_names *)
-				malloc(sizeof(struct cached_names));
-
-			ZERO_STRUCTP(new_names);
-			DLIST_ADD(cached_names, new_names);
-
-		} else {
-
-			/* Dispose of out of date name list */
-
-			free_name_list(names->name_list);
-			names->name_list = NULL;
-
-			new_names = names;
-		}
-
-		new_names->result = cli_RNetShareEnum(cli, add_cached_names, 
-						      &new_names->name_list);
-		
-		new_names->cache_timeout = now;
-		new_names->key = strdup(key);
-
-		names = new_names;
-	}
-
-	/* Return names by running callback function. */
-
-	for (tmp = names->name_list; tmp; tmp = tmp->next)
-		fn(tmp->name, tmp->stype, tmp->comment, state);
-	
-	return names->result;
-}
diff --git a/source4/smbwrapper/smbw_dir.c b/source4/smbwrapper/smbw_dir.c
deleted file mode 100644
index 31d81a1e7e..0000000000
--- a/source4/smbwrapper/smbw_dir.c
+++ /dev/null
@@ -1,688 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper directory functions
-   Copyright (C) Andrew Tridgell 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"
-#include "realcalls.h"
-
-extern pstring smbw_cwd;
-extern fstring smbw_prefix;
-
-static struct smbw_dir *smbw_dirs;
-
-extern struct bitmap *smbw_file_bmap;
-
-extern int smbw_busy;
-
-/***************************************************** 
-map a fd to a smbw_dir structure
-*******************************************************/
-struct smbw_dir *smbw_dir(int fd)
-{
-	struct smbw_dir *dir;
-
-	for (dir=smbw_dirs;dir;dir=dir->next) {
-		if (dir->fd == fd) return dir;
-	}
-	return NULL;
-}
-
-/***************************************************** 
-check if a DIR* is one of ours
-*******************************************************/
-int smbw_dirp(DIR *dirp)
-{
-	struct smbw_dir *d = (struct smbw_dir *)dirp;
-	struct smbw_dir *dir;
-
-	for (dir=smbw_dirs;dir;dir=dir->next) {
-		if (dir == d) return 1;
-	}
-	return 0;
-}
-
-/***************************************************** 
-free a smbw_dir structure and all entries
-*******************************************************/
-static void free_dir(struct smbw_dir *dir)
-{
-	if(!dir) return;
-
-	SAFE_FREE(dir->list);
-	SAFE_FREE(dir->path);
-	ZERO_STRUCTP(dir);
-	SAFE_FREE(dir);
-}
-
-static struct smbw_dir *cur_dir;
-
-/***************************************************** 
-add a entry to a directory listing
-*******************************************************/
-static void smbw_dir_add(struct file_info *finfo, const char *mask, 
-			 void *state)
-{
-	struct file_info *cdl;
-
-	DEBUG(5,("%s\n", finfo->name));
-
-	if (cur_dir->malloced == cur_dir->count) {
-		cdl = (struct file_info *)Realloc(cur_dir->list, 
-							    sizeof(cur_dir->list[0])*
-							    (cur_dir->count+100));
-		if (!cdl) {
-			/* oops */
-			return;
-		}
-		cur_dir->list = cdl;
-		cur_dir->malloced += 100;
-	}
-
-	cur_dir->list[cur_dir->count] = *finfo;
-	cur_dir->count++;
-}
-
-/***************************************************** 
-add a entry to a directory listing
-*******************************************************/
-static void smbw_share_add(const char *share, uint32 type, 
-			   const char *comment, void *state)
-{
-	struct file_info finfo;
-
-	if (strcmp(share,"IPC$") == 0) return;
-
-	ZERO_STRUCT(finfo);
-
-	pstrcpy(finfo.name, share);
-	finfo.mode = aRONLY | aDIR;	
-
-	smbw_dir_add(&finfo, NULL, NULL);
-}
-
-
-/***************************************************** 
-add a server to a directory listing
-*******************************************************/
-static void smbw_server_add(const char *name, uint32 type, 
-			    const char *comment, void *state)
-{
-	struct file_info finfo;
-
-	ZERO_STRUCT(finfo);
-
-	pstrcpy(finfo.name, name);
-	finfo.mode = aRONLY | aDIR;	
-
-	smbw_dir_add(&finfo, NULL, NULL);
-}
-
-
-/***************************************************** 
-add a entry to a directory listing
-*******************************************************/
-static void smbw_printjob_add(struct print_job_info *job)
-{
-	struct file_info finfo;
-
-	ZERO_STRUCT(finfo);
-
-	pstrcpy(finfo.name, job->name);
-	finfo.mode = aRONLY | aDIR;	
-	finfo.mtime = job->t;
-	finfo.atime = job->t;
-	finfo.ctime = job->t;
-	finfo.uid = nametouid(job->user);
-	finfo.mode = aRONLY;
-	finfo.size = job->size;
-
-	smbw_dir_add(&finfo, NULL, NULL);
-}
-
-
-/***************************************************** 
-open a directory on the server
-*******************************************************/
-int smbw_dir_open(const char *fname)
-{
-	fstring server, share;
-	pstring path;
-	struct smbw_server *srv=NULL;
-	struct smbw_dir *dir=NULL;
-	pstring mask;
-	int fd;
-	char *s, *p;
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_init();
-
-	/* work out what server they are after */
-	s = smbw_parse_path(fname, server, share, path);
-
-	DEBUG(4,("dir_open share=%s\n", share));
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	dir = (struct smbw_dir *)malloc(sizeof(*dir));
-	if (!dir) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	ZERO_STRUCTP(dir);
-
-	cur_dir = dir;
-
-	slprintf(mask, sizeof(mask)-1, "%s\\*", path);
-	all_string_sub(mask,"\\\\","\\",0);
-
-	if ((p=strstr(srv->server_name,"#01"))) {
-		*p = 0;
-		smbw_server_add(".",0,"", NULL);
-		smbw_server_add("..",0,"", NULL);
-		smbw_NetServerEnum(&srv->cli, srv->server_name, 
-				   SV_TYPE_DOMAIN_ENUM, smbw_server_add, NULL);
-		*p = '#';
-	} else if ((p=strstr(srv->server_name,"#1D"))) {
-		DEBUG(4,("doing NetServerEnum\n"));
-		*p = 0;
-		smbw_server_add(".",0,"", NULL);
-		smbw_server_add("..",0,"", NULL);
-		smbw_NetServerEnum(&srv->cli, srv->server_name, SV_TYPE_ALL,
-				   smbw_server_add, NULL);
-		*p = '#';
-	} else if (strcmp(srv->cli.dev,"IPC") == 0) {
-		DEBUG(4,("doing NetShareEnum\n"));
-		smbw_share_add(".",0,"", NULL);
-		smbw_share_add("..",0,"", NULL);
-		if (smbw_RNetShareEnum(&srv->cli, smbw_share_add, NULL) < 0) {
-			errno = smbw_errno(&srv->cli);
-			goto failed;
-		}
-	} else if (strncmp(srv->cli.dev,"LPT",3) == 0) {
-		smbw_share_add(".",0,"", NULL);
-		smbw_share_add("..",0,"", NULL);
-		if (cli_print_queue(&srv->cli, smbw_printjob_add) < 0) {
-			errno = smbw_errno(&srv->cli);
-			goto failed;
-		}
-	} else {
-#if 0
-		if (strcmp(path,"\\") == 0) {
-			smbw_share_add(".",0,"");
-			smbw_share_add("..",0,"");
-		}
-#endif
-		if (cli_list(&srv->cli, mask, aHIDDEN|aSYSTEM|aDIR, 
-			     smbw_dir_add, NULL) < 0) {
-			errno = smbw_errno(&srv->cli);
-			goto failed;
-		}
-	}
-
-	cur_dir = NULL;
-	
-	fd = open(SMBW_DUMMY, O_WRONLY);
-	if (fd == -1) {
-		errno = EMFILE;
-		goto failed;
-	}
-
-	if (bitmap_query(smbw_file_bmap, fd)) {
-		DEBUG(0,("ERROR: fd used in smbw_dir_open\n"));
-		errno = EIO;
-		goto failed;
-	}
-
-	DLIST_ADD(smbw_dirs, dir);
-	
-	bitmap_set(smbw_file_bmap, fd);
-
-	dir->fd = fd;
-	dir->srv = srv;
-	dir->path = strdup(s);
-
-	DEBUG(4,("  -> %d\n", dir->count));
-
-	return dir->fd;
-
- failed:
-	free_dir(dir);
-	
-	return -1;
-}
-
-/***************************************************** 
-a wrapper for fstat() on a directory
-*******************************************************/
-int smbw_dir_fstat(int fd, struct stat *st)
-{
-	struct smbw_dir *dir;
-
-	dir = smbw_dir(fd);
-	if (!dir) {
-		errno = EBADF;
-		return -1;
-	}
-
-	ZERO_STRUCTP(st);
-
-	smbw_setup_stat(st, "", dir->count*DIRP_SIZE, aDIR);
-
-	st->st_dev = dir->srv->dev;
-
-	return 0;
-}
-
-/***************************************************** 
-close a directory handle
-*******************************************************/
-int smbw_dir_close(int fd)
-{
-	struct smbw_dir *dir;
-
-	dir = smbw_dir(fd);
-	if (!dir) {
-		errno = EBADF;
-		return -1;
-	}
-
-	bitmap_clear(smbw_file_bmap, dir->fd);
-	close(dir->fd);
-	
-	DLIST_REMOVE(smbw_dirs, dir);
-
-	free_dir(dir);
-
-	return 0;
-}
-
-/***************************************************** 
-a wrapper for getdents()
-*******************************************************/
-int smbw_getdents(unsigned int fd, struct dirent *dirp, int count)
-{
-	struct smbw_dir *dir;
-	int n=0;
-
-	smbw_busy++;
-
-	dir = smbw_dir(fd);
-	if (!dir) {
-		errno = EBADF;
-		smbw_busy--;
-		return -1;
-	}
-
-	while (count>=DIRP_SIZE && (dir->offset < dir->count)) {
-#if HAVE_DIRENT_D_OFF
-		dirp->d_off = (dir->offset+1)*DIRP_SIZE;
-#endif
-		dirp->d_reclen = DIRP_SIZE;
-		fstrcpy(&dirp->d_name[0], dir->list[dir->offset].name);
-		dirp->d_ino = smbw_inode(dir->list[dir->offset].name);
-		dir->offset++;
-		count -= dirp->d_reclen;
-#if HAVE_DIRENT_D_OFF
-		if (dir->offset == dir->count) {
-			dirp->d_off = -1;
-		}
-#endif
-		dirp = (struct dirent *)(((char *)dirp) + DIRP_SIZE);
-		n++;
-	}
-
-	smbw_busy--;
-	return n*DIRP_SIZE;
-}
-
-
-/***************************************************** 
-a wrapper for chdir()
-*******************************************************/
-int smbw_chdir(const char *name)
-{
-	struct smbw_server *srv;
-	fstring server, share;
-	pstring path;
-	uint16 mode = aDIR;
-	char *cwd;
-	int len;
-
-	smbw_init();
-
-	len = strlen(smbw_prefix);
-
-	if (smbw_busy) return real_chdir(name);
-
-	smbw_busy++;
-
-	if (!name) {
-		errno = EINVAL;
-		goto failed;
-	}
-
-	DEBUG(4,("smbw_chdir(%s)\n", name));
-
-	/* work out what server they are after */
-	cwd = smbw_parse_path(name, server, share, path);
-
-	/* a special case - accept cd to /smb */
-	if (strncmp(cwd, smbw_prefix, len-1) == 0 &&
-	    cwd[len-1] == 0) {
-		goto success1;
-	}
-
-	if (strncmp(cwd,smbw_prefix,strlen(smbw_prefix))) {
-		if (real_chdir(cwd) == 0) {
-			goto success2;
-		}
-		goto failed;
-	}
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	if (strncmp(srv->cli.dev,"IPC",3) &&
-	    strncmp(srv->cli.dev,"LPT",3) &&
-	    !smbw_getatr(srv, path, 
-			 &mode, NULL, NULL, NULL, NULL, NULL)) {
-		errno = smbw_errno(&srv->cli);
-		goto failed;
-	}
-
-	if (!(mode & aDIR)) {
-		errno = ENOTDIR;
-		goto failed;
-	}
-
- success1:
-	/* we don't want the old directory to be busy */
-	real_chdir("/");
-
- success2:
-
-	DEBUG(4,("set SMBW_CWD to %s\n", cwd));
-
-	pstrcpy(smbw_cwd, cwd);
-
-	smbw_busy--;
-	return 0;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-
-/***************************************************** 
-a wrapper for lseek() on directories
-*******************************************************/
-off_t smbw_dir_lseek(int fd, off_t offset, int whence)
-{
-	struct smbw_dir *dir;
-	off_t ret;
-
-	dir = smbw_dir(fd);
-	if (!dir) {
-		errno = EBADF;
-		return -1;
-	}
-
-	switch (whence) {
-	case SEEK_SET:
-		dir->offset = offset/DIRP_SIZE;
-		break;
-	case SEEK_CUR:
-		dir->offset += offset/DIRP_SIZE;
-		break;
-	case SEEK_END:
-		dir->offset = (dir->count * DIRP_SIZE) + offset;
-		dir->offset /= DIRP_SIZE;
-		break;
-	}
-
-	ret = dir->offset * DIRP_SIZE;
-
-	DEBUG(4,("   -> %d\n", (int)ret));
-
-	return ret;
-}
-
-
-/***************************************************** 
-a wrapper for mkdir()
-*******************************************************/
-int smbw_mkdir(const char *fname, mode_t mode)
-{
-	struct smbw_server *srv;
-	fstring server, share;
-	pstring path;
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_init();
-
-	smbw_busy++;
-
-	/* work out what server they are after */
-	smbw_parse_path(fname, server, share, path);
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	if (!cli_mkdir(&srv->cli, path)) {
-		errno = smbw_errno(&srv->cli);
-		goto failed;
-	}
-
-	smbw_busy--;
-	return 0;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-/***************************************************** 
-a wrapper for rmdir()
-*******************************************************/
-int smbw_rmdir(const char *fname)
-{
-	struct smbw_server *srv;
-	fstring server, share;
-	pstring path;
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	smbw_init();
-
-	smbw_busy++;
-
-	/* work out what server they are after */
-	smbw_parse_path(fname, server, share, path);
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-		/* smbw_server sets errno */
-		goto failed;
-	}
-
-	if (!cli_rmdir(&srv->cli, path)) {
-		errno = smbw_errno(&srv->cli);
-		goto failed;
-	}
-
-	smbw_busy--;
-	return 0;
-
- failed:
-	smbw_busy--;
-	return -1;
-}
-
-
-/***************************************************** 
-a wrapper for getcwd()
-*******************************************************/
-char *smbw_getcwd(char *buf, size_t size)
-{
-	smbw_init();
-
-	if (smbw_busy) {
-		return (char *)real_getcwd(buf, size);
-	}
-
-	smbw_busy++;
-
-	if (!buf) {
-		if (size <= 0) size = strlen(smbw_cwd)+1;
-		buf = (char *)malloc(size);
-		if (!buf) {
-			errno = ENOMEM;
-			smbw_busy--;
-			return NULL;
-		}
-	}
-
-	if (strlen(smbw_cwd) > size-1) {
-		errno = ERANGE;
-		smbw_busy--;
-		return NULL;
-	}
-
-	safe_strcpy(buf, smbw_cwd, size);
-
-	smbw_busy--;
-	return buf;
-}
-
-/***************************************************** 
-a wrapper for fchdir()
-*******************************************************/
-int smbw_fchdir(unsigned int fd)
-{
-	struct smbw_dir *dir;
-	int ret;
-
-	smbw_busy++;
-
-	dir = smbw_dir(fd);
-	if (dir) {
-		smbw_busy--;
-		return chdir(dir->path);
-	}	
-
-	ret = real_fchdir(fd);
-	if (ret == 0) {
-		sys_getwd(smbw_cwd);		
-	}
-
-	smbw_busy--;
-	return ret;
-}
-
-/***************************************************** 
-open a directory on the server
-*******************************************************/
-DIR *smbw_opendir(const char *fname)
-{
-	int fd;
-
-	smbw_busy++;
-
-	fd = smbw_dir_open(fname);
-
-	if (fd == -1) {
-		smbw_busy--;
-		return NULL;
-	}
-
-	smbw_busy--;
-
-	return (DIR *)smbw_dir(fd);
-}
-
-/***************************************************** 
-read one entry from a directory
-*******************************************************/
-struct dirent *smbw_readdir(DIR *dirp)
-{
-	struct smbw_dir *d = (struct smbw_dir *)dirp;
-	static union {
-		char buf[DIRP_SIZE];
-		struct dirent de;
-	} dbuf;
-
-	if (smbw_getdents(d->fd, &dbuf.de, DIRP_SIZE) > 0) 
-		return &dbuf.de;
-
-	return NULL;
-}
-
-/***************************************************** 
-close a DIR*
-*******************************************************/
-int smbw_closedir(DIR *dirp)
-{
-	struct smbw_dir *d = (struct smbw_dir *)dirp;
-	return smbw_close(d->fd);
-}
-
-/***************************************************** 
-seek in a directory
-*******************************************************/
-void smbw_seekdir(DIR *dirp, off_t offset)
-{
-	struct smbw_dir *d = (struct smbw_dir *)dirp;
-	smbw_dir_lseek(d->fd,offset, SEEK_SET);
-}
-
-/***************************************************** 
-current loc in a directory
-*******************************************************/
-off_t smbw_telldir(DIR *dirp)
-{
-	struct smbw_dir *d = (struct smbw_dir *)dirp;
-	return smbw_dir_lseek(d->fd,0,SEEK_CUR);
-}
diff --git a/source4/smbwrapper/smbw_stat.c b/source4/smbwrapper/smbw_stat.c
deleted file mode 100644
index 6c476a8a67..0000000000
--- a/source4/smbwrapper/smbw_stat.c
+++ /dev/null
@@ -1,250 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper stat functions
-   Copyright (C) Andrew Tridgell 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"
-
-extern int smbw_busy;
-
-/***************************************************** 
-setup basic info in a stat structure
-*******************************************************/
-void smbw_setup_stat(struct stat *st, char *fname, size_t size, int mode)
-{
-	st->st_mode = 0;
-
-	if (IS_DOS_DIR(mode)) {
-		st->st_mode = SMBW_DIR_MODE;
-	} else {
-		st->st_mode = SMBW_FILE_MODE;
-	}
-
-	if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
-	if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
-	if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
-	if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
-
-	st->st_size = size;
-	st->st_blksize = 512;
-	st->st_blocks = (size+511)/512;
-	st->st_uid = getuid();
-	st->st_gid = getgid();
-	if (IS_DOS_DIR(mode)) {
-		st->st_nlink = 2;
-	} else {
-		st->st_nlink = 1;
-	}
-	if (st->st_ino == 0) {
-		st->st_ino = smbw_inode(fname);
-	}
-}
-
-
-/***************************************************** 
-try to do a QPATHINFO and if that fails then do a getatr
-this is needed because win95 sometimes refuses the qpathinfo
-*******************************************************/
-BOOL smbw_getatr(struct smbw_server *srv, char *path, 
-		 uint16 *mode, size_t *size, 
-		 time_t *c_time, time_t *a_time, time_t *m_time,
-		 SMB_INO_T *ino)
-{
-	DEBUG(4,("sending qpathinfo\n"));
-
-	if (!srv->no_pathinfo2 &&
-	    cli_qpathinfo2(&srv->cli, path, c_time, a_time, m_time, NULL,
-			   size, mode, ino)) return True;
-
-	/* if this is NT then don't bother with the getatr */
-	if (srv->cli.capabilities & CAP_NT_SMBS) return False;
-
-	if (cli_getatr(&srv->cli, path, mode, size, m_time)) {
-		a_time = c_time = m_time;
-		srv->no_pathinfo2 = True;
-		return True;
-	}
-	return False;
-}
-
-
-static struct print_job_info printjob;
-
-/***************************************************** 
-gather info from a printjob listing
-*******************************************************/
-static void smbw_printjob_stat(struct print_job_info *job)
-{
-	if (strcmp(job->name, printjob.name) == 0) {
-		printjob = *job;
-	}
-}
-
-/***************************************************** 
-stat a printjob
-*******************************************************/
-int smbw_stat_printjob(struct smbw_server *srv,char *path,
-		       size_t *size, time_t *m_time)
-{
-	if (path[0] == '\\') path++;
-
-	ZERO_STRUCT(printjob);
-
-	fstrcpy(printjob.name, path);
-	cli_print_queue(&srv->cli, smbw_printjob_stat);
-
-	if (size) {
-		*size = printjob.size;
-	}
-	if (m_time) {
-		*m_time = printjob.t;
-	}
-	return printjob.id;
-}
-
-
-/***************************************************** 
-a wrapper for fstat()
-*******************************************************/
-int smbw_fstat(int fd, struct stat *st)
-{
-	struct smbw_file *file;
-	time_t c_time, a_time, m_time;
-	size_t size;
-	uint16 mode;
-	SMB_INO_T ino = 0;
-
-	smbw_busy++;
-
-	ZERO_STRUCTP(st);
-
-	file = smbw_file(fd);
-	if (!file) {
-		int ret = smbw_dir_fstat(fd, st);
-		smbw_busy--;
-		return ret;
-	}
-
-	if (!cli_qfileinfo(&file->srv->cli, file->f->cli_fd, 
-			   &mode, &size, &c_time, &a_time, &m_time, NULL,
-			   &ino) &&
-	    !cli_getattrE(&file->srv->cli, file->f->cli_fd, 
-			  &mode, &size, &c_time, &a_time, &m_time)) {
-		errno = EINVAL;
-		smbw_busy--;
-		return -1;
-	}
-
-	st->st_ino = ino;
-
-	smbw_setup_stat(st, file->f->fname, size, mode);
-
-	st->st_atime = a_time;
-	st->st_ctime = c_time;
-	st->st_mtime = m_time;
-	st->st_dev = file->srv->dev;
-
-	smbw_busy--;
-	return 0;
-}
-
-
-/***************************************************** 
-a wrapper for stat()
-*******************************************************/
-int smbw_stat(const char *fname, struct stat *st)
-{
-	struct smbw_server *srv;
-	fstring server, share;
-	pstring path;
-	time_t m_time=0, a_time=0, c_time=0;
-	size_t size=0;
-	uint16 mode=0;
-	SMB_INO_T ino = 0;
-	int result = 0;
-
-	ZERO_STRUCTP(st);
-
-	if (!fname) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	DEBUG(4,("stat(%s)\n", fname));
-
-	smbw_init();
-
-	smbw_busy++;
-
-	/* work out what server they are after */
-	smbw_parse_path(fname, server, share, path);
-
-	/* get a connection to the server */
-	srv = smbw_server(server, share);
-	if (!srv) {
-
-		/* For shares we aren't allowed to connect to, or no master
-		   browser found, return an empty directory */
-
-		if ((server[0] && share[0] && !path[0] && errno == EACCES) ||
-		    (!path[0] && errno == ENOENT)) {
-			mode = aDIR | aRONLY;
-			smbw_setup_stat(st, path, size, mode);
-			goto done;
-		}
-
-		/* smbw_server sets errno */
-		result = -1;
-		goto done;
-	}
-
-	DEBUG(4,("smbw_stat\n"));
-
-	if (strncmp(srv->cli.dev,"IPC",3) == 0) {
-		mode = aDIR | aRONLY;
-	} else if (strncmp(srv->cli.dev,"LPT",3) == 0) {
-		if (strcmp(path,"\\") == 0) {
-			mode = aDIR | aRONLY;
-		} else {
-			mode = aRONLY;
-			smbw_stat_printjob(srv, path, &size, &m_time);
-			c_time = a_time = m_time;
-		}
-	} else {
-		if (!smbw_getatr(srv, path, 
-				 &mode, &size, &c_time, &a_time, &m_time,
-				 &ino)) {
-			errno = smbw_errno(&srv->cli);
-			result = -1;
-			goto done;
-		}
-	}
-
-	st->st_ino = ino;
-
-	smbw_setup_stat(st, path, size, mode);
-
-	st->st_atime = a_time;
-	st->st_ctime = c_time;
-	st->st_mtime = m_time;
-	st->st_dev = srv->dev;
-
- done:
-	smbw_busy--;
-	return result;
-}
diff --git a/source4/smbwrapper/wrapped.c b/source4/smbwrapper/wrapped.c
deleted file mode 100644
index 338ee0d5b1..0000000000
--- a/source4/smbwrapper/wrapped.c
+++ /dev/null
@@ -1,705 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   SMB wrapper functions
-   Copyright (C) Andrew Tridgell 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.
-*/
-
-/* NOTE: This file WILL produce compiler warnings. They are unavoidable 
-
-   Do not try and get rid of them by including other include files or
-   by including includes.h or proto.h or you will break portability. 
-  */
-
-#include "config.h"
-#include <sys/types.h>
-#include <errno.h>
-#include "realcalls.h"
-
-#ifndef NULL
-# define NULL ((void *)0)
-#endif
-
- int open(char *name, int flags, mode_t mode)
-{
-	if (smbw_path(name)) {
-		return smbw_open(name, flags, mode);
-	}
-
-	return real_open(name, flags, mode);
-}
-
-#ifdef HAVE__OPEN
- int _open(char *name, int flags, mode_t mode) 
-{
-	return open(name, flags, mode);
-}
-#elif HAVE___OPEN
- int __open(char *name, int flags, mode_t mode) 
-{
-	return open(name, flags, mode);
-}
-#endif
-
-
-#ifdef HAVE_OPEN64
- int open64(char *name, int flags, mode_t mode)
-{
-	if (smbw_path(name)) {
-		return smbw_open(name, flags, mode);
-	}
-
-	return real_open64(name, flags, mode);
-}
-#endif
-
-#ifndef NO_OPEN64_ALIAS
-#ifdef HAVE__OPEN64
- int _open64(char *name, int flags, mode_t mode) 
-{
-	return open64(name, flags, mode);
-}
-#elif HAVE___OPEN64
- int __open64(char *name, int flags, mode_t mode) 
-{
-	return open64(name, flags, mode);
-}
-#endif
-#endif
-
-#ifdef HAVE_PREAD
- ssize_t pread(int fd, void *buf, size_t size, off_t ofs)
-{
-	if (smbw_fd(fd)) {
-		return smbw_pread(fd, buf, size, ofs);
-	}
-
-	return real_pread(fd, buf, size, ofs);
-}
-#endif
-
-#if defined(HAVE_PREAD64) && defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT)
- ssize_t pread64(int fd, void *buf, size_t size, off64_t ofs)
-{
-	if (smbw_fd(fd)) {
-		return smbw_pread(fd, buf, size, ofs);
-	}
-
-	return real_pread64(fd, buf, size, ofs);
-}
-#endif
-
-#ifdef HAVE_PWRITE
- ssize_t pwrite(int fd, void *buf, size_t size, off_t ofs)
-{
-	if (smbw_fd(fd)) {
-		return smbw_pwrite(fd, buf, size, ofs);
-	}
-
-	return real_pwrite(fd, buf, size, ofs);
-}
-#endif
-
-#if defined(HAVE_PWRITE64) && defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT)
- ssize_t pwrite64(int fd, void *buf, size_t size, off64_t ofs)
-{
-	if (smbw_fd(fd)) {
-		return smbw_pwrite(fd, buf, size, ofs);
-	}
-
-	return real_pwrite64(fd, buf, size, ofs);
-}
-#endif
-
-
- int chdir(char *name)
-{
-	return smbw_chdir(name);
-}
-
-#ifdef HAVE___CHDIR
- int __chdir(char *name)
-{
-	return chdir(name);
-}
-#elif HAVE__CHDIR
- int _chdir(char *name)
-{
-	return chdir(name);
-}
-#endif
-
-
- int close(int fd)
-{
-	if (smbw_fd(fd)) {
-		return smbw_close(fd);
-	}
-	if (smbw_local_fd(fd)) {
-		errno = EBADF;
-		return -1;
-	}
-
-	return real_close(fd);
-}
-
-#ifdef HAVE___CLOSE
- int __close(int fd)
-{
-	return close(fd);
-}
-#elif HAVE__CLOSE
- int _close(int fd)
-{
-	return close(fd);
-}
-#endif
-
-
- int fchdir(int fd)
-{
-	return smbw_fchdir(fd);
-}
-
-#ifdef HAVE___FCHDIR
- int __fchdir(int fd)
-{
-	return fchdir(fd);
-}
-#elif HAVE__FCHDIR
- int _fchdir(int fd)
-{
-	return fchdir(fd);
-}
-#endif
-
-
- int fcntl(int fd, int cmd, long arg)
-{
-	if (smbw_fd(fd)) {
-		return smbw_fcntl(fd, cmd, arg);
-	}
-
-	return real_fcntl(fd, cmd, arg);
-}
-
-
-#ifdef HAVE___FCNTL
- int __fcntl(int fd, int cmd, long arg)
-{
-	return fcntl(fd, cmd, arg);
-}
-#elif HAVE__FCNTL
- int _fcntl(int fd, int cmd, long arg)
-{
-	return fcntl(fd, cmd, arg);
-}
-#endif
-
-
-
-#ifdef real_getdents
- int getdents(int fd, void *dirp, unsigned int count)
-{
-	if (smbw_fd(fd)) {
-		return smbw_getdents(fd, dirp, count);
-	}
-
-	return real_getdents(fd, dirp, count);
-}
-#endif
-
-#ifdef HAVE___GETDENTS
- int __getdents(int fd, void *dirp, unsigned int count)
-{
-	return getdents(fd, dirp, count);
-}
-#elif HAVE__GETDENTS
- int _getdents(int fd, void *dirp, unsigned int count)
-{
-	return getdents(fd, dirp, count);
-}
-#endif
-
-
- off_t lseek(int fd, off_t offset, int whence)
-{
-	if (smbw_fd(fd)) {
-		return smbw_lseek(fd, offset, whence);
-	}
-
-	return real_lseek(fd, offset, whence);
-}
-
-#ifdef HAVE___LSEEK
- off_t __lseek(int fd, off_t offset, int whence)
-{
-	return lseek(fd, offset, whence);
-}
-#elif HAVE__LSEEK
- off_t _lseek(int fd, off_t offset, int whence)
-{
-	return lseek(fd, offset, whence);
-}
-#endif
-
-
- ssize_t read(int fd, void *buf, size_t count)
-{
-	if (smbw_fd(fd)) {
-		return smbw_read(fd, buf, count);
-	}
-
-	return real_read(fd, buf, count);
-}
-
-#ifdef HAVE___READ
- ssize_t __read(int fd, void *buf, size_t count)
-{
-	return read(fd, buf, count);
-}
-#elif HAVE__READ
- ssize_t _read(int fd, void *buf, size_t count)
-{
-	return read(fd, buf, count);
-}
-#endif
-
-
- ssize_t write(int fd, void *buf, size_t count)
-{
-	if (smbw_fd(fd)) {
-		return smbw_write(fd, buf, count);
-	}
-
-	return real_write(fd, buf, count);
-}
-
-#ifdef HAVE___WRITE
- ssize_t __write(int fd, void *buf, size_t count)
-{
-	return write(fd, buf, count);
-}
-#elif HAVE__WRITE
- ssize_t _write(int fd, void *buf, size_t count)
-{
-	return write(fd, buf, count);
-}
-#endif
-
-
-
- int access(char *name, int mode)
-{
-	if (smbw_path(name)) {
-		return smbw_access(name, mode);
-	}
-
-	return real_access(name, mode);
-}
-
-
-
- int chmod(char *name,mode_t mode)
-{
-	if (smbw_path(name)) {
-		return smbw_chmod(name, mode);
-	}
-
-	return real_chmod(name, mode);
-}
-
-
-
- int chown(char *name,uid_t owner, gid_t group)
-{
-	if (smbw_path(name)) {
-		return smbw_chown(name, owner, group);
-	}
-
-	return real_chown(name, owner, group);
-}
-
-
- char *getcwd(char *buf, size_t size)
-{
-	return (char *)smbw_getcwd(buf, size);
-}
-
-
-
-
- int mkdir(char *name, mode_t mode)
-{
-	if (smbw_path(name)) {
-		return smbw_mkdir(name, mode);
-	}
-
-	return real_mkdir(name, mode);
-}
-
-
-#if HAVE___FXSTAT
- int __fxstat(int vers, int fd, void *st)
-{
-	double xx[32];
-	int ret;
-
-	if (smbw_fd(fd)) {
-		return smbw_fstat(fd, st);
-	}
-
-	ret = real_fstat(fd, xx);
-	xstat_convert(vers, st, xx);
-	return ret;
-}
-#endif
-
-#if HAVE___XSTAT
- int __xstat(int vers, char *name, void *st)
-{
-	double xx[32];
-	int ret;
-
-	if (smbw_path(name)) {
-		return smbw_stat(name, st);
-	}
-
-	ret = real_stat(name, xx);
-	xstat_convert(vers, st, xx);
-	return ret;
-}
-#endif
-
-
-#if HAVE___LXSTAT
- int __lxstat(int vers, char *name, void *st)
-{
-	double xx[32];
-	int ret;
-
-	if (smbw_path(name)) {
-		return smbw_stat(name, st);
-	}
-
-	ret = real_lstat(name, xx);
-	xstat_convert(vers, st, xx);
-	return ret;
-}
-#endif
-
-
- int stat(char *name, void *st)
-{
-#if HAVE___XSTAT
-	return __xstat(0, name, st);
-#else
-	if (smbw_path(name)) {
-		return smbw_stat(name, st);
-	}
-	return real_stat(name, st);
-#endif
-}
-
- int lstat(char *name, void *st)
-{
-#if HAVE___LXSTAT
-	return __lxstat(0, name, st);
-#else
-	if (smbw_path(name)) {
-		return smbw_stat(name, st);
-	}
-	return real_lstat(name, st);
-#endif
-}
-
- int fstat(int fd, void *st)
-{
-#if HAVE___LXSTAT
-	return __fxstat(0, fd, st);
-#else
-	if (smbw_fd(fd)) {
-		return smbw_fstat(fd, st);
-	}
-	return real_fstat(fd, st);
-#endif
-}
-
-
- int unlink(char *name)
-{
-	if (smbw_path(name)) {
-		return smbw_unlink(name);
-	}
-
-	return real_unlink(name);
-}
-
-
-#ifdef HAVE_UTIME
- int utime(char *name,void *tvp)
-{
-	if (smbw_path(name)) {
-		return smbw_utime(name, tvp);
-	}
-
-	return real_utime(name, tvp);
-}
-#endif
-
-#ifdef HAVE_UTIMES
- int utimes(const char *name, const struct timeval *tvp)
-{
-	if (smbw_path(name)) {
-		return smbw_utimes(name, tvp);
-	}
-
-	return real_utimes(name, tvp);
-}
-#endif
-
- int readlink(char *path, char *buf, size_t bufsize)
-{
-	if (smbw_path(path)) {
-		return smbw_readlink(path, buf, bufsize);
-	}
-
-	return real_readlink(path, buf, bufsize);
-}
-
-
- int rename(char *oldname,char *newname)
-{
-	int p1, p2;
-	p1 = smbw_path(oldname); 
-	p2 = smbw_path(newname); 
-	if (p1 ^ p2) {
-		/* can't cross filesystem boundaries */
-		errno = EXDEV;
-		return -1;
-	}
-	if (p1 && p2) {
-		return smbw_rename(oldname, newname);
-	}
-
-	return real_rename(oldname, newname);
-}
-
- int rmdir(char *name)
-{
-	if (smbw_path(name)) {
-		return smbw_rmdir(name);
-	}
-
-	return real_rmdir(name);
-}
-
-
- int symlink(char *topath,char *frompath)
-{
-	int p1, p2;
-	p1 = smbw_path(topath); 
-	p2 = smbw_path(frompath); 
-	if (p1 || p2) {
-		/* can't handle symlinks */
-		errno = EPERM;
-		return -1;
-	}
-
-	return real_symlink(topath, frompath);
-}
-
- int dup(int fd)
-{
-	if (smbw_fd(fd)) {
-		return smbw_dup(fd);
-	}
-
-	return real_dup(fd);
-}
-
- int dup2(int oldfd, int newfd)
-{
-	if (smbw_fd(newfd)) {
-		close(newfd);
-	}
-
-	if (smbw_fd(oldfd)) {
-		return smbw_dup2(oldfd, newfd);
-	}
-
-	return real_dup2(oldfd, newfd);
-}
-
-#ifdef real_opendir
- void *opendir(char *name)
-{
-	if (smbw_path(name)) {
-		return (void *)smbw_opendir(name);
-	}
-
-	return (void *)real_opendir(name);
-}
-#endif
-
-#ifdef real_readdir
- void *readdir(void *dir)
-{
-	if (smbw_dirp(dir)) {
-		return (void *)smbw_readdir(dir);
-	}
-
-	return (void *)real_readdir(dir);
-}
-#endif
-
-#ifdef real_closedir
- int closedir(void *dir)
-{
-	if (smbw_dirp(dir)) {
-		return smbw_closedir(dir);
-	}
-
-	return real_closedir(dir);
-}
-#endif
-
-#ifdef real_telldir
- off_t telldir(void *dir)
-{
-	if (smbw_dirp(dir)) {
-		return smbw_telldir(dir);
-	}
-
-	return real_telldir(dir);
-}
-#endif
-
-#ifdef real_seekdir
- int seekdir(void *dir, off_t offset)
-{
-	if (smbw_dirp(dir)) {
-		smbw_seekdir(dir, offset);
-		return 0;
-	}
-
-	real_seekdir(dir, offset);
-	return 0;
-}
-#endif
-
-
-#ifndef NO_ACL_WRAPPER
- int  acl(char  *pathp,  int  cmd,  int  nentries, void *aclbufp)
-{
-	if (smbw_path(pathp)) {
-		return smbw_acl(pathp, cmd, nentries, aclbufp);
-	}
-
-	return real_acl(pathp, cmd, nentries, aclbufp);
-}
-#endif
-
-#ifndef NO_FACL_WRAPPER
- int  facl(int fd,  int  cmd,  int  nentries, void *aclbufp)
-{
-	if (smbw_fd(fd)) {
-		return smbw_facl(fd, cmd, nentries, aclbufp);
-	}
-
-	return real_facl(fd, cmd, nentries, aclbufp);
-}
-#endif
-
- int creat(char *path, mode_t mode)
-{
-	extern int creat_bits;
-	return open(path, creat_bits, mode);
-}
-
-#ifdef HAVE_CREAT64
- int creat64(char *path, mode_t mode)
-{
-	extern int creat_bits;
-	return open64(path, creat_bits, mode);
-}
-#endif
-
-#ifdef HAVE_STAT64
-  int stat64(char *name, void *st64)
-{
-	if (smbw_path(name)) {
-		double xx[32];
-		int ret = stat(name, xx);
-		stat64_convert(xx, st64);
-		return ret;
-	}
-	return real_stat64(name, st64);
-}
-
-  int fstat64(int fd, void *st64)
-{
-	if (smbw_fd(fd)) {
-		double xx[32];
-		int ret = fstat(fd, xx);
-		stat64_convert(xx, st64);
-		return ret;
-	}
-	return real_fstat64(fd, st64);
-}
-
-  int lstat64(char *name, void *st64)
-{
-	if (smbw_path(name)) {
-		double xx[32];
-		int ret = lstat(name, xx);
-		stat64_convert(xx, st64);
-		return ret;
-	}
-	return real_lstat64(name, st64);
-}
-#endif
-
-#ifdef HAVE_LLSEEK
-  offset_t llseek(int fd, offset_t ofs, int whence)
-{
-	if (smbw_fd(fd)) {
-		return lseek(fd, ofs, whence);
-	}
-	return real_llseek(fd, ofs, whence);
-}
-#endif
-
-#ifdef HAVE_READDIR64
- void *readdir64(void *dir)
-{
-	if (smbw_dirp(dir)) {
-		static double xx[70];
-		void *d;
-		d = (void *)readdir(dir);
-		if (!d) return NULL;
-		dirent64_convert(d, xx);
-		return xx;
-	}
-	return (void *)real_readdir64(dir);
-}
-#endif
-
- int fork(void)
-{
-	return smbw_fork();
-}
-