diff options
21 files changed, 4481 insertions, 168 deletions
diff --git a/WHATSNEW.txt b/WHATSNEW.txt index e02cb1e8fab..0dd513c9ec3 100644 --- a/WHATSNEW.txt +++ b/WHATSNEW.txt @@ -1,13 +1,203 @@ + ================================== + Release Notes for Samba 3.0.15pre1 + Apr 11, 2005 + ================================== + +This is a preview release of the Samba 3.0.15 code base and +is provided for testing only. This release is *not* intended +for production servers. However, there have been several bug +fixes and new features added since 3.0.14 that we feel are +important to make available to the Samba community for wider +testing. There are still more changes planned before the +final 3.0.15 release. + +Additional features introduced in Samba 3.0.15pre1 include: + + o Support for several new Win32 rpc pipes. + o Improved support for OS/2 clients. + o New 'net rpc service' tool for managing Win32 services. + o Capability to set the owner on new files and directory + based on the parent's ownership. + + +###################################################################### +Changes +####### + +Changes since 3.0.14 +-------------------- + + Parameter Name Action + -------------- ------ + inherit owner New + max stat cache size New + +commits +------- + +o Jeremy Allison <jra@samba.org> + * BUG 2533: Fix incorrect directory listings for OS/2 clients. + * Ensure the old SMB search calls always ask mask_match() to + translate patterns like ????????.???. + * Split out the check_path_syntax() into a findfirst, findnext, + & wildcard versions. + * Fix checks for matching groups in an file ACL against the + user's primary and supplementary group list. + * BUG 2541: Ensure we recognise LANMAN2.1 as OS/2 and select + LANMAN2 protocol, ensure the EA size is always correctly + set on a query for a file with no EA's. + * BUG 2551: Look at the incoming flags2 flag + FLAGS2_LONG_PATH_COMPONENTS determines if a reply is + uppercased on a SMBsearch request, not the protocol level. + * Added "volume" command to smbclient that prints out the + volume name and serial number. + * Added "fix for broken SMB_INFO_VOLUME level used by OS/2. + * Add support for OS/2 Extended Attributes. + * Correctly check OpenX open modes. + * Ensure allocation size is correctly returned for OpenX. + * Only set allocation on create/truncate for nttrans. + * Fix oplock bug in trans2open() code. + * Remove unix_ERR_XXX global nastiness. + * Only do the strange DOS error for openX, not trans2open. + * Ensure SMBopen replies includes the share modes as well as + open modes. + * BUG 2581: Add size limit (in kb) to stat cache. + + +o Timur Bakeyev <timur@com.bat.ru> + * BUG 2546: Add support for FreeBSD EA API + + +o Gerald (Jerry) Carter <jerry@samba.org> + * Added support for \svcctl pipe rpcs. + * Added 'net rpc service' subcommand for managing Win32 + services. + * Refactoring work on the rpc [un]marshalling layer and + structures. + * Verify privilege name in 'net rpc rights privileges' in + order to provide better error messages. + * Cleanup rpc structures in rpc_spoolss.h. + * Cleanups and fixes for the \winreg server code. + * Cleanup of rpc structures used by LsaEnumerateTrustedDomains. + + +o Jeremy Cooper <jeremy@ncircle.com> + * Added support for several new \winreg client rpcs. + + +o Guenther Deschner <gd@samba.org> + * Close handles on group creation in rpcclient to better + support mass group account creation. + * Fix account policy key lookup for minimum and maximum + password lengths. + * Fix some compiler warnings and add missing exclude-block + in 'net rpc share migrate'. + + +o Steve French <sfrench@us.ibm.com> + * Update list of mount options for mount.cifs. + * Add more defines for POSIX extensions to match the newly + added client implementation. + * Add initial support for cifs umount utility. + * Fix cifs mounts to handle commas embedded in prompted + password, and password and credential files. + * Fix cifs mounts to handle domain name and user name in + username field (in form domain\user). + + +o Guenter Kukkukk <guenter.kukkukk@kukkukk.com> + * BUG 2541: Fix copying of file(s) from samba share to an OS/2 + local drive. + + +o Tom Lackemann <cessnatomny@yahoo.com> + * BUG 2242: Patch to ensure that we only set the security + descriptor on an NTtransact create if we created the file. + + +o Volker Lendecke <vl@samba.org> + * Port some of the non-critical changes from HEAD to 3_0. + The main one is the change in pdb_enum_alias_memberships + to match samr.idl a bit closer. + * Close handles on user creation in rpcclient to better + support mass user account creation. + * Implement client RAP calls for enumusers/enumgroups level 0. + * Implement a new caching API for enumerating the pdb elements. + * Convert the RAP user and group enumeration functions to the + utilized the pdb_search API. + * BUG 2438: Partial fix for 'net rpc trustdom establish' in + RestrictAnonymous environments. + + +o Herb Lewis <herb@samba.org> + * Compiler warning cleanups. + + +o Derrell Lipman <derrell@samba.org> + * add support for opening a file for write with O_APPEND + in libsmbclient. + * Added smbsh/smbwrapper for Linux to example/libsmbclient + tree. + * Fix smbc_stat() from returning incorrect timestamps IFF + it used cli_qpathinfo2() to retrieve the timestamps (Win2k) + and not if it used cli-getatr() to retrieve the timestamps + (Win98). + * Fix handful of compiler warnings. + * BUG 2498, 2484: smbc_getxattr() fixes. + * BUG 1133: Added provision for overloading some global + configuration options via the new, per-user file + ~/.smb/smb.conf.append. + * BUG 2543: Properly cache anonymous username when reverting + to anonymous login, in libsmbclient. + * BUG 2505: Fix large file support in libsmbclient. + + +o Jason Mader <jason@ncac.gwu.edu> + * BUG 2483, 2468. 2469, 2478, 2093: Compiler warning fixes. + + +o Jim McDonough <jmcd@us.ibm.com> + * Fixes for samr_lookup_rids() when using ldapsam:trusted=yes + (in conjunction with Volker). + +o Marcel Müller <mueller@maazl.de> + * Patch to fix the OS/2 EA_FROM_LIST info level call. + + + +o James Peach <jpeach@sgi.com> + * BUG 1843: Fix quotas (with no soft limits) on IRIX. + + +o Marcin Porwit <mporwit@centeris.com> + * Initial support for the \eventlog pipe. + + +o Simo Sorce <idra@samba.org> + * Allow Domain Admins to force user sessions to close via the + Windows Server Manager. + * Add support to 'net rpc right privileges <name>' to enumerate + accounts which possess a specific privilege. + + +o Mark Weaver <mark-clist@npsl.co.uk> + * Patch to fix sys_select so it can't drop signals if another + fd is ready to read. + + +o Jelmer Vernooij <jelmer@samba.org> + * Remove --with-manpage-languages configure option. + + + +Release Notes for older release follow: + + -------------------------------------------------- ============================== Release Notes for Samba 3.0.14 Apr 11, 2005 ============================== -This is the latest stable release of Samba. This is the version -that production Samba servers should be running for all current -bug-fixes. Please read the following important changes in this -release. - Common bugs fixed in 3.0.14 include: o Compatibility issues between Winbind and Windows 2003 SP1 @@ -92,11 +282,6 @@ o Simo Sorce <irda@samba.org> * Debian packaging fixes. - - - -Release Notes for older release follow: - -------------------------------------------------- ============================== Release Notes for Samba 3.0.13 diff --git a/examples/libsmbclient/Makefile b/examples/libsmbclient/Makefile index fcd5ef29003..4b4919ee7ff 100644 --- a/examples/libsmbclient/Makefile +++ b/examples/libsmbclient/Makefile @@ -6,19 +6,24 @@ EXTLIB_INCL = -I/usr/include/gtk-1.2 \ -I/usr/include/glib-1.2 \ -I/usr/lib/glib/include -CFLAGS = -I$(SAMBA_INCL) $(EXTLIB_INCL) +DEFS = -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE +CFLAGS = -O0 -g -I$(SAMBA_INCL) $(EXTLIB_INCL) $(DEFS) -LDFLAGS = -L/usr/lib +LDFLAGS = -L/usr/local/samba/lib -all: testsmbc tree testacl testbrowse +TESTS= testsmbc \ + tree \ + testacl \ + testbrowse \ + teststat \ + testchmod \ + testutime -testsmbc: testsmbc.o - @echo Linking testsmbc - $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< -lsmbclient -L/usr/local/lib +all: $(TESTS) smbsh -testsmbc-static: testsmbc.o +testsmbc: testsmbc.o @echo Linking testsmbc - @$(CC) $(CFLAGS) -static $(LDFLAGS) -o $@ $< -lsmbclient -ldl -lnsl + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< -lsmbclient tree: tree.o @echo Linking tree @@ -32,5 +37,21 @@ testbrowse: testbrowse.o @echo Linking testbrowse @$(CC) $(CFLAGS) $(LDFLAGS) -o $@ -lsmbclient -lpopt $< +teststat: teststat.o + @echo Linking teststat + @$(CC) $(CFLAGS) $(LDFLAGS) -o $@ /usr/local/samba/lib/libsmbclient.so -lpopt $< + +testchmod: testchmod.o + @echo Linking testchmod + @$(CC) $(CFLAGS) $(LDFLAGS) -o $@ /usr/local/samba/lib/libsmbclient.so -lpopt $< + +testutime: testutime.o + @echo Linking testutime + @$(CC) $(CFLAGS) $(LDFLAGS) -o $@ /usr/local/samba/lib/libsmbclient.so -lpopt $< + +smbsh: + make -C smbwrapper + clean: - @rm -f *.o *~ + @rm -f *.o *~ $(TESTS) + @make -C smbwrapper clean diff --git a/examples/libsmbclient/README b/examples/libsmbclient/README index d9a9f829174..c45dd8b9d68 100644 --- a/examples/libsmbclient/README +++ b/examples/libsmbclient/README @@ -2,7 +2,16 @@ Some simple example programs for libsmbclient ... testsmbc.c is kinda broken as it has many hardcoded bits in it +testbrowse.c opens a remote folder and displays its contents + +teststat.c allows comparing the results of smbc_stat() against a local stat() of +the same file. + tree.c is an example of how you might do some of these things with GTK+ It needs lots of work but shows you some ways to use libsmbclient. -Richard Sharpe, 17-May-2001 ... +smbwrapper implements the old smbsh/smbwrapper mechanism using libsmbclient, in +such a way that it works on Linux + +Richard Sharpe, 17 May 2001 +Derrell Lipman, 30 Mar 2005 diff --git a/examples/libsmbclient/smbwrapper/Makefile b/examples/libsmbclient/smbwrapper/Makefile new file mode 100644 index 00000000000..8e7070cb597 --- /dev/null +++ b/examples/libsmbclient/smbwrapper/Makefile @@ -0,0 +1,36 @@ +LIBS = -lsmbclient -ldl +DEFS = -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE + +CFLAGS = -I$(SAMBA_INCL) $(EXTLIB_INCL) + +LDFLAGS = -L/usr/local/samba/lib + +SMBINCLUDE = -I../../../source/include +CFLAGS= -fpic -g -O0 $(DEFS) $(SMBINCLUDE) + +BIN = . + +SMBWRAPPER_OBJS = smbw.o smbw_dir.o smbw_stat.o wrapper.o select.o +SMBSH_OBJS = smbsh.o + +all: $(BIN)/smbwrapper.so $(BIN)/smbsh + +$(BIN)/smbwrapper.so: $(SMBWRAPPER_OBJS) + $(CC) -g \ + -Wl,-init=smbw_initialize \ + -shared \ + --export-all-symbols \ + -o $(BIN)/smbwrapper.so \ + $(SMBWRAPPER_OBJS) \ + $(LDFLAGS) \ + $(LIBS) \ + -Wl,-soname=`basename $@` + +$(BIN)/smbsh: $(SMBSH_OBJS) + $(CC) -g -o $(BIN)/smbsh $(SMBSH_OBJS) $(LIBS) $(LDFLAGS) + +opendir_smbsh: opendir_smbsh.o + $(CC) -g -o opendir_smbsh opendir_smbsh.o $(LIBS) $(DMALLOC) + +clean: + rm -f *.o *~ opendir_smbsh smbsh smbwrapper.so diff --git a/examples/libsmbclient/smbwrapper/README b/examples/libsmbclient/smbwrapper/README new file mode 100644 index 00000000000..7b71ec06ba0 --- /dev/null +++ b/examples/libsmbclient/smbwrapper/README @@ -0,0 +1,40 @@ +To create "smbsh" on Linux, just type "make". + +If you execute "smbsh" in *this* directory (so that it can find the required +shared library), you'll find yourself in a new shell. You can then issue +commands referencing the "/smb" pseudo-filesystem: + + ls /smb + ls /smb/WORKGROUP_OR_DOMAIN + ls /smb/SERVER + ls /smb/SERVER/SHARE + ls /smb/SERVER/SHARE/PATH + +Note that WORKGROUP_OR_DOMAIN is *not* used other than at that level. This is +consistent with the smb:// URI definition. + +Usage: + smbsh [-L <path to find smbwrapper.so>] + [-p <library to load before smbwrapper.so>] + [-a <library to load after smbwrapper.so>] + [-d <debug value for libsmbclient>] + [-n] (do not ask for username/password) + [-W <workgroup>] + [-U <username%password] + [command] + +So to list the contents of \\MYDESK\C$ where a username (adventure) and password +(xyzzy) are required, and with smbwrapper.so installed in /usr/share/samba, you +could try: + + smbsh -L /usr/share/samba -U adventure%xyzzy ls '/smb/MYDESK/C$' + +(It's a good idea to get in the habit of surrounding windows paths in single +quotes, since they often contain spaces and other characters that'll give you +headaches when not escaped.) + +This smbsh seems to work quite well on Linux 2.4 and 2.6. The biggest problem it +has is in tracking your current working directory. I haven't had the time to +track that down and fix it. + +Derrell Lipman diff --git a/examples/libsmbclient/smbwrapper/opendir_smbsh.c b/examples/libsmbclient/smbwrapper/opendir_smbsh.c new file mode 100644 index 00000000000..275b95f8ea1 --- /dev/null +++ b/examples/libsmbclient/smbwrapper/opendir_smbsh.c @@ -0,0 +1,47 @@ +#include <sys/types.h> +#include <dirent.h> +#include <errno.h> +#include <stdio.h> +#include <string.h> +#include <libsmbclient.h> + +int +main(int argc, char * argv[]) +{ + char * p; + char buf[1024]; + DIR * dir; + struct dirent * dirent; + + setbuf(stdout, NULL); + + for (fputs("path: ", stdout), p = fgets(buf, sizeof(buf), stdin); + p != NULL && *p != '\n' && *p != '\0'; + fputs("path: ", stdout), p = fgets(buf, sizeof(buf), stdin)) + { + if ((p = strchr(buf, '\n')) != NULL) + { + *p = '\0'; + } + + printf("Opening (%s)...\n", buf); + + if ((dir = opendir(buf)) == NULL) + { + printf("Could not open directory [%s]: \n", + buf, strerror(errno)); + continue; + } + + while ((dirent = readdir(dir)) != NULL) + { + printf("%-30s", dirent->d_name); + printf("%-30s", dirent->d_name + strlen(dirent->d_name) + 1); + printf("\n"); + } + + closedir(dir); + } + + exit(0); +} diff --git a/examples/libsmbclient/smbwrapper/select.c b/examples/libsmbclient/smbwrapper/select.c new file mode 100644 index 00000000000..aa90169ee71 --- /dev/null +++ b/examples/libsmbclient/smbwrapper/select.c @@ -0,0 +1,124 @@ +/* + Unix SMB/Netbios implementation. + Version 3.0 + Samba select/poll implementation + Copyright (C) Andrew Tridgell 1992-1998 + Copyright (C) Derrell Lipman 2003-2005 + + 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. +*/ + +/* + * WHY THIS FILE? + * + * This file implements the two functions in the select() family, as required + * by samba. The samba native functions, though, implement a pipe to help + * alleviate a deadlock problem, but which creates problems of its own (the + * timeout stops working correctly). Those functions also require that all + * signal handlers call a function which writes to the pipe -- a task which is + * difficult to do in the smbwrapper environment. + */ + + +#include <sys/select.h> +#include <errno.h> +#include <stdio.h> + +int sys_select(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *tval) +{ + int ret; + fd_set *readfds2, readfds_buf; + + /* If readfds is NULL we need to provide our own set. */ + if (readfds) { + readfds2 = readfds; + } else { + readfds2 = &readfds_buf; + FD_ZERO(readfds2); + } + + errno = 0; + ret = select(maxfd,readfds2,writefds,errorfds,tval); + + if (ret <= 0) { + FD_ZERO(readfds2); + if (writefds) + FD_ZERO(writefds); + if (errorfds) + FD_ZERO(errorfds); + } + + return ret; +} + +/******************************************************************* + Similar to sys_select() but catch EINTR and continue. + This is what sys_select() used to do in Samba. +********************************************************************/ + +int sys_select_intr(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *tval) +{ + int ret; + fd_set *readfds2, readfds_buf, *writefds2, writefds_buf, *errorfds2, errorfds_buf; + struct timeval tval2, *ptval, end_time, now_time; + extern void GetTimeOfDay(struct timeval *tval); + + readfds2 = (readfds ? &readfds_buf : NULL); + writefds2 = (writefds ? &writefds_buf : NULL); + errorfds2 = (errorfds ? &errorfds_buf : NULL); + if (tval) { + GetTimeOfDay(&end_time); + end_time.tv_sec += tval->tv_sec; + end_time.tv_usec += tval->tv_usec; + end_time.tv_sec += end_time.tv_usec / 1000000; + end_time.tv_usec %= 1000000; + ptval = &tval2; + } else { + ptval = NULL; + } + + do { + if (readfds) + readfds_buf = *readfds; + if (writefds) + writefds_buf = *writefds; + if (errorfds) + errorfds_buf = *errorfds; + if (tval) { + GetTimeOfDay(&now_time); + tval2.tv_sec = end_time.tv_sec - now_time.tv_sec; + tval2.tv_usec = end_time.tv_usec - now_time.tv_usec; + if ((signed long) tval2.tv_usec < 0) { + tval2.tv_usec += 1000000; + tval2.tv_sec--; + } + if ((signed long) tval2.tv_sec < 0) { + ret = 0; + break; /* time has already elapsed */ + } + } + + ret = sys_select(maxfd, readfds2, writefds2, errorfds2, ptval); + } while (ret == -1 && errno == EINTR); + + if (readfds) + *readfds = readfds_buf; + if (writefds) + *writefds = writefds_buf; + if (errorfds) + *errorfds = errorfds_buf; + + return ret; +} diff --git a/examples/libsmbclient/smbwrapper/smbsh.c b/examples/libsmbclient/smbwrapper/smbsh.c new file mode 100644 index 00000000000..7b33de766fd --- /dev/null +++ b/examples/libsmbclient/smbwrapper/smbsh.c @@ -0,0 +1,160 @@ +/* + Unix SMB/Netbios implementation. + Version 2.0 + SMB wrapper functions - frontend + Copyright (C) Andrew Tridgell 1998 + Copyright (C) Derrell Lipman 2003-2005 + + 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 <sys/types.h> +#include <sys/stat.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <limits.h> +#include <string.h> +#include <libsmbclient.h> + +#ifndef FALSE +# define FALSE (0) +# define TRUE (! FALSE) +#endif + +static void smbsh_usage(void) +{ + printf("smbsh [options] [command [args] ...]\n\n"); + printf(" -p prepend library name\n"); + printf(" -a append library name\n"); + printf(" -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; + char *libd = "."; + char line[PATH_MAX], pre[PATH_MAX], post[PATH_MAX]; + int opt; + int no_ask = 0; + struct stat statbuf; + extern char *optarg; + extern int optind; + + *pre = *post = '\0'; + + while ((opt = getopt(argc, argv, "p:a:d:nL:W:U:h")) != -1) { + switch (opt) { + case 'p': /* prepend library before smbwrapper.so */ + if (*pre != '\0') + strncat(pre, " ", PATH_MAX - strlen(pre)); + strncat(pre, optarg, PATH_MAX - strlen(pre)); + break; + + case 'a': /* append library after smbwrapper.so */ + strncat(post, " ", PATH_MAX - strlen(post)); + strncat(post, optarg, PATH_MAX - strlen(post)); + break; + + case 'd': + setenv("DEBUG", optarg, TRUE); + break; + + case 'n': /* don't ask for username/password */ + no_ask++; + break; + + case 'L': + libd = optarg; + break; + + case 'W': + setenv("WORKGROUP", optarg, TRUE); + break; + + case 'U': + p = strchr(optarg,'%'); + if (p) { + *p=0; + setenv("PASSWORD", p+1, TRUE); + } + setenv("USER", optarg, TRUE); + break; + + case 'h': + default: + smbsh_usage(); + } + } + + + if (! no_ask) { + if (!getenv("USER")) { + printf("Username: "); + u = fgets(line, sizeof(line)-1, stdin); + setenv("USER", u, TRUE); + } + + if (!getenv("PASSWORD")) { + p = getpass("Password: "); + setenv("PASSWORD", p, TRUE); + } + } + + strncpy(line, pre, PATH_MAX - strlen(line)); + strncat(line, " ", PATH_MAX - strlen(line)); + strncat(line, libd, PATH_MAX - strlen(line)); + strncat(line, "/smbwrapper.so", PATH_MAX - strlen(line)); + strncat(line, post, PATH_MAX - strlen(line)); + setenv("LD_PRELOAD", line, TRUE); + setenv("LD_BIND_NOW", "true", TRUE); + + snprintf(line,sizeof(line)-1,"%s/smbwrapper.32.so", libd); + + if (stat(line, &statbuf) == 0 && S_ISREG(statbuf.st_mode)) { + snprintf(line,sizeof(line)-1,"%s/smbwrapper.32.so:DEFAULT", libd); + setenv("_RLD_LIST", line, TRUE); + snprintf(line,sizeof(line)-1,"%s/smbwrapper.so:DEFAULT", libd); + setenv("_RLDN32_LIST", line, TRUE); + } else { + snprintf(line,sizeof(line)-1,"%s/smbwrapper.so:DEFAULT", libd); + setenv("_RLD_LIST", line, TRUE); + } + + if (optind < argc) { + execvp(argv[optind], &argv[optind]); + } else { + char *shellpath = getenv("SHELL"); + + setenv("PS1", "smbsh$ ", TRUE); + + if(shellpath) { + execl(shellpath,"smbsh", NULL); + } else { + setenv("SHELL", "/bin/sh", TRUE); + execl("/bin/sh", "smbsh", NULL); + } + } + printf("launch failed!\n"); + return 1; +} diff --git a/examples/libsmbclient/smbwrapper/smbw.c b/examples/libsmbclient/smbwrapper/smbw.c new file mode 100644 index 00000000000..d2f1c18695d --- /dev/null +++ b/examples/libsmbclient/smbwrapper/smbw.c @@ -0,0 +1,910 @@ +/* + Unix SMB/Netbios implementation. + Version 2.0 + SMB wrapper functions + Copyright (C) Andrew Tridgell 1998 + Copyright (C) Derrell Lipman 2003-2005 + + 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 <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <stdarg.h> +#include <assert.h> +#include "smbw.h" + +int smbw_fd_map[__FD_SETSIZE]; +int smbw_ref_count[__FD_SETSIZE]; +char smbw_cwd[PATH_MAX]; +char smbw_prefix[] = SMBW_PREFIX; + +/* needs to be here because of dumb include files on some systems */ +int creat_bits = O_WRONLY|O_CREAT|O_TRUNC; + +int smbw_initialized = 0; + +static int debug_level = 0; + +static SMBCCTX *smbw_ctx; + +extern int smbw_debug; + + +int smbw_ref(int client_fd, Ref_Count_Type type, ...) +{ + va_list ap; + + /* client id values begin at SMBC_BASE_FC. */ + client_fd -= SMBC_BASE_FD; + + va_start(ap, type); + switch(type) + { + case SMBW_RCT_Increment: + return ++smbw_ref_count[client_fd]; + + case SMBW_RCT_Decrement: + return --smbw_ref_count[client_fd]; + + case SMBW_RCT_Get: + return smbw_ref_count[client_fd]; + + case SMBW_RCT_Set: + return (smbw_ref_count[client_fd] = va_arg(ap, int)); + } + va_end(ap); + + /* never gets here */ + return -1; +} + + +/* + * Return a username and password given a server and share name + * + * Returns 0 upon success; + * non-zero otherwise, and errno is set to indicate the error. + */ +static void get_envvar_auth_data(const char *srv, + const char *shr, + char *wg, int wglen, + char *un, int unlen, + char *pw, int pwlen) +{ + char *u; + char *p; + char *w; + + /* Fall back to environment variables */ + + w = getenv("WORKGROUP"); + if (w == NULL) w = ""; + + u = getenv("USER"); + if (u == NULL) u = ""; + + p = getenv("PASSWORD"); + if (p == NULL) p = ""; + + strncpy(wg, w, wglen); + strncpy(un, u, unlen); + strncpy(pw, p, pwlen); +} + +static smbc_get_auth_data_fn get_auth_data_fn = get_envvar_auth_data; + +/***************************************************** +set the get auth data function +******************************************************/ +void smbw_set_auth_data_fn(smbc_get_auth_data_fn fn) +{ + get_auth_data_fn = fn; +} + + +/***************************************************** +ensure that all connections are terminated upon exit +******************************************************/ +static void do_shutdown(void) +{ + if (smbw_ctx != NULL) { + smbc_free_context(smbw_ctx, 1); + } +} + + +/***************************************************** +initialise structures +*******************************************************/ +static void do_init(int is_real_startup) +{ + int i; + char *p; + + smbw_initialized = 1; /* this must be first to avoid recursion! */ + + smbw_ctx = NULL; /* don't free context until it's established */ + + /* initially, no file descriptors are mapped */ + for (i = 0; i < __FD_SETSIZE; i++) { + smbw_fd_map[i] = -1; + smbw_ref_count[i] = 0; + } + + /* See if we've been told to start in a particular directory */ + if ((p=getenv("SMBW_DIR")) != NULL) { + strncpy(smbw_cwd, p, PATH_MAX); + + /* we don't want the old directory to be busy */ + (* smbw_libc.chdir)("/"); + + } else { + *smbw_cwd = '\0'; + } + + if ((p=getenv("DEBUG"))) { + debug_level = atoi(p); + } + + if ((smbw_ctx = smbc_new_context()) == NULL) { + exit(1); + } + + smbw_ctx->debug = debug_level; + smbw_ctx->callbacks.auth_fn = get_auth_data_fn; + smbw_ctx->options.browse_max_lmb_count = 0; + smbw_ctx->options.urlencode_readdir_entries = 1; + smbw_ctx->options.one_share_per_server = 1; +// smbw_cache_functions(smbw_ctx); + + if (smbc_init_context(smbw_ctx) == NULL) { + exit(1); + } + + smbc_set_context(smbw_ctx); + + /* if not real startup, exit handler has already been established */ + if (is_real_startup) { + atexit(do_shutdown); + } +} + +/***************************************************** +initialise structures, real start up vs a fork() +*******************************************************/ +void smbw_init(void) +{ + do_init(1); +} + + +/***************************************************** +determine if a file descriptor is a smb one +*******************************************************/ +int smbw_fd(int smbw_fd) +{ + SMBW_INIT(); + + return (smbw_fd >= 0 && + smbw_fd < __FD_SETSIZE && + smbw_fd_map[smbw_fd] >= SMBC_BASE_FD); /* minimum smbc_ fd */ +} + + +/***************************************************** +determine if a path is a smb one +*******************************************************/ +int smbw_path(const char *name) +{ + int len; + int ret; + int saved_errno; + + saved_errno = errno; + + SMBW_INIT(); + + len = strlen(smbw_prefix); + + ret = ((strncmp(name, smbw_prefix, len) == 0 && + (name[len] == '\0' || name[len] == '/')) || + (*name != '/' && *smbw_cwd != '\0')); + + errno = saved_errno; + return ret; +} + + +/***************************************************** +remove redundent stuff from a filename +*******************************************************/ +void smbw_clean_fname(char *name) +{ + char *p, *p2; + int l; + int modified = 1; + + if (!name) return; + + DEBUG(10, ("Clean [%s]...\n", name)); + + while (modified) { + modified = 0; + + if ((p=strstr(name,"/./"))) { + modified = 1; + while (*p) { + p[0] = p[2]; + p++; + } + DEBUG(10, ("\tclean 1 (/./) produced [%s]\n", name)); + } + + if ((p=strstr(name,"//"))) { + modified = 1; + while (*p) { + p[0] = p[1]; + p++; + } + DEBUG(10, ("\tclean 2 (//) produced [%s]\n", name)); + } + + if (strcmp(name,"/../")==0) { + modified = 1; + name[1] = 0; + DEBUG(10,("\tclean 3 (^/../$) produced [%s]\n", name)); + } + + if ((p=strstr(name,"/../"))) { + modified = 1; + for (p2 = (p > name ? p-1 : p); p2 > name; p2--) { + if (p2[0] == '/') break; + } + if (p2 > name) p2++; + while (*p2) { + p2[0] = p[3]; + p2++; + p++; + } + DEBUG(10, ("\tclean 4 (/../) produced [%s]\n", name)); + } + + if (strcmp(name,"/..")==0) { + modified = 1; + name[1] = 0; + DEBUG(10, ("\tclean 5 (^/..$) produced [%s]\n", name)); + } + + 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; + } + DEBUG(10, ("\tclean 6 (/..) produced [%s]\n", name)); + } + + l = strlen(name); + p = l>=2?(name+l-2):name; + if (strcmp(p,"/.")==0) { + modified = 1; + if (p == name) { + p[1] = 0; + } else { + p[0] = 0; + } + DEBUG(10, ("\tclean 7 (/.) produced [%s]\n", name)); + } + + if (strncmp(p=name,"./",2) == 0) { + modified = 1; + do { + p[0] = p[2]; + } while (*p++); + DEBUG(10, ("\tclean 8 (^./) produced [%s]\n", name)); + } + + l = strlen(p=name); + if (l > 1 && p[l-1] == '/') { + modified = 1; + p[l-1] = 0; + DEBUG(10, ("\tclean 9 (/) produced [%s]\n", name)); + } + } +} + +void smbw_fix_path(const char *src, char *dest) +{ + const char *p; + int len = strlen(smbw_prefix); + + if (*src == '/') { + for (p = src + len; *p == '/'; p++) + ; + snprintf(dest, PATH_MAX, "smb://%s", p); + } else { + snprintf(dest, PATH_MAX, "%s/%s", smbw_cwd, src); + } + + smbw_clean_fname(dest + 5); + + DEBUG(10, ("smbw_fix_path(%s) returning [%s]\n", src, dest)); +} + + + +/***************************************************** +a wrapper for open() +*******************************************************/ +int smbw_open(const char *fname, int flags, mode_t mode) +{ + int client_fd; + int smbw_fd; + char path[PATH_MAX]; + + SMBW_INIT(); + + if (!fname) { + errno = EINVAL; + return -1; + } + + smbw_fd = (smbw_libc.open)(SMBW_DUMMY, O_WRONLY, 0200); + if (smbw_fd == -1) { + errno = EMFILE; + return -1; + } + + smbw_fix_path(fname, path); + if (flags == creat_bits) { + client_fd = smbc_creat(path, mode); + } else { + client_fd = smbc_open(path, flags, mode); + } + + if (client_fd < 0) { + (* smbw_libc.close)(smbw_fd); + return -1; + } + + smbw_fd_map[smbw_fd] = client_fd; + smbw_ref(client_fd, SMBW_RCT_Increment); + return smbw_fd; +} + + +/***************************************************** +a wrapper for pread() + +there should really be an smbc_pread() to avoid the two +lseek()s required in this kludge. +*******************************************************/ +ssize_t smbw_pread(int smbw_fd, void *buf, size_t count, SMBW_OFF_T ofs) +{ + int client_fd; + ssize_t ret; + int saved_errno; + SMBW_OFF_T old_ofs; + + client_fd = smbw_fd_map[smbw_fd]; + + if ((old_ofs = smbc_lseek(client_fd, 0, SEEK_CUR)) < 0 || + smbc_lseek(client_fd, ofs, SEEK_SET) < 0) { + return -1; + } + + if ((ret = smbc_read(client_fd, buf, count)) < 0) { + saved_errno = errno; + (void) smbc_lseek(client_fd, old_ofs, SEEK_SET); + errno = saved_errno; + return -1; + } + + return ret; +} + +/***************************************************** +a wrapper for read() +*******************************************************/ +ssize_t smbw_read(int smbw_fd, void *buf, size_t count) +{ + int client_fd; + + client_fd = smbw_fd_map[smbw_fd]; + + return smbc_read(client_fd, buf, count); +} + + + +/***************************************************** +a wrapper for write() +*******************************************************/ +ssize_t smbw_write(int smbw_fd, void *buf, size_t count) +{ + int client_fd; + + client_fd = smbw_fd_map[smbw_fd]; + + return smbc_write(client_fd, buf, count); +} + +/***************************************************** +a wrapper for pwrite() +*******************************************************/ +ssize_t smbw_pwrite(int smbw_fd, void *buf, size_t count, SMBW_OFF_T ofs) +{ + int saved_errno; + int client_fd; + ssize_t ret; + SMBW_OFF_T old_ofs; + + client_fd = smbw_fd_map[smbw_fd]; + + if ((old_ofs = smbc_lseek(client_fd, 0, SEEK_CUR)) < 0 || + smbc_lseek(client_fd, ofs, SEEK_SET) < 0) { + return -1; + } + + if ((ret = smbc_write(client_fd, buf, count)) < 0) { + saved_errno = errno; + (void) smbc_lseek(client_fd, old_ofs, SEEK_SET); + errno = saved_errno; + return -1; + } + + return ret; +} + +/***************************************************** +a wrapper for close() +*******************************************************/ +int smbw_close(int smbw_fd) +{ + int client_fd; + + client_fd = smbw_fd_map[smbw_fd]; + + if (smbw_ref(client_fd, SMBW_RCT_Decrement) > 0) { + return 0; + } + + (* smbw_libc.close)(smbw_fd); + smbw_fd_map[smbw_fd] = -1; + return smbc_close(client_fd); +} + + +/***************************************************** +a wrapper for fcntl() +*******************************************************/ +int smbw_fcntl(int smbw_fd, int cmd, long arg) +{ + return 0; +} + + +/***************************************************** +a wrapper for access() +*******************************************************/ +int smbw_access(const char *name, int mode) +{ + struct SMBW_stat st; + + SMBW_INIT(); + + if (smbw_stat(name, &st)) return -1; + + if (((mode & R_OK) && !(st.s_mode & S_IRUSR)) || + ((mode & W_OK) && !(st.s_mode & S_IWUSR)) || + ((mode & X_OK) && !(st.s_mode & S_IXUSR))) { + errno = EACCES; + return -1; + } + + return 0; +} + +/***************************************************** +a wrapper for readlink() - needed for correct errno setting +*******************************************************/ +int smbw_readlink(const char *fname, char *buf, size_t bufsize) +{ + struct SMBW_stat st; + int ret; + + SMBW_INIT(); + + ret = smbw_stat(fname, &st); + if (ret != 0) { + return -1; + } + + /* it exists - say it isn't a link */ + errno = EINVAL; + return -1; +} + + +/***************************************************** +a wrapper for unlink() +*******************************************************/ +int smbw_unlink(const char *fname) +{ + char path[PATH_MAX]; + + SMBW_INIT(); + + smbw_fix_path(fname, path); + return smbc_unlink(path); +} + + +/***************************************************** +a wrapper for rename() +*******************************************************/ +int smbw_rename(const char *oldname, const char *newname) +{ + char path_old[PATH_MAX]; + char path_new[PATH_MAX]; + + SMBW_INIT(); + + smbw_fix_path(oldname, path_old); + smbw_fix_path(newname, path_new); + return smbc_rename(path_old, path_new); +} + + +/***************************************************** +a wrapper for utimes +*******************************************************/ +int smbw_utimes(const char *fname, void *buf) +{ + char path[PATH_MAX]; + + smbw_fix_path(fname, path); + return smbc_utimes(path, buf); +} + + +/***************************************************** +a wrapper for utime +*******************************************************/ +int smbw_utime(const char *fname, void *buf) +{ + char path[PATH_MAX]; + + smbw_fix_path(fname, path); + return smbc_utime(path, buf); +} + +/***************************************************** +a wrapper for chown() +*******************************************************/ +int smbw_chown(const char *fname, uid_t owner, gid_t group) +{ + /* always indiciate that this is not supported. */ + errno = ENOTSUP; + return -1; +} + +/***************************************************** +a wrapper for chmod() +*******************************************************/ +int smbw_chmod(const char *fname, mode_t newmode) +{ + char path[PATH_MAX]; + + smbw_fix_path(fname, path); + return smbc_chmod(path, newmode); +} + + +/***************************************************** +a wrapper for lseek() +*******************************************************/ +SMBW_OFF_T smbw_lseek(int smbw_fd, + SMBW_OFF_T offset, + int whence) +{ + int client_fd; + SMBW_OFF_T ret; + + client_fd = smbw_fd_map[smbw_fd]; + + ret = smbc_lseek(client_fd, offset, whence); + if (smbw_debug) + { + printf("smbw_lseek(%d/%d, 0x%llx) returned 0x%llx\n", + smbw_fd, client_fd, + (unsigned long long) offset, + (unsigned long long) ret); + } + return ret; +} + +/***************************************************** +a wrapper for dup() +*******************************************************/ +int smbw_dup(int smbw_fd) +{ + int fd2; + + fd2 = (smbw_libc.dup)(smbw_fd); + if (fd2 == -1) { + return -1; + } + + smbw_fd_map[fd2] = smbw_fd_map[smbw_fd]; + smbw_ref(smbw_fd_map[smbw_fd], SMBW_RCT_Increment); + return fd2; +} + + +/***************************************************** +a wrapper for dup2() +*******************************************************/ +int smbw_dup2(int smbw_fd, int fd2) +{ + if ((* smbw_libc.dup2)(smbw_fd, fd2) != fd2) { + return -1; + } + + smbw_fd_map[fd2] = smbw_fd_map[smbw_fd]; + smbw_ref(smbw_fd_map[smbw_fd], SMBW_RCT_Increment); + return fd2; +} + + +/***************************************************** +when we fork we have to close all connections and files +in the child +*******************************************************/ +int smbw_fork(void) +{ + int i; + pid_t child_pid; + int p[2]; + char c = 0; + + SMBW_INIT(); + + if (pipe(p)) return (* smbw_libc.fork)(); + + child_pid = (* smbw_libc.fork)(); + + if (child_pid) { + /* block the parent for a moment until the sockets are + closed */ + (* smbw_libc.close)(p[1]); + (* smbw_libc.read)(p[0], &c, 1); + (* smbw_libc.close)(p[0]); + return child_pid; + } + + (* smbw_libc.close)(p[0]); + + /* close all server connections and locally-opened files */ + for (i = 0; i < __FD_SETSIZE; i++) { + if (smbw_fd_map[i] > 0 && + smbw_ref(smbw_fd_map[i], SMBW_RCT_Get) > 0) { + + smbc_close(smbw_fd_map[i]); + smbw_ref(smbw_fd_map[i], SMBW_RCT_Set, 0); + (* smbw_libc.close)(i); + } + + smbw_fd_map[i] = -1; + } + + /* unblock the parent */ + write(p[1], &c, 1); + (* smbw_libc.close)(p[1]); + + /* specify directory to start in, if it's simulated smb */ + if (*smbw_cwd != '\0') { + setenv("SMBW_DIR", smbw_cwd, 1); + } else { + unsetenv("SMBW_DIR"); + } + + /* Re-initialize this library for the child */ + do_init(0); + + /* and continue in the child */ + return 0; +} + +int smbw_setxattr(const char *fname, + const char *name, + const void *value, + size_t size, + int flags) +{ + char path[PATH_MAX]; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + smbw_fix_path(fname, path); + return smbc_setxattr(path, name, value, size, flags); +} + +int smbw_lsetxattr(const char *fname, + const char *name, + const void *value, + size_t size, + int flags) +{ + char path[PATH_MAX]; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + smbw_fix_path(fname, path); + return smbc_lsetxattr(path, name, value, size, flags); +} + +int smbw_fsetxattr(int smbw_fd, + const char *name, + const void *value, + size_t size, + int flags) +{ + int client_fd; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + client_fd = smbw_fd_map[smbw_fd]; + return smbc_fsetxattr(client_fd, name, value, size, flags); +} + +int smbw_getxattr(const char *fname, + const char *name, + const void *value, + size_t size) +{ + char path[PATH_MAX]; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + smbw_fix_path(fname, path); + + return smbc_getxattr(path, name, value, size); +} + +int smbw_lgetxattr(const char *fname, + const char *name, + const void *value, + size_t size) +{ + char path[PATH_MAX]; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + smbw_fix_path(fname, path); + return smbc_lgetxattr(path, name, value, size); +} + +int smbw_fgetxattr(int smbw_fd, + const char *name, + const void *value, + size_t size) +{ + int client_fd; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + client_fd = smbw_fd_map[smbw_fd]; + return smbc_fgetxattr(client_fd, name, value, size); +} + +int smbw_removexattr(const char *fname, + const char *name) +{ + char path[PATH_MAX]; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + smbw_fix_path(fname, path); + return smbc_removexattr(path, name); +} + +int smbw_lremovexattr(const char *fname, + const char *name) +{ + char path[PATH_MAX]; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + smbw_fix_path(fname, path); + return smbc_lremovexattr(path, name); +} + +int smbw_fremovexattr(int smbw_fd, + const char *name) +{ + int client_fd; + + if (strcmp(name, "system.posix_acl_access") == 0) + { + name = "system.*"; + } + + client_fd = smbw_fd_map[smbw_fd]; + return smbc_fremovexattr(client_fd, name); +} + +int smbw_listxattr(const char *fname, + char *list, + size_t size) +{ + char path[PATH_MAX]; + + smbw_fix_path(fname, path); + return smbc_listxattr(path, list, size); +} + +int smbw_llistxattr(const char *fname, + char *list, + size_t size) +{ + char path[PATH_MAX]; + + smbw_fix_path(fname, path); + return smbc_llistxattr(path, list, size); +} + +int smbw_flistxattr(int smbw_fd, + char *list, + size_t size) +{ + int client_fd; + + client_fd = smbw_fd_map[smbw_fd]; + return smbc_flistxattr(client_fd, list, size); +} diff --git a/examples/libsmbclient/smbwrapper/smbw.h b/examples/libsmbclient/smbwrapper/smbw.h new file mode 100644 index 00000000000..717b5c2f1c7 --- /dev/null +++ b/examples/libsmbclient/smbwrapper/smbw.h @@ -0,0 +1,163 @@ +/* + Unix SMB/Netbios implementation. + Version 2.0 + SMB wrapper functions - definitions + Copyright (C) Andrew Tridgell 1998 + Copyright (C) Derrell Lipman 2003-2005 + + 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 + +#include <sys/types.h> +#include <errno.h> +#include <malloc.h> +#include <limits.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include "config.h" /* must come before libsmbclient.h */ +#include "libsmbclient.h" +#include "wrapper.h" + +#undef DEBUG +#define DEBUG(level, s) do { if (level <= debug_level) printf s; } while (0) + + +#define SMBW_PREFIX "/smb" +#define SMBW_DUMMY "/dev/null" + +extern int smbw_initialized; +#define SMBW_INIT() do { if (! smbw_initialized) smbw_init(); } while (0) + +#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) +# define SMBW_OFF_T off64_t +#else +# define SMBW_OFF_T off_t +#endif + + +/* The following definitions come from smbwrapper/smbw.c */ + +typedef enum { + SMBW_RCT_Increment, + SMBW_RCT_Decrement, + SMBW_RCT_Get, + SMBW_RCT_Set +} Ref_Count_Type; + +int smbw_ref(int client_fd, Ref_Count_Type type, ...); +void smbw_init(void); +int smbw_fd(int fd); +int smbw_path(const char *path); +void smbw_clean_fname(char *name); +void smbw_fix_path(const char *src, char *dest); +void smbw_set_auth_data_fn(smbc_get_auth_data_fn fn); +int smbw_open(const char *fname, int flags, mode_t mode); +ssize_t smbw_pread(int fd, void *buf, size_t count, SMBW_OFF_T ofs); +ssize_t smbw_read(int fd, void *buf, size_t count); +ssize_t smbw_write(int fd, void *buf, size_t count); +ssize_t smbw_pwrite(int fd, void *buf, size_t count, SMBW_OFF_T ofs); +int smbw_close(int fd); +int smbw_fcntl(int fd, int cmd, long arg); +int smbw_access(const char *name, int mode); +int smbw_readlink(const char *path, char *buf, size_t bufsize); +int smbw_unlink(const char *fname); +int smbw_rename(const char *oldname, const char *newname); +int smbw_utime(const char *fname, void *buf); +int smbw_utimes(const char *fname, void *buf); +int smbw_chown(const char *fname, uid_t owner, gid_t group); +int smbw_chmod(const char *fname, mode_t newmode); +SMBW_OFF_T smbw_lseek(int smbw_fd, SMBW_OFF_T offset, int whence); +int smbw_dup(int fd); +int smbw_dup2(int fd, int fd2); +int smbw_fork(void); + +/* The following definitions come from smbwrapper/smbw_dir.c */ + +int smbw_dirp(DIR * dirp); +int smbw_dir_open(const char *fname); +int smbw_dir_fstat(int fd, SMBW_stat *st); +int smbw_dir_close(int fd); +int smbw_getdents(unsigned int fd, SMBW_dirent *dirp, int count); +int smbw_chdir(const char *name); +int smbw_mkdir(const char *fname, mode_t mode); +int smbw_rmdir(const char *fname); +char *smbw_getcwd(char *buf, size_t size); +int smbw_fchdir(int fd); +DIR *smbw_opendir(const char *fname); +SMBW_dirent *smbw_readdir(DIR *dirp); +int smbw_readdir_r(DIR *dirp, + struct SMBW_dirent *__restrict entry, + struct SMBW_dirent **__restrict result); +int smbw_closedir(DIR *dirp); +void smbw_seekdir(DIR *dirp, long long offset); +long long smbw_telldir(DIR *dirp); +int smbw_setxattr(const char *fname, + const char *name, + const void *value, + size_t size, + int flags); +int smbw_lsetxattr(const char *fname, + const char *name, + const void *value, + size_t size, + int flags); +int smbw_fsetxattr(int smbw_fd, + const char *name, + const void *value, + size_t size, + int flags); +int smbw_getxattr(const char *fname, + const char *name, + const void *value, + size_t size); +int smbw_lgetxattr(const char *fname, + const char *name, + const void *value, + size_t size); +int smbw_fgetxattr(int smbw_fd, + const char *name, + const void *value, + size_t size); +int smbw_removexattr(const char *fname, + const char *name); +int smbw_lremovexattr(const char *fname, + const char *name); +int smbw_fremovexattr(int smbw_fd, + const char *name); +int smbw_listxattr(const char *fname, + char *list, + size_t size); +int smbw_llistxattr(const char *fname, + char *list, + size_t size); +int smbw_flistxattr(int smbw_fd, + char *list, + size_t size); + +/* The following definitions come from smbwrapper/smbw_stat.c */ + +int smbw_fstat(int fd, SMBW_stat *st); +int smbw_stat(const char *fname, SMBW_stat *st); + +/* The following definitions come from smbwrapper/cache.c */ +int +smbw_cache_functions(SMBCCTX * context); + + +#endif /* _SMBW_H */ diff --git a/examples/libsmbclient/smbwrapper/smbw_dir.c b/examples/libsmbclient/smbwrapper/smbw_dir.c new file mode 100644 index 00000000000..f3ec03e5a85 --- /dev/null +++ b/examples/libsmbclient/smbwrapper/smbw_dir.c @@ -0,0 +1,355 @@ +/* + Unix SMB/Netbios implementation. + Version 2.0 + SMB wrapper directory functions + Copyright (C) Andrew Tridgell 1998 + Copyright (C) Derrell Lipman 2003-2005 + + 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 "smbw.h" + +/***************************************************** +determine if a directory handle is a smb one +*******************************************************/ +int smbw_dirp(DIR * dirp) +{ + return ((char *) dirp >= (char *) smbw_fd_map && + (char *) dirp < (char *) &smbw_fd_map[__FD_SETSIZE] && + *(int *) dirp != -1); +} + + +/***************************************************** +a wrapper for getdents() +*******************************************************/ +int smbw_getdents(unsigned int fd_smbw, + struct SMBW_dirent *dirent_external, + int count) +{ + int remaining; + int fd_client = smbw_fd_map[fd_smbw]; + struct smbc_dirent *dirent_internal; + + + for (remaining = count; + remaining > sizeof(struct SMBW_dirent); + dirent_external++) { + + /* + * We do these one at a time because there's otherwise no way + * to limit how many smbc_getdents() will return for us, and + * if it returns too many, it also doesn't give us offsets to + * be able to seek back to where we need to be. In practice, + * this one-at-a-time retrieval isn't a problem because the + * time-consuming network transaction is all done at + * smbc_opendir() time. + */ + dirent_internal = smbc_readdir(fd_client); + if (dirent_internal == NULL) { + break; + } + + remaining -= sizeof(struct SMBW_dirent); + + dirent_external->d_ino = -1; /* not supported */ + dirent_external->d_off = smbc_telldir(fd_client); + dirent_external->d_reclen = sizeof(struct SMBW_dirent); + dirent_external->d_type = dirent_internal->smbc_type; + + strncpy(dirent_external->d_name, + dirent_internal->name, + sizeof(dirent_external->d_name) - 1); + strncpy(dirent_external->d_comment, + dirent_internal->comment, + sizeof(dirent_external->d_comment) - 1); + } + + return(count - remaining); +} + + +/***************************************************** +a wrapper for chdir() +*******************************************************/ +int smbw_chdir(const char *name) +{ + int simulate; + struct stat statbuf; + char path[PATH_MAX]; + char *p; + + SMBW_INIT(); + + if (!name) { + errno = EINVAL; + return -1; + } + + if (! smbw_path((char *) name)) { + if ((* smbw_libc.chdir)(name) == 0) { + *smbw_cwd = '\0'; + return 0; + } + + return -1; + } + + smbw_fix_path(name, path); + + /* ensure it exists */ + p = path + 6; /* look just past smb:// */ + simulate = (strchr(p, '/') == NULL); + + /* special case for full-network scan, workgroups, and servers */ + if (! simulate) { + + if (smbc_stat(path, &statbuf) < 0) { + return -1; + } + + /* ensure it's a directory */ + if (! S_ISDIR(statbuf.st_mode)) { + errno = ENOTDIR; + return -1; + } + } + + strncpy(smbw_cwd, path, PATH_MAX); + + /* we don't want the old directory to be busy */ + (* smbw_libc.chdir)("/"); + + return 0; +} + + +/***************************************************** +a wrapper for mkdir() +*******************************************************/ +int smbw_mkdir(const char *fname, mode_t mode) +{ + char path[PATH_MAX]; + + if (!fname) { + errno = EINVAL; + return -1; + } + + SMBW_INIT(); + + smbw_fix_path(fname, path); + return smbc_mkdir(path, mode); +} + +/***************************************************** +a wrapper for rmdir() +*******************************************************/ +int smbw_rmdir(const char *fname) +{ + char path[PATH_MAX]; + + if (!fname) { + errno = EINVAL; + return -1; + } + + SMBW_INIT(); + + smbw_fix_path(fname, path); + return smbc_rmdir(path); +} + + +/***************************************************** +a wrapper for getcwd() +*******************************************************/ +char *smbw_getcwd(char *buf, size_t size) +{ + SMBW_INIT(); + + if (*smbw_cwd == '\0') { + return (* smbw_libc.getcwd)(buf, size); + } + + if (buf == NULL) { + if (size == 0) { + size = strlen(smbw_cwd) + 1; + } + buf = malloc(size); + if (buf == NULL) { + errno = ENOMEM; + return NULL; + } + } + + strncpy(buf, smbw_cwd, size); + buf[size-1] = '\0'; + return buf; +} + +/***************************************************** +a wrapper for fchdir() +*******************************************************/ +int smbw_fchdir(int fd_smbw) +{ + int ret; + + SMBW_INIT(); + + if (! smbw_fd(fd_smbw)) { + ret = (* smbw_libc.fchdir)(fd_smbw); + (void) (* smbw_libc.getcwd)(smbw_cwd, PATH_MAX); + return ret; + } + + errno = EACCES; + return -1; +} + +/***************************************************** +open a directory on the server +*******************************************************/ +DIR *smbw_opendir(const char *fname) +{ + int fd_client; + int fd_smbw; + char path[PATH_MAX]; + DIR * dirp; + + SMBW_INIT(); + + if (!fname) { + errno = EINVAL; + return NULL; + } + + fd_smbw = (smbw_libc.open)(SMBW_DUMMY, O_WRONLY, 0200); + if (fd_smbw == -1) { + errno = EMFILE; + return NULL; + } + + smbw_fix_path(fname, path); + fd_client = smbc_opendir(path); + + if (fd_client < 0) { + (* smbw_libc.close)(fd_smbw); + return NULL; + } + + smbw_fd_map[fd_smbw] = fd_client; + smbw_ref(fd_client, SMBW_RCT_Increment); + dirp = (DIR *) &smbw_fd_map[fd_smbw]; + return dirp; +} + +/***************************************************** +read one entry from a directory +*******************************************************/ +struct SMBW_dirent *smbw_readdir(DIR *dirp) +{ + int fd_smbw; + int fd_client; + struct smbc_dirent *dirent_internal; + static struct SMBW_dirent dirent_external; + + fd_smbw = (int *) dirp - smbw_fd_map; + fd_client = smbw_fd_map[fd_smbw]; + + if ((dirent_internal = smbc_readdir(fd_client)) == NULL) { + return NULL; + } + + dirent_external.d_ino = -1; /* not supported */ + dirent_external.d_off = smbc_telldir(fd_client); + dirent_external.d_reclen = sizeof(struct SMBW_dirent); + dirent_external.d_type = dirent_internal->smbc_type; + strncpy(dirent_external.d_name, + dirent_internal->name, + sizeof(dirent_external.d_name) - 1); + strncpy(dirent_external.d_comment, + dirent_internal->comment, + sizeof(dirent_external.d_comment) - 1); + + return &dirent_external; +} + +/***************************************************** +read one entry from a directory in a reentrant fashion +ha! samba is not re-entrant, and neither is the +libsmbclient library +*******************************************************/ +int smbw_readdir_r(DIR *dirp, + struct SMBW_dirent *__restrict entry, + struct SMBW_dirent **__restrict result) +{ + SMBW_dirent *dirent; + + dirent = smbw_readdir(dirp); + + if (dirent != NULL) { + *entry = *dirent; + if (result != NULL) { + *result = entry; + } + return 0; + } + + if (result != NULL) { + *result = NULL; + } + return EBADF; +} + + +/***************************************************** +close a DIR* +*******************************************************/ +int smbw_closedir(DIR *dirp) +{ + int fd_smbw = (int *) dirp - smbw_fd_map; + int fd_client = smbw_fd_map[fd_smbw]; + + (* smbw_libc.close)(fd_smbw); + if (smbw_ref(fd_client, SMBW_RCT_Decrement) > 0) { + return 0; + } + smbw_fd_map[fd_smbw] = -1; + return smbc_closedir(fd_client); +} + +/***************************************************** +seek in a directory +*******************************************************/ +void smbw_seekdir(DIR *dirp, long long offset) +{ + int fd_smbw = (int *) dirp - smbw_fd_map; + int fd_client = smbw_fd_map[fd_smbw]; + + smbc_lseekdir(fd_client, offset); +} + +/***************************************************** +current loc in a directory +*******************************************************/ +long long smbw_telldir(DIR *dirp) +{ + int fd_smbw = (int *) dirp - smbw_fd_map; + int fd_client = smbw_fd_map[fd_smbw]; + + return (long long) smbc_telldir(fd_client); +} diff --git a/examples/libsmbclient/smbwrapper/smbw_stat.c b/examples/libsmbclient/smbwrapper/smbw_stat.c new file mode 100644 index 00000000000..70b3064d227 --- /dev/null +++ b/examples/libsmbclient/smbwrapper/smbw_stat.c @@ -0,0 +1,146 @@ +/* + Unix SMB/Netbios implementation. + Version 2.0 + SMB wrapper stat functions + Copyright (C) Andrew Tridgell 1998 + Copyright (C) Derrell Lipman 2003-2005 + + 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 "smbw.h" + +static int timezone_diff = -1; + +#define TM_YEAR_BASE 1900 + +/******************************************************************* +yield the difference between *A and *B, in seconds, ignoring leap seconds +********************************************************************/ +static int tm_diff(struct tm *a, struct tm *b) +{ + int ay = a->tm_year + (TM_YEAR_BASE - 1); + int by = b->tm_year + (TM_YEAR_BASE - 1); + int intervening_leap_days = + (ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400); + int years = ay - by; + int days = 365*years + intervening_leap_days + (a->tm_yday - b->tm_yday); + int hours = 24*days + (a->tm_hour - b->tm_hour); + int minutes = 60*hours + (a->tm_min - b->tm_min); + int seconds = 60*minutes + (a->tm_sec - b->tm_sec); + + return seconds; +} + +/******************************************************************* + return the UTC offset in seconds west of UTC, or 0 if it cannot be determined + ******************************************************************/ +static int TimeZone(time_t t) +{ + struct tm *tm = gmtime(&t); + struct tm tm_utc; + if (!tm) + return 0; + tm_utc = *tm; + tm = localtime(&t); + if (!tm) + return 0; + return tm_diff(&tm_utc,tm); + +} + + +static void copy_stat(struct SMBW_stat *external, struct stat *internal) +{ + if (timezone_diff < 0) + { + timezone_diff = TimeZone(time(NULL)); + } + + external->s_dev = internal->st_dev; + external->s_ino = internal->st_ino; + external->s_mode = internal->st_mode; + external->s_nlink = internal->st_nlink; + external->s_uid = internal->st_uid; + external->s_gid = internal->st_gid; + external->s_rdev = internal->st_rdev; + external->s_size = internal->st_size; + external->s_blksize = internal->st_blksize; + external->s_blocks = internal->st_blocks; + external->s_atime = internal->st_atime + timezone_diff; + external->s_mtime = internal->st_mtime + timezone_diff; + external->s_ctime = internal->st_ctime + timezone_diff; +} + + +/***************************************************** +a wrapper for fstat() +*******************************************************/ +int smbw_fstat(int fd_smbw, struct SMBW_stat *st) +{ + int fd_client = smbw_fd_map[fd_smbw]; + struct stat statbuf; + + if (smbc_fstat(fd_client, &statbuf) < 0) { + return -1; + } + + copy_stat(st, &statbuf); + + return 0; +} + + +/***************************************************** +a wrapper for stat() +*******************************************************/ +int smbw_stat(const char *fname, struct SMBW_stat *st) +{ + int simulate; + char *p; + char path[PATH_MAX]; + struct stat statbuf; + + SMBW_INIT(); + + smbw_fix_path(fname, path); + + p = path + 6; /* look just past smb:// */ + simulate = (strchr(p, '/') == NULL); + + /* special case for full-network scan, workgroups, and servers */ + if (simulate) { + statbuf.st_dev = 0; + statbuf.st_ino = 0; + statbuf.st_mode = 0040777; + statbuf.st_nlink = 1; + statbuf.st_uid = 0; + statbuf.st_gid = 0; + statbuf.st_rdev = 0; + statbuf.st_size = 0; + statbuf.st_blksize = 1024; + statbuf.st_blocks = 1; + statbuf.st_atime = 0; /* beginning of epoch */ + statbuf.st_mtime = 0; /* beginning of epoch */ + statbuf.st_ctime = 0; /* beginning of epoch */ + + } else if (smbc_stat(path, &statbuf) < 0) { + return -1; + } + + copy_stat(st, &statbuf); + + return 0; +} diff --git a/examples/libsmbclient/smbwrapper/wrapper.c b/examples/libsmbclient/smbwrapper/wrapper.c new file mode 100644 index 00000000000..71d6f203ada --- /dev/null +++ b/examples/libsmbclient/smbwrapper/wrapper.c @@ -0,0 +1,1729 @@ +/* + Unix SMB/Netbios implementation. + Version 2.0 + SMB wrapper functions + Copyright (C) Andrew Tridgell 1998 + Copyright (C) Derrell Lipman 2002-2005 + + 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. +*/ + +/* + * This is a rewrite of the original wrapped.c file, using libdl to obtain + * pointers into the C library rather than attempting to find undocumented + * functions in the C library to call for native file access. The problem + * with the original implementation's paradigm is that samba manipulates + * defines such that it gets the sizes of structures that it wants + * (e.g. mapping 32-bit functions to 64-bit functions with their associated + * 64-bit structure fields), but programs run under smbsh or using + * smbwrapper.so were not necessarily compiled with the same flags. As an + * example of the problem, a program calling stat() passes a pointer to a + * "struct stat" but the fields in that structure are different in samba than + * they are in the calling program if the calling program was not compiled to + * force stat() to be mapped to stat64(). + * + * In this version, we provide an interface to each of the native functions, + * not just the ones that samba is compiled to map to. We obtain the function + * pointers from the C library using dlsym(), and for native file operations, + * directly call the same function that the calling application was + * requesting. Since the size of the calling application's structures vary + * depending on what function was called, we use our own internal structures + * for passing information to/from the SMB equivalent functions, and map them + * back to the native structures before returning the result to the caller. + * + * This implementation was completed 25 December 2002. + * Derrell Lipman + */ + +/* We do not want auto munging of 32->64 bit names in this file (only) */ +#undef _FILE_OFFSET_BITS +#undef _GNU_SOURCE + +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <stdlib.h> +#include <fcntl.h> +#include <unistd.h> +#include <utime.h> +#include <stdio.h> +#include <dirent.h> +#include <signal.h> +#include <stdarg.h> +#include <dlfcn.h> +#include <errno.h> +#include "libsmbclient.h" +#include "wrapper.h" + +/* + * Debug bits: + * 0x0 = none + * 0x1 = display symbol definitions not found in C library + * 0x2 = show wrapper functions being called + * 0x4 = log to file SMBW_DEBUG_FILE instead of stderr + */ +#define SMBW_DEBUG 0x0 +#define SMBW_DEBUG_FILE "/tmp/smbw.log" + +int smbw_debug = 0; + +#if SMBW_DEBUG & 0x2 +static int debugFd = 2; +#endif + +#ifndef ENOTSUP +#define ENOTSUP EOPNOTSUPP +#endif + +/* + * None of the methods of having the initialization function called + * automatically upon shared library startup are effective in all situations. + * We provide the "-init" parameter to the linker which is effective most of + * the time, but fails for applications that provide their own shared + * libraries with _init() functions (e.g. ps). We can't use "-z initfirst" + * because the environment isn't yet set up at that point, so we can't find + * our shared memory identifier (see shared.c). We therefore must resort to + * this tried-and-true method of keeping an "initialized" flag. We check it + * prior to calling the initialize() function to save a function call (a slow + * operation on x86). + */ +#if SMBW_DEBUG & 0x2 +# define check_init(buf) \ + do { \ + int saved_errno = errno; \ + if (! initialized) initialize(); \ + (* smbw_libc.write)(debugFd, "["buf"]", sizeof(buf)+1); \ + errno = saved_errno; \ + } while (0); +#else +# define check_init(buf) \ + do { \ + if (! initialized) smbw_initialize(); \ + } while (0); +#endif + +static void initialize(void); + +static int initialized = 0; + +SMBW_libc_pointers smbw_libc; + +/* + * A public entry point used by the "-init" option to the linker. + */ +void smbw_initialize(void) +{ + initialize(); +} + +static void initialize(void) +{ + void *lib = NULL; + int saved_errno; +#if SMBW_DEBUG & 0x1 + char *error; +#endif + + saved_errno = errno; + + if (initialized) { + errno = saved_errno; + return; + } + initialized = 1; + + if ((lib = dlopen("/lib/libc.so.6", RTLD_NOW | RTLD_GLOBAL)) == NULL) { + exit(1); + } + +#if SMBW_DEBUG & 0x1 +# define GETSYM(symname, symstring) \ + if ((smbw_libc.symname = dlsym(lib, symstring)) == NULL) { \ + if (smbw_libc.write != NULL && \ + (error = dlerror()) != NULL) { \ + (* smbw_libc.write)(1, error, strlen(error)); \ + (* smbw_libc.write)(1, "\n", 1); \ + } \ + } +#else +# define GETSYM(symname, symstring) \ + smbw_libc.symname = dlsym(lib, symstring); +#endif + + /* + * Get pointers to each of the symbols we'll need, from the C library + * + * Some of these symbols may not be found in the C library. That's + * fine. We declare all of them here, and if the C library supports + * them, they may be called so we have the wrappers for them. If the + * C library doesn't support them, then the wrapper function will + * never be called, and the null pointer will never be dereferenced. + */ + do { + GETSYM(write, "write"); /* first, to allow debugging */ + GETSYM(open, "open"); + GETSYM(_open, "_open"); + GETSYM(__open, "__open"); + GETSYM(open64, "open64"); + GETSYM(_open64, "_open64"); + GETSYM(__open64, "__open64"); + GETSYM(pread, "pread"); + GETSYM(pread64, "pread64"); + GETSYM(pwrite, "pwrite"); + GETSYM(pwrite64, "pwrite64"); + GETSYM(close, "close"); + GETSYM(__close, "__close"); + GETSYM(_close, "_close"); + GETSYM(fcntl, "fcntl"); + GETSYM(__fcntl, "__fcntl"); + GETSYM(_fcntl, "_fcntl"); + GETSYM(getdents, "getdents"); + GETSYM(__getdents, "__getdents"); + GETSYM(_getdents, "_getdents"); + GETSYM(getdents64, "getdents64"); + GETSYM(lseek, "lseek"); + GETSYM(__lseek, "__lseek"); + GETSYM(_lseek, "_lseek"); + GETSYM(lseek64, "lseek64"); + GETSYM(__lseek64, "__lseek64"); + GETSYM(_lseek64, "_lseek64"); + GETSYM(read, "read"); + GETSYM(__read, "__read"); + GETSYM(_read, "_read"); + GETSYM(__write, "__write"); + GETSYM(_write, "_write"); + GETSYM(access, "access"); + GETSYM(chmod, "chmod"); + GETSYM(fchmod, "fchmod"); + GETSYM(chown, "chown"); + GETSYM(fchown, "fchown"); + GETSYM(__xstat, "__xstat"); + GETSYM(getcwd, "getcwd"); + GETSYM(mkdir, "mkdir"); + GETSYM(__fxstat, "__fxstat"); + GETSYM(__lxstat, "__lxstat"); + GETSYM(stat, "stat"); + GETSYM(lstat, "lstat"); + GETSYM(fstat, "fstat"); + GETSYM(unlink, "unlink"); + GETSYM(utime, "utime"); + GETSYM(utimes, "utimes"); + GETSYM(readlink, "readlink"); + GETSYM(rename, "rename"); + GETSYM(rmdir, "rmdir"); + GETSYM(symlink, "symlink"); + GETSYM(dup, "dup"); + GETSYM(dup2, "dup2"); + GETSYM(opendir, "opendir"); + GETSYM(readdir, "readdir"); + GETSYM(closedir, "closedir"); + GETSYM(telldir, "telldir"); + GETSYM(seekdir, "seekdir"); + GETSYM(creat, "creat"); + GETSYM(creat64, "creat64"); + GETSYM(__xstat64, "__xstat64"); + GETSYM(stat64, "stat64"); + GETSYM(__fxstat64, "__fxstat64"); + GETSYM(fstat64, "fstat64"); + GETSYM(__lxstat64, "__lxstat64"); + GETSYM(lstat64, "lstat64"); + GETSYM(_llseek, "_llseek"); + GETSYM(readdir64, "readdir64"); + GETSYM(readdir_r, "readdir_r"); + GETSYM(readdir64_r, "readdir64_r"); + GETSYM(setxattr, "setxattr"); + GETSYM(lsetxattr, "lsetxattr"); + GETSYM(fsetxattr, "fsetxattr"); + GETSYM(getxattr, "getxattr"); + GETSYM(lgetxattr, "lgetxattr"); + GETSYM(fgetxattr, "fgetxattr"); + GETSYM(removexattr, "removexattr"); + GETSYM(lremovexattr, "lremovexattr"); + GETSYM(fremovexattr, "fremovexattr"); + GETSYM(listxattr, "listxattr"); + GETSYM(llistxattr, "llistxattr"); + GETSYM(flistxattr, "flistxattr"); + GETSYM(chdir, "chdir"); + GETSYM(fchdir, "fchdir"); + GETSYM(fork, "fork"); + GETSYM(select, "select"); + GETSYM(_select, "_select"); + GETSYM(__select, "__select"); + } while (0); + + dlclose(lib); + + if ((lib = dlopen("/lib/libc.so.6", RTLD_NOW | RTLD_GLOBAL)) == NULL) { + exit(1); + } + +#if SMBW_DEBUG & 4 + { + if ((debugFd = + open(SMBW_DEBUG_FILE, O_WRONLY | O_CREAT | O_APPEND)) < 0) + { +# define SMBW_MESSAGE "Could not create " SMBW_DEBUG_FILE "\n" + (* smbw_libc.write)(1, SMBW_MESSAGE, sizeof(SMBW_MESSAGE)); +# undef SMBW_MESSAGE + exit(1); + } + } +#endif + + errno = saved_errno; +} + +/** + ** Static Functions + **/ + +static void stat_convert(struct SMBW_stat *src, struct stat *dest) +{ + memset(dest, '\0', sizeof(*dest)); + dest->st_size = src->s_size; + dest->st_mode = src->s_mode; + dest->st_ino = src->s_ino; + dest->st_dev = src->s_dev; + dest->st_rdev = src->s_rdev; + dest->st_nlink = src->s_nlink; + dest->st_uid = src->s_uid; + dest->st_gid = src->s_gid; + dest->st_atime = src->s_atime; + dest->st_mtime = src->s_mtime; + dest->st_ctime = src->s_ctime; + dest->st_blksize = src->s_blksize; + dest->st_blocks = src->s_blocks; +} + +static void stat64_convert(struct SMBW_stat *src, struct stat64 *dest) +{ + memset(dest, '\0', sizeof(*dest)); + dest->st_size = src->s_size; + dest->st_mode = src->s_mode; + dest->st_ino = src->s_ino; + dest->st_dev = src->s_dev; + dest->st_rdev = src->s_rdev; + dest->st_nlink = src->s_nlink; + dest->st_uid = src->s_uid; + dest->st_gid = src->s_gid; + dest->st_atime = src->s_atime; + dest->st_mtime = src->s_mtime; + dest->st_ctime = src->s_ctime; + dest->st_blksize = src->s_blksize; + dest->st_blocks = src->s_blocks; +} + +static void dirent_convert(struct SMBW_dirent *src, struct dirent *dest) +{ + char *p; + + memset(dest, '\0', sizeof(*dest)); + dest->d_ino = src->d_ino; + dest->d_off = src->d_off; + + switch(src->d_type) + { + case SMBC_WORKGROUP: + case SMBC_SERVER: + case SMBC_FILE_SHARE: + case SMBC_DIR: + dest->d_type = DT_DIR; + break; + + case SMBC_FILE: + dest->d_type = DT_REG; + break; + + case SMBC_PRINTER_SHARE: + dest->d_type = DT_CHR; + break; + + case SMBC_COMMS_SHARE: + dest->d_type = DT_SOCK; + break; + + case SMBC_IPC_SHARE: + dest->d_type = DT_FIFO; + break; + + case SMBC_LINK: + dest->d_type = DT_LNK; + break; + } + + dest->d_reclen = src->d_reclen; + strncpy(dest->d_name, src->d_name, sizeof(dest->d_name)); + p = dest->d_name + strlen(dest->d_name) + 1; + strncpy(p, src->d_comment, sizeof(dest->d_name) - (p - dest->d_name)); +} + +static void dirent64_convert(struct SMBW_dirent *src, struct dirent64 *dest) +{ + char *p; + + memset(dest, '\0', sizeof(*dest)); + dest->d_ino = src->d_ino; + dest->d_off = src->d_off; + + switch(src->d_type) + { + case SMBC_WORKGROUP: + case SMBC_SERVER: + case SMBC_FILE_SHARE: + case SMBC_DIR: + dest->d_type = DT_DIR; + break; + + case SMBC_FILE: + dest->d_type = DT_REG; + break; + + case SMBC_PRINTER_SHARE: + dest->d_type = DT_CHR; + break; + + case SMBC_COMMS_SHARE: + dest->d_type = DT_SOCK; + break; + + case SMBC_IPC_SHARE: + dest->d_type = DT_FIFO; + break; + + case SMBC_LINK: + dest->d_type = DT_LNK; + break; + } + + dest->d_reclen = src->d_reclen; + strncpy(dest->d_name, src->d_name, sizeof(dest->d_name)); + p = dest->d_name + strlen(dest->d_name) + 1; + strncpy(p, src->d_comment, sizeof(dest->d_name) - (p - dest->d_name)); +} + +static int openx(char *name, int flags, mode_t mode, int (* f)(char *, int, mode_t)) +{ + if (smbw_path(name)) { + return smbw_open(name, flags, mode); + } + + return (* f)(name, flags, mode); +} + +static int closex(int fd, int (* f)(int fd)) +{ + if (smbw_fd(fd)) { + return smbw_close(fd); + } + + return (* f)(fd); +} + +static int fcntlx(int fd, int cmd, long arg, int (* f)(int, int, long)) +{ + if (smbw_fd(fd)) { + return smbw_fcntl(fd, cmd, arg); + } + + return (* f)(fd, cmd, arg); +} + +static int getdentsx(int fd, struct dirent *external, unsigned int count, int (* f)(int, struct dirent *, unsigned int)) +{ + if (smbw_fd(fd)) { + int i; + int internal_count; + struct SMBW_dirent *internal; + int ret; + int n; + + /* + * LIMITATION: If they pass a count which is not a multiple of + * the size of struct dirent, they will not get a partial + * structure; we ignore the excess count. + */ + n = (count / sizeof(struct dirent)); + + internal_count = sizeof(struct SMBW_dirent) * n; + internal = malloc(internal_count); + if (internal == NULL) { + errno = ENOMEM; + return -1; + } + ret = smbw_getdents(fd, internal, internal_count); + if (ret <= 0) + return ret; + + ret = sizeof(struct dirent) * n; + + for (i = 0; i < n; i++) + dirent_convert(&internal[i], &external[i]); + + return ret; + } + + return (* f)(fd, external, count); +} + +static off_t lseekx(int fd, + off_t offset, + int whence, + off_t (* f)(int, off_t, int)) +{ + off_t ret; + + /* + * We have left the definitions of the smbw_ functions undefined, + * because types such as off_t can differ in meaning betweent his + * function and smbw.c et al. Functions that return other than an + * integer value, however, MUST have their return value defined. + */ + off64_t smbw_lseek(); + + if (smbw_fd(fd)) { + return (off_t) smbw_lseek(fd, offset, whence); + } + + ret = (* f)(fd, offset, whence); + if (smbw_debug) + { + printf("lseekx(%d, 0x%llx) returned 0x%llx\n", + fd, + (unsigned long long) offset, + (unsigned long long) ret); + } + return ret; +} + +static off64_t lseek64x(int fd, + off64_t offset, + int whence, + off64_t (* f)(int, off64_t, int)) +{ + off64_t ret; + + /* + * We have left the definitions of the smbw_ functions undefined, + * because types such as off_t can differ in meaning betweent his + * function and smbw.c et al. Functions that return other than an + * integer value, however, MUST have their return value defined. + */ + off64_t smbw_lseek(); + + if (smbw_fd(fd)) + ret = smbw_lseek(fd, offset, whence); + else + ret = (* f)(fd, offset, whence); + if (smbw_debug) + { + printf("lseek64x(%d, 0x%llx) returned 0x%llx\n", + fd, + (unsigned long long) offset, + (unsigned long long) ret); + } + return ret; +} + +static ssize_t readx(int fd, void *buf, size_t count, ssize_t (* f)(int, void *, size_t)) +{ + if (smbw_fd(fd)) { + return smbw_read(fd, buf, count); + } + + return (* f)(fd, buf, count); +} + +static ssize_t writex(int fd, void *buf, size_t count, ssize_t (* f)(int, void *, size_t)) +{ + if (smbw_fd(fd)) { + return smbw_write(fd, buf, count); + } + + return (* f)(fd, buf, count); +} + + +/** + ** Wrapper Functions + **/ + +int open(__const char *name, int flags, ...) +{ + va_list ap; + mode_t mode; + + va_start(ap, flags); + mode = va_arg(ap, mode_t); + va_end(ap); + + check_init("open"); + + return openx((char *) name, flags, mode, smbw_libc.open); +} + +int _open(char *name, int flags, mode_t mode) +{ + check_init("open"); + + return openx(name, flags, mode, smbw_libc._open); +} + +int __open(char *name, int flags, mode_t mode) +{ + check_init("open"); + + return openx(name, flags, mode, smbw_libc.__open); +} + +int open64 (__const char *name, int flags, ...) +{ + va_list ap; + mode_t mode; + + va_start(ap, flags); + mode = va_arg(ap, mode_t); + va_end(ap); + + check_init("open64"); + return openx((char *) name, flags, mode, smbw_libc.open64); +} + +int _open64(char *name, int flags, mode_t mode) +{ + check_init("_open64"); + return openx(name, flags, mode, smbw_libc._open64); +} + +int __open64(char *name, int flags, mode_t mode) +{ + check_init("__open64"); + return openx(name, flags, mode, smbw_libc.__open64); +} + +ssize_t pread(int fd, void *buf, size_t size, off_t ofs) +{ + check_init("pread"); + + if (smbw_fd(fd)) { + return smbw_pread(fd, buf, size, ofs); + } + + return (* smbw_libc.pread)(fd, buf, size, ofs); +} + +ssize_t pread64(int fd, void *buf, size_t size, off64_t ofs) +{ + check_init("pread64"); + + if (smbw_fd(fd)) { + return smbw_pread(fd, buf, size, (off_t) ofs); + } + + return (* smbw_libc.pread64)(fd, buf, size, ofs); +} + +ssize_t pwrite(int fd, const void *buf, size_t size, off_t ofs) +{ + check_init("pwrite"); + + if (smbw_fd(fd)) { + return smbw_pwrite(fd, (void *) buf, size, ofs); + } + + return (* smbw_libc.pwrite)(fd, (void *) buf, size, ofs); +} + +ssize_t pwrite64(int fd, const void *buf, size_t size, off64_t ofs) +{ + check_init("pwrite64"); + + if (smbw_fd(fd)) { + return smbw_pwrite(fd, (void *) buf, size, (off_t) ofs); + } + + return (* smbw_libc.pwrite64)(fd, (void *) buf, size, ofs); +} + +int chdir(const char *name) +{ + check_init("chdir"); + return smbw_chdir((char *) name);; +} + +int __chdir(char *name) +{ + check_init("__chdir"); + return smbw_chdir(name); +} + +int _chdir(char *name) +{ + check_init("_chdir"); + return smbw_chdir(name); +} + +int close(int fd) +{ + check_init("close"); + return closex(fd, smbw_libc.close); +} + +int __close(int fd) +{ + check_init("__close"); + return closex(fd, smbw_libc.__close); +} + +int _close(int fd) +{ + check_init("_close"); + return closex(fd, smbw_libc._close); +} + +int fchdir(int fd) +{ + check_init("fchdir"); + return smbw_fchdir(fd); +} + +int __fchdir(int fd) +{ + check_init("__fchdir"); + return fchdir(fd); +} + +int _fchdir(int fd) +{ + check_init("_fchdir"); + return fchdir(fd); +} + +int fcntl (int fd, int cmd, ...) +{ + va_list ap; + long arg; + + va_start(ap, cmd); + arg = va_arg(ap, long); + va_end(ap); + + check_init("fcntl"); + return fcntlx(fd, cmd, arg, smbw_libc.fcntl); +} + +int __fcntl(int fd, int cmd, ...) +{ + va_list ap; + long arg; + + va_start(ap, cmd); + arg = va_arg(ap, long); + va_end(ap); + + check_init("__fcntl"); + return fcntlx(fd, cmd, arg, smbw_libc.__fcntl); +} + +int _fcntl(int fd, int cmd, ...) +{ + va_list ap; + long arg; + + va_start(ap, cmd); + arg = va_arg(ap, long); + va_end(ap); + + check_init("_fcntl"); + return fcntlx(fd, cmd, arg, smbw_libc._fcntl); +} + +int getdents(int fd, struct dirent *dirp, unsigned int count) +{ + check_init("getdents"); + return getdentsx(fd, dirp, count, smbw_libc.getdents); +} + +int __getdents(int fd, struct dirent *dirp, unsigned int count) +{ + check_init("__getdents"); + return getdentsx(fd, dirp, count, smbw_libc.__getdents); +} + +int _getdents(int fd, struct dirent *dirp, unsigned int count) +{ + check_init("_getdents"); + return getdentsx(fd, dirp, count, smbw_libc._getdents); +} + +int getdents64(int fd, struct dirent64 *external, unsigned int count) +{ + check_init("getdents64"); + if (smbw_fd(fd)) { + int i; + struct SMBW_dirent *internal; + int ret; + int n; + + /* + * LIMITATION: If they pass a count which is not a multiple of + * the size of struct dirent, they will not get a partial + * structure; we ignore the excess count. + */ + n = (count / sizeof(struct dirent64)); + + internal = malloc(sizeof(struct SMBW_dirent) * n); + if (internal == NULL) { + errno = ENOMEM; + return -1; + } + ret = smbw_getdents(fd, internal, count); + if (ret <= 0) + return ret; + + ret = sizeof(struct dirent) * count; + + for (i = 0; count; i++, count--) + dirent64_convert(&internal[i], &external[i]); + + return ret; + } + + return (* smbw_libc.getdents64)(fd, external, count); +} + +off_t lseek(int fd, off_t offset, int whence) +{ + off_t ret; + check_init("lseek"); + ret = lseekx(fd, offset, whence, smbw_libc.lseek); + if (smbw_debug) + { + printf("lseek(%d, 0x%llx) returned 0x%llx\n", + fd, + (unsigned long long) offset, + (unsigned long long) ret); + } + return ret; +} + +off_t __lseek(int fd, off_t offset, int whence) +{ + off_t ret; + check_init("__lseek"); + ret = lseekx(fd, offset, whence, smbw_libc.__lseek); + if (smbw_debug) + { + printf("__lseek(%d, 0x%llx) returned 0x%llx\n", + fd, + (unsigned long long) offset, + (unsigned long long) ret); + } + return ret; +} + +off_t _lseek(int fd, off_t offset, int whence) +{ + off_t ret; + check_init("_lseek"); + ret = lseekx(fd, offset, whence, smbw_libc._lseek); + if (smbw_debug) + { + printf("_lseek(%d, 0x%llx) returned 0x%llx\n", + fd, + (unsigned long long) offset, + (unsigned long long) ret); + } + return ret; +} + +off64_t lseek64(int fd, off64_t offset, int whence) +{ + off64_t ret; + check_init("lseek64"); + ret = lseek64x(fd, offset, whence, smbw_libc.lseek64); + if (smbw_debug) + { + printf("lseek64(%d, 0x%llx) returned 0x%llx\n", + fd, + (unsigned long long) offset, + (unsigned long long) ret); + } + return ret; +} + +off64_t __lseek64(int fd, off64_t offset, int whence) +{ + check_init("__lseek64"); + return lseek64x(fd, offset, whence, smbw_libc.__lseek64); +} + +off64_t _lseek64(int fd, off64_t offset, int whence) +{ + off64_t ret; + check_init("_lseek64"); + ret = lseek64x(fd, offset, whence, smbw_libc._lseek64); + if (smbw_debug) + { + printf("_lseek64(%d, 0x%llx) returned 0x%llx\n", + fd, + (unsigned long long) offset, + (unsigned long long) ret); + } + return ret; +} + +ssize_t read(int fd, void *buf, size_t count) +{ + check_init("read"); + return readx(fd, buf, count, smbw_libc.read); +} + +ssize_t __read(int fd, void *buf, size_t count) +{ + check_init("__read"); + return readx(fd, buf, count, smbw_libc.__read); +} + +ssize_t _read(int fd, void *buf, size_t count) +{ + check_init("_read"); + return readx(fd, buf, count, smbw_libc._read); +} + +ssize_t write(int fd, const void *buf, size_t count) +{ + check_init("write"); + return writex(fd, (void *) buf, count, smbw_libc.write); +} + +ssize_t __write(int fd, const void *buf, size_t count) +{ + check_init("__write"); + return writex(fd, (void *) buf, count, smbw_libc.__write); +} + +ssize_t _write(int fd, const void *buf, size_t count) +{ + check_init("_write"); + return writex(fd, (void *) buf, count, smbw_libc._write); +} + +int access(const char *name, int mode) +{ + check_init("access"); + + if (smbw_path((char *) name)) { + return smbw_access((char *) name, mode); + } + + return (* smbw_libc.access)((char *) name, mode); +} + +int chmod(const char *name, mode_t mode) +{ + check_init("chmod"); + + if (smbw_path((char *) name)) { + return smbw_chmod((char *) name, mode); + } + + return (* smbw_libc.chmod)((char *) name, mode); +} + +int fchmod(int fd, mode_t mode) +{ + check_init("fchmod"); + + if (smbw_fd(fd)) { + /* Not yet implemented in libsmbclient */ + return ENOTSUP; + } + + return (* smbw_libc.fchmod)(fd, mode); +} + +int chown(const char *name, uid_t owner, gid_t group) +{ + check_init("chown"); + + if (smbw_path((char *) name)) { + return smbw_chown((char *) name, owner, group); + } + + return (* smbw_libc.chown)((char *) name, owner, group); +} + +int fchown(int fd, uid_t owner, gid_t group) +{ + check_init("fchown"); + + if (smbw_fd(fd)) { + /* Not yet implemented in libsmbclient */ + return ENOTSUP; + } + + return (* smbw_libc.fchown)(fd, owner, group); +} + +char *getcwd(char *buf, size_t size) +{ + check_init("getcwd"); + return (char *)smbw_getcwd(buf, size); +} + +int mkdir(const char *name, mode_t mode) +{ + check_init("mkdir"); + + if (smbw_path((char *) name)) { + return smbw_mkdir((char *) name, mode); + } + + return (* smbw_libc.mkdir)((char *) name, mode); +} + +int __fxstat(int vers, int fd, struct stat *st) +{ + check_init("__fxstat"); + + if (smbw_fd(fd)) { + struct SMBW_stat statbuf; + int ret = smbw_fstat(fd, &statbuf); + stat_convert(&statbuf, st); + return ret; + } + + return (* smbw_libc.__fxstat)(vers, fd, st); +} + +int __xstat(int vers, const char *name, struct stat *st) +{ + check_init("__xstat"); + + if (smbw_path((char *) name)) { + struct SMBW_stat statbuf; + int ret = smbw_stat((char *) name, &statbuf); + stat_convert(&statbuf, st); + return ret; + } + + return (* smbw_libc.__xstat)(vers, (char *) name, st); +} + +int __lxstat(int vers, const char *name, struct stat *st) +{ + check_init("__lxstat"); + + if (smbw_path((char *) name)) { + struct SMBW_stat statbuf; + int ret = smbw_stat((char *) name, &statbuf); + stat_convert(&statbuf, st); + return ret; + } + + return (* smbw_libc.__lxstat)(vers, (char *) name, st); +} + +int stat(const char *name, struct stat *st) +{ + check_init("stat"); + + if (smbw_path((char *) name)) { + struct SMBW_stat statbuf; + int ret = smbw_stat((char *) name, &statbuf); + stat_convert(&statbuf, st); + return ret; + } + + return (* smbw_libc.stat)((char *) name, st); +} + +int lstat(const char *name, struct stat *st) +{ + check_init("lstat"); + + if (smbw_path((char *) name)) { + struct SMBW_stat statbuf; + int ret = smbw_stat((char *) name, &statbuf); + stat_convert(&statbuf, st); + return ret; + } + + return (* smbw_libc.lstat)((char *) name, st); +} + +int fstat(int fd, struct stat *st) +{ + check_init("fstat"); + + if (smbw_fd(fd)) { + struct SMBW_stat statbuf; + int ret = smbw_fstat(fd, &statbuf); + stat_convert(&statbuf, st); + return ret; + } + + return (* smbw_libc.fstat)(fd, st); +} + +int unlink(const char *name) +{ + check_init("unlink"); + + if (smbw_path((char *) name)) { + return smbw_unlink((char *) name); + } + + return (* smbw_libc.unlink)((char *) name); +} + +int utime(const char *name, const struct utimbuf *tvp) +{ + check_init("utime"); + + if (smbw_path(name)) { + return smbw_utime(name, (struct utimbuf *) tvp); + } + + return (* smbw_libc.utime)((char *) name, (struct utimbuf *) tvp); +} + +int utimes(const char *name, const struct timeval *tvp) +{ + check_init("utimes"); + + if (smbw_path(name)) { + return smbw_utimes(name, (struct timeval *) tvp); + } + + return (* smbw_libc.utimes)((char *) name, (struct timeval *) tvp); +} + +int readlink(const char *path, char *buf, size_t bufsize) +{ + check_init("readlink"); + + if (smbw_path((char *) path)) { + return smbw_readlink(path, (char *) buf, bufsize); + } + + return (* smbw_libc.readlink)((char *) path, buf, bufsize); +} + +int rename(const char *oldname, const char *newname) +{ + int p1, p2; + + check_init("rename"); + + p1 = smbw_path((char *) oldname); + p2 = smbw_path((char *) newname); + if (p1 ^ p2) { + /* can't cross filesystem boundaries */ + errno = EXDEV; + return -1; + } + if (p1 && p2) { + return smbw_rename((char *) oldname, (char *) newname); + } + + return (* smbw_libc.rename)((char *) oldname, (char *) newname); +} + +int rmdir(const char *name) +{ + check_init("rmdir"); + + if (smbw_path((char *) name)) { + return smbw_rmdir((char *) name); + } + + return (* smbw_libc.rmdir)((char *) name); +} + +int symlink(const char *topath, const char *frompath) +{ + int p1, p2; + + check_init("symlink"); + + p1 = smbw_path((char *) topath); + p2 = smbw_path((char *) frompath); + if (p1 || p2) { + /* can't handle symlinks */ + errno = EPERM; + return -1; + } + + return (* smbw_libc.symlink)((char *) topath, (char *) frompath); +} + +int dup(int fd) +{ + check_init("dup"); + + if (smbw_fd(fd)) { + return smbw_dup(fd); + } + + return (* smbw_libc.dup)(fd); +} + +int dup2(int oldfd, int newfd) +{ + check_init("dup2"); + + if (smbw_fd(newfd)) { + (* smbw_libc.close)(newfd); + } + + if (smbw_fd(oldfd)) { + return smbw_dup2(oldfd, newfd); + } + + return (* smbw_libc.dup2)(oldfd, newfd); +} + + +DIR *opendir(const char *name) +{ + check_init("opendir"); + + if (smbw_path((char *) name)) { + return (void *)smbw_opendir((char *) name); + } + + return (* smbw_libc.opendir)((char *) name); +} + +struct dirent *readdir(DIR *dir) +{ + check_init("readdir"); + + if (smbw_dirp(dir)) { + static struct dirent external; + struct SMBW_dirent * internal = (void *)smbw_readdir(dir); + if (internal != NULL) { + dirent_convert(internal, &external); + return &external; + } + return NULL; + } + return (* smbw_libc.readdir)(dir); +} + +int closedir(DIR *dir) +{ + check_init("closedir"); + + if (smbw_dirp(dir)) { + return smbw_closedir(dir); + } + + return (* smbw_libc.closedir)(dir); +} + +long telldir(DIR *dir) +{ + check_init("telldir"); + + if (smbw_dirp(dir)) { + return (long) smbw_telldir(dir); + } + + return (* smbw_libc.telldir)(dir); +} + +void seekdir(DIR *dir, long offset) +{ + check_init("seekdir"); + + if (smbw_dirp(dir)) { + smbw_seekdir(dir, (long long) offset); + return; + } + + (* smbw_libc.seekdir)(dir, offset); +} + +int creat(const char *path, mode_t mode) +{ + extern int creat_bits; + + check_init("creat"); + return openx((char *) path, creat_bits, mode, smbw_libc.open); +} + +int creat64(const char *path, mode_t mode) +{ + extern int creat_bits; + + check_init("creat64"); + return openx((char *) path, creat_bits, mode, smbw_libc.open64); +} + +int __xstat64 (int ver, const char *name, struct stat64 *st64) +{ + check_init("__xstat64"); + + if (smbw_path((char *) name)) { + struct SMBW_stat statbuf; + int ret = smbw_stat((char *) name, &statbuf); + stat64_convert(&statbuf, st64); + return ret; + } + + return (* smbw_libc.__xstat64)(ver, (char *) name, st64); +} + +int stat64(const char *name, struct stat64 *st64) +{ + check_init("stat64"); + + if (smbw_path((char *) name)) { + struct SMBW_stat statbuf; + int ret = smbw_stat((char *) name, &statbuf); + stat64_convert(&statbuf, st64); + return ret; + } + + return (* smbw_libc.stat64)((char *) name, st64); +} + +int __fxstat64(int ver, int fd, struct stat64 *st64) +{ + check_init("__fxstat64"); + + if (smbw_fd(fd)) { + struct SMBW_stat statbuf; + int ret = smbw_fstat(fd, &statbuf); + stat64_convert(&statbuf, st64); + return ret; + } + + return (* smbw_libc.__fxstat64)(ver, fd, st64); +} + +int fstat64(int fd, struct stat64 *st64) +{ + check_init("fstat64"); + + if (smbw_fd(fd)) { + struct SMBW_stat statbuf; + int ret = smbw_fstat(fd, &statbuf); + stat64_convert(&statbuf, st64); + return ret; + } + + return (* smbw_libc.fstat64)(fd, st64); +} + +int __lxstat64(int ver, const char *name, struct stat64 *st64) +{ + check_init("__lxstat64"); + + if (smbw_path((char *) name)) { + struct SMBW_stat statbuf; + int ret = smbw_stat(name, &statbuf); + stat64_convert(&statbuf, st64); + return ret; + } + + return (* smbw_libc.__lxstat64)(ver, (char *) name, st64); +} + +int lstat64(const char *name, struct stat64 *st64) +{ + check_init("lstat64"); + + if (smbw_path((char *) name)) { + struct SMBW_stat statbuf; + int ret = smbw_stat((char *) name, &statbuf); + stat64_convert(&statbuf, st64); + return ret; + } + + return (* smbw_libc.lstat64)((char *) name, st64); +} + +int _llseek(unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t *result, unsigned int whence) +{ + check_init("_llseek"); + + if (smbw_fd(fd)) { + *result = lseek(fd, offset_low, whence); + return (*result < 0 ? -1 : 0); + } + + return (* smbw_libc._llseek)(fd, offset_high, offset_low, result, whence); +} + +struct dirent64 *readdir64(DIR *dir) +{ + check_init("readdir64"); + + if (smbw_dirp(dir)) { + static struct dirent64 external; + struct SMBW_dirent * internal = (void *)smbw_readdir(dir); + if (internal != NULL) { + dirent64_convert(internal, &external); + return &external; + } + return NULL; + } + + return (* smbw_libc.readdir64)(dir); +} + +int readdir_r(DIR *dir, struct dirent *external, struct dirent **result) +{ + check_init("readdir_r"); + + if (smbw_dirp(dir)) { + struct SMBW_dirent internal; + int ret = smbw_readdir_r(dir, &internal, NULL); + if (ret == 0) { + dirent_convert(&internal, external); + *result = external; + } + return ret; + } + + return (* smbw_libc.readdir_r)(dir, external, result); +} + +int readdir64_r(DIR *dir, struct dirent64 *external, struct dirent64 **result) +{ + check_init("readdir64_r"); + + if (smbw_dirp(dir)) { + struct SMBW_dirent internal; + int ret = smbw_readdir_r(dir, &internal, NULL); + if (ret == 0) { + dirent64_convert(&internal, external); + *result = external; + } + return ret; + } + + return (* smbw_libc.readdir64_r)(dir, external, result); +} + +int fork(void) +{ + check_init("fork"); + return smbw_fork(); +} + +int setxattr(const char *fname, + const char *name, + const void *value, + size_t size, + int flags) +{ + if (smbw_path(fname)) { + return smbw_setxattr(fname, name, value, size, flags); + } + + return (* smbw_libc.setxattr)(fname, name, value, size, flags); +} + +int lsetxattr(const char *fname, + const char *name, + const void *value, + size_t size, + int flags) +{ + if (smbw_path(fname)) { + return smbw_lsetxattr(fname, name, value, size, flags); + } + + return (* smbw_libc.lsetxattr)(fname, name, value, size, flags); +} + +int fsetxattr(int fd, + const char *name, + const void *value, + size_t size, + int flags) +{ + if (smbw_fd(fd)) { + return smbw_fsetxattr(fd, name, value, size, flags); + } + + return (* smbw_libc.fsetxattr)(fd, name, value, size, flags); +} + +int getxattr(const char *fname, + const char *name, + const void *value, + size_t size) +{ + if (smbw_path(fname)) { + return smbw_getxattr(fname, name, value, size); + } + + return (* smbw_libc.getxattr)(fname, name, value, size); +} + +int lgetxattr(const char *fname, + const char *name, + const void *value, + size_t size) +{ + if (smbw_path(fname)) { + return smbw_lgetxattr(fname, name, value, size); + } + + return (* smbw_libc.lgetxattr)(fname, name, value, size); +} + +int fgetxattr(int fd, + const char *name, + const void *value, + size_t size) +{ + if (smbw_fd(fd)) { + return smbw_fgetxattr(fd, name, value, size); + } + + return (* smbw_libc.fgetxattr)(fd, name, value, size); +} + +int removexattr(const char *fname, + const char *name) +{ + if (smbw_path(fname)) { + return smbw_removexattr(fname, name); + } + + return (* smbw_libc.removexattr)(fname, name); +} + +int lremovexattr(const char *fname, + const char *name) +{ + if (smbw_path(fname)) { + return smbw_lremovexattr(fname, name); + } + + return (* smbw_libc.lremovexattr)(fname, name); +} + +int fremovexattr(int fd, + const char *name) +{ + if (smbw_fd(fd)) { + return smbw_fremovexattr(fd, name); + } + + return (* smbw_libc.fremovexattr)(fd, name); +} + +int listxattr(const char *fname, + char *list, + size_t size) +{ + if (smbw_path(fname)) { + return smbw_listxattr(fname, list, size); + } + + return (* smbw_libc.listxattr)(fname, list, size); +} + +int llistxattr(const char *fname, + char *list, + size_t size) +{ + if (smbw_path(fname)) { + return smbw_llistxattr(fname, list, size); + } + + return (* smbw_libc.llistxattr)(fname, list, size); +} + +int flistxattr(int fd, + char *list, + size_t size) +{ + if (smbw_fd(fd)) { + return smbw_flistxattr(fd, list, size); + } + + return (* smbw_libc.flistxattr)(fd, list, size); +} + + +/* + * We're ending up with a different implementation of malloc() with smbwrapper + * than without it. The one with it does not support returning a non-NULL + * pointer from a call to malloc(0), and many apps depend on getting a valid + * pointer when requesting zero length (e.g. df, emacs). + * + * Unfortunately, initializing the smbw_libc[] array via the dynamic link + * library (libdl) requires malloc so we can't just do the same type of + * mapping to the C library as we do with everything else. We need to + * implement a different way of allocating memory that ensures that the C + * library version of malloc() gets used. This is the only place where we + * kludge the code to use an undocumented interface to the C library. + * + * If anyone can come up with a way to dynamically link to the C library + * rather than using this undocumented interface, I'd sure love to hear about + * it. Better yet, if you can figure out where the alternate malloc() + * functions are coming from and arrange for them not to be called, that would + * be even better. We should try to avoid wrapping functions that don't + * really require it. + */ + +void *malloc(size_t size) +{ + void *__libc_malloc(size_t size); + return __libc_malloc(size); +} + +void *calloc(size_t nmemb, size_t size) +{ + void *__libc_calloc(size_t nmemb, size_t size); + return __libc_calloc(nmemb, size); +} + +void *realloc(void *ptr, size_t size) +{ + void *__libc_realloc(void *ptr, size_t size); + return __libc_realloc(ptr, size); +} + +void free(void *ptr) +{ + static int in_progress = 0; + void __libc_free(void *ptr); + + if (in_progress) return; + in_progress = 1; + __libc_free(ptr); + in_progress = 0; +} + + +#if 0 /* SELECT */ + +static struct sigaction user_action[_NSIG]; + +static void +smbw_sigaction_handler(int signum, + siginfo_t *info, + void *context) +{ + /* Our entire purpose for trapping signals is to call this! */ + sys_select_signal(); + + /* Call the user's handler */ + if (user_action[signum].sa_handler != SIG_IGN && + user_action[signum].sa_handler != SIG_DFL && + user_action[signum].sa_handler != SIG_ERR) { + (* user_action[signum].sa_sigaction)(signum, info, context); + } +} + + +/* + * Every Samba signal handler must call sys_select_signal() to avoid a race + * condition, so we'll take whatever signal handler is currently assigned, + * call call sys_select_signal() in addition to their call. + */ +static int +do_select(int n, + fd_set *readfds, + fd_set *writefds, + fd_set *exceptfds, + struct timeval *timeout, + int (* select_fn)(int n, + fd_set *readfds, + fd_set *writefds, + fd_set *exceptfds, + struct timeval *timeout)) +{ + int i; + int ret; + int saved_errno; + sigset_t sigset; + struct sigaction new_action; + + saved_errno = errno; + for (i=1; i<_NSIG; i++) { + sigemptyset(&sigset); + new_action.sa_mask = sigset; + new_action.sa_flags = SA_SIGINFO; + new_action.sa_sigaction = smbw_sigaction_handler; + + if (sigaction(i, &new_action, &user_action[i]) < 0) { + if (errno != EINVAL) { + return -1; + } + } + } + errno = saved_errno; + + ret = (* select_fn)(n, readfds, writefds, exceptfds, timeout); + saved_errno = errno; + + for (i=0; i<_NSIG; i++) { + (void) sigaction(i, &user_action[i], NULL); + } + + errno = saved_errno; + return ret; +} + +int +select(int n, + fd_set *readfds, + fd_set *writefds, + fd_set *exceptfds, + struct timeval *timeout) +{ + check_init("select"); + + return do_select(n, readfds, writefds, exceptfds, + timeout, smbw_libc.select); +} + +int +_select(int n, + fd_set *readfds, + fd_set *writefds, + fd_set *exceptfds, + struct timeval *timeout) +{ + check_init("_select"); + + return do_select(n, readfds, writefds, exceptfds, + timeout, smbw_libc._select); +} + +int +__select(int n, + fd_set *readfds, + fd_set *writefds, + fd_set *exceptfds, + struct timeval *timeout) +{ + check_init("__select"); + + return do_select(n, readfds, writefds, exceptfds, + timeout, smbw_libc.__select); +} + +#endif diff --git a/examples/libsmbclient/smbwrapper/wrapper.h b/examples/libsmbclient/smbwrapper/wrapper.h new file mode 100644 index 00000000000..6d0d9f527a3 --- /dev/null +++ b/examples/libsmbclient/smbwrapper/wrapper.h @@ -0,0 +1,209 @@ +/* + Unix SMB/Netbios implementation. + Version 2.0 + SMB wrapper functions + Copyright (C) Derrell Lipman 2003-2005 + + 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 __WRAPPER_H__ +#define __WRAPPER_H__ + +#include <sys/stat.h> +#include <sys/select.h> +#include <sys/time.h> +#include <sys/types.h> +#include <unistd.h> +#include <dirent.h> +#include <utime.h> +#include <signal.h> +#include <stdio.h> + +extern int smbw_fd_map[__FD_SETSIZE]; +extern int smbw_ref_count[__FD_SETSIZE]; +extern char smbw_cwd[PATH_MAX]; +extern char smbw_prefix[]; + +typedef struct SMBW_stat { + unsigned long s_dev; /* device */ + unsigned long s_ino; /* inode */ + unsigned long s_mode; /* protection */ + unsigned long s_nlink; /* number of hard links */ + unsigned long s_uid; /* user ID of owner */ + unsigned long s_gid; /* group ID of owner */ + unsigned long s_rdev; /* device type (if inode device) */ + unsigned long long s_size; /* total size, in bytes */ + unsigned long s_blksize; /* blocksize for filesystem I/O */ + unsigned long s_blocks; /* number of blocks allocated */ + unsigned long s_atime; /* time of last access */ + unsigned long s_mtime; /* time of last modification */ + unsigned long s_ctime; /* time of last change */ +} SMBW_stat; + +typedef struct SMBW_dirent { + unsigned long d_ino; /* inode number */ + unsigned long long d_off; /* offset to the next dirent */ + unsigned long d_reclen; /* length of this record */ + unsigned long d_type; /* type of file */ + char d_name[256]; /* filename */ + char d_comment[256]; /* comment */ +} SMBW_dirent; + +struct kernel_sigaction { + __sighandler_t k_sa_handler; + unsigned long sa_flags; + sigset_t sa_mask; +}; + +typedef struct SMBW_libc +{ + /* write() is first, to allow debugging */ + ssize_t (* write)(int fd, void *buf, size_t count); + int (* open)(char *name, int flags, mode_t mode); + int (* _open)(char *name, int flags, mode_t mode) ; + int (* __open)(char *name, int flags, mode_t mode) ; + int (* open64)(char *name, int flags, mode_t mode); + int (* _open64)(char *name, int flags, mode_t mode) ; + int (* __open64)(char *name, int flags, mode_t mode) ; + ssize_t (* pread)(int fd, void *buf, size_t size, off_t ofs); + ssize_t (* pread64)(int fd, void *buf, size_t size, off64_t ofs); + ssize_t (* pwrite)(int fd, void *buf, size_t size, off_t ofs); + ssize_t (* pwrite64)(int fd, void *buf, size_t size, off64_t ofs); + int (* close)(int fd); + int (* __close)(int fd); + int (* _close)(int fd); + int (* fcntl)(int fd, int cmd, long arg); + int (* __fcntl)(int fd, int cmd, long arg); + int (* _fcntl)(int fd, int cmd, long arg); + int (* getdents)(int fd, struct dirent *dirp, unsigned int count); + int (* __getdents)(int fd, struct dirent *dirp, unsigned int count); + int (* _getdents)(int fd, struct dirent *dirp, unsigned int count); + int (* getdents64)(int fd, struct dirent64 *dirp, unsigned int count); + off_t (* lseek)(int fd, off_t offset, int whence); + off_t (* __lseek)(int fd, off_t offset, int whence); + off_t (* _lseek)(int fd, off_t offset, int whence); + off64_t (* lseek64)(int fd, off64_t offset, int whence); + off64_t (* __lseek64)(int fd, off64_t offset, int whence); + off64_t (* _lseek64)(int fd, off64_t offset, int whence); + ssize_t (* read)(int fd, void *buf, size_t count); + ssize_t (* __read)(int fd, void *buf, size_t count); + ssize_t (* _read)(int fd, void *buf, size_t count); + ssize_t (* __write)(int fd, void *buf, size_t count); + ssize_t (* _write)(int fd, void *buf, size_t count); + int (* access)(char *name, int mode); + int (* chmod)(char *name, mode_t mode); + int (* fchmod)(int fd, mode_t mode); + int (* chown)(char *name, uid_t owner, gid_t group); + int (* fchown)(int fd, uid_t owner, gid_t group); + int (* __xstat)(int vers, char *name, struct stat *st); + char * ( *getcwd)(char *buf, size_t size); + int (* mkdir)(char *name, mode_t mode); + int (* __fxstat)(int vers, int fd, struct stat *st); + int (* __lxstat)(int vers, char *name, struct stat *st); + int (* stat)(char *name, struct stat *st); + int (* lstat)(char *name, struct stat *st); + int (* fstat)(int fd, struct stat *st); + int (* unlink)(char *name); + int (* utime)(char *name, struct utimbuf *tvp); + int (* utimes)(char *name, struct timeval *tvp); + int (* readlink)(char *path, char *buf, size_t bufsize); + int (* rename)(char *oldname, char *newname); + int (* rmdir)(char *name); + int (* symlink)(char *topath, char *frompath); + int (* dup)(int fd); + int (* dup2)(int oldfd, int newfd); + DIR * (* opendir)(char *name); + struct dirent * (* readdir)(DIR *dir); + int (* closedir)(DIR *dir); + off_t (* telldir)(DIR *dir); + void (* seekdir)(DIR *dir, off_t offset); + int (* creat)(char *path, mode_t mode); + int (* creat64)(char *path, mode_t mode); + int (* __xstat64)(int ver, char *name, struct stat64 *st64); + int (* stat64)(char *name, struct stat64 *st64); + int (* __fxstat64)(int ver, int fd, struct stat64 *st64); + int (* fstat64)(int fd, struct stat64 *st64); + int (* __lxstat64)(int ver, char *name, struct stat64 *st64); + int (* lstat64)(char *name, struct stat64 *st64); + int (* _llseek)(unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t *result, unsigned int whence); + struct dirent64 * (* readdir64)(DIR *dir); + int (* readdir_r)(DIR *dir, struct dirent *entry, struct dirent **result); + int (* readdir64_r)(DIR *dir, struct dirent64 *entry, struct dirent64 **result); + int (* setxattr)(const char *fname, + const char *name, + const void *value, + size_t size, + int flags); + int (* lsetxattr)(const char *fname, + const char *name, + const void *value, + size_t size, + int flags); + int (* fsetxattr)(int smbw_fd, + const char *name, + const void *value, + size_t size, + int flags); + int (* getxattr)(const char *fname, + const char *name, + const void *value, + size_t size); + int (* lgetxattr)(const char *fname, + const char *name, + const void *value, + size_t size); + int (* fgetxattr)(int smbw_fd, + const char *name, + const void *value, + size_t size); + int (* removexattr)(const char *fname, + const char *name); + int (* lremovexattr)(const char *fname, + const char *name); + int (* fremovexattr)(int smbw_fd, + const char *name); + int (* listxattr)(const char *fname, + char *list, + size_t size); + int (* llistxattr)(const char *fname, + char *list, + size_t size); + int (* flistxattr)(int smbw_fd, + char *list, + size_t size); + int (* chdir)(const char *path); + int (* fchdir)(int fd); + pid_t (* fork)(void); + int (* select)(int n, + fd_set *readfds, + fd_set *writefds, + fd_set *exceptfds, + struct timeval *timeout); + int (* _select)(int n, + fd_set *readfds, + fd_set *writefds, + fd_set *exceptfds, + struct timeval *timeout); + int (* __select)(int n, + fd_set *readfds, + fd_set *writefds, + fd_set *exceptfds, + struct timeval *timeout); +} SMBW_libc_pointers; + +extern SMBW_libc_pointers smbw_libc; + +#endif /* __WRAPPER_H__ */ diff --git a/examples/libsmbclient/testacl.c b/examples/libsmbclient/testacl.c index 47668f7c9c4..ce5694b331a 100644 --- a/examples/libsmbclient/testacl.c +++ b/examples/libsmbclient/testacl.c @@ -3,6 +3,7 @@ #include <errno.h> #include <popt.h> #include "libsmbclient.h" +#include "get_auth_data_fn.h" enum acl_mode { @@ -15,59 +16,6 @@ enum acl_mode SMB_ACL_CHGRP }; -static void -get_auth_data_fn(const char * pServer, - const char * pShare, - char * pWorkgroup, - int maxLenWorkgroup, - char * pUsername, - int maxLenUsername, - char * pPassword, - int maxLenPassword) - -{ - char temp[128]; - - fprintf(stdout, "Workgroup: [%s] ", pWorkgroup); - fgets(temp, sizeof(temp), stdin); - - if (temp[strlen(temp) - 1] == '\n') /* A new line? */ - { - temp[strlen(temp) - 1] = '\0'; - } - - if (temp[0] != '\0') - { - strncpy(pWorkgroup, temp, maxLenWorkgroup - 1); - } - - fprintf(stdout, "Username: [%s] ", pUsername); - fgets(temp, sizeof(temp), stdin); - - if (temp[strlen(temp) - 1] == '\n') /* A new line? */ - { - temp[strlen(temp) - 1] = '\0'; - } - - if (temp[0] != '\0') - { - strncpy(pUsername, temp, maxLenUsername - 1); - } - - fprintf(stdout, "Password: "); - fgets(temp, sizeof(temp), stdin); - - if (temp[strlen(temp) - 1] == '\n') /* A new line? */ - { - temp[strlen(temp) - 1] = '\0'; - } - - if (temp[0] != '\0') - { - strncpy(pPassword, temp, maxLenPassword - 1); - } -} - int main(int argc, const char *argv[]) { diff --git a/examples/libsmbclient/testbrowse.c b/examples/libsmbclient/testbrowse.c index d2472230a20..27d6a697388 100644 --- a/examples/libsmbclient/testbrowse.c +++ b/examples/libsmbclient/testbrowse.c @@ -1,91 +1,144 @@ -/* - Unix SMB/CIFS implementation. - SMB client library test program for browsing with different master browsers - Copyright (C) Derrell Lipman 2004 - - 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 <stdio.h> +#include <sys/types.h> +#include <unistd.h> +#include <dirent.h> #include <errno.h> -#include <sys/time.h> +#include <stdio.h> #include <string.h> -#include <unistd.h> +#include <popt.h> #include <stdlib.h> #include <libsmbclient.h> +#include "get_auth_data_fn.h" -static void -auth_fn(const char * pServer, - const char * pShare, - char * pWorkgroup, - int workgroup_len, - char * pUsername, - int username_len, - char * pPassword, - int password_len) - +void error_message(char * pMessage) { - strncpy(pUsername, "anonymous", username_len); /* doesn't matter what */ - strncpy(pPassword, "password", password_len); /* ditto */ + printf("ERROR: %s\n", pMessage); } int main(int argc, char * argv[]) { - int debug = 4; + int debug = 0; int opt; char * p; + char * q; char buf[1024]; int dir; + struct stat stat; struct smbc_dirent * dirent; - char ** ppUrl; - char * urlList[] = + poptContext pc; + struct poptOption long_options[] = { - "smb://", - "smb://?mb=.any", - "smb://?mb=.all", - "smb://?mb=xx", /* this one is suupposed to fail */ - NULL + POPT_AUTOHELP + { + "debug", 'd', POPT_ARG_INT, &debug, + 0, "Set debug level", "integer" + }, + { + NULL + } }; - if (smbc_init(auth_fn, debug) != 0) + setbuf(stdout, NULL); + + pc = poptGetContext("opendir", argc, (const char **)argv, long_options, 0); + + poptSetOtherOptionHelp(pc, ""); + + while ((opt = poptGetNextOpt(pc)) != -1) { + printf("Got option %d = %c\n", opt, opt); + switch (opt) { + } + } + + if (smbc_init(get_auth_data_fn, debug) != 0) { printf("Could not initialize smbc_ library\n"); return 1; } - for (ppUrl = urlList; *ppUrl != NULL; ppUrl++) + for (fputs("url: ", stdout), p = fgets(buf, sizeof(buf), stdin); + p != NULL && *p != '\n' && *p != '\0'; + fputs("url: ", stdout), p = fgets(buf, sizeof(buf), stdin)) { - printf("Opening (%s)...\n", *ppUrl); - - if ((dir = smbc_opendir(*ppUrl)) < 0) + if ((p = strchr(buf, '\n')) != NULL) { - printf("Could not open [%s] (%d:%s)\n", - *ppUrl, errno, strerror(errno)); + *p = '\0'; + } + + printf("Opening (%s)...\n", buf); + + if ((dir = smbc_opendir(buf)) < 0) + { + printf("Could not open directory [%s] (%d:%s)\n", + buf, errno, strerror(errno)); continue; } - + while ((dirent = smbc_readdir(dir)) != NULL) { - printf("%s\n", dirent->name); + printf("%-30s", dirent->name); + printf("%-30s", dirent->comment); + + switch(dirent->smbc_type) + { + case SMBC_WORKGROUP: + printf("WORKGROUP"); + break; + + case SMBC_SERVER: + printf("SERVER"); + break; + + case SMBC_FILE_SHARE: + printf("FILE_SHARE"); + break; + + case SMBC_PRINTER_SHARE: + printf("PRINTER_SHARE"); + break; + + case SMBC_COMMS_SHARE: + printf("COMMS_SHARE"); + break; + + case SMBC_IPC_SHARE: + printf("IPC_SHARE"); + break; + + case SMBC_DIR: + printf("DIR"); + break; + + case SMBC_FILE: + printf("FILE"); + + q = buf + strlen(buf); + strcat(q, "/"); + strcat(q+1, dirent->name); + if (smbc_stat(buf, &stat) < 0) + { + printf(" unknown size (reason %d: %s)", + errno, strerror(errno)); + } + else + { + printf(" size %lu", (unsigned long) stat.st_size); + } + *p = '\0'; + + break; + + case SMBC_LINK: + printf("LINK"); + break; + } + + printf("\n"); } - + smbc_closedir(dir); } - + exit(0); } - diff --git a/examples/libsmbclient/testchmod.c b/examples/libsmbclient/testchmod.c new file mode 100644 index 00000000000..774daaed596 --- /dev/null +++ b/examples/libsmbclient/testchmod.c @@ -0,0 +1,64 @@ +#include <stdio.h> +#include <unistd.h> +#include <string.h> +#include <time.h> +#include <libsmbclient.h> +#include "get_auth_data_fn.h" + + +int main(int argc, char * argv[]) +{ + int ret; + int debug = 0; + int mode = 0666; + char buffer[16384]; + char * pSmbPath = NULL; + struct stat st; + + if (argc == 1) + { + pSmbPath = "smb://RANDOM/Public/small"; + } + else if (argc == 2) + { + pSmbPath = argv[1]; + } + else if (argc == 3) + { + pSmbPath = argv[1]; + mode = (int) strtol(argv[2], NULL, 8); + } + else + { + printf("usage: " + "%s [ smb://path/to/file [ octal_mode ] ]\n", + argv[0]); + return 1; + } + + smbc_init(get_auth_data_fn, debug); + + if (smbc_stat(pSmbPath, &st) < 0) + { + perror("smbc_stat"); + return 1; + } + + printf("\nBefore chmod: mode = %04o\n", st.st_mode); + + if (smbc_chmod(pSmbPath, mode) < 0) + { + perror("smbc_chmod"); + return 1; + } + + if (smbc_stat(pSmbPath, &st) < 0) + { + perror("smbc_stat"); + return 1; + } + + printf("After chmod: mode = %04o\n", st.st_mode); + + return 0; +} diff --git a/examples/libsmbclient/testsmbc.c b/examples/libsmbclient/testsmbc.c index 888a9c0d4f9..45e67bee62c 100644 --- a/examples/libsmbclient/testsmbc.c +++ b/examples/libsmbclient/testsmbc.c @@ -27,40 +27,7 @@ #include <unistd.h> #include <stdlib.h> #include <libsmbclient.h> - -void auth_fn(const char *server, const char *share, - char *workgroup, int wgmaxlen, char *username, int unmaxlen, - char *password, int pwmaxlen) -{ - char temp[128]; - - fprintf(stdout, "Need password for //%s/%s\n", server, share); - - fprintf(stdout, "Enter workgroup: [%s] ", workgroup); - fgets(temp, sizeof(temp), stdin); - - if (temp[strlen(temp) - 1] == 0x0a) /* A new line? */ - temp[strlen(temp) - 1] = 0x00; - - if (temp[0]) strncpy(workgroup, temp, wgmaxlen - 1); - - fprintf(stdout, "Enter username: [%s] ", username); - fgets(temp, sizeof(temp), stdin); - - if (temp[strlen(temp) - 1] == 0x0a) /* A new line? */ - temp[strlen(temp) - 1] = 0x00; - - if (temp[0]) strncpy(username, temp, unmaxlen - 1); - - fprintf(stdout, "Enter password: [%s] ", password); - fgets(temp, sizeof(temp), stdin); - - if (temp[strlen(temp) - 1] == 0x0a) /* A new line? */ - temp[strlen(temp) - 1] = 0x00; - - if (temp[0]) strncpy(password, temp, pwmaxlen - 1); - -} +#include "get_auth_data_fn.h" int global_id = 0; @@ -84,7 +51,7 @@ int main(int argc, char *argv[]) char *dirp; struct stat st1, st2; - err = smbc_init(auth_fn, 10); /* Initialize things */ + err = smbc_init(get_auth_data_fn, 10); /* Initialize things */ if (err < 0) { @@ -132,7 +99,7 @@ int main(int argc, char *argv[]) ((struct smbc_dirent *)dirp)->comment); dirp += dsize; - (char *)dirc -= dsize; + dirc -= dsize; } diff --git a/examples/libsmbclient/teststat.c b/examples/libsmbclient/teststat.c new file mode 100644 index 00000000000..29517efb6f6 --- /dev/null +++ b/examples/libsmbclient/teststat.c @@ -0,0 +1,71 @@ +#include <stdio.h> +#include <unistd.h> +#include <string.h> +#include <time.h> +#include <libsmbclient.h> +#include "get_auth_data_fn.h" + + +int main(int argc, char * argv[]) +{ + int debug = 0; + char buffer[16384]; + char mtime[32]; + char ctime[32]; + char atime[32]; + char * pSmbPath = NULL; + char * pLocalPath = NULL; + struct stat st; + + if (argc == 1) + { + pSmbPath = "smb://RANDOM/Public/small"; + pLocalPath = "/random/home/samba/small"; + } + else if (argc == 2) + { + pSmbPath = argv[1]; + pLocalPath = NULL; + } + else if (argc == 3) + { + pSmbPath = argv[1]; + pLocalPath = argv[2]; + } + else + { + printf("usage: " + "%s [ smb://path/to/file [ /nfs/or/local/path/to/file ] ]\n", + argv[0]); + return 1; + } + + smbc_init(get_auth_data_fn, debug); + + if (smbc_stat(pSmbPath, &st) < 0) + { + perror("smbc_stat"); + return 1; + } + + printf("SAMBA\n mtime:%lu/%s ctime:%lu/%s atime:%lu/%s\n", + st.st_mtime, ctime_r(&st.st_mtime, mtime), + st.st_ctime, ctime_r(&st.st_ctime, ctime), + st.st_atime, ctime_r(&st.st_atime, atime)); + + if (pLocalPath != NULL) + { + if (stat(pLocalPath, &st) < 0) + { + perror("stat"); + return 1; + } + + printf("LOCAL\n mtime:%lu/%s ctime:%lu/%s atime:%lu/%s\n", + st.st_mtime, ctime_r(&st.st_mtime, mtime), + st.st_ctime, ctime_r(&st.st_ctime, ctime), + st.st_atime, ctime_r(&st.st_atime, atime)); + } + + return 0; +} diff --git a/examples/libsmbclient/testutime.c b/examples/libsmbclient/testutime.c new file mode 100644 index 00000000000..3a1540c6542 --- /dev/null +++ b/examples/libsmbclient/testutime.c @@ -0,0 +1,76 @@ +#include <stdio.h> +#include <unistd.h> +#include <string.h> +#include <time.h> +#include <libsmbclient.h> +#include "get_auth_data_fn.h" + + +int main(int argc, char * argv[]) +{ + int ret; + int debug = 0; + int mode = 0666; + char buffer[16384]; + char mtime[32]; + char ctime[32]; + char atime[32]; + char * pSmbPath = NULL; + struct stat st; + struct utimbuf utimbuf; + + if (argc == 1) + { + pSmbPath = "smb://RANDOM/Public/small"; + } + else if (argc == 2) + { + pSmbPath = argv[1]; + } + else if (argc == 3) + { + pSmbPath = argv[1]; + mode = (int) strtol(argv[2], NULL, 8); + } + else + { + printf("usage: " + "%s [ smb://path/to/file [ octal_mode ] ]\n", + argv[0]); + return 1; + } + + smbc_init(get_auth_data_fn, debug); + + if (smbc_stat(pSmbPath, &st) < 0) + { + perror("smbc_stat"); + return 1; + } + + printf("Before\n mtime:%lu/%s ctime:%lu/%s atime:%lu/%s\n", + st.st_mtime, ctime_r(&st.st_mtime, mtime), + st.st_ctime, ctime_r(&st.st_ctime, ctime), + st.st_atime, ctime_r(&st.st_atime, atime)); + + utimbuf.actime = st.st_atime - 120; /* unchangable. this one wont change */ + utimbuf.modtime = st.st_mtime - 120; /* this one should succeed */ + if (smbc_utime(pSmbPath, &utimbuf) < 0) + { + perror("smbc_utime"); + return 1; + } + + if (smbc_stat(pSmbPath, &st) < 0) + { + perror("smbc_stat"); + return 1; + } + + printf("After\n mtime:%lu/%s ctime:%lu/%s atime:%lu/%s\n", + st.st_mtime, ctime_r(&st.st_mtime, mtime), + st.st_ctime, ctime_r(&st.st_ctime, ctime), + st.st_atime, ctime_r(&st.st_atime, atime)); + + return 0; +} diff --git a/examples/libsmbclient/tree.c b/examples/libsmbclient/tree.c index f50b3670cff..d8a69c8d4cc 100644 --- a/examples/libsmbclient/tree.c +++ b/examples/libsmbclient/tree.c @@ -294,7 +294,7 @@ static void cb_select_child (GtkWidget *root_tree, GtkWidget *child, gtk_clist_append(GTK_CLIST(clist), rowdata); - (char *)dirp += dirlen; + dirp = (struct smbc_dirent *) ((char *) dirp + dirlen); err -= dirlen; } @@ -429,7 +429,7 @@ static void cb_itemsignal( GtkWidget *item, } - (char *)dirp += dirlen; + dirp = (struct smbc_dirent *) ((char *) dirp + dirlen); err -= dirlen; } @@ -564,7 +564,7 @@ static void cb_wholenet(GtkWidget *item, gchar *signame) gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child", GTK_SIGNAL_FUNC(cb_unselect_child), real_tree); - (char *)dirp += dirlen; + dirp = (struct smbc_dirent *) ((char *) dirp + dirlen); err -= dirlen; } @@ -797,7 +797,7 @@ int main( int argc, gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child", GTK_SIGNAL_FUNC(cb_unselect_child), tree); - (char *)dirp += dirlen; + dirp = (struct smbc_dirent *) ((char *) dirp + dirlen); err -= dirlen; } |