diff options
| -rw-r--r-- | source4/client/cifsdd.c | 599 | ||||
| -rw-r--r-- | source4/client/cifsdd.h | 99 | ||||
| -rw-r--r-- | source4/client/cifsddio.c | 456 | ||||
| -rw-r--r-- | source4/client/config.mk | 17 | ||||
| -rw-r--r-- | source4/lib/util_str.c | 71 | ||||
| -rw-r--r-- | source4/libcli/cliconnect.c | 34 | ||||
| -rwxr-xr-x | source4/script/tests/test_cifsdd.sh | 84 | ||||
| -rwxr-xr-x | source4/script/tests/tests_all.sh | 1 | ||||
| -rwxr-xr-x | source4/script/tests/tests_client.sh | 2 |
9 files changed, 1356 insertions, 7 deletions
diff --git a/source4/client/cifsdd.c b/source4/client/cifsdd.c new file mode 100644 index 0000000000..cf3ab17308 --- /dev/null +++ b/source4/client/cifsdd.c @@ -0,0 +1,599 @@ +/* + CIFSDD - dd for SMB. + Main program, argument handling and block copying. + + Copyright (C) James Peach 2005-2006 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "auth/gensec/gensec.h" +#include "lib/cmdline/popt_common.h" + +#include "cifsdd.h" + +const char * const PROGNAME = "cifsdd"; + +#define SYNTAX_EXIT_CODE 1 /* Invokation syntax or logic error. */ +#define EOM_EXIT_CODE 9 /* Out of memory error. */ +#define FILESYS_EXIT_CODE 10 /* File manipulation error. */ +#define IOERROR_EXIT_CODE 11 /* Error during IO phase. */ + +struct dd_stats_record dd_stats; + +static int dd_sigint; +static int dd_sigusr1; + +static void dd_handle_signal(int sig) +{ + switch (sig) + { + case SIGINT: + ++dd_sigint; + break; + case SIGUSR1: + ++dd_sigusr1; + break; + default: + break; + } +} + +/* ------------------------------------------------------------------------- */ +/* Argument handling. */ +/* ------------------------------------------------------------------------- */ + +static const char * argtype_str(enum argtype arg_type) +{ + static const struct { + enum argtype arg_type; + const char * arg_name; + } names [] = + { + { ARG_NUMERIC, "COUNT" }, + { ARG_SIZE, "SIZE" }, + { ARG_PATHNAME, "FILE" }, + { ARG_BOOL, "BOOLEAN" }, + }; + + int i; + + for (i = 0; i < ARRAY_SIZE(names); ++i) { + if (arg_type == names[i].arg_type) { + return(names[i].arg_name); + } + } + + return("<unknown>"); +} + +static struct argdef args[] = +{ + { "bs", ARG_SIZE, "force ibs and obs to SIZE bytes" }, + { "ibs", ARG_SIZE, "read SIZE bytes at a time" }, + { "obs", ARG_SIZE, "write SIZE bytes at a time" }, + + { "count", ARG_NUMERIC, "copy COUNT input blocks" }, + { "seek",ARG_NUMERIC, "skip COUNT blocks at start of output" }, + { "skip",ARG_NUMERIC, "skip COUNT blocks at start of input" }, + + { "if", ARG_PATHNAME, "read input from FILE" }, + { "of", ARG_PATHNAME, "write output to FILE" }, + + { "direct", ARG_BOOL, "use direct I/O if non-zero" }, + { "sync", ARG_BOOL, "use synchronous writes if non-zero" }, + { "oplock", ARG_BOOL, "take oplocks on the input and output files" }, + +/* FIXME: We should support using iflags and oflags for setting oplock and I/O + * options. This would make us compatible with GNU dd. + */ +}; + +struct argdef * find_named_arg(const char * arg) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(args); ++i) { + if (strwicmp(arg, args[i].arg_name) == 0) { + return(&args[i]); + } + } + + return(NULL); +} + +int set_arg_argv(const char * argv) +{ + struct argdef * arg; + + char * name; + char * val; + + if ((name = strdup(argv)) == NULL) { + return(0); + } + + if ((val = strchr(name, '=')) == NULL) { + fprintf(stderr, "%s: malformed argument \"%s\"\n", + PROGNAME, argv); + goto fail; + } + + *val = '\0'; + val++; + + if ((arg = find_named_arg(name)) == NULL) { + fprintf(stderr, "%s: ignoring unknown argument \"%s\"\n", + PROGNAME, name); + goto fail; + } + + /* Found a matching name; convert the variable argument. */ + switch (arg->arg_type) { + case ARG_NUMERIC: + if (!conv_str_u64(val, &arg->arg_val.nval)) { + goto fail; + } + break; + case ARG_SIZE: + if (!conv_str_size(val, &arg->arg_val.nval)) { + goto fail; + } + break; + case ARG_BOOL: + if (!conv_str_bool(val, &arg->arg_val.bval)) { + goto fail; + } + break; + case ARG_PATHNAME: + if (!(arg->arg_val.pval = strdup(val))) { + goto fail; + } + break; + default: + fprintf(stderr, "%s: argument \"%s\" is of " + "unknown type\n", PROGNAME, name); + goto fail; + } + + free(name); + return(1); + +fail: + free(name); + return(0); +} + +void set_arg_val(const char * name, ...) +{ + va_list ap; + struct argdef * arg; + + va_start(ap, name); + if ((arg = find_named_arg(name)) == NULL) { + goto fail; + } + + /* Found a matching name; convert the variable argument. */ + switch (arg->arg_type) { + case ARG_NUMERIC: + case ARG_SIZE: + arg->arg_val.nval = va_arg(ap, uint64_t); + break; + case ARG_BOOL: + arg->arg_val.bval = va_arg(ap, BOOL); + break; + case ARG_PATHNAME: + arg->arg_val.pval = va_arg(ap, char *); + if (arg->arg_val.pval) { + arg->arg_val.pval = strdup(arg->arg_val.pval); + } + break; + default: + fprintf(stderr, "%s: argument \"%s\" is of " + "unknown type\n", PROGNAME, name); + goto fail; + } + + va_end(ap); + return; + +fail: + fprintf(stderr, "%s: ignoring unknown argument \"%s\"\n", + PROGNAME, name); + va_end(ap); + return; +} + +BOOL check_arg_bool(const char * name) +{ + struct argdef * arg; + + if ((arg = find_named_arg(name)) && + (arg->arg_type == ARG_BOOL)) { + return(arg->arg_val.bval); + } + + DEBUG(0, ("invalid argument name: %s", name)); + SMB_ASSERT(0); + return(False); +} + +uint64_t check_arg_numeric(const char * name) +{ + struct argdef * arg; + + if ((arg = find_named_arg(name)) && + (arg->arg_type == ARG_NUMERIC || arg->arg_type == ARG_SIZE)) { + return(arg->arg_val.nval); + } + + DEBUG(0, ("invalid argument name: %s", name)); + SMB_ASSERT(0); + return(-1); +} + +const char * check_arg_pathname(const char * name) +{ + struct argdef * arg; + + if ((arg = find_named_arg(name)) && + (arg->arg_type == ARG_PATHNAME)) { + return(arg->arg_val.pval); + } + + DEBUG(0, ("invalid argument name: %s", name)); + SMB_ASSERT(0); + return(NULL); +} + +static void dump_args(void) +{ + int i; + + DEBUG(10, ("dumping argument values:\n")); + for (i = 0; i < ARRAY_SIZE(args); ++i) { + switch (args[i].arg_type) { + case ARG_NUMERIC: + case ARG_SIZE: + DEBUG(10, ("\t%s=%llu\n", args[i].arg_name, + (unsigned long long)args[i].arg_val.nval)); + break; + case ARG_BOOL: + DEBUG(10, ("\t%s=%s\n", args[i].arg_name, + args[i].arg_val.bval ? "yes" : "no")); + break; + case ARG_PATHNAME: + DEBUG(10, ("\t%s=%s\n", args[i].arg_name, + args[i].arg_val.pval ? + args[i].arg_val.pval : + "(NULL)")); + break; + default: + SMB_ASSERT(0); + } + } +} + +static void cifsdd_help_message(poptContext pctx, + enum poptCallbackReason preason, + struct poptOption * poption, + const char * parg, + void * pdata) +{ + static const char const notes[] = +"FILE can be a local filename or a UNC path of the form //server/share/path.\n"; + + char prefix[24]; + int i; + + if (poption->shortName != '?') { + poptPrintUsage(pctx, stdout, 0); + fprintf(stdout, " [dd options]\n"); + exit(0); + } + + poptPrintHelp(pctx, stdout, 0); + fprintf(stdout, "\nCIFS dd options:\n"); + + for (i = 0; i < ARRAY_SIZE(args); ++i) { + if (args[i].arg_name == NULL) { + break; + } + + snprintf(prefix, sizeof(prefix), "%s=%-*s", + args[i].arg_name, + (int)(sizeof(prefix) - strlen(args[i].arg_name) - 2), + argtype_str(args[i].arg_type)); + prefix[sizeof(prefix) - 1] = '\0'; + fprintf(stdout, " %s%s\n", prefix, args[i].arg_help); + } + + fprintf(stdout, "\n%s\n", notes); + exit(0); +} + +/* ------------------------------------------------------------------------- */ +/* Main block copying routine. */ +/* ------------------------------------------------------------------------- */ + +static void print_transfer_stats(void) +{ + if (DEBUGLEVEL > 0) { + printf("%llu+%llu records in (%llu bytes)\n" + "%llu+%llu records out (%llu bytes)\n", + (unsigned long long)dd_stats.in.fblocks, + (unsigned long long)dd_stats.in.pblocks, + (unsigned long long)dd_stats.in.bytes, + (unsigned long long)dd_stats.out.fblocks, + (unsigned long long)dd_stats.out.pblocks, + (unsigned long long)dd_stats.out.bytes); + } else { + printf("%llu+%llu records in\n%llu+%llu records out\n", + (unsigned long long)dd_stats.in.fblocks, + (unsigned long long)dd_stats.in.pblocks, + (unsigned long long)dd_stats.out.fblocks, + (unsigned long long)dd_stats.out.pblocks); + } +} + +static struct dd_iohandle * open_file(const char * which) +{ + int options = 0; + const char * path = NULL; + struct dd_iohandle * handle = NULL; + + if (check_arg_bool("direct")) { + options |= DD_DIRECT_IO; + } + + if (check_arg_bool("sync")) { + options |= DD_SYNC_IO; + } + + if (check_arg_bool("oplock")) { + options |= DD_OPLOCK; + } + + if (strcmp(which, "if") == 0) { + path = check_arg_pathname("if"); + handle = dd_open_path(path, check_arg_numeric("ibs"), + options); + } else if (strcmp(which, "of") == 0) { + options |= DD_WRITE; + path = check_arg_pathname("of"); + handle = dd_open_path(path, check_arg_numeric("obs"), + options); + } else { + SMB_ASSERT(0); + return(NULL); + } + + if (!handle) { + fprintf(stderr, "%s: failed to open %s\n", PROGNAME, path); + } + + return(handle); +} + +static void set_max_xmit(uint64_t iomax) +{ + char buf[64]; + + snprintf(buf, sizeof(buf), "%llu", (unsigned long long)iomax); + lp_set_cmdline("max xmit", buf); +} + +static int copy_files(void) +{ + uint8_t * iobuf; /* IO buffer. */ + uint64_t iomax; /* Size of the IO buffer. */ + uint64_t iosz; /* Amount of data in the IO buffer. */ + + uint64_t ibs; + uint64_t obs; + uint64_t count; + + struct dd_iohandle * ifile; + struct dd_iohandle * ofile; + + ibs = check_arg_numeric("ibs"); + obs = check_arg_numeric("obs"); + count = check_arg_numeric("count"); + + /* Allocate IO buffer. We need more than the max IO size because we + * could accumulate a remainder if ibs and obs don't match. + */ + iomax = 2 * MAX(ibs, obs); + if ((iobuf = malloc(iomax)) == NULL) { + fprintf(stderr, + "%s: failed to allocate IO buffer of %llu bytes\n", + PROGNAME, (unsigned long long)iomax); + return(EOM_EXIT_CODE); + } + + set_max_xmit(MAX(ibs, obs)); + + DEBUG(4, ("IO buffer size is %llu, max xmit is %d\n", + (unsigned long long)iomax, lp_max_xmit())); + + if (!(ifile = open_file("if"))) { + return(FILESYS_EXIT_CODE); + } + + if (!(ofile = open_file("of"))) { + return(FILESYS_EXIT_CODE); + } + + /* Seek the files to their respective starting points. */ + ifile->io_seek(ifile, check_arg_numeric("skip") * ibs); + ofile->io_seek(ofile, check_arg_numeric("seek") * obs); + + DEBUG(4, ("max xmit was negotiated to be %d\n", lp_max_xmit())); + + for (iosz = 0;;) { + + /* Handle signals. We are somewhat compatible with GNU dd. + * SIGINT makes us stop, but still print transfer statistics. + * SIGUSR1 makes us print transfer statistics but we continue + * copying. + */ + if (dd_sigint) { + break; + } + + if (dd_sigusr1) { + print_transfer_stats(); + dd_sigusr1 = 0; + } + + if (ifile->io_flags & DD_END_OF_FILE) { + DEBUG(4, ("flushing %llu bytes at EOF\n", (unsigned long long)iosz)); + while (iosz > 0) { + if (!dd_flush_block(ofile, iobuf, + &iosz, obs)) { + return(IOERROR_EXIT_CODE); + } + } + goto done; + } + + /* Try and read enough blocks of ibs bytes to be able write + * out one of obs bytes. + */ + if (!dd_fill_block(ifile, iobuf, &iosz, obs, ibs)) { + return(IOERROR_EXIT_CODE); + } + + if (iosz == 0) { + /* Done. */ + SMB_ASSERT(ifile->io_flags & DD_END_OF_FILE); + } + + /* Stop reading when we hit the block count. */ + if (dd_stats.in.bytes >= (ibs * count)) { + ifile->io_flags |= DD_END_OF_FILE; + } + + /* If we wanted to be a legitimate dd, we would do character + * conversions and other shenanigans here. + */ + + /* Flush what we read in units of obs bytes. We want to have + * at least obs bytes in the IO buffer but might not if the + * file is too small. + */ + if (!dd_flush_block(ofile, iobuf, &iosz, obs)) { + return(IOERROR_EXIT_CODE); + } + } + +done: + print_transfer_stats(); + return(0); +} + +/* ------------------------------------------------------------------------- */ +/* Main. */ +/* ------------------------------------------------------------------------- */ + +struct poptOption cifsddHelpOptions[] = { + { NULL, '\0', POPT_ARG_CALLBACK, (void *)&cifsdd_help_message, '\0', NULL, NULL }, + { "help", '?', 0, NULL, '?', "Show this help message", NULL }, + { "usage", '\0', 0, NULL, 'u', "Display brief usage message", NULL }, + POPT_TABLEEND +} ; + +int main(int argc, const char ** argv) +{ + int i; + const char ** dd_args; + + poptContext pctx; + struct poptOption poptions[] = { + /* POPT_AUTOHELP */ + { NULL, '\0', POPT_ARG_INCLUDE_TABLE, cifsddHelpOptions, + 0, "Help options:", NULL }, + POPT_COMMON_SAMBA + POPT_COMMON_CONNECTION + POPT_COMMON_CREDENTIALS + POPT_COMMON_VERSION + POPT_TABLEEND + }; + + /* Block sizes. */ + set_arg_val("bs", (uint64_t)4096); + set_arg_val("ibs", (uint64_t)4096); + set_arg_val("obs", (uint64_t)4096); + /* Block counts. */ + set_arg_val("count", (uint64_t)-1); + set_arg_val("seek", (uint64_t)0); + set_arg_val("seek", (uint64_t)0); + /* Files. */ + set_arg_val("if", NULL); + set_arg_val("of", NULL); + /* Options. */ + set_arg_val("direct", False); + set_arg_val("sync", False); + set_arg_val("oplock", False); + + pctx = poptGetContext(PROGNAME, argc, argv, poptions, 0); + while ((i = poptGetNextOpt(pctx)) != -1) { + ; + } + + for (dd_args = poptGetArgs(pctx); dd_args && *dd_args; ++dd_args) { + + if (!set_arg_argv(*dd_args)) { + fprintf(stderr, "%s: invalid option: %s\n", + PROGNAME, *dd_args); + exit(SYNTAX_EXIT_CODE); + } + + /* "bs" has the side-effect of setting "ibs" and "obs". */ + if (strncmp(*dd_args, "bs=", 3) == 0) { + uint64_t bs = check_arg_numeric("bs"); + set_arg_val("ibs", bs); + set_arg_val("obs", bs); + } + } + + gensec_init(); + dump_args(); + + if (check_arg_numeric("ibs") == 0 || check_arg_numeric("ibs") == 0) { + fprintf(stderr, "%s: block sizes must be greater that zero\n", + PROGNAME); + exit(SYNTAX_EXIT_CODE); + } + + if (check_arg_pathname("if") == NULL) { + fprintf(stderr, "%s: missing input filename\n", PROGNAME); + exit(SYNTAX_EXIT_CODE); + } + + if (check_arg_pathname("of") == NULL) { + fprintf(stderr, "%s: missing output filename\n", PROGNAME); + exit(SYNTAX_EXIT_CODE); + } + + CatchSignal(SIGINT, dd_handle_signal); + CatchSignal(SIGUSR1, dd_handle_signal); + return(copy_files()); +} + +/* vim: set sw=8 sts=8 ts=8 tw=79 : */ diff --git a/source4/client/cifsdd.h b/source4/client/cifsdd.h new file mode 100644 index 0000000000..28d31010ba --- /dev/null +++ b/source4/client/cifsdd.h @@ -0,0 +1,99 @@ +/* + CIFSDD - dd for SMB. + Declarations and administrivia. + + Copyright (C) James Peach 2005-2006 + + 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. +*/ + +extern const char * const PROGNAME; + +enum argtype +{ + ARG_NUMERIC, + ARG_SIZE, + ARG_PATHNAME, + ARG_BOOL, +}; + +struct argdef +{ + const char * arg_name; + enum argtype arg_type; + const char * arg_help; + + union + { + BOOL bval; + uint64_t nval; + const char * pval; + } arg_val; +}; + +int set_arg_argv(const char * argv); +void set_arg_val(const char * name, ...); + +BOOL check_arg_bool(const char * name); +uint64_t check_arg_numeric(const char * name); +const char * check_arg_pathname(const char * name); + +typedef BOOL (*dd_seek_func)(void * handle, uint64_t offset); +typedef BOOL (*dd_read_func)(void * handle, uint8_t * buf, + uint64_t wanted, uint64_t * actual); +typedef BOOL (*dd_write_func)(void * handle, uint8_t * buf, + uint64_t wanted, uint64_t * actual); + +struct dd_stats_record +{ + struct + { + uint64_t fblocks; /* Full blocks. */ + uint64_t pblocks; /* Partial blocks. */ + uint64_t bytes; /* Total bytes read. */ + } in; + struct + { + uint64_t fblocks; /* Full blocks. */ + uint64_t pblocks; /* Partial blocks. */ + uint64_t bytes; /* Total bytes written. */ + } out; +}; + +extern struct dd_stats_record dd_stats; + +struct dd_iohandle +{ + dd_seek_func io_seek; + dd_read_func io_read; + dd_write_func io_write; + int io_flags; +}; + +#define DD_END_OF_FILE 0x10000000 + +#define DD_DIRECT_IO 0x00000001 +#define DD_SYNC_IO 0x00000002 +#define DD_WRITE 0x00000004 +#define DD_OPLOCK 0x00000008 + +struct dd_iohandle * dd_open_path(const char * path, + uint64_t iosz, int options); +BOOL dd_fill_block(struct dd_iohandle * h, uint8_t * buf, + uint64_t * bufsz, uint64_t needsz, uint64_t blocksz); +BOOL dd_flush_block(struct dd_iohandle * h, uint8_t * buf, + uint64_t * bufsz, uint64_t blocksz); + +/* vim: set sw=8 sts=8 ts=8 tw=79 : */ diff --git a/source4/client/cifsddio.c b/source4/client/cifsddio.c new file mode 100644 index 0000000000..51528406bf --- /dev/null +++ b/source4/client/cifsddio.c @@ -0,0 +1,456 @@ +/* + CIFSDD - dd for SMB. + IO routines, generic and specific. + + Copyright (C) James Peach 2005-2006 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "libcli/raw/libcliraw.h" +#include "libcli/libcli.h" +#include "lib/cmdline/popt_common.h" + +#include "cifsdd.h" + +/* ------------------------------------------------------------------------- */ +/* UNIX file descriptor IO. */ +/* ------------------------------------------------------------------------- */ + +struct fd_handle +{ + struct dd_iohandle h; + int fd; +}; + +#define IO_HANDLE_TO_FD(h) (((struct fd_handle *)(h))->fd) + +static BOOL fd_seek_func(void * handle, uint64_t offset) +{ + ssize_t ret; + + ret = lseek(IO_HANDLE_TO_FD(handle), offset, SEEK_SET); + if (ret < 0) { + fprintf(stderr, "%s: seek failed: %s\n", + PROGNAME, strerror(errno)); + return(False); + } + + return(True); +} + +static BOOL fd_read_func(void * handle, uint8_t * buf, uint64_t wanted, uint64_t * actual) +{ + ssize_t ret; + + ret = read(IO_HANDLE_TO_FD(handle), buf, wanted); + if (ret < 0) { + fprintf(stderr, "%s: %llu byte read failed: %s\n", + PROGNAME, (unsigned long long)wanted, strerror(errno)); + return(False); + } + + *actual = (uint64_t)ret; + return(True); +} + +static BOOL +fd_write_func(void * handle, uint8_t * buf, uint64_t wanted, uint64_t * actual) +{ + ssize_t ret; + + ret = write(IO_HANDLE_TO_FD(handle), buf, wanted); + if (ret < 0) { + fprintf(stderr, "%s: %llu byte write failed: %s\n", + PROGNAME, (unsigned long long)wanted, strerror(errno)); + return(False); + } + + *actual = (uint64_t)ret; + return(True); +} + +static struct dd_iohandle * +open_fd_handle(const char * path, uint64_t iosz, int options) +{ + struct fd_handle * fdh; + int oflags = 0; + + DEBUG(4, ("opening fd stream for %s\n", path)); + if ((fdh = talloc_zero(NULL, struct fd_handle)) == NULL) { + return(NULL); + } + + fdh->h.io_read = fd_read_func; + fdh->h.io_write = fd_write_func; + fdh->h.io_seek = fd_seek_func; + + if (options & DD_DIRECT_IO) + oflags |= O_DIRECT; + + if (options & DD_SYNC_IO) + oflags |= O_SYNC; + + oflags |= (options & DD_WRITE) ? (O_WRONLY | O_CREAT) : (O_RDONLY); + + fdh->fd = open(path, oflags, 0644); + if (fdh->fd < 0) { + fprintf(stderr, "%s: %s: %s\n", + PROGNAME, path, strerror(errno)); + talloc_free(fdh); + return(NULL); + } + + if (options & DD_OPLOCK) { + DEBUG(2, ("FIXME: take local oplock on %s\n", path)); + } + + SMB_ASSERT((void *)fdh == (void *)&fdh->h); + return(&fdh->h); +} + +/* ------------------------------------------------------------------------- */ +/* CIFS client IO. */ +/* ------------------------------------------------------------------------- */ + +struct smb_handle +{ + struct dd_iohandle h; + struct smbcli_state * cli; + int fnum; + uint64_t offset; +}; + +#define IO_HANDLE_TO_SMB(h) ((struct smb_handle *)(h)) + +BOOL smb_seek_func(void * handle, uint64_t offset) +{ + IO_HANDLE_TO_SMB(handle)->offset = offset; + return(True); +} + +BOOL smb_read_func(void * handle, uint8_t * buf, + uint64_t wanted, uint64_t * actual) +{ + NTSTATUS ret; + union smb_read r; + struct smb_handle * smbh; + + ZERO_STRUCT(r); + smbh = IO_HANDLE_TO_SMB(handle); + + r.generic.level = RAW_READ_READX; + r.readx.in.fnum = smbh->fnum; + r.readx.in.offset = smbh->offset; + r.readx.in.mincnt = wanted; + r.readx.in.maxcnt = wanted; + r.readx.out.data = buf; + + /* FIXME: Should I really set readx.in.remaining? That just seems + * redundant. + */ + ret = smb_raw_read(smbh->cli->tree, &r); + if (!NT_STATUS_IS_OK(ret)) { + fprintf(stderr, "%s: %llu byte read failed: %s\n", + PROGNAME, (unsigned long long)wanted, nt_errstr(ret)); + return(False); + } + + /* Trap integer wrap. */ + SMB_ASSERT((smbh->offset + r.readx.out.nread) >= smbh->offset); + + *actual = r.readx.out.nread; + smbh->offset += r.readx.out.nread; + return(True); +} + +BOOL smb_write_func(void * handle, uint8_t * buf, + uint64_t wanted, uint64_t * actual) +{ + NTSTATUS ret; + union smb_write w; + struct smb_handle * smbh; + + ZERO_STRUCT(w); + smbh = IO_HANDLE_TO_SMB(handle); + + w.generic.level = RAW_WRITE_WRITEX; + w.writex.in.fnum = smbh->fnum; + w.writex.in.offset = smbh->offset; + w.writex.in.count = wanted; + w.writex.in.data = buf; + + ret = smb_raw_write(smbh->cli->tree, &w); + if (!NT_STATUS_IS_OK(ret)) { + fprintf(stderr, "%s: %llu byte write failed: %s\n", + PROGNAME, (unsigned long long)wanted, nt_errstr(ret)); + return(False); + } + + *actual = w.writex.out.nwritten; + smbh->offset += w.writex.out.nwritten; + return(True); +} + +static struct smbcli_state * init_smb_session(const char * host, const char * share) +{ + NTSTATUS ret; + struct smbcli_state * cli = NULL; + + /* When we support SMB URLs, we can get different user credentials for + * each connection, but for now, we just use the same one for both. + */ + ret = smbcli_full_connection(NULL, &cli, host, share, + NULL /* devtype */, cmdline_credentials, NULL /* events */); + + if (!NT_STATUS_IS_OK(ret)) { + fprintf(stderr, "%s: connecting to //%s/%s: %s\n", + PROGNAME, host, share, nt_errstr(ret)); + return(NULL); + } + + return(cli); +} + +static int open_smb_file(struct smbcli_state * cli, const char * path, int options) +{ + NTSTATUS ret; + union smb_open o; + + ZERO_STRUCT(o); + + o.ntcreatex.level = RAW_OPEN_NTCREATEX; + o.ntcreatex.in.fname = path; + + /* TODO: It's not clear whether to use these flags or to use the + * similarly named NTCREATEX flags in the create_options field. + */ + if (options & DD_DIRECT_IO) + o.ntcreatex.in.flags |= FILE_FLAG_NO_BUFFERING; + + if (options & DD_SYNC_IO) + o.ntcreatex.in.flags |= FILE_FLAG_WRITE_THROUGH; + + o.ntcreatex.in.access_mask |= + (options & DD_WRITE) ? SEC_FILE_WRITE_DATA + : SEC_FILE_READ_DATA; + + /* Try to create the file only if we will be writing to it. */ + o.ntcreatex.in.open_disposition = + (options & DD_WRITE) ? NTCREATEX_DISP_OPEN_IF + : NTCREATEX_DISP_OPEN; + + o.ntcreatex.in.share_access = + NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE; + + if (options & DD_OPLOCK) { + o.ntcreatex.in.flags |= NTCREATEX_FLAGS_REQUEST_OPLOCK; + } + + ret = smb_raw_open(cli->tree, NULL, &o); + if (!NT_STATUS_IS_OK(ret)) { + fprintf(stderr, "%s: opening %s: %s\n", + PROGNAME, path, nt_errstr(ret)); + return(-1); + } + + return(o.ntcreatex.out.fnum); +} + +static struct dd_iohandle * open_smb_handle(const char * host, const char * share, + const char * path, uint64_t iosz, int options) +{ + struct smb_handle * smbh; + + DEBUG(4, ("opening SMB stream to //%s/%s for %s\n", + host, share, path)); + + if ((smbh = talloc_zero(NULL, struct smb_handle)) == NULL) { + return(NULL); + } + + smbh->h.io_read = smb_read_func; + smbh->h.io_write = smb_write_func; + smbh->h.io_seek = smb_seek_func; + + if ((smbh->cli = init_smb_session(host, share)) == NULL) { + return(NULL); + } + + DEBUG(4, ("connected to //%s/%s with xmit size of %u bytes\n", + host, share, smbh->cli->transport->negotiate.max_xmit)); + + smbh->fnum = open_smb_file(smbh->cli, path, options); + return(&smbh->h); +} + +/* ------------------------------------------------------------------------- */ +/* Abstract IO interface. */ +/* ------------------------------------------------------------------------- */ + +struct dd_iohandle * dd_open_path(const char * path, uint64_t iosz, int options) +{ + if (file_exist(path)) { + return(open_fd_handle(path, iosz, options)); + } else { + char * host; + char * share; + + if (smbcli_parse_unc(path, NULL, &host, &share)) { + const char * remain; + remain = strstr(path, share) + strlen(share); + + /* Skip over leading directory separators. */ + while (*remain == '/' || *remain == '\\') { remain++; } + + return(open_smb_handle(host, share, remain, + iosz, options)); + } + + return(open_fd_handle(path, iosz, options)); + } +} + +/* Fill the buffer till it has at least needsz bytes. Use read operations of + * blocksz bytes. Return the number of bytes read and fill bufsz with the new + * buffer size. + * + * NOTE: The IO buffer is guaranteed to be big enough to fit needsz + blocksz + * bytes into it. + */ +BOOL dd_fill_block(struct dd_iohandle * h, uint8_t * buf, + uint64_t * bufsz, uint64_t needsz, uint64_t blocksz) +{ + uint64_t readsz; + + SMB_ASSERT(blocksz > 0); + SMB_ASSERT(needsz > 0); + + while (*bufsz < needsz) { + + if (!h->io_read(h, buf + (*bufsz), blocksz, &readsz)) { + return(False); + } + + if (readsz == 0) { + h->io_flags |= DD_END_OF_FILE; + break; + } + + DEBUG(6, ("added %llu bytes to IO buffer (need %llu bytes)\n", + (unsigned long long)readsz, (unsigned long long)needsz)); + + *bufsz += readsz; + dd_stats.in.bytes += readsz; + + if (readsz == blocksz) { + dd_stats.in.fblocks++; + } else { + DEBUG(3, ("partial read of %llu bytes (expected %llu)\n", + (unsigned long long)readsz, (unsigned long long)blocksz)); + dd_stats.in.pblocks++; + } + } + + return(True); +} + +/* Flush a buffer that contains bufsz bytes. Use writes of blocksz to do it, + * and shift any remaining bytes back to the head of the buffer when there are + * no more blocksz sized IOs left. + */ +BOOL dd_flush_block(struct dd_iohandle * h, uint8_t * buf, + uint64_t * bufsz, uint64_t blocksz) +{ + uint64_t writesz; + uint64_t totalsz = 0; + + SMB_ASSERT(blocksz > 0); + + /* We have explicitly been asked to write a partial block. */ + if ((*bufsz) < blocksz) { + + if (!h->io_write(h, buf, *bufsz, &writesz)) { + return(False); + } + + if (writesz == 0) { + fprintf(stderr, "%s: unexpectedly wrote 0 bytes\n", + PROGNAME); + return(False); + } + + totalsz += writesz; + dd_stats.out.bytes += writesz; + dd_stats.out.pblocks++; + } + + /* Write as many full blocks as there are in the buffer. */ + while (((*bufsz) - totalsz) >= blocksz) { + + if (!h->io_write(h, buf + totalsz, blocksz, &writesz)) { + return(False); + } + + if (writesz == 0) { + fprintf(stderr, "%s: unexpectedly wrote 0 bytes\n", + PROGNAME); + return(False); + } + + if (writesz == blocksz) { + dd_stats.out.fblocks++; + } else { + dd_stats.out.pblocks++; + } + + totalsz += writesz; + dd_stats.out.bytes += writesz; + + DEBUG(6, ("flushed %llu bytes from IO buffer of %llu bytes (%llu remain)\n", + (unsigned long long)blocksz, (unsigned long long)blocksz, + (unsigned long long)(blocksz - totalsz))); + } + + SMB_ASSERT(totalsz > 0); + + /* We have flushed as much of the IO buffer as we can while + * still doing blocksz-sized operations. Shift any remaining data + * to the front of the IO buffer. + */ + if ((*bufsz) > totalsz) { + uint64_t remain = (*bufsz) - totalsz; + + DEBUG(3, ("shifting %llu remainder bytes to IO buffer head\n", + (unsigned long long)remain)); + + memmove(buf, buf + totalsz, remain); + (*bufsz) = remain; + } else if ((*bufsz) == totalsz) { + (*bufsz) = 0; + } else { + /* Else buffer contains bufsz bytes that we will append + * to next time round. + */ + DEBUG(3, ("%llu unflushed bytes left in IO buffer\n", + (unsigned long long)(*bufsz))); + } + + return(True); +} + +/* vim: set sw=8 sts=8 ts=8 tw=79 : */ diff --git a/source4/client/config.mk b/source4/client/config.mk index 2cf5dbb80a..10f56da138 100644 --- a/source4/client/config.mk +++ b/source4/client/config.mk @@ -18,3 +18,20 @@ REQUIRED_SUBSYSTEMS = \ POPT_CREDENTIALS # End BINARY smbclient ################################# + +################################# +# Start BINARY cifsdd +[BINARY::cifsdd] +INSTALLDIR = BINDIR +OBJ_FILES = \ + cifsdd.o \ + cifsddio.o +REQUIRED_SUBSYSTEMS = \ + CONFIG \ + LIBSMB \ + LIBPOPT \ + POPT_SAMBA \ + POPT_CREDENTIALS +# End BINARY sdd +################################# + diff --git a/source4/lib/util_str.c b/source4/lib/util_str.c index 311f81eaf3..6da0063c50 100644 --- a/source4/lib/util_str.c +++ b/source4/lib/util_str.c @@ -5,6 +5,7 @@ Copyright (C) Andrew Tridgell 1992-2001 Copyright (C) Simo Sorce 2001-2002 Copyright (C) Martin Pool 2003 + Copyright (C) James Peach 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 @@ -1136,3 +1137,73 @@ BOOL set_boolean(const char *boolean_string, BOOL *boolean) return False; } +BOOL conv_str_bool(const char * str, BOOL * val) +{ + char * end = NULL; + long lval; + + if (str == NULL || *str == '\0') { + return False; + } + + lval = strtol(str, &end, 10 /* base */); + if (end == NULL || *end != '\0' || end == str) { + return set_boolean(str, val); + } + + *val = (lval) ? True : False; + return True; +} + +/* Convert a size specification like 16K into an integral number of bytes. */ +BOOL conv_str_size(const char * str, uint64_t * val) +{ + char * end = NULL; + unsigned long long lval; + + if (str == NULL || *str == '\0') { + return False; + } + + lval = strtoull(str, &end, 10 /* base */); + if (end == NULL || end == str) { + return False; + } + + if (*end) { + if (strwicmp(end, "K") == 0) { + lval *= 1024ULL; + } else if (strwicmp(end, "M") == 0) { + lval *= (1024ULL * 1024ULL); + } else if (strwicmp(end, "G") == 0) { + lval *= (1024ULL * 1024ULL * 1024ULL); + } else if (strwicmp(end, "T") == 0) { + lval *= (1024ULL * 1024ULL * 1024ULL * 1024ULL); + } else if (strwicmp(end, "P") == 0) { + lval *= (1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL); + } else { + return False; + } + } + + *val = (uint64_t)lval; + return True; +} + +BOOL conv_str_u64(const char * str, uint64_t * val) +{ + char * end = NULL; + unsigned long long lval; + + if (str == NULL || *str == '\0') { + return False; + } + + lval = strtoull(str, &end, 10 /* base */); + if (end == NULL || *end != '\0' || end == str) { + return False; + } + + *val = (uint64_t)lval; + return True; +} diff --git a/source4/libcli/cliconnect.c b/source4/libcli/cliconnect.c index fe0ad9c9f5..9a5236a661 100644 --- a/source4/libcli/cliconnect.c +++ b/source4/libcli/cliconnect.c @@ -4,6 +4,7 @@ client connect/disconnect routines Copyright (C) Andrew Tridgell 2003-2005 + Copyright (C) James Peach 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 @@ -175,11 +176,33 @@ struct smbcli_state *smbcli_state_init(TALLOC_CTX *mem_ctx) return talloc_zero(mem_ctx, struct smbcli_state); } +/* Insert a NULL at the first separator of the given path and return a pointer + * to the location it was inserted at. + */ +static char * +terminate_path_at_separator(char * path) +{ + char * p; + + if ((p = strchr_m(path, '/'))) { + *p = '\0'; + return(p); + } + + if ((p = strchr_m(path, '\\'))) { + *p = '\0'; + return(p); + } + + /* No terminator. Return pointer to the last byte. */ + return(p + strlen(path)); +} + /* parse a //server/share type UNC name */ BOOL smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx, - const char **hostname, const char **sharename) + char **hostname, char **sharename) { char *p; @@ -189,13 +212,10 @@ BOOL smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx, } *hostname = talloc_strdup(mem_ctx, &unc_name[2]); - p = strchr_m(&(*hostname)[2],'/'); - if (!p) { - p = strchr_m(&(*hostname)[2],'\\'); - if (!p) return False; - } - *p = 0; + p = terminate_path_at_separator(*hostname); + *sharename = talloc_strdup(mem_ctx, p+1); + p = terminate_path_at_separator(*sharename); return True; } diff --git a/source4/script/tests/test_cifsdd.sh b/source4/script/tests/test_cifsdd.sh new file mode 100755 index 0000000000..9462187f9c --- /dev/null +++ b/source4/script/tests/test_cifsdd.sh @@ -0,0 +1,84 @@ +#!/bin/sh + +# Basic script to make sure that cifsdd can do both local and remote I/O. + +if [ $# -lt 4 ]; then +cat <<EOF +Usage: test_cifsdd.sh SERVER USERNAME PASSWORD DOMAIN +EOF +exit 1; +fi + +SERVER=$1 +USERNAME=$2 +PASSWORD=$3 +DOMAIN=$4 + +DD=bin/cifsdd + +SHARE=tmp +DEBUGLEVEL=4 + +failed=0 + +failtest() { + failed=`expr $failed + 1` +} + +runcopy() { + message="$1" + shift + + testit "$message" $DD --debuglevel=$DEBUGLEVEL -W "$DOMAIN" -U "$USERNAME"%"$PASSWORD" \ + "$@" +} + +compare() { + if [ -r $1 -a -r $2 ] ; then + sum1=`sum $1` + sum2=`sum $2` + + [[ x"$sum1" = x"$sum2" ]] + else + false + fi +} + +incdir=`dirname $0` +. $incdir/test_functions.sh + +sourcepath=tempfile.src.$$ +destpath=tempfile.dst.$$ + +# Create a source file with arbitrary contents +cp $DD $sourcepath + +for bs in 512 4k 48k ; do + +echo "Testing $bs block size ..." + +# Check whether we can do local IO +runcopy "Testing local -> local copy" if=$sourcepath of=$destpath bs=$bs || failtest +compare $sourcepath $destpath || failtest + +# Check whether we can do a round trip +runcopy "Testing local -> remote copy" \ + if=$sourcepath of=//$SERVER/$SHARE/$sourcepath bs=$bs || failtest +runcopy "Testing remote ->local copy" \ + if=//$SERVER/$SHARE/$sourcepath of=$destpath bs=$bs || failtest +compare $sourcepath $destpath || failtest + +# Check that copying within the remote server works +runcopy "Testing local -> remote copy" \ + if=//$SERVER/$SHARE/$sourcepath of=//$SERVER/$SHARE/$sourcepath bs=$bs || failtest +runcopy "Testing remote -> remote copy" \ + if=//$SERVER/$SHARE/$sourcepath of=//$SERVER/$SHARE/$destpath bs=$bs || failtest +runcopy "Testing remote ->local copy" \ + if=//$SERVER/$SHARE/$destpath of=$destpath bs=$bs || failtest +compare $sourcepath $destpath || failtest + +done + +rm -f $sourcepath $destpath + +testok $0 $failed diff --git a/source4/script/tests/tests_all.sh b/source4/script/tests/tests_all.sh index e940ec16c1..d5d20d8f92 100755 --- a/source4/script/tests/tests_all.sh +++ b/source4/script/tests/tests_all.sh @@ -10,3 +10,4 @@ $SRCDIR/script/tests/test_local.sh || failed=`expr $failed + $?` $SRCDIR/script/tests/test_pidl.sh || failed=`expr $failed + $?` $SRCDIR/script/tests/test_smbclient.sh $SERVER $USERNAME $PASSWORD $DOMAIN $PREFIX || failed=`expr $failed + $?` + $SRCDIR/script/tests/test_cifsdd.sh $SERVER $USERNAME $PASSWORD $DOMAIN || failed=`expr $failed + $?` diff --git a/source4/script/tests/tests_client.sh b/source4/script/tests/tests_client.sh new file mode 100755 index 0000000000..5a3c5eb79a --- /dev/null +++ b/source4/script/tests/tests_client.sh @@ -0,0 +1,2 @@ + $SRCDIR/script/tests/test_smbclient.sh $SERVER $USERNAME $PASSWORD $DOMAIN $PREFIX || failed=`expr $failed + $?` + $SRCDIR/script/tests/test_cifsdd.sh $SERVER $USERNAME $PASSWORD $DOMAIN || failed=`expr $failed + $?` |