From ffb63e4f8ec2b7390cbb00bca74a9bedb8399a91 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 19 Jun 2001 02:02:19 +0000 Subject: moved all our torture code to a separate directory (This used to be commit dd12c47645e2d0e832bc555492a6a8725a4495ee) --- source3/Makefile.in | 16 +- source3/torture/locktest.c | 567 ++++++++ source3/torture/locktest2.c | 626 +++++++++ source3/torture/masktest.c | 521 +++++++ source3/torture/msgtest.c | 96 ++ source3/torture/nbio.c | 240 ++++ source3/torture/rpctorture.c | 559 ++++++++ source3/torture/torture.c | 3053 ++++++++++++++++++++++++++++++++++++++++++ source3/utils/locktest.c | 567 -------- source3/utils/locktest2.c | 626 --------- source3/utils/masktest.c | 521 ------- source3/utils/msgtest.c | 96 -- source3/utils/nbio.c | 240 ---- source3/utils/rpctorture.c | 559 -------- 14 files changed, 5670 insertions(+), 2617 deletions(-) create mode 100644 source3/torture/locktest.c create mode 100644 source3/torture/locktest2.c create mode 100644 source3/torture/masktest.c create mode 100644 source3/torture/msgtest.c create mode 100644 source3/torture/nbio.c create mode 100644 source3/torture/rpctorture.c create mode 100644 source3/torture/torture.c delete mode 100644 source3/utils/locktest.c delete mode 100644 source3/utils/locktest2.c delete mode 100644 source3/utils/masktest.c delete mode 100644 source3/utils/msgtest.c delete mode 100644 source3/utils/nbio.c delete mode 100644 source3/utils/rpctorture.c (limited to 'source3') diff --git a/source3/Makefile.in b/source3/Makefile.in index 5d51f808ef..c0ef71af81 100644 --- a/source3/Makefile.in +++ b/source3/Makefile.in @@ -298,28 +298,28 @@ UMOUNT_OBJ = client/smbumount.o \ NMBLOOKUP_OBJ = utils/nmblookup.o $(PARAM_OBJ) $(UBIQX_OBJ) \ $(LIBSMB_OBJ) $(LIB_OBJ) -SMBTORTURE_OBJ = utils/torture.o utils/nbio.o $(LIBSMB_OBJ) $(PARAM_OBJ) \ +SMBTORTURE_OBJ = torture/torture.o torture/nbio.o $(LIBSMB_OBJ) $(PARAM_OBJ) \ $(UBIQX_OBJ) $(LIB_OBJ) -MASKTEST_OBJ = utils/masktest.o $(LIBSMB_OBJ) $(PARAM_OBJ) \ +MASKTEST_OBJ = torture/masktest.o $(LIBSMB_OBJ) $(PARAM_OBJ) \ $(UBIQX_OBJ) $(LIB_OBJ) -MSGTEST_OBJ = utils/msgtest.o $(LIBSMB_OBJ) $(PARAM_OBJ) \ +MSGTEST_OBJ = torture/msgtest.o $(LIBSMB_OBJ) $(PARAM_OBJ) \ $(UBIQX_OBJ) $(LIB_OBJ) -LOCKTEST_OBJ = utils/locktest.o $(LOCKING_OBJ) $(LIBSMB_OBJ) $(PARAM_OBJ) \ +LOCKTEST_OBJ = torture/locktest.o $(LOCKING_OBJ) $(LIBSMB_OBJ) $(PARAM_OBJ) \ $(UBIQX_OBJ) $(LIB_OBJ) +LOCKTEST2_OBJ = torture/locktest2.o $(LOCKING_OBJ) $(LIBSMB_OBJ) $(PARAM_OBJ) \ + $(UBIQX_OBJ) $(LIB_OBJ) + SMBCACLS_OBJ = utils/smbcacls.o $(LOCKING_OBJ) $(LIBSMB_OBJ) $(PARAM_OBJ) \ $(UBIQX_OBJ) $(LIB_OBJ) $(RPC_PARSE_OBJ) $(PASSDB_OBJ) \ $(LIBMSRPC_OBJ) $(GROUPDB_OBJ) -LOCKTEST2_OBJ = utils/locktest2.o $(LOCKING_OBJ) $(LIBSMB_OBJ) $(PARAM_OBJ) \ - $(UBIQX_OBJ) $(LIB_OBJ) - -RPCTORTURE_OBJ = utils/rpctorture.o \ +RPCTORTURE_OBJ = torture/rpctorture.o \ rpcclient/display.o \ rpcclient/cmd_lsarpc.o \ rpcclient/cmd_wkssvc.o \ diff --git a/source3/torture/locktest.c b/source3/torture/locktest.c new file mode 100644 index 0000000000..80dbba1e37 --- /dev/null +++ b/source3/torture/locktest.c @@ -0,0 +1,567 @@ +/* + Unix SMB/Netbios implementation. + Version 2.0 + randomised byte range lock tester + Copyright (C) Andrew Tridgell 1999 + + 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. +*/ + +#define NO_SYSLOG + +#include "includes.h" + +static fstring password; +static fstring username; +static int got_pass; +static int numops = 1000; +static BOOL showall; +static BOOL analyze; +static BOOL hide_unlock_fails; +static BOOL use_oplocks; + +#define FILENAME "\\locktest.dat" +#define LOCKRANGE 1000 +#define LOCKBASE 0; + +/* +#define LOCKBASE (0x40000000 - 50) +*/ + +#define READ_PCT 50 +#define LOCK_PCT 35 +#define UNLOCK_PCT 55 +#define RANGE_MULTIPLE 1 +#define NSERVERS 2 +#define NCONNECTIONS 2 +#define NFILES 2 +#define LOCK_TIMEOUT 0 + +#define NASTY_POSIX_LOCK_HACK 0 + + +struct record { + char r1, r2; + char conn, f; + SMB_BIG_UINT start, len; + char needed; +}; + +static struct record preset[] = { +#if 0 +{36, 5, 0, 0, 0, 8, 1}, +{ 2, 6, 0, 1, 0, 1, 1}, +{53, 92, 0, 0, 0, 0, 1}, +{99, 11, 0, 0, 7, 1, 1}, +#endif +}; + +static struct record *recorded; + +static void print_brl(SMB_DEV_T dev, SMB_INO_T ino, int pid, + enum brl_type lock_type, + br_off start, br_off size) +{ +#if NASTY_POSIX_LOCK_HACK + { + pstring cmd; + static SMB_INO_T lastino; + + if (lastino != ino) { + slprintf(cmd, sizeof(cmd), + "egrep POSIX.*%u /proc/locks", (int)ino); + system(cmd); + } + lastino = ino; + } +#endif + + printf("%6d %05x:%05x %s %.0f:%.0f(%.0f)\n", + (int)pid, (int)dev, (int)ino, + lock_type==READ_LOCK?"R":"W", + (double)start, (double)start+size-1,(double)size); + +} + + +static void show_locks(void) +{ + brl_forall(print_brl); + /* system("cat /proc/locks"); */ +} + + +/***************************************************** +return a connection to a server +*******************************************************/ +struct cli_state *connect_one(char *share) +{ + struct cli_state *c; + struct nmb_name called, calling; + char *server_n; + fstring server; + struct in_addr ip; + extern struct in_addr ipzero; + fstring myname; + static int count; + + fstrcpy(server,share+2); + share = strchr(server,'\\'); + if (!share) return NULL; + *share = 0; + share++; + + server_n = server; + + ip = ipzero; + + slprintf(myname,sizeof(myname), "lock-%u-%u", getpid(), count++); + + make_nmb_name(&calling, myname, 0x0); + make_nmb_name(&called , server, 0x20); + + again: + ip = ipzero; + + /* have to open a new connection */ + if (!(c=cli_initialise(NULL)) || (cli_set_port(c, 139) == 0) || + !cli_connect(c, server_n, &ip)) { + DEBUG(0,("Connection to %s failed\n", server_n)); + return NULL; + } + + if (!cli_session_request(c, &calling, &called)) { + DEBUG(0,("session request to %s failed\n", called.name)); + cli_shutdown(c); + if (strcmp(called.name, "*SMBSERVER")) { + make_nmb_name(&called , "*SMBSERVER", 0x20); + goto again; + } + return NULL; + } + + DEBUG(4,(" session request ok\n")); + + if (!cli_negprot(c)) { + DEBUG(0,("protocol negotiation failed\n")); + cli_shutdown(c); + return NULL; + } + + if (!got_pass) { + char *pass = getpass("Password: "); + if (pass) { + pstrcpy(password, pass); + } + } + + if (!cli_session_setup(c, username, + password, strlen(password), + password, strlen(password), + lp_workgroup())) { + DEBUG(0,("session setup failed: %s\n", cli_errstr(c))); + return NULL; + } + + /* + * These next two lines are needed to emulate + * old client behaviour for people who have + * scripts based on client output. + * QUESTION ? Do we want to have a 'client compatibility + * mode to turn these on/off ? JRA. + */ + + if (*c->server_domain || *c->server_os || *c->server_type) + DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n", + c->server_domain,c->server_os,c->server_type)); + + DEBUG(4,(" session setup ok\n")); + + if (!cli_send_tconX(c, share, "?????", + password, strlen(password)+1)) { + DEBUG(0,("tree connect failed: %s\n", cli_errstr(c))); + cli_shutdown(c); + return NULL; + } + + DEBUG(4,(" tconx ok\n")); + + c->use_oplocks = use_oplocks; + + return c; +} + + +static void reconnect(struct cli_state *cli[NSERVERS][NCONNECTIONS], int fnum[NSERVERS][NCONNECTIONS][NFILES], + char *share[NSERVERS]) +{ + int server, conn, f; + + for (server=0;serverconn; + unsigned f = rec->f; + SMB_BIG_UINT start = rec->start; + SMB_BIG_UINT len = rec->len; + unsigned r1 = rec->r1; + unsigned r2 = rec->r2; + unsigned op; + int server; + BOOL ret[NSERVERS]; + + if (r1 < READ_PCT) { + op = READ_LOCK; + } else { + op = WRITE_LOCK; + } + + if (r2 < LOCK_PCT) { + /* set a lock */ + for (server=0;server %u:%u\n", + conn, f, + (double)start, (double)start+len-1, (double)len, + op==READ_LOCK?"READ_LOCK":"WRITE_LOCK", + ret[0], ret[1]); + } + if (showall || ret[0] != ret[1]) show_locks(); + if (ret[0] != ret[1]) return False; + } else if (r2 < LOCK_PCT+UNLOCK_PCT) { + /* unset a lock */ + for (server=0;server %u:%u\n", + conn, f, + (double)start, (double)start+len-1, (double)len, + ret[0], ret[1]); + } + if (showall || ret[0] != ret[1]) show_locks(); + if (!hide_unlock_fails && ret[0] != ret[1]) return False; + } else { + /* reopen the file */ + for (server=0;serverserver_domain || *c->server_os || *c->server_type) + DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n", + c->server_domain,c->server_os,c->server_type)); + + DEBUG(4,(" session setup ok\n")); + + if (!cli_send_tconX(c, share, "?????", + password, strlen(password)+1)) { + DEBUG(0,("tree connect failed: %s\n", cli_errstr(c))); + cli_shutdown(c); + return NULL; + } + + DEBUG(4,(" tconx ok\n")); + + c->use_oplocks = use_oplocks; + + return c; +} + + +static void reconnect(struct cli_state *cli[NSERVERS][NCONNECTIONS], + char *nfs[NSERVERS], + int fnum[NSERVERS][NUMFSTYPES][NCONNECTIONS][NFILES], + char *share1, char *share2) +{ + int server, conn, f, fstype; + char *share[2]; + share[0] = share1; + share[1] = share2; + + fstype = FSTYPE_SMB; + + for (server=0;serverconn; + unsigned f = rec->f; + unsigned fstype = rec->fstype; + unsigned start = rec->start; + unsigned len = rec->len; + unsigned r1 = rec->r1; + unsigned r2 = rec->r2; + unsigned op; + int server; + BOOL ret[NSERVERS]; + + if (r1 < READ_PCT) { + op = READ_LOCK; + } else { + op = WRITE_LOCK; + } + + if (r2 < LOCK_PCT) { + /* set a lock */ + for (server=0;server %u:%u\n", + conn, fstype, f, + start, start+len-1, len, + op==READ_LOCK?"READ_LOCK":"WRITE_LOCK", + ret[0], ret[1]); + } + if (showall) brl_forall(print_brl); + if (ret[0] != ret[1]) return False; + } else if (r2 < LOCK_PCT+UNLOCK_PCT) { + /* unset a lock */ + for (server=0;server %u:%u\n", + conn, fstype, f, + start, start+len-1, len, + ret[0], ret[1]); + } + if (showall) brl_forall(print_brl); + if (!hide_unlock_fails && ret[0] != ret[1]) return False; + } else { + /* reopen the file */ + for (server=0;server': + if (n[0] == '.') { + if (! n[1] && ms_fnmatch_lanman_core(p, n+1) == 0) goto match; + if (ms_fnmatch_lanman_core(p, n) == 0) goto match; + goto nomatch; + } + if (! *n) goto next; + n++; + break; + + case '*': + if (! *p) goto match; + for (; *n; n++) { + if (ms_fnmatch_lanman_core(p, n) == 0) goto match; + } + break; + + case '<': + for (; *n; n++) { + if (ms_fnmatch_lanman_core(p, n) == 0) goto match; + if (*n == '.' && !strchr(n+1,'.')) { + n++; + break; + } + } + break; + + case '"': + if (*n == 0 && ms_fnmatch_lanman_core(p, n) == 0) goto match; + if (*n != '.') goto nomatch; + n++; + break; + + default: + if (c != *n) goto nomatch; + n++; + } + } + + if (! *n) goto match; + + nomatch: + if (verbose) printf("NOMATCH pattern=[%s] string=[%s]\n", pattern, string); + return -1; + +next: + if (ms_fnmatch_lanman_core(p, n) == 0) goto match; + goto nomatch; + + match: + if (verbose) printf("MATCH pattern=[%s] string=[%s]\n", pattern, string); + return 0; +} + +int ms_fnmatch_lanman(char *pattern, char *string) +{ + if (!strpbrk(pattern, "?*<>\"")) { + if (strcmp(string,"..") == 0) string = "."; + return strcmp(pattern, string); + } + + if (strcmp(string,"..") == 0 || strcmp(string,".") == 0) { + return ms_fnmatch_lanman_core(pattern, "..") && + ms_fnmatch_lanman_core(pattern, "."); + } + + return ms_fnmatch_lanman_core(pattern, string); +} + +static BOOL reg_match_one(char *pattern, char *file) +{ + /* oh what a weird world this is */ + if (old_list && strcmp(pattern, "*.*") == 0) return True; + + if (strcmp(pattern,".") == 0) return False; + + if (max_protocol <= PROTOCOL_LANMAN2) { + return ms_fnmatch_lanman(pattern, file)==0; + } + + if (strcmp(file,"..") == 0) file = "."; + + return ms_fnmatch(pattern, file)==0; +} + +static char *reg_test(char *pattern, char *long_name, char *short_name) +{ + static fstring ret; + fstrcpy(ret, "---"); + + pattern = 1+strrchr(pattern,'\\'); + + if (reg_match_one(pattern, ".")) ret[0] = '+'; + if (reg_match_one(pattern, "..")) ret[1] = '+'; + if (reg_match_one(pattern, long_name) || + (*short_name && reg_match_one(pattern, short_name))) ret[2] = '+'; + return ret; +} + + +/***************************************************** +return a connection to a server +*******************************************************/ +struct cli_state *connect_one(char *share) +{ + struct cli_state *c; + struct nmb_name called, calling; + char *server_n; + char *server; + struct in_addr ip; + extern struct in_addr ipzero; + + server = share+2; + share = strchr(server,'\\'); + if (!share) return NULL; + *share = 0; + share++; + + server_n = server; + + ip = ipzero; + + make_nmb_name(&calling, "masktest", 0x0); + make_nmb_name(&called , server, 0x20); + + again: + ip = ipzero; + + /* have to open a new connection */ + if (!(c=cli_initialise(NULL)) || (cli_set_port(c, 139) == 0) || + !cli_connect(c, server_n, &ip)) { + DEBUG(0,("Connection to %s failed\n", server_n)); + return NULL; + } + + c->protocol = max_protocol; + + if (!cli_session_request(c, &calling, &called)) { + DEBUG(0,("session request to %s failed\n", called.name)); + cli_shutdown(c); + if (strcmp(called.name, "*SMBSERVER")) { + make_nmb_name(&called , "*SMBSERVER", 0x20); + goto again; + } + return NULL; + } + + DEBUG(4,(" session request ok\n")); + + if (!cli_negprot(c)) { + DEBUG(0,("protocol negotiation failed\n")); + cli_shutdown(c); + return NULL; + } + + if (!got_pass) { + char *pass = getpass("Password: "); + if (pass) { + pstrcpy(password, pass); + } + } + + if (!cli_session_setup(c, username, + password, strlen(password), + password, strlen(password), + lp_workgroup())) { + DEBUG(0,("session setup failed: %s\n", cli_errstr(c))); + return NULL; + } + + /* + * These next two lines are needed to emulate + * old client behaviour for people who have + * scripts based on client output. + * QUESTION ? Do we want to have a 'client compatibility + * mode to turn these on/off ? JRA. + */ + + if (*c->server_domain || *c->server_os || *c->server_type) + DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n", + c->server_domain,c->server_os,c->server_type)); + + DEBUG(4,(" session setup ok\n")); + + if (!cli_send_tconX(c, share, "?????", + password, strlen(password)+1)) { + DEBUG(0,("tree connect failed: %s\n", cli_errstr(c))); + cli_shutdown(c); + return NULL; + } + + DEBUG(4,(" tconx ok\n")); + + return c; +} + +static char *resultp; +static file_info *finfo; + +void listfn(file_info *f, const char *s, void *state) +{ + if (strcmp(f->name,".") == 0) { + resultp[0] = '+'; + } else if (strcmp(f->name,"..") == 0) { + resultp[1] = '+'; + } else { + resultp[2] = '+'; + } + finfo = f; +} + +static void get_real_name(struct cli_state *cli, + pstring long_name, fstring short_name) +{ + /* nasty hack to force level 260 listings - tridge */ + cli->capabilities |= CAP_NT_SMBS; + if (max_protocol <= PROTOCOL_LANMAN1) { + cli_list_new(cli, "\\masktest\\*.*", aHIDDEN | aDIR, listfn, NULL); + } else { + cli_list_new(cli, "\\masktest\\*", aHIDDEN | aDIR, listfn, NULL); + } + if (finfo) { + fstrcpy(short_name, finfo->short_name); + strlower(short_name); + pstrcpy(long_name, finfo->name); + strlower(long_name); + } + + if (*short_name == 0) { + fstrcpy(short_name, long_name); + } + +#if 0 + if (!strchr(short_name,'.')) { + fstrcat(short_name,"."); + } +#endif +} + +static void testpair(struct cli_state *cli, char *mask, char *file) +{ + int fnum; + fstring res1; + char *res2; + static int count; + fstring short_name; + pstring long_name; + + count++; + + fstrcpy(res1, "---"); + + fnum = cli_open(cli, file, O_CREAT|O_TRUNC|O_RDWR, 0); + if (fnum == -1) { + DEBUG(0,("Can't create %s\n", file)); + return; + } + cli_close(cli, fnum); + + resultp = res1; + fstrcpy(short_name, ""); + finfo = NULL; + get_real_name(cli, long_name, short_name); + finfo = NULL; + fstrcpy(res1, "---"); + cli_list(cli, mask, aHIDDEN | aDIR, listfn, NULL); + + res2 = reg_test(mask, long_name, short_name); + + if (showall || strcmp(res1, res2)) { + DEBUG(0,("%s %s %d mask=[%s] file=[%s] rfile=[%s/%s]\n", + res1, res2, count, mask, file, long_name, short_name)); + if (die_on_error) exit(1); + } + + cli_unlink(cli, file); + + if (count % 100 == 0) DEBUG(0,("%d\n", count)); +} + +static void test_mask(int argc, char *argv[], + struct cli_state *cli) +{ + pstring mask, file; + int l1, l2, i, l; + int mc_len = strlen(maskchars); + int fc_len = strlen(filechars); + + cli_mkdir(cli, "\\masktest"); + + cli_unlink(cli, "\\masktest\\*"); + + if (argc >= 2) { + while (argc >= 2) { + pstrcpy(mask,"\\masktest\\"); + pstrcpy(file,"\\masktest\\"); + pstrcat(mask, argv[0]); + pstrcat(file, argv[1]); + testpair(cli, mask, file); + argv += 2; + argc -= 2; + } + goto finished; + } + + while (1) { + l1 = 1 + random() % 20; + l2 = 1 + random() % 20; + pstrcpy(mask,"\\masktest\\"); + pstrcpy(file,"\\masktest\\"); + l = strlen(mask); + for (i=0;i st_size) { +#if NBDEBUG + printf("(%d) needs expanding %s to %d from %d\n", + line_count, fname, size, (int)st_size); +#endif + } else if (size < st_size) { +#if NBDEBUG + printf("(%d) needs truncating %s to %d from %d\n", + line_count, fname, size, (int)st_size); +#endif + } + for (i=0;icapabilities |= CAP_NT_SMBS; +} + +/**************************************************************************** +make smb client connection +****************************************************************************/ +static BOOL rpcclient_connect(struct client_info *info) +{ + struct nmb_name calling; + struct nmb_name called; + + make_nmb_name(&called , dns_to_netbios_name(info->dest_host ), info->name_type); + make_nmb_name(&calling, dns_to_netbios_name(info->myhostname), 0x0); + + if (!cli_establish_connection(smb_cli, + info->dest_host, &info->dest_ip, + &calling, &called, + info->share, info->svc_type, + False, True)) + { + DEBUG(0,("rpcclient_connect: connection failed\n")); + cli_shutdown(smb_cli); + return False; + } + + return True; +} + +/**************************************************************************** +stop the smb connection(s?) +****************************************************************************/ +static void rpcclient_stop(void) +{ + cli_shutdown(smb_cli); +} + +/**************************************************************************** + log in as an nt user, log out again. +****************************************************************************/ +void run_enums_test(int num_ops, struct client_info *cli_info, struct cli_state *cli) +{ + pstring cmd; + int i; + + /* establish connections. nothing to stop these being re-established. */ + rpcclient_connect(cli_info); + + DEBUG(5,("rpcclient_connect: cli->fd:%d\n", cli->fd)); + if (cli->fd <= 0) + { + fprintf(out_hnd, "warning: connection could not be established to %s<%02x>\n", + cli_info->dest_host, cli_info->name_type); + return; + } + + for (i = 0; i < num_ops; i++) + { + set_first_token(""); + cmd_srv_enum_sess(cli_info); + set_first_token(""); + cmd_srv_enum_shares(cli_info); + set_first_token(""); + cmd_srv_enum_files(cli_info); + + if (password[0] != 0) + { + slprintf(cmd, sizeof(cmd)-1, "1"); + set_first_token(cmd); + } + else + { + set_first_token(""); + } + cmd_srv_enum_conn(cli_info); + } + + rpcclient_stop(); + +} + +/**************************************************************************** + log in as an nt user, log out again. +****************************************************************************/ +void run_ntlogin_test(int num_ops, struct client_info *cli_info, struct cli_state *cli) +{ + pstring cmd; + int i; + + /* establish connections. nothing to stop these being re-established. */ + rpcclient_connect(cli_info); + + DEBUG(5,("rpcclient_connect: cli->fd:%d\n", cli->fd)); + if (cli->fd <= 0) + { + fprintf(out_hnd, "warning: connection could not be established to %s<%02x>\n", + cli_info->dest_host, cli_info->name_type); + return; + } + + for (i = 0; i < num_ops; i++) + { + slprintf(cmd, sizeof(cmd)-1, "%s %s", cli->user_name, password); + set_first_token(cmd); + + cmd_netlogon_login_test(cli_info); + } + + rpcclient_stop(); + +} + +/**************************************************************************** + runs n simultaneous functions. +****************************************************************************/ +static void create_procs(int nprocs, int numops, + struct client_info *cli_info, struct cli_state *cli, + void (*fn)(int, struct client_info *, struct cli_state *)) +{ + int i, status; + + for (i=0;i [-d debuglevel] [-l log] ", + pname); + + fprintf(out_hnd, "\nVersion %s\n",VERSION); + fprintf(out_hnd, "\t-d debuglevel set the debuglevel\n"); + fprintf(out_hnd, "\t-l log basename. Basename for log/debug files\n"); + fprintf(out_hnd, "\t-n netbios name. Use this name as my netbios name\n"); + fprintf(out_hnd, "\t-m max protocol set the max protocol level\n"); + fprintf(out_hnd, "\t-I dest IP use this IP to connect to\n"); + fprintf(out_hnd, "\t-E write messages to stderr instead of stdout\n"); + fprintf(out_hnd, "\t-U username set the network username\n"); + fprintf(out_hnd, "\t-W workgroup set the workgroup name\n"); + fprintf(out_hnd, "\t-t terminal code terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n"); + fprintf(out_hnd, "\n"); +} + +enum client_action +{ + CLIENT_NONE, + CLIENT_IPC, + CLIENT_SVC +}; + +/**************************************************************************** + main program +****************************************************************************/ + int main(int argc,char *argv[]) +{ + char *pname = argv[0]; + int opt; + extern FILE *dbf; + extern char *optarg; + extern int optind; + static pstring servicesf = CONFIGFILE; + pstring term_code; + BOOL got_pass = False; + char *cmd_str=""; + mode_t myumask = 0755; + enum client_action cli_action = CLIENT_NONE; + int nprocs = 1; + int numops = 100; + + struct client_info cli_info; + + out_hnd = stdout; + + rpcclient_init(); + +#ifdef KANJI + pstrcpy(term_code, KANJI); +#else /* KANJI */ + *term_code = 0; +#endif /* KANJI */ + + if (!lp_load(servicesf,True, False, False)) + { + fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf); + } + + codepage_initialise(lp_client_code_page()); + + DEBUGLEVEL = 0; + + cli_info.put_total_size = 0; + cli_info.put_total_time_ms = 0; + cli_info.get_total_size = 0; + cli_info.get_total_time_ms = 0; + + cli_info.dir_total = 0; + cli_info.newer_than = 0; + cli_info.archive_level = 0; + cli_info.print_mode = 1; + + cli_info.translation = False; + cli_info.recurse_dir = False; + cli_info.lowercase = False; + cli_info.prompt = True; + cli_info.abort_mget = True; + + cli_info.dest_ip.s_addr = 0; + cli_info.name_type = 0x20; + + pstrcpy(cli_info.cur_dir , "\\"); + pstrcpy(cli_info.file_sel, ""); + pstrcpy(cli_info.base_dir, ""); + pstrcpy(smb_cli->domain, ""); + pstrcpy(smb_cli->user_name, ""); + pstrcpy(cli_info.myhostname, ""); + pstrcpy(cli_info.dest_host, ""); + + pstrcpy(cli_info.svc_type, "A:"); + pstrcpy(cli_info.share, ""); + pstrcpy(cli_info.service, ""); + + ZERO_STRUCT(cli_info.dom.level3_sid); + pstrcpy(cli_info.dom.level3_dom, ""); + ZERO_STRUCT(cli_info.dom.level5_sid); + pstrcpy(cli_info.dom.level5_dom, ""); + + smb_cli->nt_pipe_fnum = 0xffff; + + setup_logging(pname, True); + + TimeInit(); + charset_initialise(); + + myumask = umask(0); + umask(myumask); + + if (!get_myname(global_myname)) + { + fprintf(stderr, "Failed to get my hostname.\n"); + } + + password[0] = 0; + + if (argc < 2) + { + usage(pname); + exit(1); + } + + if (*argv[1] != '-') + { + pstrcpy(cli_info.service, argv[1]); + /* Convert any '/' characters in the service name to '\' characters */ + string_replace( cli_info.service, '/','\\'); + argc--; + argv++; + + DEBUG(1,("service: %s\n", cli_info.service)); + + if (count_chars(cli_info.service,'\\') < 3) + { + usage(pname); + printf("\n%s: Not enough '\\' characters in service\n", cli_info.service); + exit(1); + } + + /* + if (count_chars(cli_info.service,'\\') > 3) + { + usage(pname); + printf("\n%s: Too many '\\' characters in service\n", cli_info.service); + exit(1); + } + */ + + if (argc > 1 && (*argv[1] != '-')) + { + got_pass = True; + pstrcpy(password,argv[1]); + memset(argv[1],'X',strlen(argv[1])); + argc--; + argv++; + } + + cli_action = CLIENT_SVC; + } + + while ((opt = getopt(argc, argv,"s:O:M:S:i:N:o:n:d:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF) + { + switch (opt) + { + case 'm': + { + /* FIXME ... max_protocol seems to be funny here */ + + int max_protocol = 0; + max_protocol = interpret_protocol(optarg,max_protocol); + fprintf(stderr, "max protocol not currently supported\n"); + break; + } + + case 'O': + { + pstrcpy(user_socket_options,optarg); + break; + } + + case 'S': + { + pstrcpy(cli_info.dest_host,optarg); + strupper(cli_info.dest_host); + cli_action = CLIENT_IPC; + break; + } + + case 'i': + { + pstrcpy(scope, optarg); + break; + } + + case 'U': + { + char *lp; + pstrcpy(smb_cli->user_name,optarg); + if ((lp=strchr(smb_cli->user_name,'%'))) + { + *lp = 0; + pstrcpy(password,lp+1); + got_pass = True; + memset(strchr(optarg,'%')+1,'X',strlen(password)); + } + break; + } + + case 'W': + { + pstrcpy(smb_cli->domain,optarg); + break; + } + + case 'E': + { + dbf = stderr; + break; + } + + case 'I': + { + cli_info.dest_ip = *interpret_addr2(optarg); + if (zero_ip(cli_info.dest_ip)) + { + exit(1); + } + break; + } + + case 'N': + { + nprocs = atoi(optarg); + break; + } + + case 'o': + { + numops = atoi(optarg); + break; + } + + case 'n': + { + fstrcpy(global_myname, optarg); + break; + } + + case 'd': + { + if (*optarg == 'A') + DEBUGLEVEL = 10000; + else + DEBUGLEVEL = atoi(optarg); + break; + } + + case 'l': + { + slprintf(debugf, sizeof(debugf)-1, + "%s.client",optarg); + break; + } + + case 'c': + { + cmd_str = optarg; + got_pass = True; + break; + } + + case 'h': + { + usage(pname); + exit(0); + break; + } + + case 's': + { + pstrcpy(servicesf, optarg); + break; + } + + case 't': + { + pstrcpy(term_code, optarg); + break; + } + + default: + { + usage(pname); + exit(1); + break; + } + } + } + + if (cli_action == CLIENT_NONE) + { + usage(pname); + exit(1); + } + + strupper(global_myname); + fstrcpy(cli_info.myhostname, global_myname); + + DEBUG(3,("%s client started (version %s)\n",timestring(False),VERSION)); + + if (*smb_cli->domain == 0) + { + pstrcpy(smb_cli->domain,lp_workgroup()); + } + strupper(smb_cli->domain); + + load_interfaces(); + + if (cli_action == CLIENT_IPC) + { + pstrcpy(cli_info.share, "IPC$"); + pstrcpy(cli_info.svc_type, "IPC"); + } + + fstrcpy(cli_info.mach_acct, cli_info.myhostname); + strupper(cli_info.mach_acct); + fstrcat(cli_info.mach_acct, "$"); + + /* set the password cache info */ + if (got_pass) + { + if (password[0] == 0) + { + pwd_set_nullpwd(&(smb_cli->pwd)); + } + else + { + pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */ + } + } + else + { + char *pwd = getpass("Enter Password:"); + safe_strcpy(password, pwd, sizeof(password)); + pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */ + } + + create_procs(nprocs, numops, &cli_info, smb_cli, run_enums_test); + + if (password[0] != 0) + { + create_procs(nprocs, numops, &cli_info, smb_cli, run_ntlogin_test); + } + + fflush(out_hnd); + + return(0); +} diff --git a/source3/torture/torture.c b/source3/torture/torture.c new file mode 100644 index 0000000000..6f4076cecb --- /dev/null +++ b/source3/torture/torture.c @@ -0,0 +1,3053 @@ +/* + Unix SMB/Netbios implementation. + Version 1.9. + SMB torture tester + Copyright (C) Andrew Tridgell 1997-1998 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#define NO_SYSLOG + +#include "includes.h" + +static fstring host, workgroup, share, password, username, myname; +static int max_protocol = PROTOCOL_NT1; +static char *sockops="TCP_NODELAY"; +static int nprocs=1, numops=100; +static int procnum; /* records process count number when forking */ +static struct cli_state current_cli; +static fstring randomfname; +static BOOL use_oplocks; +static BOOL use_level_II_oplocks; + +static double create_procs(void (*fn)(int)); + + +static struct timeval tp1,tp2; + +static void start_timer(void) +{ + gettimeofday(&tp1,NULL); +} + +static double end_timer(void) +{ + gettimeofday(&tp2,NULL); + return((tp2.tv_sec - tp1.tv_sec) + + (tp2.tv_usec - tp1.tv_usec)*1.0e-6); +} + + +/* return a pointer to a anonymous shared memory segment of size "size" + which will persist across fork() but will disappear when all processes + exit + + The memory is not zeroed + + This function uses system5 shared memory. It takes advantage of a property + that the memory is not destroyed if it is attached when the id is removed + */ +static void *shm_setup(int size) +{ + int shmid; + void *ret; + + shmid = shmget(IPC_PRIVATE, size, SHM_R | SHM_W); + if (shmid == -1) { + printf("can't get shared memory\n"); + exit(1); + } + ret = (void *)shmat(shmid, 0, 0); + if (!ret || ret == (void *)-1) { + printf("can't attach to shared memory\n"); + return NULL; + } + /* the following releases the ipc, but note that this process + and all its children will still have access to the memory, its + just that the shmid is no longer valid for other shm calls. This + means we don't leave behind lots of shm segments after we exit + + See Stevens "advanced programming in unix env" for details + */ + shmctl(shmid, IPC_RMID, 0); + + return ret; +} + + +static BOOL open_nbt_connection(struct cli_state *c) +{ + struct nmb_name called, calling; + struct in_addr ip; + extern struct in_addr ipzero; + + ZERO_STRUCTP(c); + + make_nmb_name(&calling, myname, 0x0); + make_nmb_name(&called , host, 0x20); + + ip = ipzero; + + if (!cli_initialise(c) || !cli_connect(c, host, &ip)) { + printf("Failed to connect with %s\n", host); + return False; + } + + c->timeout = 120000; /* set a really long timeout (2 minutes) */ + if (use_oplocks) c->use_oplocks = True; + if (use_level_II_oplocks) c->use_level_II_oplocks = True; + + if (!cli_session_request(c, &calling, &called)) { + printf("%s rejected the session\n",host); + cli_shutdown(c); + return False; + } + + return True; +} + +static BOOL open_connection(struct cli_state *c) +{ + ZERO_STRUCTP(c); + + if (!open_nbt_connection(c)) { + return False; + } + + if (!cli_negprot(c)) { + printf("%s rejected the negprot (%s)\n",host, cli_errstr(c)); + cli_shutdown(c); + return False; + } + + if (!cli_session_setup(c, username, + password, strlen(password), + password, strlen(password), + workgroup)) { + printf("%s rejected the sessionsetup (%s)\n", host, cli_errstr(c)); + cli_shutdown(c); + return False; + } + + if (!cli_send_tconX(c, share, "?????", + password, strlen(password)+1)) { + printf("%s refused tree connect (%s)\n", host, cli_errstr(c)); + cli_shutdown(c); + return False; + } + + return True; +} + + +static void close_connection(struct cli_state *c) +{ + if (!cli_tdis(c)) { + printf("tdis failed (%s)\n", cli_errstr(c)); + } + + cli_shutdown(c); +} + + +/* check if the server produced the expected error code */ +static BOOL check_error(struct cli_state *c, + uint8 eclass, uint32 ecode, uint32 nterr) +{ + uint8 class; + uint32 num; + (void)cli_error(c, &class, &num, NULL); + if ((eclass != class || ecode != num) && + num != (nterr&0xFFFFFF)) { + printf("unexpected error code class=%d code=%d\n", + (int)class, (int)num); + printf(" expected %d/%d %d\n", + (int)eclass, (int)ecode, (int)nterr); + return False; + } + return True; +} + + +static BOOL wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len) +{ + while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) { + if (!check_error(c, ERRDOS, ERRlock, 0)) return False; + } + return True; +} + + +static BOOL rw_torture(struct cli_state *c) +{ + char *lockfname = "\\torture.lck"; + fstring fname; + int fnum; + int fnum2; + pid_t pid2, pid = getpid(); + int i, j; + char buf[1024]; + + fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL, + DENY_NONE); + if (fnum2 == -1) + fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE); + if (fnum2 == -1) { + printf("open of %s failed (%s)\n", lockfname, cli_errstr(c)); + return False; + } + + + for (i=0;i= countprev) { + printf("%d %8d\r", i, count); + fflush(stdout); + i++; + countprev += (sizeof(buf) / 20); + } + + if (procnum == 0) + { + sent = ((unsigned)sys_random()%(20))+ 1; + if (sent > sizeof(buf) - count) + { + sent = sizeof(buf) - count; + } + + if (cli_write(c, fnum, 0, buf+count, count, sent) != sent) { + printf("write failed (%s)\n", cli_errstr(c)); + } + } + else + { + sent = cli_read(c, fnum, buf_rd+count, count, + sizeof(buf)-count); + if (sent < 0) + { + printf("read failed offset:%d size:%d (%s)\n", + count, sizeof(buf)-count, + cli_errstr(c)); + sent = 0; + } + if (sent > 0) + { + if (memcmp(buf_rd+count, buf+count, sent) != 0) + { + printf("read/write compare failed\n"); + printf("offset: %d req %d recvd %d\n", + count, sizeof(buf)-count, sent); + break; + } + } + } + + } + + if (!cli_close(c, fnum)) { + printf("close failed (%s)\n", cli_errstr(c)); + } + + return True; +} + +static BOOL rw_torture2(struct cli_state *c1, struct cli_state *c2) +{ + char *lockfname = "\\torture.lck"; + int fnum1; + int fnum2; + int i; + char buf[131072]; + char buf_rd[131072]; + + if (!cli_unlink(c1, lockfname)) { + printf("unlink failed (%s)\n", cli_errstr(c1)); + } + + fnum1 = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL, + DENY_NONE); + if (fnum1 == -1) { + printf("first open read/write of %s failed (%s)\n", + lockfname, cli_errstr(c1)); + return False; + } + fnum2 = cli_open(c2, lockfname, O_RDONLY, + DENY_NONE); + if (fnum2 == -1) { + printf("second open read-only of %s failed (%s)\n", + lockfname, cli_errstr(c2)); + cli_close(c1, fnum1); + return False; + } + + for (i=0;i 0) { + fnum--; + slprintf(fname,sizeof(fname)-1,template, fnum,(int)getpid()); + cli_close(&cli, fnum); + if (!cli_unlink(&cli, fname)) { + printf("unlink of %s failed (%s)\n", + fname, cli_errstr(&cli)); + } + } + + printf("maxfid test finished\n"); + close_connection(&cli); +} + +/* generate a random buffer */ +static void rand_buf(char *buf, int len) +{ + while (len--) { + *buf = (char)sys_random(); + buf++; + } +} + +/* send smb negprot commands, not reading the response */ +static void run_negprot_nowait(int dummy) +{ + int i; + static struct cli_state cli; + + printf("starting negprot nowait test\n"); + + if (!open_nbt_connection(&cli)) { + return; + } + + for (i=0;i<50000;i++) { + cli_negprot_send(&cli); + } + + close_connection(&cli); + + printf("finished negprot nowait test\n"); +} + + +/* send random IPC commands */ +static void run_randomipc(int dummy) +{ + char *rparam = NULL; + char *rdata = NULL; + int rdrcnt,rprcnt; + pstring param; + int api, param_len, i; + static struct cli_state cli; + + printf("starting random ipc test\n"); + + if (!open_connection(&cli)) { + return; + } + + for (i=0;i<50000;i++) { + api = sys_random() % 500; + param_len = (sys_random() % 64); + + rand_buf(param, param_len); + + SSVAL(param,0,api); + + cli_api(&cli, + param, param_len, 8, + NULL, 0, BUFFER_SIZE, + &rparam, &rprcnt, + &rdata, &rdrcnt); + } + + close_connection(&cli); + + printf("finished random ipc test\n"); +} + + + +static void browse_callback(const char *sname, uint32 stype, + const char *comment, void *state) +{ + printf("\t%20.20s %08x %s\n", sname, stype, comment); +} + + + +/* + This test checks the browse list code + +*/ +static void run_browsetest(int dummy) +{ + static struct cli_state cli; + + printf("starting browse test\n"); + + if (!open_connection(&cli)) { + return; + } + + printf("domain list:\n"); + cli_NetServerEnum(&cli, cli.server_domain, + SV_TYPE_DOMAIN_ENUM, + browse_callback, NULL); + + printf("machine list:\n"); + cli_NetServerEnum(&cli, cli.server_domain, + SV_TYPE_ALL, + browse_callback, NULL); + + close_connection(&cli); + + printf("browse test finished\n"); +} + + +/* + This checks how the getatr calls works +*/ +static void run_attrtest(int dummy) +{ + static struct cli_state cli; + int fnum; + time_t t, t2; + char *fname = "\\attrib.tst"; + + printf("starting attrib test\n"); + + if (!open_connection(&cli)) { + return; + } + + cli_unlink(&cli, fname); + fnum = cli_open(&cli, fname, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE); + cli_close(&cli, fnum); + if (!cli_getatr(&cli, fname, NULL, NULL, &t)) { + printf("getatr failed (%s)\n", cli_errstr(&cli)); + } + + if (abs(t - time(NULL)) > 2) { + printf("ERROR: SMBgetatr bug. time is %s", + ctime(&t)); + t = time(NULL); + } + + t2 = t-60*60*24; /* 1 day ago */ + + if (!cli_setatr(&cli, fname, 0, t2)) { + printf("setatr failed (%s)\n", cli_errstr(&cli)); + } + + if (!cli_getatr(&cli, fname, NULL, NULL, &t)) { + printf("getatr failed (%s)\n", cli_errstr(&cli)); + } + + if (t != t2) { + printf("ERROR: getatr/setatr bug. times are\n%s", + ctime(&t)); + printf("%s", ctime(&t2)); + } + + cli_unlink(&cli, fname); + + close_connection(&cli); + + printf("attrib test finished\n"); +} + + +/* + This checks a couple of trans2 calls +*/ +static void run_trans2test(int dummy) +{ + static struct cli_state cli; + int fnum; + size_t size; + time_t c_time, a_time, m_time, w_time, m_time2; + char *fname = "\\trans2.tst"; + char *dname = "\\trans2"; + char *fname2 = "\\trans2\\trans2.tst"; + + printf("starting trans2 test\n"); + + if (!open_connection(&cli)) { + return; + } + + cli_unlink(&cli, fname); + fnum = cli_open(&cli, fname, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE); + if (!cli_qfileinfo(&cli, fnum, NULL, &size, &c_time, &a_time, &m_time, + NULL, NULL)) { + printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(&cli)); + } + cli_close(&cli, fnum); + + sleep(2); + + cli_unlink(&cli, fname); + fnum = cli_open(&cli, fname, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE); + cli_close(&cli, fnum); + + if (!cli_qpathinfo(&cli, fname, &c_time, &a_time, &m_time, &size, NULL)) { + printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(&cli)); + } else { + if (c_time != m_time) { + printf("create time=%s", ctime(&c_time)); + printf("modify time=%s", ctime(&m_time)); + printf("This system appears to have sticky create times\n"); + } + if (a_time % (60*60) == 0) { + printf("access time=%s", ctime(&a_time)); + printf("This system appears to set a midnight access time\n"); + } + + if (abs(m_time - time(NULL)) > 60*60*24*7) { + printf("ERROR: totally incorrect times - maybe word reversed?\n"); + } + } + + + cli_unlink(&cli, fname); + fnum = cli_open(&cli, fname, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE); + cli_close(&cli, fnum); + if (!cli_qpathinfo2(&cli, fname, &c_time, &a_time, &m_time, + &w_time, &size, NULL, NULL)) { + printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(&cli)); + } else { + if (w_time < 60*60*24*2) { + printf("write time=%s", ctime(&w_time)); + printf("This system appears to set a initial 0 write time\n"); + } + } + + cli_unlink(&cli, fname); + + + /* check if the server updates the directory modification time + when creating a new file */ + if (!cli_mkdir(&cli, dname)) { + printf("ERROR: mkdir failed (%s)\n", cli_errstr(&cli)); + } + sleep(3); + if (!cli_qpathinfo2(&cli, "\\trans2\\", &c_time, &a_time, &m_time, + &w_time, &size, NULL, NULL)) { + printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(&cli)); + } + + fnum = cli_open(&cli, fname2, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE); + cli_write(&cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum)); + cli_close(&cli, fnum); + if (!cli_qpathinfo2(&cli, "\\trans2\\", &c_time, &a_time, &m_time2, + &w_time, &size, NULL, NULL)) { + printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(&cli)); + } else { + if (m_time2 == m_time) + printf("This system does not update directory modification times\n"); + } + cli_unlink(&cli, fname2); + cli_rmdir(&cli, dname); + + + close_connection(&cli); + + printf("trans2 test finished\n"); +} + +/* + This checks new W2K calls. +*/ + +void new_trans(struct cli_state *pcli, int fnum, int level) +{ + char buf[4096]; + + memset(buf, 0xff, sizeof(buf)); + + if (!cli_qfileinfo_test(pcli, fnum, level, buf)) { + printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli)); + } else { + printf("qfileinfo: level %d\n", level); + dump_data(0, buf, 256); + printf("\n"); + } +} + +static void run_w2ktest(int dummy) +{ + static struct cli_state cli; + int fnum; + char *fname = "\\w2ktest\\w2k.tst"; + int level; + + printf("starting w2k test\n"); + + if (!open_connection(&cli)) { + return; + } + + fnum = cli_open(&cli, fname, + O_RDWR | O_CREAT , DENY_NONE); + + for (level = 1004; level < 1040; level++) + new_trans(&cli, fnum, level); + + cli_close(&cli, fnum); + + + close_connection(&cli); + + printf("w2k test finished\n"); +} + + +/* + this is a harness for some oplock tests + */ +static void run_oplock1(int dummy) +{ + static struct cli_state cli1; + char *fname = "\\lockt1.lck"; + int fnum1; + + printf("starting oplock test 1\n"); + + if (!open_connection(&cli1)) { + return; + } + + cli_unlink(&cli1, fname); + + cli_sockopt(&cli1, sockops); + + cli1.use_oplocks = True; + + fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE); + if (fnum1 == -1) { + printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + cli1.use_oplocks = False; + + cli_unlink(&cli1, fname); + cli_unlink(&cli1, fname); + + if (!cli_close(&cli1, fnum1)) { + printf("close2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (!cli_unlink(&cli1, fname)) { + printf("unlink failed (%s)\n", cli_errstr(&cli1)); + return; + } + + + close_connection(&cli1); + + printf("finished oplock test 1\n"); +} + +static void run_oplock2(int dummy) +{ + static struct cli_state cli1, cli2; + char *fname = "\\lockt2.lck"; + int fnum1, fnum2; + int saved_use_oplocks = use_oplocks; + char buf[4]; + + use_level_II_oplocks = True; + use_oplocks = True; + + printf("starting oplock test 2\n"); + + if (!open_connection(&cli1)) { + use_level_II_oplocks = False; + use_oplocks = saved_use_oplocks; + return; + } + + cli1.use_oplocks = True; + cli1.use_level_II_oplocks = True; + + if (!open_connection(&cli2)) { + use_level_II_oplocks = False; + use_oplocks = saved_use_oplocks; + return; + } + + cli2.use_oplocks = True; + cli2.use_level_II_oplocks = True; + + cli_unlink(&cli1, fname); + + cli_sockopt(&cli1, sockops); + cli_sockopt(&cli2, sockops); + + fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE); + if (fnum1 == -1) { + printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + /* Don't need the globals any more. */ + use_level_II_oplocks = False; + use_oplocks = saved_use_oplocks; + + if (fork() == 0) { + /* Child code */ + fnum2 = cli_open(&cli2, fname, O_RDWR, DENY_NONE); + if (fnum2 == -1) { + printf("second open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + exit(0); + } + + sleep(2); + + if (!cli_close(&cli2, fnum2)) { + printf("close2 failed (%s)\n", cli_errstr(&cli1)); + } + + exit(0); + } + + sleep(2); + + /* Ensure cli1 processes the break. */ + + if (cli_read(&cli1, fnum1, buf, 0, 4) != 4) { + printf("read on fnum1 failed (%s)\n", cli_errstr(&cli1)); + } + + /* Should now be at level II. */ + /* Test if sending a write locks causes a break to none. */ + + if (!cli_lock(&cli1, fnum1, 0, 4, 0, READ_LOCK)) { + printf("lock failed (%s)\n", cli_errstr(&cli1)); + } + + cli_unlock(&cli1, fnum1, 0, 4); + + sleep(2); + + if (!cli_lock(&cli1, fnum1, 0, 4, 0, WRITE_LOCK)) { + printf("lock failed (%s)\n", cli_errstr(&cli1)); + } + + cli_unlock(&cli1, fnum1, 0, 4); + + sleep(2); + + cli_read(&cli1, fnum1, buf, 0, 4); + +#if 0 + if (cli_write(&cli1, fnum1, 0, buf, 0, 4) != 4) { + printf("write on fnum1 failed (%s)\n", cli_errstr(&cli1)); + } +#endif + + if (!cli_close(&cli1, fnum1)) { + printf("close1 failed (%s)\n", cli_errstr(&cli1)); + } + + sleep(4); + + if (!cli_unlink(&cli1, fname)) { + printf("unlink failed (%s)\n", cli_errstr(&cli1)); + } + + close_connection(&cli1); + + printf("finished oplock test 2\n"); +} + +/* handler for oplock 3 tests */ +static BOOL oplock3_handler(struct cli_state *cli, int fnum, unsigned char level) +{ + printf("got oplock break fnum=%d level=%d\n", + fnum, level); + return cli_oplock_ack(cli, fnum, level); +} + +static void run_oplock3(int dummy) +{ + static struct cli_state cli; + char *fname = "\\oplockt3.dat"; + int fnum; + char buf[4] = "abcd"; + + printf("starting oplock test 3\n"); + + if (fork() == 0) { + /* Child code */ + if (!open_connection(&cli)) return; + sleep(2); + /* try to trigger a oplock break in parent */ + fnum = cli_open(&cli, fname, O_RDWR, DENY_NONE); + cli_write(&cli, fnum, 0, buf, 0, 4); + exit(0); + } + + /* parent code */ + use_oplocks = True; + use_level_II_oplocks = True; + if (!open_connection(&cli)) return; + cli_oplock_handler(&cli, oplock3_handler); + fnum = cli_open(&cli, fname, O_RDWR|O_CREAT, DENY_NONE); + cli_write(&cli, fnum, 0, buf, 0, 4); + cli_close(&cli, fnum); + fnum = cli_open(&cli, fname, O_RDWR, DENY_NONE); + cli.timeout = 20000; + cli_receive_smb(&cli); + printf("finished oplock test 3\n"); +} + + + +/* + Test delete on close semantics. + */ +static void run_deletetest(int dummy) +{ + static struct cli_state cli1; + static struct cli_state cli2; + char *fname = "\\delete.file"; + int fnum1, fnum2; + + printf("starting delete test\n"); + + if (!open_connection(&cli1)) { + return; + } + + cli_sockopt(&cli1, sockops); + + /* Test 1 - this should *NOT* delete the file on close. */ + + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + fnum1 = cli_nt_create_full(&cli1, fname, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_DELETE, FILE_OVERWRITE_IF, DELETE_ON_CLOSE_FLAG); + + if (fnum1 == -1) { + printf("[1] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[1] close failed (%s)\n", cli_errstr(&cli1)); + return; + } + + fnum1 = cli_open(&cli1, fname, O_RDWR, DENY_NONE); + if (fnum1 == -1) { + printf("[1] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[1] close failed (%s)\n", cli_errstr(&cli1)); + return; + } + + printf("first delete on close test succeeded.\n"); + + /* Test 2 - this should delete the file on close. */ + + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + fnum1 = cli_nt_create_full(&cli1, fname, GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0); + + if (fnum1 == -1) { + printf("[2] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_nt_delete_on_close(&cli1, fnum1, True)) { + printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[2] close failed (%s)\n", cli_errstr(&cli1)); + return; + } + + fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_NONE); + if (fnum1 != -1) { + printf("[2] open of %s succeeded should have been deleted on close !\n", fname); + if (!cli_close(&cli1, fnum1)) { + printf("[2] close failed (%s)\n", cli_errstr(&cli1)); + } + cli_unlink(&cli1, fname); + } else + printf("second delete on close test succeeded.\n"); + + + /* Test 3 - ... */ + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + fnum1 = cli_nt_create_full(&cli1, fname, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0); + + if (fnum1 == -1) { + printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + /* This should fail with a sharing violation - open for delete is only compatible + with SHARE_DELETE. */ + + fnum2 = cli_nt_create_full(&cli1, fname, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0); + + if (fnum2 != -1) { + printf("[3] open - 2 of %s succeeded - should have failed.\n", fname); + return; + } + + /* This should succeed. */ + + fnum2 = cli_nt_create_full(&cli1, fname, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0); + + if (fnum2 == -1) { + printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_nt_delete_on_close(&cli1, fnum1, True)) { + printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[3] close 1 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum2)) { + printf("[3] close 2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + /* This should fail - file should no longer be there. */ + + fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_NONE); + if (fnum1 != -1) { + printf("[3] open of %s succeeded should have been deleted on close !\n", fname); + if (!cli_close(&cli1, fnum1)) { + printf("[3] close failed (%s)\n", cli_errstr(&cli1)); + } + cli_unlink(&cli1, fname); + } else + printf("third delete on close test succeeded.\n"); + + /* Test 4 ... */ + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + fnum1 = cli_nt_create_full(&cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0); + + if (fnum1 == -1) { + printf("[4] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + /* This should succeed. */ + fnum2 = cli_nt_create_full(&cli1, fname, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0); + if (fnum2 == -1) { + printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum2)) { + printf("[4] close - 1 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (!cli_nt_delete_on_close(&cli1, fnum1, True)) { + printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(&cli1)); + return; + } + + /* This should fail - no more opens once delete on close set. */ + fnum2 = cli_nt_create_full(&cli1, fname, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0); + if (fnum2 != -1) { + printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname ); + return; + } else + printf("fourth delete on close test succeeded.\n"); + + if (!cli_close(&cli1, fnum1)) { + printf("[4] close - 2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + /* Test 5 ... */ + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT, DENY_NONE); + if (fnum1 == -1) { + printf("[5] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + /* This should fail - only allowed on NT opens with DELETE access. */ + + if (cli_nt_delete_on_close(&cli1, fnum1, True)) { + printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n"); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[5] close - 2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + printf("fifth delete on close test succeeded.\n"); + + /* Test 6 ... */ + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + fnum1 = cli_nt_create_full(&cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0); + + if (fnum1 == -1) { + printf("[6] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + /* This should fail - only allowed on NT opens with DELETE access. */ + + if (cli_nt_delete_on_close(&cli1, fnum1, True)) { + printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n"); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[6] close - 2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + printf("sixth delete on close test succeeded.\n"); + + /* Test 7 ... */ + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + fnum1 = cli_nt_create_full(&cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0); + + if (fnum1 == -1) { + printf("[7] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_nt_delete_on_close(&cli1, fnum1, True)) { + printf("[7] setting delete_on_close on file failed !\n"); + return; + } + + if (!cli_nt_delete_on_close(&cli1, fnum1, False)) { + printf("[7] unsetting delete_on_close on file failed !\n"); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[7] close - 2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + /* This next open should succeed - we reset the flag. */ + + fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_NONE); + if (fnum1 == -1) { + printf("[5] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[7] close - 2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + printf("seventh delete on close test succeeded.\n"); + + /* Test 7 ... */ + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + if (!open_connection(&cli2)) { + printf("[8] failed to open second connection.\n"); + return; + } + + cli_sockopt(&cli1, sockops); + + fnum1 = cli_nt_create_full(&cli1, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0); + + if (fnum1 == -1) { + printf("[8] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + fnum2 = cli_nt_create_full(&cli2, fname, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0); + + if (fnum2 == -1) { + printf("[8] open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_nt_delete_on_close(&cli1, fnum1, True)) { + printf("[8] setting delete_on_close on file failed !\n"); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("[8] close - 1 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli2, fnum2)) { + printf("[8] close - 2 failed (%s)\n", cli_errstr(&cli2)); + return; + } + + /* This should fail.. */ + fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_NONE); + if (fnum1 != -1) { + printf("[8] open of %s succeeded should have been deleted on close !\n", fname); + if (!cli_close(&cli1, fnum1)) { + printf("[8] close failed (%s)\n", cli_errstr(&cli1)); + } + cli_unlink(&cli1, fname); + } else + printf("eighth delete on close test succeeded.\n"); + + printf("finished delete test\n"); + + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + close_connection(&cli1); + close_connection(&cli2); +} + +/* + Test open mode returns on read-only files. + */ +static void run_opentest(int dummy) +{ + static struct cli_state cli1; + char *fname = "\\readonly.file"; + int fnum1, fnum2; + uint8 eclass; + uint32 errnum; + char buf[20]; + size_t fsize; + + printf("starting open test\n"); + + if (!open_connection(&cli1)) { + return; + } + + cli_setatr(&cli1, fname, 0, 0); + cli_unlink(&cli1, fname); + + cli_sockopt(&cli1, sockops); + + fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE); + if (fnum1 == -1) { + printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("close2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (!cli_setatr(&cli1, fname, aRONLY, 0)) { + printf("cli_setatr failed (%s)\n", cli_errstr(&cli1)); + return; + } + + fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_WRITE); + if (fnum1 == -1) { + printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */ + fnum2 = cli_open(&cli1, fname, O_RDWR, DENY_ALL); + + cli_error( &cli1, &eclass, &errnum, NULL); + + if (eclass != ERRDOS || errnum != ERRnoaccess) { + printf("wrong error code (%x,%x) = %s\n", (unsigned int)eclass, + (unsigned int)errnum, cli_errstr(&cli1) ); + } else { + printf("correct error code ERRDOS/ERRnoaccess returned\n"); + } + + + printf("finished open test 1\n"); + + cli_close(&cli1, fnum1); + + /* Now try not readonly and ensure ERRbadshare is returned. */ + + cli_setatr(&cli1, fname, 0, 0); + + fnum1 = cli_open(&cli1, fname, O_RDONLY, DENY_WRITE); + if (fnum1 == -1) { + printf("open of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + /* This will fail - but the error should be ERRshare. */ + fnum2 = cli_open(&cli1, fname, O_RDWR, DENY_ALL); + + cli_error( &cli1, &eclass, &errnum, NULL); + + if (eclass != ERRDOS || errnum != ERRbadshare) { + printf("wrong error code (%x,%x) = %s\n", (unsigned int)eclass, + (unsigned int)errnum, cli_errstr(&cli1) ); + } else { + printf("correct error code ERRDOS/ERRbadshare returned\n"); + } + + if (!cli_close(&cli1, fnum1)) { + printf("close2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + cli_unlink(&cli1, fname); + + printf("finished open test 2\n"); + + /* Test truncate open disposition on file opened for read. */ + + fnum1 = cli_open(&cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE); + if (fnum1 == -1) { + printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + /* write 20 bytes. */ + + memset(buf, '\0', 20); + + if (cli_write(&cli1, fnum1, 0, buf, 0, 20) != 20) { + printf("write failed (%s)\n", cli_errstr(&cli1)); + } + + if (!cli_close(&cli1, fnum1)) { + printf("(3) close1 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + /* Ensure size == 20. */ + if (!cli_getatr(&cli1, fname, NULL, &fsize, NULL)) { + printf("(3) getatr failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (fsize != 20) { + printf("(3) file size != 20\n"); + return; + } + + /* Now test if we can truncate a file opened for readonly. */ + + fnum1 = cli_open(&cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE); + if (fnum1 == -1) { + printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return; + } + + if (!cli_close(&cli1, fnum1)) { + printf("close2 failed (%s)\n", cli_errstr(&cli1)); + return; + } + + /* Ensure size == 0. */ + if (!cli_getatr(&cli1, fname, NULL, &fsize, NULL)) { + printf("(3) getatr failed (%s)\n", cli_errstr(&cli1)); + return; + } + + if (fsize != 0) { + printf("(3) file size != 0\n"); + return; + } + printf("finished open test 3\n"); + + cli_unlink(&cli1, fname); + + + printf("testing ctemp\n"); + { + char *tmp_path; + fnum1 = cli_ctemp(&cli1, "\\", &tmp_path); + if (fnum1 == -1) { + printf("ctemp failed (%s)\n", cli_errstr(&cli1)); + return; + } + printf("ctemp gave path %s\n", tmp_path); + cli_close(&cli1, fnum1); + cli_unlink(&cli1, tmp_path); + } + + close_connection(&cli1); + +} + +static void list_fn(file_info *finfo, const char *name, void *state) +{ + +} + +/* + test directory listing speed + */ +static void run_dirtest(int dummy) +{ + int i; + static struct cli_state cli; + int fnum; + double t1; + + printf("starting directory test\n"); + + if (!open_connection(&cli)) { + return; + } + + cli_sockopt(&cli, sockops); + + srandom(0); + for (i=0;i TEST1 TEST2 ...\n"); + + printf("\t-d debuglevel\n"); + printf("\t-U user%%pass\n"); + printf("\t-N numprocs\n"); + printf("\t-n my_netbios_name\n"); + printf("\t-W workgroup\n"); + printf("\t-o num_operations\n"); + printf("\t-O socket_options\n"); + printf("\t-m maximum protocol\n"); + printf("\t-L use oplocks\n"); + printf("\n\n"); + + printf("tests are:"); + for (i=0;torture_ops[i].name;i++) { + printf(" %s", torture_ops[i].name); + } + printf("\n"); + + printf("default test is ALL\n"); + + exit(1); +} + + + + + +/**************************************************************************** + main program +****************************************************************************/ + int main(int argc,char *argv[]) +{ + int opt, i; + char *p; + int gotpass = 0; + extern char *optarg; + extern int optind; + extern FILE *dbf; + static pstring servicesf = CONFIGFILE; + + dbf = stdout; + + setbuffer(stdout, NULL, 0); + + charset_initialise(); + + codepage_initialise(lp_client_code_page()); + + codepage_initialise(lp_client_code_page()); + + lp_load(servicesf,True,False,False); + load_interfaces(); + + if (argc < 2) { + usage(); + } + + for(p = argv[1]; *p; p++) + if(*p == '\\') + *p = '/'; + + if (strncmp(argv[1], "//", 2)) { + usage(); + } + + fstrcpy(host, &argv[1][2]); + p = strchr(&host[2],'/'); + if (!p) { + usage(); + } + *p = 0; + fstrcpy(share, p+1); + + get_myname(myname); + + if (*username == 0 && getenv("LOGNAME")) { + pstrcpy(username,getenv("LOGNAME")); + } + + argc--; + argv++; + + + fstrcpy(workgroup, lp_workgroup()); + + while ((opt = getopt(argc, argv, "hW:U:n:N:O:o:m:Ld:")) != EOF) { + switch (opt) { + case 'W': + fstrcpy(workgroup,optarg); + break; + case 'm': + max_protocol = interpret_protocol(optarg, max_protocol); + break; + case 'N': + nprocs = atoi(optarg); + break; + case 'o': + numops = atoi(optarg); + break; + case 'd': + DEBUGLEVEL = atoi(optarg); + break; + case 'O': + sockops = optarg; + break; + case 'L': + use_oplocks = True; + break; + case 'n': + fstrcpy(myname, optarg); + break; + case 'U': + pstrcpy(username,optarg); + p = strchr(username,'%'); + if (p) { + *p = 0; + pstrcpy(password, p+1); + gotpass = 1; + } + break; + default: + printf("Unknown option %c (%d)\n", (char)opt, opt); + usage(); + } + } + + + while (!gotpass) { + p = getpass("Password:"); + if (p) { + pstrcpy(password, p); + gotpass = 1; + } + } + + printf("host=%s share=%s user=%s myname=%s\n", + host, share, username, myname); + + if (argc == 1) { + run_test("ALL"); + } else { + for (i=1;iserver_domain || *c->server_os || *c->server_type) - DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n", - c->server_domain,c->server_os,c->server_type)); - - DEBUG(4,(" session setup ok\n")); - - if (!cli_send_tconX(c, share, "?????", - password, strlen(password)+1)) { - DEBUG(0,("tree connect failed: %s\n", cli_errstr(c))); - cli_shutdown(c); - return NULL; - } - - DEBUG(4,(" tconx ok\n")); - - c->use_oplocks = use_oplocks; - - return c; -} - - -static void reconnect(struct cli_state *cli[NSERVERS][NCONNECTIONS], int fnum[NSERVERS][NCONNECTIONS][NFILES], - char *share[NSERVERS]) -{ - int server, conn, f; - - for (server=0;serverconn; - unsigned f = rec->f; - SMB_BIG_UINT start = rec->start; - SMB_BIG_UINT len = rec->len; - unsigned r1 = rec->r1; - unsigned r2 = rec->r2; - unsigned op; - int server; - BOOL ret[NSERVERS]; - - if (r1 < READ_PCT) { - op = READ_LOCK; - } else { - op = WRITE_LOCK; - } - - if (r2 < LOCK_PCT) { - /* set a lock */ - for (server=0;server %u:%u\n", - conn, f, - (double)start, (double)start+len-1, (double)len, - op==READ_LOCK?"READ_LOCK":"WRITE_LOCK", - ret[0], ret[1]); - } - if (showall || ret[0] != ret[1]) show_locks(); - if (ret[0] != ret[1]) return False; - } else if (r2 < LOCK_PCT+UNLOCK_PCT) { - /* unset a lock */ - for (server=0;server %u:%u\n", - conn, f, - (double)start, (double)start+len-1, (double)len, - ret[0], ret[1]); - } - if (showall || ret[0] != ret[1]) show_locks(); - if (!hide_unlock_fails && ret[0] != ret[1]) return False; - } else { - /* reopen the file */ - for (server=0;serverserver_domain || *c->server_os || *c->server_type) - DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n", - c->server_domain,c->server_os,c->server_type)); - - DEBUG(4,(" session setup ok\n")); - - if (!cli_send_tconX(c, share, "?????", - password, strlen(password)+1)) { - DEBUG(0,("tree connect failed: %s\n", cli_errstr(c))); - cli_shutdown(c); - return NULL; - } - - DEBUG(4,(" tconx ok\n")); - - c->use_oplocks = use_oplocks; - - return c; -} - - -static void reconnect(struct cli_state *cli[NSERVERS][NCONNECTIONS], - char *nfs[NSERVERS], - int fnum[NSERVERS][NUMFSTYPES][NCONNECTIONS][NFILES], - char *share1, char *share2) -{ - int server, conn, f, fstype; - char *share[2]; - share[0] = share1; - share[1] = share2; - - fstype = FSTYPE_SMB; - - for (server=0;serverconn; - unsigned f = rec->f; - unsigned fstype = rec->fstype; - unsigned start = rec->start; - unsigned len = rec->len; - unsigned r1 = rec->r1; - unsigned r2 = rec->r2; - unsigned op; - int server; - BOOL ret[NSERVERS]; - - if (r1 < READ_PCT) { - op = READ_LOCK; - } else { - op = WRITE_LOCK; - } - - if (r2 < LOCK_PCT) { - /* set a lock */ - for (server=0;server %u:%u\n", - conn, fstype, f, - start, start+len-1, len, - op==READ_LOCK?"READ_LOCK":"WRITE_LOCK", - ret[0], ret[1]); - } - if (showall) brl_forall(print_brl); - if (ret[0] != ret[1]) return False; - } else if (r2 < LOCK_PCT+UNLOCK_PCT) { - /* unset a lock */ - for (server=0;server %u:%u\n", - conn, fstype, f, - start, start+len-1, len, - ret[0], ret[1]); - } - if (showall) brl_forall(print_brl); - if (!hide_unlock_fails && ret[0] != ret[1]) return False; - } else { - /* reopen the file */ - for (server=0;server': - if (n[0] == '.') { - if (! n[1] && ms_fnmatch_lanman_core(p, n+1) == 0) goto match; - if (ms_fnmatch_lanman_core(p, n) == 0) goto match; - goto nomatch; - } - if (! *n) goto next; - n++; - break; - - case '*': - if (! *p) goto match; - for (; *n; n++) { - if (ms_fnmatch_lanman_core(p, n) == 0) goto match; - } - break; - - case '<': - for (; *n; n++) { - if (ms_fnmatch_lanman_core(p, n) == 0) goto match; - if (*n == '.' && !strchr(n+1,'.')) { - n++; - break; - } - } - break; - - case '"': - if (*n == 0 && ms_fnmatch_lanman_core(p, n) == 0) goto match; - if (*n != '.') goto nomatch; - n++; - break; - - default: - if (c != *n) goto nomatch; - n++; - } - } - - if (! *n) goto match; - - nomatch: - if (verbose) printf("NOMATCH pattern=[%s] string=[%s]\n", pattern, string); - return -1; - -next: - if (ms_fnmatch_lanman_core(p, n) == 0) goto match; - goto nomatch; - - match: - if (verbose) printf("MATCH pattern=[%s] string=[%s]\n", pattern, string); - return 0; -} - -int ms_fnmatch_lanman(char *pattern, char *string) -{ - if (!strpbrk(pattern, "?*<>\"")) { - if (strcmp(string,"..") == 0) string = "."; - return strcmp(pattern, string); - } - - if (strcmp(string,"..") == 0 || strcmp(string,".") == 0) { - return ms_fnmatch_lanman_core(pattern, "..") && - ms_fnmatch_lanman_core(pattern, "."); - } - - return ms_fnmatch_lanman_core(pattern, string); -} - -static BOOL reg_match_one(char *pattern, char *file) -{ - /* oh what a weird world this is */ - if (old_list && strcmp(pattern, "*.*") == 0) return True; - - if (strcmp(pattern,".") == 0) return False; - - if (max_protocol <= PROTOCOL_LANMAN2) { - return ms_fnmatch_lanman(pattern, file)==0; - } - - if (strcmp(file,"..") == 0) file = "."; - - return ms_fnmatch(pattern, file)==0; -} - -static char *reg_test(char *pattern, char *long_name, char *short_name) -{ - static fstring ret; - fstrcpy(ret, "---"); - - pattern = 1+strrchr(pattern,'\\'); - - if (reg_match_one(pattern, ".")) ret[0] = '+'; - if (reg_match_one(pattern, "..")) ret[1] = '+'; - if (reg_match_one(pattern, long_name) || - (*short_name && reg_match_one(pattern, short_name))) ret[2] = '+'; - return ret; -} - - -/***************************************************** -return a connection to a server -*******************************************************/ -struct cli_state *connect_one(char *share) -{ - struct cli_state *c; - struct nmb_name called, calling; - char *server_n; - char *server; - struct in_addr ip; - extern struct in_addr ipzero; - - server = share+2; - share = strchr(server,'\\'); - if (!share) return NULL; - *share = 0; - share++; - - server_n = server; - - ip = ipzero; - - make_nmb_name(&calling, "masktest", 0x0); - make_nmb_name(&called , server, 0x20); - - again: - ip = ipzero; - - /* have to open a new connection */ - if (!(c=cli_initialise(NULL)) || (cli_set_port(c, 139) == 0) || - !cli_connect(c, server_n, &ip)) { - DEBUG(0,("Connection to %s failed\n", server_n)); - return NULL; - } - - c->protocol = max_protocol; - - if (!cli_session_request(c, &calling, &called)) { - DEBUG(0,("session request to %s failed\n", called.name)); - cli_shutdown(c); - if (strcmp(called.name, "*SMBSERVER")) { - make_nmb_name(&called , "*SMBSERVER", 0x20); - goto again; - } - return NULL; - } - - DEBUG(4,(" session request ok\n")); - - if (!cli_negprot(c)) { - DEBUG(0,("protocol negotiation failed\n")); - cli_shutdown(c); - return NULL; - } - - if (!got_pass) { - char *pass = getpass("Password: "); - if (pass) { - pstrcpy(password, pass); - } - } - - if (!cli_session_setup(c, username, - password, strlen(password), - password, strlen(password), - lp_workgroup())) { - DEBUG(0,("session setup failed: %s\n", cli_errstr(c))); - return NULL; - } - - /* - * These next two lines are needed to emulate - * old client behaviour for people who have - * scripts based on client output. - * QUESTION ? Do we want to have a 'client compatibility - * mode to turn these on/off ? JRA. - */ - - if (*c->server_domain || *c->server_os || *c->server_type) - DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n", - c->server_domain,c->server_os,c->server_type)); - - DEBUG(4,(" session setup ok\n")); - - if (!cli_send_tconX(c, share, "?????", - password, strlen(password)+1)) { - DEBUG(0,("tree connect failed: %s\n", cli_errstr(c))); - cli_shutdown(c); - return NULL; - } - - DEBUG(4,(" tconx ok\n")); - - return c; -} - -static char *resultp; -static file_info *finfo; - -void listfn(file_info *f, const char *s, void *state) -{ - if (strcmp(f->name,".") == 0) { - resultp[0] = '+'; - } else if (strcmp(f->name,"..") == 0) { - resultp[1] = '+'; - } else { - resultp[2] = '+'; - } - finfo = f; -} - -static void get_real_name(struct cli_state *cli, - pstring long_name, fstring short_name) -{ - /* nasty hack to force level 260 listings - tridge */ - cli->capabilities |= CAP_NT_SMBS; - if (max_protocol <= PROTOCOL_LANMAN1) { - cli_list_new(cli, "\\masktest\\*.*", aHIDDEN | aDIR, listfn, NULL); - } else { - cli_list_new(cli, "\\masktest\\*", aHIDDEN | aDIR, listfn, NULL); - } - if (finfo) { - fstrcpy(short_name, finfo->short_name); - strlower(short_name); - pstrcpy(long_name, finfo->name); - strlower(long_name); - } - - if (*short_name == 0) { - fstrcpy(short_name, long_name); - } - -#if 0 - if (!strchr(short_name,'.')) { - fstrcat(short_name,"."); - } -#endif -} - -static void testpair(struct cli_state *cli, char *mask, char *file) -{ - int fnum; - fstring res1; - char *res2; - static int count; - fstring short_name; - pstring long_name; - - count++; - - fstrcpy(res1, "---"); - - fnum = cli_open(cli, file, O_CREAT|O_TRUNC|O_RDWR, 0); - if (fnum == -1) { - DEBUG(0,("Can't create %s\n", file)); - return; - } - cli_close(cli, fnum); - - resultp = res1; - fstrcpy(short_name, ""); - finfo = NULL; - get_real_name(cli, long_name, short_name); - finfo = NULL; - fstrcpy(res1, "---"); - cli_list(cli, mask, aHIDDEN | aDIR, listfn, NULL); - - res2 = reg_test(mask, long_name, short_name); - - if (showall || strcmp(res1, res2)) { - DEBUG(0,("%s %s %d mask=[%s] file=[%s] rfile=[%s/%s]\n", - res1, res2, count, mask, file, long_name, short_name)); - if (die_on_error) exit(1); - } - - cli_unlink(cli, file); - - if (count % 100 == 0) DEBUG(0,("%d\n", count)); -} - -static void test_mask(int argc, char *argv[], - struct cli_state *cli) -{ - pstring mask, file; - int l1, l2, i, l; - int mc_len = strlen(maskchars); - int fc_len = strlen(filechars); - - cli_mkdir(cli, "\\masktest"); - - cli_unlink(cli, "\\masktest\\*"); - - if (argc >= 2) { - while (argc >= 2) { - pstrcpy(mask,"\\masktest\\"); - pstrcpy(file,"\\masktest\\"); - pstrcat(mask, argv[0]); - pstrcat(file, argv[1]); - testpair(cli, mask, file); - argv += 2; - argc -= 2; - } - goto finished; - } - - while (1) { - l1 = 1 + random() % 20; - l2 = 1 + random() % 20; - pstrcpy(mask,"\\masktest\\"); - pstrcpy(file,"\\masktest\\"); - l = strlen(mask); - for (i=0;i st_size) { -#if NBDEBUG - printf("(%d) needs expanding %s to %d from %d\n", - line_count, fname, size, (int)st_size); -#endif - } else if (size < st_size) { -#if NBDEBUG - printf("(%d) needs truncating %s to %d from %d\n", - line_count, fname, size, (int)st_size); -#endif - } - for (i=0;icapabilities |= CAP_NT_SMBS; -} - -/**************************************************************************** -make smb client connection -****************************************************************************/ -static BOOL rpcclient_connect(struct client_info *info) -{ - struct nmb_name calling; - struct nmb_name called; - - make_nmb_name(&called , dns_to_netbios_name(info->dest_host ), info->name_type); - make_nmb_name(&calling, dns_to_netbios_name(info->myhostname), 0x0); - - if (!cli_establish_connection(smb_cli, - info->dest_host, &info->dest_ip, - &calling, &called, - info->share, info->svc_type, - False, True)) - { - DEBUG(0,("rpcclient_connect: connection failed\n")); - cli_shutdown(smb_cli); - return False; - } - - return True; -} - -/**************************************************************************** -stop the smb connection(s?) -****************************************************************************/ -static void rpcclient_stop(void) -{ - cli_shutdown(smb_cli); -} - -/**************************************************************************** - log in as an nt user, log out again. -****************************************************************************/ -void run_enums_test(int num_ops, struct client_info *cli_info, struct cli_state *cli) -{ - pstring cmd; - int i; - - /* establish connections. nothing to stop these being re-established. */ - rpcclient_connect(cli_info); - - DEBUG(5,("rpcclient_connect: cli->fd:%d\n", cli->fd)); - if (cli->fd <= 0) - { - fprintf(out_hnd, "warning: connection could not be established to %s<%02x>\n", - cli_info->dest_host, cli_info->name_type); - return; - } - - for (i = 0; i < num_ops; i++) - { - set_first_token(""); - cmd_srv_enum_sess(cli_info); - set_first_token(""); - cmd_srv_enum_shares(cli_info); - set_first_token(""); - cmd_srv_enum_files(cli_info); - - if (password[0] != 0) - { - slprintf(cmd, sizeof(cmd)-1, "1"); - set_first_token(cmd); - } - else - { - set_first_token(""); - } - cmd_srv_enum_conn(cli_info); - } - - rpcclient_stop(); - -} - -/**************************************************************************** - log in as an nt user, log out again. -****************************************************************************/ -void run_ntlogin_test(int num_ops, struct client_info *cli_info, struct cli_state *cli) -{ - pstring cmd; - int i; - - /* establish connections. nothing to stop these being re-established. */ - rpcclient_connect(cli_info); - - DEBUG(5,("rpcclient_connect: cli->fd:%d\n", cli->fd)); - if (cli->fd <= 0) - { - fprintf(out_hnd, "warning: connection could not be established to %s<%02x>\n", - cli_info->dest_host, cli_info->name_type); - return; - } - - for (i = 0; i < num_ops; i++) - { - slprintf(cmd, sizeof(cmd)-1, "%s %s", cli->user_name, password); - set_first_token(cmd); - - cmd_netlogon_login_test(cli_info); - } - - rpcclient_stop(); - -} - -/**************************************************************************** - runs n simultaneous functions. -****************************************************************************/ -static void create_procs(int nprocs, int numops, - struct client_info *cli_info, struct cli_state *cli, - void (*fn)(int, struct client_info *, struct cli_state *)) -{ - int i, status; - - for (i=0;i [-d debuglevel] [-l log] ", - pname); - - fprintf(out_hnd, "\nVersion %s\n",VERSION); - fprintf(out_hnd, "\t-d debuglevel set the debuglevel\n"); - fprintf(out_hnd, "\t-l log basename. Basename for log/debug files\n"); - fprintf(out_hnd, "\t-n netbios name. Use this name as my netbios name\n"); - fprintf(out_hnd, "\t-m max protocol set the max protocol level\n"); - fprintf(out_hnd, "\t-I dest IP use this IP to connect to\n"); - fprintf(out_hnd, "\t-E write messages to stderr instead of stdout\n"); - fprintf(out_hnd, "\t-U username set the network username\n"); - fprintf(out_hnd, "\t-W workgroup set the workgroup name\n"); - fprintf(out_hnd, "\t-t terminal code terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n"); - fprintf(out_hnd, "\n"); -} - -enum client_action -{ - CLIENT_NONE, - CLIENT_IPC, - CLIENT_SVC -}; - -/**************************************************************************** - main program -****************************************************************************/ - int main(int argc,char *argv[]) -{ - char *pname = argv[0]; - int opt; - extern FILE *dbf; - extern char *optarg; - extern int optind; - static pstring servicesf = CONFIGFILE; - pstring term_code; - BOOL got_pass = False; - char *cmd_str=""; - mode_t myumask = 0755; - enum client_action cli_action = CLIENT_NONE; - int nprocs = 1; - int numops = 100; - - struct client_info cli_info; - - out_hnd = stdout; - - rpcclient_init(); - -#ifdef KANJI - pstrcpy(term_code, KANJI); -#else /* KANJI */ - *term_code = 0; -#endif /* KANJI */ - - if (!lp_load(servicesf,True, False, False)) - { - fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf); - } - - codepage_initialise(lp_client_code_page()); - - DEBUGLEVEL = 0; - - cli_info.put_total_size = 0; - cli_info.put_total_time_ms = 0; - cli_info.get_total_size = 0; - cli_info.get_total_time_ms = 0; - - cli_info.dir_total = 0; - cli_info.newer_than = 0; - cli_info.archive_level = 0; - cli_info.print_mode = 1; - - cli_info.translation = False; - cli_info.recurse_dir = False; - cli_info.lowercase = False; - cli_info.prompt = True; - cli_info.abort_mget = True; - - cli_info.dest_ip.s_addr = 0; - cli_info.name_type = 0x20; - - pstrcpy(cli_info.cur_dir , "\\"); - pstrcpy(cli_info.file_sel, ""); - pstrcpy(cli_info.base_dir, ""); - pstrcpy(smb_cli->domain, ""); - pstrcpy(smb_cli->user_name, ""); - pstrcpy(cli_info.myhostname, ""); - pstrcpy(cli_info.dest_host, ""); - - pstrcpy(cli_info.svc_type, "A:"); - pstrcpy(cli_info.share, ""); - pstrcpy(cli_info.service, ""); - - ZERO_STRUCT(cli_info.dom.level3_sid); - pstrcpy(cli_info.dom.level3_dom, ""); - ZERO_STRUCT(cli_info.dom.level5_sid); - pstrcpy(cli_info.dom.level5_dom, ""); - - smb_cli->nt_pipe_fnum = 0xffff; - - setup_logging(pname, True); - - TimeInit(); - charset_initialise(); - - myumask = umask(0); - umask(myumask); - - if (!get_myname(global_myname)) - { - fprintf(stderr, "Failed to get my hostname.\n"); - } - - password[0] = 0; - - if (argc < 2) - { - usage(pname); - exit(1); - } - - if (*argv[1] != '-') - { - pstrcpy(cli_info.service, argv[1]); - /* Convert any '/' characters in the service name to '\' characters */ - string_replace( cli_info.service, '/','\\'); - argc--; - argv++; - - DEBUG(1,("service: %s\n", cli_info.service)); - - if (count_chars(cli_info.service,'\\') < 3) - { - usage(pname); - printf("\n%s: Not enough '\\' characters in service\n", cli_info.service); - exit(1); - } - - /* - if (count_chars(cli_info.service,'\\') > 3) - { - usage(pname); - printf("\n%s: Too many '\\' characters in service\n", cli_info.service); - exit(1); - } - */ - - if (argc > 1 && (*argv[1] != '-')) - { - got_pass = True; - pstrcpy(password,argv[1]); - memset(argv[1],'X',strlen(argv[1])); - argc--; - argv++; - } - - cli_action = CLIENT_SVC; - } - - while ((opt = getopt(argc, argv,"s:O:M:S:i:N:o:n:d:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF) - { - switch (opt) - { - case 'm': - { - /* FIXME ... max_protocol seems to be funny here */ - - int max_protocol = 0; - max_protocol = interpret_protocol(optarg,max_protocol); - fprintf(stderr, "max protocol not currently supported\n"); - break; - } - - case 'O': - { - pstrcpy(user_socket_options,optarg); - break; - } - - case 'S': - { - pstrcpy(cli_info.dest_host,optarg); - strupper(cli_info.dest_host); - cli_action = CLIENT_IPC; - break; - } - - case 'i': - { - pstrcpy(scope, optarg); - break; - } - - case 'U': - { - char *lp; - pstrcpy(smb_cli->user_name,optarg); - if ((lp=strchr(smb_cli->user_name,'%'))) - { - *lp = 0; - pstrcpy(password,lp+1); - got_pass = True; - memset(strchr(optarg,'%')+1,'X',strlen(password)); - } - break; - } - - case 'W': - { - pstrcpy(smb_cli->domain,optarg); - break; - } - - case 'E': - { - dbf = stderr; - break; - } - - case 'I': - { - cli_info.dest_ip = *interpret_addr2(optarg); - if (zero_ip(cli_info.dest_ip)) - { - exit(1); - } - break; - } - - case 'N': - { - nprocs = atoi(optarg); - break; - } - - case 'o': - { - numops = atoi(optarg); - break; - } - - case 'n': - { - fstrcpy(global_myname, optarg); - break; - } - - case 'd': - { - if (*optarg == 'A') - DEBUGLEVEL = 10000; - else - DEBUGLEVEL = atoi(optarg); - break; - } - - case 'l': - { - slprintf(debugf, sizeof(debugf)-1, - "%s.client",optarg); - break; - } - - case 'c': - { - cmd_str = optarg; - got_pass = True; - break; - } - - case 'h': - { - usage(pname); - exit(0); - break; - } - - case 's': - { - pstrcpy(servicesf, optarg); - break; - } - - case 't': - { - pstrcpy(term_code, optarg); - break; - } - - default: - { - usage(pname); - exit(1); - break; - } - } - } - - if (cli_action == CLIENT_NONE) - { - usage(pname); - exit(1); - } - - strupper(global_myname); - fstrcpy(cli_info.myhostname, global_myname); - - DEBUG(3,("%s client started (version %s)\n",timestring(False),VERSION)); - - if (*smb_cli->domain == 0) - { - pstrcpy(smb_cli->domain,lp_workgroup()); - } - strupper(smb_cli->domain); - - load_interfaces(); - - if (cli_action == CLIENT_IPC) - { - pstrcpy(cli_info.share, "IPC$"); - pstrcpy(cli_info.svc_type, "IPC"); - } - - fstrcpy(cli_info.mach_acct, cli_info.myhostname); - strupper(cli_info.mach_acct); - fstrcat(cli_info.mach_acct, "$"); - - /* set the password cache info */ - if (got_pass) - { - if (password[0] == 0) - { - pwd_set_nullpwd(&(smb_cli->pwd)); - } - else - { - pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */ - } - } - else - { - char *pwd = getpass("Enter Password:"); - safe_strcpy(password, pwd, sizeof(password)); - pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */ - } - - create_procs(nprocs, numops, &cli_info, smb_cli, run_enums_test); - - if (password[0] != 0) - { - create_procs(nprocs, numops, &cli_info, smb_cli, run_ntlogin_test); - } - - fflush(out_hnd); - - return(0); -} -- cgit