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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
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.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
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 bool use_oplocks;
+static bool use_level_II_oplocks;
static const char *client_txt = "client_oplocks.txt";
-static BOOL use_kerberos;
+static bool use_kerberos;
static fstring multishare_conn_fname;
-static BOOL use_multishare_conn = False;
+static bool use_multishare_conn = False;
+static bool do_encrypt;
-BOOL torture_showall = False;
+bool torture_showall = False;
-static double create_procs(BOOL (*fn)(int), BOOL *result);
+static double create_procs(bool (*fn)(int), bool *result);
static struct timeval tp1,tp2;
return ret;
}
+/********************************************************************
+ Ensure a connection is encrypted.
+********************************************************************/
+
+static bool force_cli_encryption(struct cli_state *c,
+ const char *sharename)
+{
+ uint16 major, minor;
+ uint32 caplow, caphigh;
+ NTSTATUS status;
+
+ if (!SERVER_HAS_UNIX_CIFS(c)) {
+ d_printf("Encryption required and "
+ "server that doesn't support "
+ "UNIX extensions - failing connect\n");
+ return false;
+ }
+
+ if (!cli_unix_extensions_version(c, &major, &minor, &caplow, &caphigh)) {
+ d_printf("Encryption required and "
+ "can't get UNIX CIFS extensions "
+ "version from server.\n");
+ return false;
+ }
+
+ if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
+ d_printf("Encryption required and "
+ "share %s doesn't support "
+ "encryption.\n", sharename);
+ return false;
+ }
+
+ if (c->use_kerberos) {
+ status = cli_gss_smb_encryption_start(c);
+ } else {
+ status = cli_raw_ntlm_smb_encryption_start(c,
+ username,
+ password,
+ workgroup);
+ }
+
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("Encryption required and "
+ "setup failed with error %s.\n",
+ nt_errstr(status));
+ return false;
+ }
+
+ return true;
+}
+
static struct cli_state *open_nbt_connection(void)
{
struct nmb_name called, calling;
- struct in_addr ip;
+ struct sockaddr_storage ss;
struct cli_state *c;
+ NTSTATUS status;
make_nmb_name(&calling, myname, 0x0);
make_nmb_name(&called , host, 0x20);
- zero_ip(&ip);
+ zero_sockaddr(&ss);
if (!(c = cli_initialise())) {
printf("Failed initialize cli_struct to connect with %s\n", host);
c->port = port_to_use;
- if (!cli_connect(c, host, &ip)) {
- printf("Failed to connect with %s\n", host);
+ status = cli_connect(c, host, &ss);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
return NULL;
}
if (!cli_session_request(c, &calling, &called)) {
/*
- * Well, that failed, try *SMBSERVER ...
+ * Well, that failed, try *SMBSERVER ...
* However, we must reconnect as well ...
*/
- if (!cli_connect(c, host, &ip)) {
- printf("Failed to connect with %s\n", host);
+ status = cli_connect(c, host, &ss);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
return NULL;
}
/*
parse a //server/share type UNC name
*/
-BOOL smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
+bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
char **hostname, char **sharename)
{
char *p;
return False;
}
-static BOOL torture_open_connection_share(struct cli_state **c,
+static bool torture_open_connection_share(struct cli_state **c,
const char *hostname,
const char *sharename)
{
- BOOL retry;
+ bool retry;
int flags = 0;
NTSTATUS status;
if (use_level_II_oplocks) (*c)->use_level_II_oplocks = True;
(*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
- return True;
-}
-
-void torture_open_connection_free_unclist(char **unc_list)
-{
- if (unc_list!=NULL)
- {
- SAFE_FREE(unc_list[0]);
- SAFE_FREE(unc_list);
+ if (do_encrypt) {
+ return force_cli_encryption(*c,
+ sharename);
}
+ return True;
}
-BOOL torture_open_connection(struct cli_state **c, int conn_index)
+bool torture_open_connection(struct cli_state **c, int conn_index)
{
char **unc_list = NULL;
int num_unc_names = 0;
- BOOL result;
+ bool result;
if (use_multishare_conn==True) {
char *h, *s;
- unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0);
+ unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL);
if (!unc_list || num_unc_names <= 0) {
printf("Failed to load unc names list from '%s'\n", multishare_conn_fname);
exit(1);
NULL, &h, &s)) {
printf("Failed to parse UNC name %s\n",
unc_list[conn_index % num_unc_names]);
- torture_open_connection_free_unclist(unc_list);
+ TALLOC_FREE(unc_list);
exit(1);
}
result = torture_open_connection_share(c, h, s);
/* h, s were copied earlier */
- torture_open_connection_free_unclist(unc_list);
+ TALLOC_FREE(unc_list);
return result;
}
return torture_open_connection_share(c, host, share);
}
-BOOL torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
+bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
{
uint16 old_vuid = cli->vuid;
fstring old_user_name;
size_t passlen = strlen(password);
- BOOL ret;
+ bool ret;
fstrcpy(old_user_name, cli->user_name);
cli->vuid = 0;
}
-BOOL torture_close_connection(struct cli_state *c)
+bool torture_close_connection(struct cli_state *c)
{
- BOOL ret = True;
+ bool ret = True;
if (!cli_tdis(c)) {
printf("tdis failed (%s)\n", cli_errstr(c));
ret = False;
/* check if the server produced the expected error code */
-static BOOL check_error(int line, struct cli_state *c,
+static bool check_error(int line, struct cli_state *c,
uint8 eclass, uint32 ecode, NTSTATUS nterr)
{
if (cli_is_dos_error(c)) {
}
-static BOOL wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
+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(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
}
-static BOOL rw_torture(struct cli_state *c)
+static bool rw_torture(struct cli_state *c)
{
const char *lockfname = "\\torture.lck";
fstring fname;
pid_t pid2, pid = getpid();
int i, j;
char buf[1024];
- BOOL correct = True;
+ bool correct = True;
+
+ memset(buf, '\0', sizeof(buf));
fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
DENY_NONE);
return correct;
}
-static BOOL run_torture(int dummy)
+static bool run_torture(int dummy)
{
struct cli_state *cli;
- BOOL ret;
+ bool ret;
cli = current_cli;
return ret;
}
-static BOOL rw_torture3(struct cli_state *c, char *lockfname)
+static bool rw_torture3(struct cli_state *c, char *lockfname)
{
int fnum = -1;
unsigned int i = 0;
unsigned count;
unsigned countprev = 0;
ssize_t sent = 0;
- BOOL correct = True;
+ bool correct = True;
srandom(1);
for (i = 0; i < sizeof(buf); i += sizeof(uint32))
return correct;
}
-static BOOL rw_torture2(struct cli_state *c1, struct cli_state *c2)
+static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
{
const char *lockfname = "\\torture2.lck";
int fnum1;
int i;
char buf[131072];
char buf_rd[131072];
- BOOL correct = True;
+ bool correct = True;
ssize_t bytes_read;
if (!cli_unlink(c1, lockfname)) {
return correct;
}
-static BOOL run_readwritetest(int dummy)
+static bool run_readwritetest(int dummy)
{
static struct cli_state *cli1, *cli2;
- BOOL test1, test2 = False;
+ bool test1, test2 = False;
if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
return False;
return (test1 && test2);
}
-static BOOL run_readwritemulti(int dummy)
+static bool run_readwritemulti(int dummy)
{
struct cli_state *cli;
- BOOL test;
+ bool test;
cli = current_cli;
return test;
}
-static BOOL run_readwritelarge(int dummy)
+static bool run_readwritelarge(int dummy)
{
static struct cli_state *cli1;
int fnum1;
const char *lockfname = "\\large.dat";
SMB_OFF_T fsize;
char buf[126*1024];
- BOOL correct = True;
+ bool correct = True;
if (!torture_open_connection(&cli1, 0)) {
return False;
#define ival(s) strtol(s, NULL, 0)
/* run a test that simulates an approximate netbench client load */
-static BOOL run_netbench(int client)
+static bool run_netbench(int client)
{
struct cli_state *cli;
int i;
- pstring line;
+ char line[1024];
char cname[20];
FILE *f;
const char *params[20];
- BOOL correct = True;
+ bool correct = True;
cli = current_cli;
}
while (fgets(line, sizeof(line)-1, f)) {
+ char *saveptr;
line_count++;
line[strlen(line)-1] = 0;
/* printf("[%d] %s\n", line_count, line); */
all_string_sub(line,"client1", cname, sizeof(line));
-
+
/* parse the command parameters */
- params[0] = strtok(line," ");
+ params[0] = strtok_r(line, " ", &saveptr);
i = 0;
- while (params[i]) params[++i] = strtok(NULL," ");
+ while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr);
params[i] = "";
/* run a test that simulates an approximate netbench client load */
-static BOOL run_nbench(int dummy)
+static bool run_nbench(int dummy)
{
double t;
- BOOL correct = True;
+ bool correct = True;
nbio_shmem(nprocs);
must not use posix semantics)
2) support for lock timeouts
*/
-static BOOL run_locktest1(int dummy)
+static bool run_locktest1(int dummy)
{
struct cli_state *cli1, *cli2;
const char *fname = "\\lockt1.lck";
this checks to see if a secondary tconx can use open files from an
earlier tconx
*/
-static BOOL run_tcon_test(int dummy)
+static bool run_tcon_test(int dummy)
{
static struct cli_state *cli;
const char *fname = "\\tcontest.tmp";
uint16 cnum1, cnum2, cnum3;
uint16 vuid1, vuid2;
char buf[4];
- BOOL ret = True;
+ bool ret = True;
+
+ memset(buf, '\0', sizeof(buf));
if (!torture_open_connection(&cli, 0)) {
return False;
/*
checks for old style tcon support
*/
-static BOOL run_tcon2_test(int dummy)
+static bool run_tcon2_test(int dummy)
{
static struct cli_state *cli;
uint16 cnum, max_xmit;
return True;
}
-static BOOL tcon_devtest(struct cli_state *cli,
+static bool tcon_devtest(struct cli_state *cli,
const char *myshare, const char *devtype,
const char *return_devtype,
NTSTATUS expected_error)
{
- BOOL status;
- BOOL ret;
+ bool status;
+ bool ret;
status = cli_send_tconX(cli, myshare, devtype,
password, strlen(password)+1);
/*
checks for correct tconX support
*/
-static BOOL run_tcon_devtype_test(int dummy)
+static bool run_tcon_devtype_test(int dummy)
{
static struct cli_state *cli1 = NULL;
- BOOL retry;
+ bool retry;
int flags = 0;
NTSTATUS status;
- BOOL ret = True;
+ bool ret = True;
status = cli_full_connection(&cli1, myname,
host, NULL, port_to_use,
3) the server denies unlock requests by an incorrect client PID
*/
-static BOOL run_locktest2(int dummy)
+static bool run_locktest2(int dummy)
{
static struct cli_state *cli;
const char *fname = "\\lockt2.lck";
int fnum1, fnum2, fnum3;
- BOOL correct = True;
+ bool correct = True;
if (!torture_open_connection(&cli, 0)) {
return False;
1) the server supports the full offset range in lock requests
*/
-static BOOL run_locktest3(int dummy)
+static bool run_locktest3(int dummy)
{
static struct cli_state *cli1, *cli2;
const char *fname = "\\lockt3.lck";
int fnum1, fnum2, i;
uint32 offset;
- BOOL correct = True;
+ bool correct = True;
#define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
/*
looks at overlapping locks
*/
-static BOOL run_locktest4(int dummy)
+static bool run_locktest4(int dummy)
{
static struct cli_state *cli1, *cli2;
const char *fname = "\\lockt4.lck";
int fnum1, fnum2, f;
- BOOL ret;
+ bool ret;
char buf[1000];
- BOOL correct = True;
+ bool correct = True;
if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
return False;
/*
looks at lock upgrade/downgrade.
*/
-static BOOL run_locktest5(int dummy)
+static bool run_locktest5(int dummy)
{
static struct cli_state *cli1, *cli2;
const char *fname = "\\lockt5.lck";
int fnum1, fnum2, fnum3;
- BOOL ret;
+ bool ret;
char buf[1000];
- BOOL correct = True;
+ bool correct = True;
if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
return False;
/*
tries the unusual lockingX locktype bits
*/
-static BOOL run_locktest6(int dummy)
+static bool run_locktest6(int dummy)
{
static struct cli_state *cli;
const char *fname[1] = { "\\lock6.txt" };
return True;
}
-static BOOL run_locktest7(int dummy)
+static bool run_locktest7(int dummy)
{
struct cli_state *cli1;
const char *fname = "\\lockt7.lck";
int fnum1;
char buf[200];
- BOOL correct = False;
+ bool correct = False;
if (!torture_open_connection(&cli1, 0)) {
return False;
test whether fnums and tids open on one VC are available on another (a major
security hole)
*/
-static BOOL run_fdpasstest(int dummy)
+static bool run_fdpasstest(int dummy)
{
struct cli_state *cli1, *cli2;
const char *fname = "\\fdpass.tst";
int fnum1;
- pstring buf;
+ char buf[1024];
if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
return False;
return True;
}
-static BOOL run_fdsesstest(int dummy)
+static bool run_fdsesstest(int dummy)
{
struct cli_state *cli;
uint16 new_vuid;
const char *fname1 = "\\fdsess1.tst";
int fnum1;
int fnum2;
- pstring buf;
- BOOL ret = True;
+ char buf[1024];
+ bool ret = True;
if (!torture_open_connection(&cli, 0))
return False;
1) the server does not allow an unlink on a file that is open
*/
-static BOOL run_unlinktest(int dummy)
+static bool run_unlinktest(int dummy)
{
struct cli_state *cli;
const char *fname = "\\unlink.tst";
int fnum;
- BOOL correct = True;
+ bool correct = True;
if (!torture_open_connection(&cli, 0)) {
return False;
/*
test how many open files this server supports on the one socket
*/
-static BOOL run_maxfidtest(int dummy)
+static bool run_maxfidtest(int dummy)
{
struct cli_state *cli;
const char *ftemplate = "\\maxfid.%d.%d";
fstring fname;
int fnums[0x11000], i;
int retries=4;
- BOOL correct = True;
+ bool correct = True;
cli = current_cli;
}
/* send smb negprot commands, not reading the response */
-static BOOL run_negprot_nowait(int dummy)
+static bool run_negprot_nowait(int dummy)
{
int i;
static struct cli_state *cli;
- BOOL correct = True;
+ bool correct = True;
printf("starting negprot nowait test\n");
/* send random IPC commands */
-static BOOL run_randomipc(int dummy)
+static bool run_randomipc(int dummy)
{
char *rparam = NULL;
char *rdata = NULL;
unsigned int rdrcnt,rprcnt;
- pstring param;
+ char param[1024];
int api, param_len, i;
struct cli_state *cli;
- BOOL correct = True;
+ bool correct = True;
int count = 50000;
printf("starting random ipc test\n");
This test checks the browse list code
*/
-static BOOL run_browsetest(int dummy)
+static bool run_browsetest(int dummy)
{
static struct cli_state *cli;
- BOOL correct = True;
+ bool correct = True;
printf("starting browse test\n");
/*
This checks how the getatr calls works
*/
-static BOOL run_attrtest(int dummy)
+static bool run_attrtest(int dummy)
{
struct cli_state *cli;
int fnum;
time_t t, t2;
const char *fname = "\\attrib123456789.tst";
- BOOL correct = True;
+ bool correct = True;
printf("starting attrib test\n");
/*
This checks a couple of trans2 calls
*/
-static BOOL run_trans2test(int dummy)
+static bool run_trans2test(int dummy)
{
struct cli_state *cli;
int fnum;
const char *fname = "\\trans2.tst";
const char *dname = "\\trans2";
const char *fname2 = "\\trans2\\trans2.tst";
- pstring pname;
- BOOL correct = True;
+ char pname[1024];
+ bool correct = True;
printf("starting trans2 test\n");
correct = False;
}
- if (!cli_qfilename(cli, fnum, pname)) {
+ if (!cli_qfilename(cli, fnum, pname, sizeof(pname))) {
printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
correct = False;
}
This checks new W2K calls.
*/
-static BOOL new_trans(struct cli_state *pcli, int fnum, int level)
+static bool new_trans(struct cli_state *pcli, int fnum, int level)
{
char *buf = NULL;
uint32 len;
- BOOL correct = True;
+ bool correct = True;
if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
correct = False;
} else {
printf("qfileinfo: level %d, len = %u\n", level, len);
- dump_data(0, buf, len);
+ dump_data(0, (uint8 *)buf, len);
printf("\n");
}
SAFE_FREE(buf);
return correct;
}
-static BOOL run_w2ktest(int dummy)
+static bool run_w2ktest(int dummy)
{
struct cli_state *cli;
int fnum;
const char *fname = "\\w2ktest\\w2k.tst";
int level;
- BOOL correct = True;
+ bool correct = True;
printf("starting w2k test\n");
/*
this is a harness for some oplock tests
*/
-static BOOL run_oplock1(int dummy)
+static bool run_oplock1(int dummy)
{
struct cli_state *cli1;
const char *fname = "\\lockt1.lck";
int fnum1;
- BOOL correct = True;
+ bool correct = True;
printf("starting oplock test 1\n");
return correct;
}
-static BOOL run_oplock2(int dummy)
+static bool run_oplock2(int dummy)
{
struct cli_state *cli1, *cli2;
const char *fname = "\\lockt2.lck";
int fnum1, fnum2;
int saved_use_oplocks = use_oplocks;
char buf[4];
- BOOL correct = True;
- volatile BOOL *shared_correct;
+ bool correct = True;
+ volatile bool *shared_correct;
- shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
+ shared_correct = (volatile bool *)shm_setup(sizeof(bool));
*shared_correct = True;
use_level_II_oplocks = True;
}
/* handler for oplock 3 tests */
-static BOOL oplock3_handler(struct cli_state *cli, int fnum, unsigned char level)
+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 BOOL run_oplock3(int dummy)
+static bool run_oplock3(int dummy)
{
struct cli_state *cli;
const char *fname = "\\oplockt3.dat";
int fnum;
char buf[4] = "abcd";
- BOOL correct = True;
- volatile BOOL *shared_correct;
+ bool correct = True;
+ volatile bool *shared_correct;
- shared_correct = (volatile BOOL *)shm_setup(sizeof(BOOL));
+ shared_correct = (volatile bool *)shm_setup(sizeof(bool));
*shared_correct = True;
printf("starting oplock test 3\n");
/*
Test delete on close semantics.
*/
-static BOOL run_deletetest(int dummy)
+static bool run_deletetest(int dummy)
{
struct cli_state *cli1 = NULL;
struct cli_state *cli2 = NULL;
const char *fname = "\\delete.file";
int fnum1 = -1;
int fnum2 = -1;
- BOOL correct = True;
+ bool correct = True;
printf("starting delete test\n");
/*
print out server properties
*/
-static BOOL run_properties(int dummy)
+static bool run_properties(int dummy)
{
static struct cli_state *cli;
- BOOL correct = True;
+ bool correct = True;
printf("starting properties test\n");
/*
Test ntcreate calls made by xcopy
*/
-static BOOL run_xcopy(int dummy)
+static bool run_xcopy(int dummy)
{
static struct cli_state *cli1;
const char *fname = "\\test.txt";
- BOOL correct = True;
+ bool correct = True;
int fnum1, fnum2;
printf("starting xcopy test\n");
/*
Test rename on files open with share delete and no share delete.
*/
-static BOOL run_rename(int dummy)
+static bool run_rename(int dummy)
{
static struct cli_state *cli1;
const char *fname = "\\test.txt";
const char *fname1 = "\\test1.txt";
- BOOL correct = True;
+ bool correct = True;
int fnum1;
printf("starting rename test\n");
}
if (!cli_rename(cli1, fname, fname1)) {
- printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have failed ! \n");
+ printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n",
+ cli_errstr(cli1));
correct = False;
} else {
printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", cli_errstr(cli1));
return correct;
}
-static BOOL run_pipe_number(int dummy)
+static bool run_pipe_number(int dummy)
{
struct cli_state *cli1;
const char *pipe_name = "\\SPOOLSS";
/*
Test open mode returns on read-only files.
*/
-static BOOL run_opentest(int dummy)
+static bool run_opentest(int dummy)
{
static struct cli_state *cli1;
static struct cli_state *cli2;
int fnum1, fnum2;
char buf[20];
SMB_OFF_T fsize;
- BOOL correct = True;
+ bool correct = True;
char *tmp_path;
printf("starting open test\n");
{ 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
};
-static BOOL run_openattrtest(int dummy)
+static bool run_openattrtest(int dummy)
{
static struct cli_state *cli1;
const char *fname = "\\openattr.file";
int fnum1;
- BOOL correct = True;
+ bool correct = True;
uint16 attr;
unsigned int i, j, k, l;
/*
test directory listing speed
*/
-static BOOL run_dirtest(int dummy)
+static bool run_dirtest(int dummy)
{
int i;
static struct cli_state *cli;
int fnum;
double t1;
- BOOL correct = True;
+ bool correct = True;
printf("starting directory test\n");
/*
sees what IOCTLs are supported
*/
-BOOL torture_ioctl_test(int dummy)
+bool torture_ioctl_test(int dummy)
{
static struct cli_state *cli;
uint16 device, function;
/*
tries varients of chkpath
*/
-BOOL torture_chkpath_test(int dummy)
+bool torture_chkpath_test(int dummy)
{
static struct cli_state *cli;
int fnum;
- BOOL ret;
+ bool ret;
if (!torture_open_connection(&cli, 0)) {
return False;
return ret;
}
-static BOOL run_eatest(int dummy)
+static bool run_eatest(int dummy)
{
static struct cli_state *cli;
const char *fname = "\\eatest.txt";
- BOOL correct = True;
+ bool correct = True;
int fnum, i;
size_t num_eas;
struct ea_struct *ea_list = NULL;
printf("starting eatest\n");
if (!torture_open_connection(&cli, 0)) {
+ talloc_destroy(mem_ctx);
return False;
}
if (fnum == -1) {
printf("open failed - %s\n", cli_errstr(cli));
+ talloc_destroy(mem_ctx);
return False;
}
memset(ea_val, (char)i+1, i+1);
if (!cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1)) {
printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
+ talloc_destroy(mem_ctx);
return False;
}
}
memset(ea_val, (char)i+1, i+1);
if (!cli_set_ea_path(cli, fname, ea_name, ea_val, i+1)) {
printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
+ talloc_destroy(mem_ctx);
return False;
}
}
for (i = 0; i < num_eas; i++) {
printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
- dump_data(0, (char *)ea_list[i].value.data,
+ dump_data(0, ea_list[i].value.data,
ea_list[i].value.length);
}
slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
if (!cli_set_ea_path(cli, fname, ea_name, "", 0)) {
printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
+ talloc_destroy(mem_ctx);
return False;
}
}
printf("num_eas = %d\n", (int)num_eas);
for (i = 0; i < num_eas; i++) {
printf("%d: ea_name = %s. Val = ", i, ea_list[i].name);
- dump_data(0, (char *)ea_list[i].value.data,
+ dump_data(0, ea_list[i].value.data,
ea_list[i].value.length);
}
return correct;
}
-static BOOL run_dirtest1(int dummy)
+static bool run_dirtest1(int dummy)
{
int i;
static struct cli_state *cli;
int fnum, num_seen;
- BOOL correct = True;
+ bool correct = True;
printf("starting directory test\n");
return correct;
}
-static BOOL run_error_map_extract(int dummy) {
+static bool run_error_map_extract(int dummy) {
static struct cli_state *c_dos;
static struct cli_state *c_nt;
return True;
}
-static BOOL run_local_substitute(int dummy)
+static bool run_sesssetup_bench(int dummy)
{
- TALLOC_CTX *mem_ctx;
- int diff = 0;
-
- if ((mem_ctx = talloc_init("run_local_subst")) == NULL) {
- printf("talloc_init failed\n");
- return False;
- }
-
- diff |= strcmp(talloc_sub_specified(mem_ctx, "%U", "bla", "", -1, -1),
- "bla");
- diff |= strcmp(talloc_sub_specified(mem_ctx, "%u%U", "bla", "", -1, -1),
- "blabla");
- diff |= strcmp(talloc_sub_specified(mem_ctx, "%g", "", "", -1, -1),
- "NO_GROUP");
- diff |= strcmp(talloc_sub_specified(mem_ctx, "%G", "", "", -1, -1),
- "NO_GROUP");
- diff |= strcmp(talloc_sub_specified(mem_ctx, "%g", "", "", -1, 0),
- gidtoname(0));
- diff |= strcmp(talloc_sub_specified(mem_ctx, "%G", "", "", -1, 0),
- gidtoname(0));
- diff |= strcmp(talloc_sub_specified(mem_ctx, "%D%u", "u", "dom", -1, 0),
- "domu");
- diff |= strcmp(talloc_sub_specified(mem_ctx, "%i %I", "", "", -1, -1),
- "0.0.0.0 0.0.0.0");
+ static struct cli_state *c;
+ NTSTATUS status;
+ int i;
+
+ if (!(c = open_nbt_connection())) {
+ return false;
+ }
+
+ if (!cli_negprot(c)) {
+ printf("%s rejected the NT-error negprot (%s)\n", host,
+ cli_errstr(c));
+ cli_shutdown(c);
+ return false;
+ }
+
+ for (i=0; i<torture_numops; i++) {
+ status = cli_session_setup(
+ c, username,
+ password, strlen(password),
+ password, strlen(password),
+ workgroup);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("(%s) cli_session_setup failed: %s\n",
+ __location__, nt_errstr(status));
+ return false;
+ }
+
+ if (!cli_ulogoff(c)) {
+ d_printf("(%s) cli_ulogoff failed: %s\n",
+ __location__, cli_errstr(c));
+ return false;
+ }
+ c->vuid = 0;
+ }
+
+ return true;
+}
+
+static bool subst_test(const char *str, const char *user, const char *domain,
+ uid_t uid, gid_t gid, const char *expected)
+{
+ char *subst;
+ bool result = true;
+
+ subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
+
+ if (strcmp(subst, expected) != 0) {
+ printf("sub_specified(%s, %s, %s, %d, %d) returned [%s], expected "
+ "[%s]\n", str, user, domain, (int)uid, (int)gid, subst,
+ expected);
+ result = false;
+ }
+
+ TALLOC_FREE(subst);
+ return result;
+}
+
+static void chain1_open_completion(struct async_req *req)
+{
+ int fnum;
+ NTSTATUS status;
+
+ status = cli_open_recv(req, &fnum);
+ TALLOC_FREE(req);
+
+ d_printf("cli_open_recv returned %s: %d\n",
+ nt_errstr(status),
+ NT_STATUS_IS_OK(status) ? fnum : -1);
+}
+
+static void chain1_read_completion(struct async_req *req)
+{
+ NTSTATUS status;
+ ssize_t received;
+ uint8_t *rcvbuf;
+
+ status = cli_read_andx_recv(req, &received, &rcvbuf);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(req);
+ d_printf("cli_read_andx_recv returned %s\n",
+ nt_errstr(status));
+ return;
+ }
+
+ d_printf("got %d bytes: %.*s\n", (int)received, (int)received,
+ (char *)rcvbuf);
+ TALLOC_FREE(req);
+}
+
+static void chain1_close_completion(struct async_req *req)
+{
+ NTSTATUS status;
+
+ status = cli_close_recv(req);
+ *((bool *)(req->async.priv)) = true;
+
+ TALLOC_FREE(req);
+
+ d_printf("cli_close returned %s\n", nt_errstr(status));
+}
+
+static bool run_chain1(int dummy)
+{
+ struct cli_state *cli1;
+ struct event_context *evt = event_context_init(NULL);
+ struct async_req *reqs[4];
+ bool done = false;
+
+ printf("starting chain1 test\n");
+ if (!torture_open_connection(&cli1, 0)) {
+ return False;
+ }
+
+ cli_sockopt(cli1, sockops);
+
+ cli_chain_cork(cli1, evt, 0);
+ reqs[0] = cli_open_send(talloc_tos(), evt, cli1, "\\test",
+ O_CREAT|O_RDWR, 0);
+ reqs[0]->async.fn = chain1_open_completion;
+ reqs[1] = cli_read_andx_send(talloc_tos(), evt, cli1, 0, 0, 10);
+ reqs[1]->async.fn = chain1_read_completion;
+ reqs[2] = cli_read_andx_send(talloc_tos(), evt, cli1, 0, 1, 10);
+ reqs[2]->async.fn = chain1_read_completion;
+ reqs[3] = cli_close_send(talloc_tos(), evt, cli1, 0);
+ reqs[3]->async.fn = chain1_close_completion;
+ reqs[3]->async.priv = (void *)&done;
+ cli_chain_uncork(cli1);
+
+ while (!done) {
+ event_loop_once(evt);
+ }
+
+ torture_close_connection(cli1);
+ return True;
+}
+
+static bool run_cli_echo(int dummy)
+{
+ struct cli_state *cli;
+ struct event_context *ev = event_context_init(NULL);
+ struct async_req *req;
+ NTSTATUS status;
+
+ printf("starting chain1 test\n");
+ if (!torture_open_connection(&cli, 0)) {
+ return false;
+ }
+ cli_sockopt(cli, sockops);
+
+ req = cli_echo_send(ev, ev, cli, 5, data_blob_const("hello", 5));
+ if (req == NULL) {
+ d_printf("cli_echo_send failed\n");
+ return false;
+ }
+
+ while (req->state < ASYNC_REQ_DONE) {
+ event_loop_once(ev);
+ }
+
+ status = cli_echo_recv(req);
+ d_printf("cli_echo returned %s\n", nt_errstr(status));
+
+ TALLOC_FREE(req);
+
+ torture_close_connection(cli);
+ return NT_STATUS_IS_OK(status);
+}
+
+static bool run_local_substitute(int dummy)
+{
+ bool ok = true;
+
+ ok &= subst_test("%U", "bla", "", -1, -1, "bla");
+ ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla");
+ ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP");
+ ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP");
+ ok &= subst_test("%g", "", "", -1, 0, gidtoname(0));
+ ok &= subst_test("%G", "", "", -1, 0, gidtoname(0));
+ ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu");
+ ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0");
/* Different captialization rules in sub_basic... */
- diff |= strcmp(talloc_sub_basic(mem_ctx, "BLA", "dom", "%U%D"),
- "blaDOM");
+ ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"),
+ "blaDOM") == 0);
- TALLOC_FREE(mem_ctx);
- return (diff == 0);
+ return ok;
}
-static BOOL run_local_gencache(int dummy)
+static bool run_local_gencache(int dummy)
{
char *val;
time_t tm;
+ DATA_BLOB blob;
if (!gencache_init()) {
d_printf("%s: gencache_init() failed\n", __location__);
return False;
}
+ blob = data_blob_string_const_null("bar");
+ tm = time(NULL);
+
+ if (!gencache_set_data_blob("foo", &blob, tm)) {
+ d_printf("%s: gencache_set_data_blob() failed\n", __location__);
+ return False;
+ }
+
+ data_blob_free(&blob);
+
+ if (!gencache_get_data_blob("foo", &blob, NULL)) {
+ d_printf("%s: gencache_get_data_blob() failed\n", __location__);
+ return False;
+ }
+
+ if (strcmp((const char *)blob.data, "bar") != 0) {
+ d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n",
+ __location__, (const char *)blob.data, "bar");
+ data_blob_free(&blob);
+ return False;
+ }
+
+ data_blob_free(&blob);
+
+ if (!gencache_del("foo")) {
+ d_printf("%s: gencache_del() failed\n", __location__);
+ return False;
+ }
+ if (gencache_del("foo")) {
+ d_printf("%s: second gencache_del() succeeded\n",
+ __location__);
+ return False;
+ }
+
+ if (gencache_get_data_blob("foo", &blob, NULL)) {
+ d_printf("%s: gencache_get_data_blob() on deleted entry "
+ "succeeded\n", __location__);
+ return False;
+ }
+
if (!gencache_shutdown()) {
d_printf("%s: gencache_shutdown() failed\n", __location__);
return False;
return True;
}
-static double create_procs(BOOL (*fn)(int), BOOL *result)
+static bool rbt_testval(struct db_context *db, const char *key,
+ const char *value)
+{
+ struct db_record *rec;
+ TDB_DATA data = string_tdb_data(value);
+ bool ret = false;
+ NTSTATUS status;
+
+ rec = db->fetch_locked(db, db, string_tdb_data(key));
+ if (rec == NULL) {
+ d_fprintf(stderr, "fetch_locked failed\n");
+ goto done;
+ }
+ status = rec->store(rec, data, 0);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
+ goto done;
+ }
+ TALLOC_FREE(rec);
+
+ rec = db->fetch_locked(db, db, string_tdb_data(key));
+ if (rec == NULL) {
+ d_fprintf(stderr, "second fetch_locked failed\n");
+ goto done;
+ }
+ if ((rec->value.dsize != data.dsize)
+ || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
+ d_fprintf(stderr, "Got wrong data back\n");
+ goto done;
+ }
+
+ ret = true;
+ done:
+ TALLOC_FREE(rec);
+ return ret;
+}
+
+static bool run_local_rbtree(int dummy)
+{
+ struct db_context *db;
+ bool ret = false;
+ int i;
+
+ db = db_open_rbt(NULL);
+
+ if (db == NULL) {
+ d_fprintf(stderr, "db_open_rbt failed\n");
+ return false;
+ }
+
+ for (i=0; i<1000; i++) {
+ char *key, *value;
+
+ asprintf(&key, "key%ld", random());
+ asprintf(&value, "value%ld", random());
+
+ if (!rbt_testval(db, key, value)) {
+ SAFE_FREE(key);
+ SAFE_FREE(value);
+ goto done;
+ }
+
+ SAFE_FREE(value);
+ asprintf(&value, "value%ld", random());
+
+ if (!rbt_testval(db, key, value)) {
+ SAFE_FREE(key);
+ SAFE_FREE(value);
+ goto done;
+ }
+
+ SAFE_FREE(key);
+ SAFE_FREE(value);
+ }
+
+ ret = true;
+
+ done:
+ TALLOC_FREE(db);
+ return ret;
+}
+
+static bool test_stream_name(const char *fname, const char *expected_base,
+ const char *expected_stream,
+ NTSTATUS expected_status)
+{
+ NTSTATUS status;
+ char *base = NULL;
+ char *stream = NULL;
+
+ status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream);
+ if (!NT_STATUS_EQUAL(status, expected_status)) {
+ goto error;
+ }
+
+ if (!NT_STATUS_IS_OK(status)) {
+ return true;
+ }
+
+ if (base == NULL) goto error;
+
+ if (strcmp(expected_base, base) != 0) goto error;
+
+ if ((expected_stream != NULL) && (stream == NULL)) goto error;
+ if ((expected_stream == NULL) && (stream != NULL)) goto error;
+
+ if ((stream != NULL) && (strcmp(expected_stream, stream) != 0))
+ goto error;
+
+ TALLOC_FREE(base);
+ TALLOC_FREE(stream);
+ return true;
+
+ error:
+ d_fprintf(stderr, "test_stream(%s, %s, %s, %s)\n",
+ fname, expected_base ? expected_base : "<NULL>",
+ expected_stream ? expected_stream : "<NULL>",
+ nt_errstr(expected_status));
+ d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n",
+ base ? base : "<NULL>", stream ? stream : "<NULL>",
+ nt_errstr(status));
+ TALLOC_FREE(base);
+ TALLOC_FREE(stream);
+ return false;
+}
+
+static bool run_local_stream_name(int dummy)
+{
+ bool ret = true;
+
+ ret &= test_stream_name(
+ "bla", "bla", NULL, NT_STATUS_OK);
+ ret &= test_stream_name(
+ "bla::$DATA", "bla", NULL, NT_STATUS_OK);
+ ret &= test_stream_name(
+ "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
+ ret &= test_stream_name(
+ "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID);
+ ret &= test_stream_name(
+ "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID);
+ ret &= test_stream_name(
+ "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK);
+ ret &= test_stream_name(
+ "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK);
+ ret &= test_stream_name(
+ "bla:x", "bla", "x:$DATA", NT_STATUS_OK);
+
+ return ret;
+}
+
+static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b)
+{
+ if (a.length != b.length) {
+ printf("a.length=%d != b.length=%d\n",
+ (int)a.length, (int)b.length);
+ return false;
+ }
+ if (memcmp(a.data, b.data, a.length) != 0) {
+ printf("a.data and b.data differ\n");
+ return false;
+ }
+ return true;
+}
+
+static bool run_local_memcache(int dummy)
+{
+ struct memcache *cache;
+ DATA_BLOB k1, k2;
+ DATA_BLOB d1, d2, d3;
+ DATA_BLOB v1, v2, v3;
+
+ TALLOC_CTX *mem_ctx;
+ char *str1, *str2;
+ size_t size1, size2;
+ bool ret = false;
+
+ cache = memcache_init(NULL, 100);
+
+ if (cache == NULL) {
+ printf("memcache_init failed\n");
+ return false;
+ }
+
+ d1 = data_blob_const("d1", 2);
+ d2 = data_blob_const("d2", 2);
+ d3 = data_blob_const("d3", 2);
+
+ k1 = data_blob_const("d1", 2);
+ k2 = data_blob_const("d2", 2);
+
+ memcache_add(cache, STAT_CACHE, k1, d1);
+ memcache_add(cache, GETWD_CACHE, k2, d2);
+
+ if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
+ printf("could not find k1\n");
+ return false;
+ }
+ if (!data_blob_equal(d1, v1)) {
+ return false;
+ }
+
+ if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
+ printf("could not find k2\n");
+ return false;
+ }
+ if (!data_blob_equal(d2, v2)) {
+ return false;
+ }
+
+ memcache_add(cache, STAT_CACHE, k1, d3);
+
+ if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
+ printf("could not find replaced k1\n");
+ return false;
+ }
+ if (!data_blob_equal(d3, v3)) {
+ return false;
+ }
+
+ memcache_add(cache, GETWD_CACHE, k1, d1);
+
+ if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
+ printf("Did find k2, should have been purged\n");
+ return false;
+ }
+
+ TALLOC_FREE(cache);
+
+ cache = memcache_init(NULL, 0);
+
+ mem_ctx = talloc_init("foo");
+
+ str1 = talloc_strdup(mem_ctx, "string1");
+ str2 = talloc_strdup(mem_ctx, "string2");
+
+ memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
+ data_blob_string_const("torture"), &str1);
+ size1 = talloc_total_size(cache);
+
+ memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
+ data_blob_string_const("torture"), &str2);
+ size2 = talloc_total_size(cache);
+
+ printf("size1=%d, size2=%d\n", (int)size1, (int)size2);
+
+ if (size2 > size1) {
+ printf("memcache leaks memory!\n");
+ goto fail;
+ }
+
+ ret = true;
+ fail:
+ TALLOC_FREE(cache);
+ return ret;
+}
+
+static double create_procs(bool (*fn)(int), bool *result)
{
int i, status;
volatile pid_t *child_status;
- volatile BOOL *child_status_out;
+ volatile bool *child_status_out;
int synccount;
int tries = 8;
return -1;
}
- child_status_out = (volatile BOOL *)shm_setup(sizeof(BOOL)*nprocs);
+ child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
if (!child_status_out) {
printf("Failed to setup result status shared memory\n");
return -1;
static struct {
const char *name;
- BOOL (*fn)(int);
+ bool (*fn)(int);
unsigned flags;
} torture_ops[] = {
{"FDPASS", run_fdpasstest, 0},
{"CHKPATH", torture_chkpath_test, 0},
{"FDSESS", run_fdsesstest, 0},
{ "EATEST", run_eatest, 0},
+ { "SESSSETUP_BENCH", run_sesssetup_bench, 0},
+ { "CHAIN1", run_chain1, 0},
+ { "CLI_ECHO", run_cli_echo, 0},
{ "LOCAL-SUBSTITUTE", run_local_substitute, 0},
{ "LOCAL-GENCACHE", run_local_gencache, 0},
+ { "LOCAL-RBTREE", run_local_rbtree, 0},
+ { "LOCAL-MEMCACHE", run_local_memcache, 0},
+ { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
{NULL, NULL, 0}};
/****************************************************************************
run a specified test or "ALL"
****************************************************************************/
-static BOOL run_test(const char *name)
+static bool run_test(const char *name)
{
- BOOL ret = True;
- BOOL result = True;
- BOOL found = False;
+ bool ret = True;
+ bool result = True;
+ bool found = False;
int i;
double t;
if (strequal(name,"ALL")) {
char *p;
int gotuser = 0;
int gotpass = 0;
- BOOL correct = True;
+ bool correct = True;
+ TALLOC_CTX *frame = talloc_stackframe();
+ int seed = time(NULL);
dbf = x_stdout;
load_case_tables();
- lp_load(dyn_CONFIGFILE,True,False,False,True);
+ lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
load_interfaces();
if (argc < 2) {
*p = 0;
fstrcpy(share, p+1);
- get_myname(myname);
+ fstrcpy(myname, talloc_get_myname(talloc_tos()));
+ if (!*myname) {
+ fprintf(stderr, "Failed to get my hostname.\n");
+ return 1;
+ }
if (*username == 0 && getenv("LOGNAME")) {
fstrcpy(username,getenv("LOGNAME"));
argc--;
argv++;
- srandom(time(NULL));
-
fstrcpy(workgroup, lp_workgroup());
- while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Ac:ks:b:")) != EOF) {
+ while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Aec:ks:b:")) != EOF) {
switch (opt) {
case 'p':
port_to_use = atoi(optarg);
break;
case 's':
- srandom(atoi(optarg));
+ seed = atoi(optarg);
break;
case 'W':
fstrcpy(workgroup,optarg);
case 'c':
client_txt = optarg;
break;
+ case 'e':
+ do_encrypt = true;
+ break;
case 'k':
#ifdef HAVE_KRB5
use_kerberos = True;
}
}
+ d_printf("using seed %d\n", seed);
+
+ srandom(seed);
+
if(use_kerberos && !gotuser) gotpass = True;
while (!gotpass) {
}
}
+ TALLOC_FREE(frame);
+
if (correct) {
return(0);
} else {
git.samba.org / samba.git / blobdiff