static int nprocs=1;
static int port_to_use=0;
int torture_numops=100;
+int torture_blocksize=1024*1024;
static int procnum; /* records process count number when forking */
static struct cli_state *current_cli;
static fstring randomfname;
make_nmb_name(&calling, myname, 0x0);
make_nmb_name(&called , host, 0x20);
- zero_addr(&ss);
+ zero_sockaddr(&ss);
if (!(c = cli_initialise())) {
printf("Failed initialize cli_struct to connect with %s\n", host);
printf("starting tcon2 test\n");
- asprintf(&service, "\\\\%s\\%s", host, share);
+ if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) {
+ return false;
+ }
status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum);
}
for (i=0;i<50000;i++) {
- cli_negprot_send(cli);
+ cli_negprot_sendsync(cli);
}
if (!torture_close_connection(cli)) {
static struct cli_state *c_dos;
static struct cli_state *c_nt;
+ NTSTATUS status;
uint32 error;
c_nt->use_spnego = False;
- if (!cli_negprot(c_nt)) {
- printf("%s rejected the NT-error negprot (%s)\n",host, cli_errstr(c_nt));
+ status = cli_negprot(c_nt);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("%s rejected the NT-error negprot (%s)\n", host,
+ nt_errstr(status));
cli_shutdown(c_nt);
return False;
}
c_dos->use_spnego = False;
c_dos->force_dos_errors = True;
- if (!cli_negprot(c_dos)) {
- printf("%s rejected the DOS-error negprot (%s)\n",host, cli_errstr(c_dos));
+ status = cli_negprot(c_dos);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("%s rejected the DOS-error negprot (%s)\n", host,
+ nt_errstr(status));
cli_shutdown(c_dos);
return False;
}
static bool run_sesssetup_bench(int dummy)
{
static struct cli_state *c;
+ const char *fname = "\\file.dat";
+ int fnum;
NTSTATUS status;
int i;
- if (!(c = open_nbt_connection())) {
+ if (!torture_open_connection(&c, 0)) {
return false;
}
- if (!cli_negprot(c)) {
- printf("%s rejected the NT-error negprot (%s)\n", host,
- cli_errstr(c));
- cli_shutdown(c);
+ fnum = cli_nt_create_full(
+ c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
+ FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
+ FILE_DELETE_ON_CLOSE, 0);
+ if (fnum == -1) {
+ d_printf("open %s failed: %s\n", fname, cli_errstr(c));
return false;
}
return false;
}
+ d_printf("\r%d ", (int)c->vuid);
+
if (!cli_ulogoff(c)) {
d_printf("(%s) cli_ulogoff failed: %s\n",
__location__, cli_errstr(c));
TALLOC_FREE(req);
}
+static void chain1_write_completion(struct async_req *req)
+{
+ NTSTATUS status;
+ size_t written;
+
+ status = cli_write_andx_recv(req, &written);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(req);
+ d_printf("cli_write_andx_recv returned %s\n",
+ nt_errstr(status));
+ return;
+ }
+
+ d_printf("wrote %d bytes\n", (int)written);
+ TALLOC_FREE(req);
+}
+
static void chain1_close_completion(struct async_req *req)
{
NTSTATUS status;
struct event_context *evt = event_context_init(NULL);
struct async_req *reqs[4];
bool done = false;
+ const char *text = "hallo";
printf("starting chain1 test\n");
if (!torture_open_connection(&cli1, 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[1] = cli_write_andx_send(talloc_tos(), evt, cli1, 0, 0,
+ (uint8_t *)text, 0, strlen(text));
+ reqs[1]->async.fn = chain1_write_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);
return True;
}
+static size_t null_source(uint8_t *buf, size_t n, void *priv)
+{
+ size_t *to_pull = (size_t *)priv;
+ size_t thistime = *to_pull;
+
+ thistime = MIN(thistime, n);
+ if (thistime == 0) {
+ return 0;
+ }
+
+ memset(buf, 0, thistime);
+ *to_pull -= thistime;
+ return thistime;
+}
+
+static bool run_windows_write(int dummy)
+{
+ struct cli_state *cli1;
+ int fnum;
+ int i;
+ bool ret = false;
+ const char *fname = "\\writetest.txt";
+ double seconds;
+ double kbytes;
+
+ printf("starting windows_write test\n");
+ if (!torture_open_connection(&cli1, 0)) {
+ return False;
+ }
+
+ fnum = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
+ if (fnum == -1) {
+ printf("open failed (%s)\n", cli_errstr(cli1));
+ return False;
+ }
+
+ cli_sockopt(cli1, sockops);
+
+ start_timer();
+
+ for (i=0; i<torture_numops; i++) {
+ char c = 0;
+ off_t start = i * torture_blocksize;
+ NTSTATUS status;
+ size_t to_pull = torture_blocksize - 1;
+
+ if (cli_write(cli1, fnum, 0, &c,
+ start + torture_blocksize - 1, 1) != 1) {
+ printf("cli_write failed: %s\n", cli_errstr(cli1));
+ goto fail;
+ }
+
+ status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
+ null_source, &to_pull);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("cli_push returned: %s\n", nt_errstr(status));
+ goto fail;
+ }
+ }
+
+ seconds = end_timer();
+ kbytes = (double)torture_blocksize * torture_numops;
+ kbytes /= 1024;
+
+ printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
+ (double)seconds, (int)(kbytes/seconds));
+
+ ret = true;
+ fail:
+ cli_close(cli1, fnum);
+ cli_unlink(cli1, fname);
+ torture_close_connection(cli1);
+ return ret;
+}
+
static bool run_cli_echo(int dummy)
{
struct cli_state *cli;
for (i=0; i<1000; i++) {
char *key, *value;
- asprintf(&key, "key%ld", random());
- asprintf(&value, "value%ld", random());
+ if (asprintf(&key, "key%ld", random()) == -1) {
+ goto done;
+ }
+ if (asprintf(&value, "value%ld", random()) == -1) {
+ SAFE_FREE(key);
+ goto done;
+ }
if (!rbt_testval(db, key, value)) {
SAFE_FREE(key);
}
SAFE_FREE(value);
- asprintf(&value, "value%ld", random());
+ if (asprintf(&value, "value%ld", random()) == -1) {
+ SAFE_FREE(key);
+ goto done;
+ }
if (!rbt_testval(db, key, value)) {
SAFE_FREE(key);
return ret;
}
+static void wbclient_done(struct async_req *req)
+{
+ NTSTATUS status;
+ struct winbindd_response *wb_resp;
+ int *i = (int *)req->async.priv;
+
+ status = wb_trans_recv(req, req, &wb_resp);
+ TALLOC_FREE(req);
+ *i += 1;
+ d_printf("wb_trans_recv %d returned %s\n", *i, nt_errstr(status));
+}
+
+static bool run_local_wbclient(int dummy)
+{
+ struct event_context *ev;
+ struct wb_context **wb_ctx;
+ struct winbindd_request wb_req;
+ bool result = false;
+ int i, j;
+
+ BlockSignals(True, SIGPIPE);
+
+ ev = event_context_init(talloc_tos());
+ if (ev == NULL) {
+ goto fail;
+ }
+
+ wb_ctx = TALLOC_ARRAY(ev, struct wb_context *, torture_numops);
+ if (wb_ctx == NULL) {
+ goto fail;
+ }
+
+ ZERO_STRUCT(wb_req);
+ wb_req.cmd = WINBINDD_PING;
+
+ for (i=0; i<torture_numops; i++) {
+ wb_ctx[i] = wb_context_init(ev);
+ if (wb_ctx[i] == NULL) {
+ goto fail;
+ }
+ for (j=0; j<5; j++) {
+ struct async_req *req;
+ req = wb_trans_send(ev, ev, wb_ctx[i],
+ (j % 2) == 0, &wb_req);
+ if (req == NULL) {
+ goto fail;
+ }
+ req->async.fn = wbclient_done;
+ req->async.priv = &i;
+ }
+ }
+
+ i = 0;
+
+ while (i < 5 * torture_numops) {
+ event_loop_once(ev);
+ }
+
+ result = true;
+ fail:
+ TALLOC_FREE(ev);
+ return result;
+}
+
static double create_procs(bool (*fn)(int), bool *result)
{
int i, status;
{ "EATEST", run_eatest, 0},
{ "SESSSETUP_BENCH", run_sesssetup_bench, 0},
{ "CHAIN1", run_chain1, 0},
+ { "WINDOWS-WRITE", run_windows_write, 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},
+ { "LOCAL-WBCLIENT", run_local_wbclient, 0},
{NULL, NULL, 0}};
fstrcpy(workgroup, lp_workgroup());
- while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Aec:ks:b:")) != EOF) {
+ while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Aec:ks:b:B:")) != EOF) {
switch (opt) {
case 'p':
port_to_use = atoi(optarg);
fstrcpy(multishare_conn_fname, optarg);
use_multishare_conn = True;
break;
+ case 'B':
+ torture_blocksize = atoi(optarg);
+ break;
default:
printf("Unknown option %c (%d)\n", (char)opt, opt);
usage();