torture_close_connection(cli);
- torture_comment(tctx, "finished negprot nowait test\n");
-
return correct;
}
torture_suite_add_1smb_test(suite, "SECLEAK", torture_sec_leak);
torture_suite_add_simple_test(suite, "DISCONNECT", torture_disconnect);
torture_suite_add_suite(suite, torture_delay_write());
- torture_suite_add_simple_test(suite, "SAMBA3ERROR", torture_samba3_errorpaths);
-
+ torture_suite_add_simple_test(suite, "SAMBA3ERROR",
+ torture_samba3_errorpaths);
torture_suite_add_1smb_test(suite, "CASETABLE", torture_casetable);
torture_suite_add_1smb_test(suite, "UTABLE", torture_utable);
torture_suite_add_simple_test(suite, "SMB", torture_smb_scan);
rpc/lsa_lookup.o \
rpc/session_key.o \
rpc/echo.o \
- rpc/dcom.o \
rpc/dfs.o \
rpc/drsuapi.o \
rpc/drsuapi_cracknames.o \
evt_ctx = event_context_find(torture);
net_ctx = libnet_context_init(evt_ctx);
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&net_ctx->samr.pipe,
&ndr_table_samr);
mem_ctx = talloc_init("test_userinfo");
binding = torture_setting_string(torture, "binding", NULL);
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
ctx = libnet_context_init(NULL);
ctx->cred = cmdline_credentials;
- status = torture_rpc_connection(prep_mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
if (!NT_STATUS_IS_OK(status)) {
libnetctx = libnet_context_init(NULL);
libnetctx->cred = cmdline_credentials;
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_srvsvc);
req.in.user_name = TEST_USERNAME;
req.in.domain_name = lp_workgroup();
- status = torture_rpc_connection(prep_mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
if (!NT_STATUS_IS_OK(status)) {
ctx = libnet_context_init(NULL);
ctx->cred = cmdline_credentials;
- status = torture_rpc_connection(prep_mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
if (!NT_STATUS_IS_OK(status)) {
ctx = libnet_context_init(NULL);
ctx->cred = cmdline_credentials;
- status = torture_rpc_connection(prep_mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
if (!NT_STATUS_IS_OK(status)) {
mem_ctx = talloc_init("test_userinfo");
binding = torture_setting_string(torture, "binding", NULL);
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
mem_ctx = talloc_init("test_useradd");
binding = torture_setting_string(torture, "binding", NULL);
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
mem_ctx = talloc_init("test_userdel");
binding = torture_setting_string(torture, "binding", NULL);
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
mem_ctx = talloc_init("test_userdel");
binding = torture_setting_string(torture, "binding", NULL);
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_samr);
/*
basic testing of security descriptor calls
*/
-BOOL torture_raw_acls(struct torture_context *torture)
+bool torture_raw_acls(struct torture_context *tctx, struct smbcli_state *cli)
{
- struct smbcli_state *cli;
BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_acls");
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
- ret &= test_sd(cli, mem_ctx);
- ret &= test_nttrans_create(cli, mem_ctx);
- ret &= test_creator_sid(cli, mem_ctx);
- ret &= test_generic_bits(cli, mem_ctx);
- ret &= test_owner_bits(cli, mem_ctx);
- ret &= test_inheritance(cli, mem_ctx);
- ret &= test_inheritance_dynamic(cli, mem_ctx);
- ret &= test_sd_get_set(cli, mem_ctx);
+ ret &= test_sd(cli, tctx);
+ ret &= test_nttrans_create(cli, tctx);
+ ret &= test_creator_sid(cli, tctx);
+ ret &= test_generic_bits(cli, tctx);
+ ret &= test_owner_bits(cli, tctx);
+ ret &= test_inheritance(cli, tctx);
+ ret &= test_inheritance_dynamic(cli, tctx);
+ ret &= test_sd_get_set(cli, tctx);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
basic testing of chkpath calls
*/
-BOOL torture_raw_chkpath(struct torture_context *torture)
+bool torture_raw_chkpath(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
+ bool ret = true;
int fnum;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_chkpath");
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
return False;
}
- fnum = create_complex_file(cli, mem_ctx, BASEDIR "\\nt\\V S\\VB98\\vb6.exe");
+ fnum = create_complex_file(cli, torture, BASEDIR "\\nt\\V S\\VB98\\vb6.exe");
if (fnum == -1) {
printf("failed to open \\nt\\V S\\VB98\\vb6.exe - %s\n", smbcli_errstr(cli->tree));
ret = False;
goto done;
}
- if (!test_chkpath(cli, mem_ctx)) {
- ret = False;
- }
+ ret &= test_chkpath(cli, torture);
done:
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
#include "libcli/libcli.h"
#include "torture/util.h"
-
-/* basic testing of all RAW_CLOSE_* calls
+/**
+ * basic testing of all RAW_CLOSE_* calls
*/
-BOOL torture_raw_close(struct torture_context *torture)
+bool torture_raw_close(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
+ bool ret = true;
union smb_close io;
union smb_flush io_flush;
int fnum;
union smb_fileinfo finfo, finfo2;
NTSTATUS status;
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_close");
-
#define REOPEN do { \
- fnum = create_complex_file(cli, mem_ctx, fname); \
+ fnum = create_complex_file(cli, torture, fname); \
if (fnum == -1) { \
printf("(%d) Failed to create %s\n", __LINE__, fname); \
- ret = False; \
+ ret = false; \
goto done; \
}} while (0)
if (!NT_STATUS_EQUAL(status, correct)) { \
printf("(%d) Incorrect status %s - should be %s\n", \
__LINE__, nt_errstr(status), nt_errstr(correct)); \
- ret = False; \
+ ret = false; \
goto done; \
}} while (0)
/* the file should have the write time set */
finfo.generic.level = RAW_FILEINFO_ALL_INFO;
finfo.generic.in.file.path = fname;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, torture, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
if (basetime != nt_time_to_unix(finfo.all_info.out.write_time)) {
printf("Incorrect write time on file - %s - %s\n",
- timestring(mem_ctx, basetime),
- nt_time_string(mem_ctx, finfo.all_info.out.write_time));
- dump_all_info(mem_ctx, &finfo);
- ret = False;
+ timestring(torture, basetime),
+ nt_time_string(torture, finfo.all_info.out.write_time));
+ dump_all_info(torture, &finfo);
+ ret = false;
}
printf("testing other times\n");
nt_time_equal(&finfo.all_info.out.write_time,
&finfo.all_info.out.change_time)) {
printf("Incorrect times after close - only write time should be set\n");
- dump_all_info(mem_ctx, &finfo);
+ dump_all_info(torture, &finfo);
if (!torture_setting_bool(torture, "samba3", false)) {
/*
finfo2.generic.level = RAW_FILEINFO_ALL_INFO;
finfo2.generic.in.file.path = fname;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo2);
+ status = smb_raw_pathinfo(cli->tree, torture, &finfo2);
CHECK_STATUS(status, NT_STATUS_OK);
io.close.level = RAW_CLOSE_CLOSE;
/* the file should have the write time set equal to access time */
finfo.generic.level = RAW_FILEINFO_ALL_INFO;
finfo.generic.in.file.path = fname;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, torture, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
if (!nt_time_equal(&finfo.all_info.out.write_time,
&finfo2.all_info.out.write_time)) {
printf("Incorrect write time on file - 0 time should be ignored\n");
- dump_all_info(mem_ctx, &finfo);
- ret = False;
+ dump_all_info(torture, &finfo);
+ ret = false;
}
printf("testing splclose\n");
done:
smbcli_close(cli->tree, fnum);
smbcli_unlink(cli->tree, fname);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
basic testing of libcli composite calls
*/
-BOOL torture_raw_composite(struct torture_context *torture)
+bool torture_raw_composite(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_composite");
+ bool ret = true;
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
- ret &= test_fetchfile(cli, mem_ctx);
- ret &= test_loadfile(cli, mem_ctx);
- ret &= test_appendacl(cli, mem_ctx);
- ret &= test_fsinfo(cli, mem_ctx);
+ ret &= test_fetchfile(cli, tctx);
+ ret &= test_loadfile(cli, tctx);
+ ret &= test_appendacl(cli, tctx);
+ ret &= test_fsinfo(cli, tctx);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
basic testing of session/tree context calls
*/
-static BOOL torture_raw_context_int(void)
+static bool torture_raw_context_int(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
BOOL ret = True;
- TALLOC_CTX *mem_ctx;
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_context");
-
- ret &= test_session(cli, mem_ctx);
- ret &= test_tree(cli, mem_ctx);
- ret &= test_tree_ulogoff(cli, mem_ctx);
- ret &= test_pid_exit_only_sees_open(cli, mem_ctx);
- ret &= test_pid_2sess(cli, mem_ctx);
- ret &= test_pid_2tcon(cli, mem_ctx);
+ ret &= test_session(cli, tctx);
+ ret &= test_tree(cli, tctx);
+ ret &= test_tree_ulogoff(cli, tctx);
+ ret &= test_pid_exit_only_sees_open(cli, tctx);
+ ret &= test_pid_2sess(cli, tctx);
+ ret &= test_pid_2tcon(cli, tctx);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
-
return ret;
}
/*
basic testing of session/tree context calls
*/
-BOOL torture_raw_context(struct torture_context *torture)
+bool torture_raw_context(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- BOOL ret = True;
+ bool ret = true;
if (lp_use_spnego()) {
- ret &= torture_raw_context_int();
+ ret &= torture_raw_context_int(torture, cli);
lp_set_cmdline("use spnego", "False");
}
- ret &= torture_raw_context_int();
+ ret &= torture_raw_context_int(torture, cli);
return ret;
}
/*
basic testing of EA calls
*/
-BOOL torture_raw_eas(struct torture_context *torture)
+bool torture_raw_eas(struct torture_context *torture, struct smbcli_state *cli)
{
- struct smbcli_state *cli;
BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_eas");
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
- ret &= test_eas(cli, mem_ctx);
- ret &= test_nttrans_create(cli, mem_ctx);
+ ret &= test_eas(cli, torture);
+ ret &= test_nttrans_create(cli, torture);
smb_raw_exit(cli->session);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
basic testing of some ioctl calls
*/
-BOOL torture_raw_ioctl(struct torture_context *torture)
+bool torture_raw_ioctl(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_ioctl");
+ bool ret = true;
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
- if (!test_ioctl(cli, mem_ctx)) {
- ret = False;
- }
-
- if (!test_fsctl(cli, mem_ctx)) {
- ret = False;
- }
+ ret &= test_ioctl(cli, torture);
+ ret &= test_fsctl(cli, torture);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
test SMBlock and SMBunlock ops
*/
-static BOOL test_lock(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_lock(struct torture_context *tctx, struct smbcli_state *cli)
{
union smb_lock io;
NTSTATUS status;
/*
test locking&X ops
*/
-static BOOL test_lockx(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
{
union smb_lock io;
struct smb_lock_entry lock[1];
/*
test high pid
*/
-static BOOL test_pidhigh(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_pidhigh(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_lock io;
struct smb_lock_entry lock[1];
/*
test locking&X async operation
*/
-static BOOL test_async(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_async(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
struct smbcli_session *session;
struct smb_composite_sesssetup setup;
}
printf("create a new sessions\n");
- session = smbcli_session_init(cli->transport, mem_ctx, False);
+ session = smbcli_session_init(cli->transport, tctx, False);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = lp_workgroup();
printf("create new tree context\n");
share = lp_parm_string(-1, "torture", "share");
host = lp_parm_string(-1, "torture", "host");
- tree = smbcli_tree_init(session, mem_ctx, False);
+ tree = smbcli_tree_init(session, tctx, False);
tcon.generic.level = RAW_TCON_TCONX;
tcon.tconx.in.flags = 0;
tcon.tconx.in.password = data_blob(NULL, 0);
- tcon.tconx.in.path = talloc_asprintf(mem_ctx, "\\\\%s\\%s", host, share);
+ tcon.tconx.in.path = talloc_asprintf(tctx, "\\\\%s\\%s", host, share);
tcon.tconx.in.device = "A:";
- status = smb_raw_tcon(tree, mem_ctx, &tcon);
+ status = smb_raw_tcon(tree, tctx, &tcon);
CHECK_STATUS(status, NT_STATUS_OK);
tree->tid = tcon.tconx.out.tid;
/*
test NT_STATUS_LOCK_NOT_GRANTED vs. NT_STATUS_FILE_LOCK_CONFLICT
*/
-static BOOL test_errorcode(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_errorcode(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_lock io;
union smb_open op;
op.openx.in.size = 0;
op.openx.in.timeout = 0;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum = op.openx.out.file.fnum;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum2 = op.openx.out.file.fnum;
/*
test LOCKING_ANDX_CHANGE_LOCKTYPE
*/
-static BOOL test_changetype(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_changetype(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_lock io;
struct smb_lock_entry lock[2];
/*
basic testing of lock calls
*/
-BOOL torture_raw_lock(struct torture_context *torture)
+struct torture_suite *torture_raw_lock(TALLOC_CTX *mem_ctx)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_lock");
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "LOCK");
- ret &= test_lockx(cli, mem_ctx);
- ret &= test_lock(cli, mem_ctx);
- ret &= test_pidhigh(cli, mem_ctx);
- ret &= test_async(cli, mem_ctx);
- ret &= test_errorcode(cli, mem_ctx);
- ret &= test_changetype(cli, mem_ctx);
+ torture_suite_add_1smb_test(suite, "lockx", test_lockx);
+ torture_suite_add_1smb_test(suite, "lock", test_lock);
+ torture_suite_add_1smb_test(suite, "pidhigh", test_pidhigh);
+ torture_suite_add_1smb_test(suite, "async", test_async);
+ torture_suite_add_1smb_test(suite, "errorcode", test_errorcode);
+ torture_suite_add_1smb_test(suite, "changetype", test_changetype);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
- return ret;
+ return suite;
}
/*
basic testing of all RAW_MKDIR_* calls
*/
-BOOL torture_raw_mkdir(struct torture_context *torture)
+BOOL torture_raw_mkdir(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_mkdir");
+ bool ret = true;
- if (!test_mkdir(cli, mem_ctx)) {
- ret = False;
+ if (!test_mkdir(cli, torture)) {
+ ret = false;
}
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
basic testing of multiplexing notify
*/
-BOOL torture_raw_mux(struct torture_context *torture)
+bool torture_raw_mux(struct torture_context *torture, struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
+ bool ret = true;
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_mux");
-
if (!torture_setup_dir(cli, BASEDIR)) {
- return False;
- }
-
- if (!test_mux_open(cli, mem_ctx)) {
- ret = False;
- }
-
- if (!test_mux_write(cli, mem_ctx)) {
- ret = False;
+ return false;
}
- if (!test_mux_lock(cli, mem_ctx)) {
- ret = False;
- }
+ ret &= test_mux_open(cli, torture);
+ ret &= test_mux_write(cli, torture);
+ ret &= test_mux_lock(cli, torture);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
basic testing of change notify
*/
-BOOL torture_raw_notify(struct torture_context *torture)
+bool torture_raw_notify(struct torture_context *torture,
+ struct smbcli_state *cli,
+ struct smbcli_state *cli2)
{
- struct smbcli_state *cli, *cli2;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
+ bool ret = true;
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
- if (!torture_open_connection(&cli2, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_notify");
-
if (!torture_setup_dir(cli, BASEDIR)) {
- return False;
+ return false;
}
- ret &= test_notify_dir(cli, cli2, mem_ctx);
- ret &= test_notify_mask(cli, mem_ctx);
- ret &= test_notify_recursive(cli, mem_ctx);
- ret &= test_notify_mask_change(cli, mem_ctx);
- ret &= test_notify_file(cli, mem_ctx);
- ret &= test_notify_tdis(mem_ctx);
- ret &= test_notify_exit(mem_ctx);
- ret &= test_notify_ulogoff(mem_ctx);
- ret &= test_notify_tcp_dis(mem_ctx);
- ret &= test_notify_double(cli, mem_ctx);
- ret &= test_notify_tree(cli, mem_ctx);
+ ret &= test_notify_dir(cli, cli2, torture);
+ ret &= test_notify_mask(cli, torture);
+ ret &= test_notify_recursive(cli, torture);
+ ret &= test_notify_mask_change(cli, torture);
+ ret &= test_notify_file(cli, torture);
+ ret &= test_notify_tdis(torture);
+ ret &= test_notify_exit(torture);
+ ret &= test_notify_ulogoff(torture);
+ ret &= test_notify_tcp_dis(torture);
+ ret &= test_notify_double(cli, torture);
+ ret &= test_notify_tree(cli, torture);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- torture_close_connection(cli2);
- talloc_free(mem_ctx);
return ret;
}
/* basic testing of all RAW_OPEN_* calls
*/
-BOOL torture_raw_open(struct torture_context *torture)
+bool torture_raw_open(struct torture_context *torture, struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_open");
+ bool ret = true;
if (!torture_setup_dir(cli, BASEDIR)) {
- return False;
+ return false;
}
- ret &= test_ntcreatex_brlocked(cli, mem_ctx);
- ret &= test_open(cli, mem_ctx);
+ ret &= test_ntcreatex_brlocked(cli, torture);
+ ret &= test_open(cli, torture);
ret &= test_raw_open_multi();
- ret &= test_openx(cli, mem_ctx);
- ret &= test_ntcreatex(cli, mem_ctx);
- ret &= test_nttrans_create(cli, mem_ctx);
- ret &= test_t2open(cli, mem_ctx);
- ret &= test_mknew(cli, mem_ctx);
- ret &= test_create(cli, mem_ctx);
- ret &= test_ctemp(cli, mem_ctx);
- ret &= test_chained(cli, mem_ctx);
- ret &= test_no_leading_slash(cli, mem_ctx);
+ ret &= test_openx(cli, torture);
+ ret &= test_ntcreatex(cli, torture);
+ ret &= test_nttrans_create(cli, torture);
+ ret &= test_t2open(cli, torture);
+ ret &= test_mknew(cli, torture);
+ ret &= test_create(cli, torture);
+ ret &= test_ctemp(cli, torture);
+ ret &= test_chained(cli, torture);
+ ret &= test_no_leading_slash(cli, torture);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
basic testing of oplocks
*/
-struct torture_suite *torture_raw_oplock(void)
+struct torture_suite *torture_raw_oplock(TALLOC_CTX *mem_ctx)
{
- struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "OPLOCK");
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "OPLOCK");
torture_suite_add_2smb_test(suite, "NORMAL", test_raw_oplock_normal);
torture_suite_add_2smb_test(suite, "BATCH1", test_raw_oplock_batch1);
for each call we test that it succeeds, and where possible test
for consistency between the calls.
*/
-static BOOL torture_raw_qfileinfo_internals(struct torture_context *torture, TALLOC_CTX *mem_ctx,
- struct smbcli_tree *tree, int fnum, const char *fname,
- bool is_ipc)
+static BOOL torture_raw_qfileinfo_internals(struct torture_context *torture,
+ TALLOC_CTX *mem_ctx,
+ struct smbcli_tree *tree,
+ int fnum, const char *fname,
+ bool is_ipc)
{
int i;
BOOL ret = True;
for each call we test that it succeeds, and where possible test
for consistency between the calls.
*/
-BOOL torture_raw_qfileinfo(struct torture_context *torture)
+bool torture_raw_qfileinfo(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
int fnum;
+ bool ret;
const char *fname = "\\torture_qfileinfo.txt";
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_qfileinfo");
-
- fnum = create_complex_file(cli, mem_ctx, fname);
+ fnum = create_complex_file(cli, torture, fname);
if (fnum == -1) {
printf("ERROR: open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
- ret = False;
- goto done;
+ return false;
}
- ret = torture_raw_qfileinfo_internals(torture, mem_ctx, cli->tree, fnum, fname, False /* is_ipc */);
+ ret = torture_raw_qfileinfo_internals(torture, torture, cli->tree, fnum, fname, False /* is_ipc */);
smbcli_close(cli->tree, fnum);
smbcli_unlink(cli->tree, fname);
-done:
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
-BOOL torture_raw_qfileinfo_pipe(struct torture_context *torture)
+bool torture_raw_qfileinfo_pipe(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
+ bool ret = true;
int fnum;
const char *fname = "\\lsass";
- struct smbcli_state *cli;
struct dcerpc_pipe *p;
struct smbcli_tree *ipc_tree;
NTSTATUS status;
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_qfileinfo_pipe");
-
- if (!(p = dcerpc_pipe_init(mem_ctx,
+ if (!(p = dcerpc_pipe_init(torture,
cli->tree->session->transport->socket->event.ctx))) {
return False;
}
ipc_tree = dcerpc_smb_tree(p->conn);
fnum = dcerpc_smb_fnum(p->conn);
- ret = torture_raw_qfileinfo_internals(torture, mem_ctx, ipc_tree, fnum, fname, True /* is_ipc */);
+ ret = torture_raw_qfileinfo_internals(torture, torture, ipc_tree, fnum, fname, True /* is_ipc */);
talloc_free(p);
return ret;
Some of the consistency tests assume that the target filesystem is
quiescent, which is sometimes hard to achieve
*/
-BOOL torture_raw_qfsinfo(struct torture_context *torture)
+bool torture_raw_qfsinfo(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
int i;
BOOL ret = True;
int count;
union smb_fsinfo *s1, *s2;
- TALLOC_CTX *mem_ctx;
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_qfsinfo");
-
/* scan all the levels, pulling the results */
for (i=0; levels[i].name; i++) {
printf("Running level %s\n", levels[i].name);
levels[i].fsinfo.generic.level = levels[i].level;
- levels[i].status = smb_raw_fsinfo(cli->tree, mem_ctx, &levels[i].fsinfo);
+ levels[i].status = smb_raw_fsinfo(cli->tree, torture, &levels[i].fsinfo);
}
/* check for completely broken levels */
}
if (count != 0) {
- ret = False;
printf("%d levels failed\n", count);
if (count > 13) {
printf("too many level failures - giving up\n");
- goto done;
+ return False;
}
}
STR_CHECK("ATTRIBUTE_INFO", attribute_info, fs_type, STR_UNICODE);
STR_CHECK("ATTRIBUTE_INFORMATION", attribute_info, fs_type, STR_UNICODE);
-done:
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
#include "torture/torture.h"
#include "libcli/raw/libcliraw.h"
#include "torture/raw/proto.h"
+#include "torture/util.h"
NTSTATUS torture_raw_init(void)
{
torture_suite_add_simple_test(suite, "BENCH-OPLOCK", torture_bench_oplock);
torture_suite_add_simple_test(suite, "BENCH-LOCK", torture_bench_lock);
torture_suite_add_simple_test(suite, "BENCH-OPEN", torture_bench_open);
- torture_suite_add_simple_test(suite, "QFSINFO", torture_raw_qfsinfo);
- torture_suite_add_simple_test(suite, "QFILEINFO", torture_raw_qfileinfo);
- torture_suite_add_simple_test(suite, "QFILEINFO-IPC", torture_raw_qfileinfo_pipe);
- torture_suite_add_simple_test(suite, "SFILEINFO", torture_raw_sfileinfo);
- torture_suite_add_simple_test(suite, "SFILEINFO-BUG", torture_raw_sfileinfo_bug);
- torture_suite_add_simple_test(suite, "SFILEINFO-RENAME",
+ torture_suite_add_1smb_test(suite, "QFSINFO", torture_raw_qfsinfo);
+ torture_suite_add_1smb_test(suite, "QFILEINFO", torture_raw_qfileinfo);
+ torture_suite_add_1smb_test(suite, "QFILEINFO-IPC", torture_raw_qfileinfo_pipe);
+ torture_suite_add_1smb_test(suite, "SFILEINFO", torture_raw_sfileinfo);
+ torture_suite_add_1smb_test(suite, "SFILEINFO-BUG", torture_raw_sfileinfo_bug);
+ torture_suite_add_1smb_test(suite, "SFILEINFO-RENAME",
torture_raw_sfileinfo_rename);
- torture_suite_add_simple_test(suite, "SEARCH", torture_raw_search);
- torture_suite_add_simple_test(suite, "CLOSE", torture_raw_close);
- torture_suite_add_simple_test(suite, "OPEN", torture_raw_open);
- torture_suite_add_simple_test(suite, "MKDIR", torture_raw_mkdir);
- torture_suite_add_suite(suite, torture_raw_oplock());
- torture_suite_add_simple_test(suite, "NOTIFY", torture_raw_notify);
- torture_suite_add_simple_test(suite, "MUX", torture_raw_mux);
- torture_suite_add_simple_test(suite, "IOCTL", torture_raw_ioctl);
- torture_suite_add_simple_test(suite, "CHKPATH", torture_raw_chkpath);
- torture_suite_add_simple_test(suite, "UNLINK", torture_raw_unlink);
- torture_suite_add_simple_test(suite, "READ", torture_raw_read);
- torture_suite_add_simple_test(suite, "WRITE", torture_raw_write);
- torture_suite_add_simple_test(suite, "LOCK", torture_raw_lock);
- torture_suite_add_simple_test(suite, "CONTEXT", torture_raw_context);
- torture_suite_add_simple_test(suite, "RENAME", torture_raw_rename);
- torture_suite_add_simple_test(suite, "SEEK", torture_raw_seek);
- torture_suite_add_simple_test(suite, "EAS", torture_raw_eas);
- torture_suite_add_simple_test(suite, "STREAMS", torture_raw_streams);
- torture_suite_add_simple_test(suite, "ACLS", torture_raw_acls);
- torture_suite_add_simple_test(suite, "COMPOSITE", torture_raw_composite);
+ torture_suite_add_suite(suite, torture_raw_search(suite));
+ torture_suite_add_1smb_test(suite, "CLOSE", torture_raw_close);
+ torture_suite_add_1smb_test(suite, "OPEN", torture_raw_open);
+ torture_suite_add_1smb_test(suite, "MKDIR", torture_raw_mkdir);
+ torture_suite_add_suite(suite, torture_raw_oplock(suite));
+ torture_suite_add_2smb_test(suite, "NOTIFY", torture_raw_notify);
+ torture_suite_add_1smb_test(suite, "MUX", torture_raw_mux);
+ torture_suite_add_1smb_test(suite, "IOCTL", torture_raw_ioctl);
+ torture_suite_add_1smb_test(suite, "CHKPATH", torture_raw_chkpath);
+ torture_suite_add_suite(suite, torture_raw_unlink(suite));
+ torture_suite_add_suite(suite, torture_raw_read(suite));
+ torture_suite_add_suite(suite, torture_raw_write(suite));
+ torture_suite_add_suite(suite, torture_raw_lock(suite));
+ torture_suite_add_1smb_test(suite, "CONTEXT", torture_raw_context);
+ torture_suite_add_suite(suite, torture_raw_rename(suite));
+ torture_suite_add_1smb_test(suite, "SEEK", torture_raw_seek);
+ torture_suite_add_1smb_test(suite, "EAS", torture_raw_eas);
+ torture_suite_add_1smb_test(suite, "STREAMS", torture_raw_streams);
+ torture_suite_add_1smb_test(suite, "ACLS", torture_raw_acls);
+ torture_suite_add_1smb_test(suite, "COMPOSITE", torture_raw_composite);
torture_suite_add_simple_test(suite, "SAMBA3HIDE", torture_samba3_hide);
torture_suite_add_simple_test(suite, "SAMBA3CLOSEERR", torture_samba3_closeerr);
torture_suite_add_simple_test(suite, "SAMBA3CHECKFSP", torture_samba3_checkfsp);
/*
test read ops
*/
-static BOOL test_read(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_read(struct torture_context *tctx, struct smbcli_state *cli)
{
union smb_read io;
NTSTATUS status;
const char *test_data = "TEST DATA";
uint_t seed = time(NULL);
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
/*
test lockread ops
*/
-static BOOL test_lockread(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_lockread(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_read io;
NTSTATUS status;
const char *test_data = "TEST DATA";
uint_t seed = time(NULL);
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
/*
test readx ops
*/
-static BOOL test_readx(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_readx(struct torture_context *tctx, struct smbcli_state *cli)
{
union smb_read io;
NTSTATUS status;
const char *test_data = "TEST DATA";
uint_t seed = time(NULL);
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
/*
test readbraw ops
*/
-static BOOL test_readbraw(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_readbraw(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_read io;
NTSTATUS status;
const char *test_data = "TEST DATA";
uint_t seed = time(NULL);
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
/*
test read for execute
*/
-static BOOL test_read_for_execute(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_read_for_execute(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_open op;
union smb_write wr;
const char *fname = BASEDIR "\\test.txt";
const uint8_t data[] = "TEST DATA";
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
op.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
op.ntcreatex.in.security_flags = 0;
op.ntcreatex.in.fname = fname;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum = op.ntcreatex.out.file.fnum;
op.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
op.ntcreatex.in.security_flags = 0;
op.ntcreatex.in.fname = fname;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum = op.ntcreatex.out.file.fnum;
op.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
op.ntcreatex.in.security_flags = 0;
op.ntcreatex.in.fname = fname;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum = op.ntcreatex.out.file.fnum;
/*
basic testing of read calls
*/
-BOOL torture_raw_read(struct torture_context *torture)
+struct torture_suite *torture_raw_read(TALLOC_CTX *mem_ctx)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_read");
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "READ");
- ret &= test_read(cli, mem_ctx);
- ret &= test_readx(cli, mem_ctx);
- ret &= test_lockread(cli, mem_ctx);
- ret &= test_readbraw(cli, mem_ctx);
- ret &= test_read_for_execute(cli, mem_ctx);
+ torture_suite_add_1smb_test(suite, "read", test_read);
+ torture_suite_add_1smb_test(suite, "readx", test_readx);
+ torture_suite_add_1smb_test(suite, "lockread", test_lockread);
+ torture_suite_add_1smb_test(suite, "readbraw", test_readbraw);
+ torture_suite_add_1smb_test(suite, "read for execute",
+ test_read_for_execute);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
- return ret;
+ return suite;
}
/*
test SMBmv ops
*/
-static BOOL test_mv(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_mv(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_rename io;
NTSTATUS status;
op.ntcreatex.in.security_flags = 0;
op.ntcreatex.in.fname = fname1;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum = op.ntcreatex.out.file.fnum;
NTCREATEX_SHARE_ACCESS_DELETE |
NTCREATEX_SHARE_ACCESS_READ |
NTCREATEX_SHARE_ACCESS_WRITE;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum = op.ntcreatex.out.file.fnum;
finfo.generic.level = RAW_FILEINFO_ALL_INFO;
finfo.all_info.in.file.path = fname1;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
if (strcmp(finfo.all_info.out.fname.s, Fname1) != 0) {
printf("(%s) Incorrect filename [%s] after case-changing "
/*
test SMBntrename ops
*/
-static BOOL test_ntrename(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_ntrename(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_rename io;
NTSTATUS status;
printf("Trying simple rename\n");
- fnum = create_complex_file(cli, mem_ctx, fname1);
+ fnum = create_complex_file(cli, tctx, fname1);
io.generic.level = RAW_RENAME_NTRENAME;
io.ntrename.in.old_name = fname1;
finfo.generic.level = RAW_FILEINFO_ALL_INFO;
finfo.generic.in.file.path = fname2;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(finfo.all_info.out.nlink, 2);
CHECK_VALUE(finfo.all_info.out.attrib, FILE_ATTRIBUTE_SYSTEM);
finfo.generic.in.file.path = fname1;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(finfo.all_info.out.nlink, 2);
CHECK_VALUE(finfo.all_info.out.attrib, FILE_ATTRIBUTE_SYSTEM);
smbcli_unlink(cli->tree, fname2);
finfo.generic.in.file.path = fname1;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(finfo.all_info.out.nlink, 1);
CHECK_VALUE(finfo.all_info.out.attrib, FILE_ATTRIBUTE_NORMAL);
finfo.generic.level = RAW_FILEINFO_ALL_INFO;
finfo.generic.in.file.path = fname1;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(finfo.all_info.out.nlink, 1);
CHECK_VALUE(finfo.all_info.out.attrib, FILE_ATTRIBUTE_NORMAL);
finfo.generic.level = RAW_FILEINFO_ALL_INFO;
finfo.generic.in.file.path = fname2;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(finfo.all_info.out.nlink, 1);
CHECK_VALUE(finfo.all_info.out.attrib, FILE_ATTRIBUTE_NORMAL);
finfo.generic.level = RAW_FILEINFO_ALL_INFO;
finfo.generic.in.file.path = fname2;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(finfo.all_info.out.nlink, 1);
CHECK_VALUE(finfo.all_info.out.attrib, FILE_ATTRIBUTE_NORMAL);
finfo.generic.in.file.path = fname1;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(finfo.all_info.out.nlink, 1);
CHECK_VALUE(finfo.all_info.out.attrib, FILE_ATTRIBUTE_SYSTEM);
smbcli_unlink(cli->tree, fname2);
finfo.generic.in.file.path = fname1;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(finfo.all_info.out.nlink, 1);
/*
basic testing of rename calls
*/
-BOOL torture_raw_rename(struct torture_context *torture)
+struct torture_suite *torture_raw_rename(TALLOC_CTX *mem_ctx)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "RENAME");
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
+ torture_suite_add_1smb_test(suite, "mv", test_mv);
+ torture_suite_add_1smb_test(suite, "ntrename", test_ntrename);
- mem_ctx = talloc_init("torture_raw_rename");
-
- if (!test_mv(cli, mem_ctx)) {
- ret = False;
- }
-
- if (!test_ntrename(cli, mem_ctx)) {
- ret = False;
- }
-
- torture_close_connection(cli);
- talloc_free(mem_ctx);
- return ret;
+ return suite;
}
do a single file (non-wildcard) search
*/
_PUBLIC_ NTSTATUS torture_single_search(struct smbcli_state *cli,
- TALLOC_CTX *mem_ctx,
+ TALLOC_CTX *tctx,
const char *pattern,
enum smb_search_level level,
enum smb_search_data_level data_level,
return NT_STATUS_INVALID_LEVEL;
}
- status = smb_raw_search_first(cli->tree, mem_ctx,
+ status = smb_raw_search_first(cli->tree, tctx,
&io, (void *)data, single_search_callback);
if (NT_STATUS_IS_OK(status) && level == RAW_SEARCH_FFIRST) {
/*
basic testing of all RAW_SEARCH_* calls using a single file
*/
-static BOOL test_one_file(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static BOOL test_one_file(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
BOOL ret = True;
int fnum;
printf("Testing one file searches\n");
- fnum = create_complex_file(cli, mem_ctx, fname);
+ fnum = create_complex_file(cli, tctx, fname);
if (fnum == -1) {
printf("ERROR: open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
ret = False;
printf("testing %s\n", levels[i].name);
- levels[i].status = torture_single_search(cli, mem_ctx, fname,
+ levels[i].status = torture_single_search(cli, tctx, fname,
levels[i].level,
levels[i].data_level,
0,
continue;
}
- status = torture_single_search(cli, mem_ctx, fname2,
+ status = torture_single_search(cli, tctx, fname2,
levels[i].level,
levels[i].data_level,
0,
/* get the all_info file into to check against */
all_info.generic.level = RAW_FILEINFO_ALL_INFO;
all_info.generic.in.file.path = fname;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &all_info);
+ status = smb_raw_pathinfo(cli->tree, tctx, &all_info);
if (!NT_STATUS_IS_OK(status)) {
printf("RAW_FILEINFO_ALL_INFO failed - %s\n", nt_errstr(status));
ret = False;
alt_info.generic.level = RAW_FILEINFO_ALT_NAME_INFO;
alt_info.generic.in.file.path = fname;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &alt_info);
+ status = smb_raw_pathinfo(cli->tree, tctx, &alt_info);
if (!NT_STATUS_IS_OK(status)) {
printf("RAW_FILEINFO_ALT_NAME_INFO failed - %s\n", nt_errstr(status));
ret = False;
internal_info.generic.level = RAW_FILEINFO_INTERNAL_INFORMATION;
internal_info.generic.in.file.path = fname;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &internal_info);
+ status = smb_raw_pathinfo(cli->tree, tctx, &internal_info);
if (!NT_STATUS_IS_OK(status)) {
printf("RAW_FILEINFO_INTERNAL_INFORMATION failed - %s\n", nt_errstr(status));
ret = False;
name_info.generic.level = RAW_FILEINFO_NAME_INFO;
name_info.generic.in.file.path = fname;
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &name_info);
+ status = smb_raw_pathinfo(cli->tree, tctx, &name_info);
if (!NT_STATUS_IS_OK(status)) {
printf("RAW_FILEINFO_NAME_INFO failed - %s\n", nt_errstr(status));
ret = False;
if (s->sname1.field1 != (~1 & nt_time_to_unix(v.sname2.out.field2))) { \
printf("(%s) %s/%s [%s] != %s/%s [%s]\n", \
__location__, \
- #sname1, #field1, timestring(mem_ctx, s->sname1.field1), \
- #sname2, #field2, nt_time_string(mem_ctx, v.sname2.out.field2)); \
+ #sname1, #field1, timestring(tctx, s->sname1.field1), \
+ #sname2, #field2, nt_time_string(tctx, v.sname2.out.field2)); \
ret = False; \
} \
}} while (0)
if (s->sname1.field1 != v.sname2.out.field2) { \
printf("(%s) %s/%s [%s] != %s/%s [%s]\n", \
__location__, \
- #sname1, #field1, nt_time_string(mem_ctx, s->sname1.field1), \
- #sname2, #field2, nt_time_string(mem_ctx, v.sname2.out.field2)); \
+ #sname1, #field1, nt_time_string(tctx, s->sname1.field1), \
+ #sname2, #field2, nt_time_string(tctx, v.sname2.out.field2)); \
ret = False; \
} \
}} while (0)
struct multiple_result {
- TALLOC_CTX *mem_ctx;
+ TALLOC_CTX *tctx;
int count;
union smb_search_data *list;
};
data->count++;
- data->list = talloc_realloc(data->mem_ctx,
+ data->list = talloc_realloc(data->tctx,
data->list,
union smb_search_data,
data->count);
do a single file (non-wildcard) search
*/
static NTSTATUS multiple_search(struct smbcli_state *cli,
- TALLOC_CTX *mem_ctx,
+ TALLOC_CTX *tctx,
const char *pattern,
enum smb_search_data_level data_level,
enum continue_type cont_type,
}
}
- status = smb_raw_search_first(cli->tree, mem_ctx,
+ status = smb_raw_search_first(cli->tree, tctx,
&io, data, multiple_search_callback);
}
}
- status = smb_raw_search_next(cli->tree, mem_ctx,
+ status = smb_raw_search_next(cli->tree, tctx,
&io2, data, multiple_search_callback);
if (!NT_STATUS_IS_OK(status)) {
break;
/*
basic testing of search calls using many files
*/
-static BOOL test_many_files(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_many_files(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
const int num_files = 700;
int i, fnum, t;
for (t=0;t<ARRAY_SIZE(search_types);t++) {
ZERO_STRUCT(result);
- result.mem_ctx = talloc_new(mem_ctx);
+ result.tctx = talloc_new(tctx);
printf("Continue %s via %s\n", search_types[t].name, search_types[t].cont_name);
- status = multiple_search(cli, mem_ctx, BASEDIR "\\*.*",
+ status = multiple_search(cli, tctx, BASEDIR "\\*.*",
search_types[t].data_level,
search_types[t].cont_type,
&result);
}
talloc_free(fname);
}
- talloc_free(result.mem_ctx);
+ talloc_free(result.tctx);
}
done:
/*
test what happens when the directory is modified during a search
*/
-static BOOL test_modify_search(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_modify_search(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
const int num_files = 20;
int i, fnum;
printf("pulling the first file\n");
ZERO_STRUCT(result);
- result.mem_ctx = talloc_new(mem_ctx);
+ result.tctx = talloc_new(tctx);
io.t2ffirst.level = RAW_SEARCH_TRANS2;
io.t2ffirst.data_level = RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO;
io.t2ffirst.in.storage_type = 0;
io.t2ffirst.in.pattern = BASEDIR "\\*.*";
- status = smb_raw_search_first(cli->tree, mem_ctx,
+ status = smb_raw_search_first(cli->tree, tctx,
&io, &result, multiple_search_callback);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(result.count, 1);
io2.t2fnext.in.flags = 0;
io2.t2fnext.in.last_name = result.list[result.count-1].both_directory_info.name.s;
- status = smb_raw_search_next(cli->tree, mem_ctx,
+ status = smb_raw_search_next(cli->tree, tctx,
&io2, &result, multiple_search_callback);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(result.count, 2);
printf("Changing attributes and deleting\n");
smbcli_open(cli->tree, BASEDIR "\\T003-03.txt.2", O_CREAT|O_RDWR, DENY_NONE);
smbcli_open(cli->tree, BASEDIR "\\T013-13.txt.2", O_CREAT|O_RDWR, DENY_NONE);
- fnum = create_complex_file(cli, mem_ctx, BASEDIR "\\T013-13.txt.3");
+ fnum = create_complex_file(cli, tctx, BASEDIR "\\T013-13.txt.3");
smbcli_unlink(cli->tree, BASEDIR "\\T014-14.txt");
torture_set_file_attribute(cli->tree, BASEDIR "\\T015-15.txt", FILE_ATTRIBUTE_HIDDEN);
torture_set_file_attribute(cli->tree, BASEDIR "\\T016-16.txt", FILE_ATTRIBUTE_NORMAL);
io2.t2fnext.in.flags = 0;
io2.t2fnext.in.last_name = ".";
- status = smb_raw_search_next(cli->tree, mem_ctx,
+ status = smb_raw_search_next(cli->tree, tctx,
&io2, &result, multiple_search_callback);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(result.count, 20);
for (i=0;i<result.count;i++) {
printf("%s %s (0x%x)\n",
result.list[i].both_directory_info.name.s,
- attrib_string(mem_ctx, result.list[i].both_directory_info.attrib),
+ attrib_string(tctx, result.list[i].both_directory_info.attrib),
result.list[i].both_directory_info.attrib);
}
}
/*
testing if directories always come back sorted
*/
-static BOOL test_sorted(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_sorted(struct torture_context *tctx, struct smbcli_state *cli)
{
const int num_files = 700;
int i, fnum;
printf("Creating %d files\n", num_files);
for (i=0;i<num_files;i++) {
- fname = talloc_asprintf(cli, BASEDIR "\\%s.txt", generate_random_str_list(mem_ctx, 10, "abcdefgh"));
+ fname = talloc_asprintf(cli, BASEDIR "\\%s.txt", generate_random_str_list(tctx, 10, "abcdefgh"));
fnum = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR, DENY_NONE);
if (fnum == -1) {
printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
ZERO_STRUCT(result);
- result.mem_ctx = mem_ctx;
+ result.tctx = tctx;
- status = multiple_search(cli, mem_ctx, BASEDIR "\\*.*",
+ status = multiple_search(cli, tctx, BASEDIR "\\*.*",
RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
CONT_NAME, &result);
CHECK_STATUS(status, NT_STATUS_OK);
/*
basic testing of many old style search calls using separate dirs
*/
-static BOOL test_many_dirs(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_many_dirs(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
const int num_dirs = 20;
int i, fnum, n;
talloc_free(dname);
}
- file = talloc_zero_array(mem_ctx, union smb_search_data, num_dirs);
- file2 = talloc_zero_array(mem_ctx, union smb_search_data, num_dirs);
- file3 = talloc_zero_array(mem_ctx, union smb_search_data, num_dirs);
+ file = talloc_zero_array(tctx, union smb_search_data, num_dirs);
+ file2 = talloc_zero_array(tctx, union smb_search_data, num_dirs);
+ file3 = talloc_zero_array(tctx, union smb_search_data, num_dirs);
printf("Search first on %d dirs\n", num_dirs);
io.search_first.data_level = RAW_SEARCH_DATA_SEARCH;
io.search_first.in.max_count = 1;
io.search_first.in.search_attrib = 0;
- io.search_first.in.pattern = talloc_asprintf(mem_ctx, BASEDIR "\\d%d\\*.txt", i);
- fname = talloc_asprintf(mem_ctx, "f%d-", i);
+ io.search_first.in.pattern = talloc_asprintf(tctx, BASEDIR "\\d%d\\*.txt", i);
+ fname = talloc_asprintf(tctx, "f%d-", i);
io.search_first.out.count = 0;
- status = smb_raw_search_first(cli->tree, mem_ctx,
+ status = smb_raw_search_first(cli->tree, tctx,
&io, (void *)&file[i], single_search_callback);
if (io.search_first.out.count != 1) {
printf("(%s) search first gave %d entries for dir %d - %s\n",
io2.search_next.in.max_count = 1;
io2.search_next.in.search_attrib = 0;
io2.search_next.in.id = file[i].search.id;
- fname = talloc_asprintf(mem_ctx, "f%d-", i);
+ fname = talloc_asprintf(tctx, "f%d-", i);
io2.search_next.out.count = 0;
- status = smb_raw_search_next(cli->tree, mem_ctx,
+ status = smb_raw_search_next(cli->tree, tctx,
&io2, (void *)&file2[i], single_search_callback);
if (io2.search_next.out.count != 1) {
printf("(%s) search next gave %d entries for dir %d - %s\n",
io2.search_next.in.max_count = 1;
io2.search_next.in.search_attrib = 0;
io2.search_next.in.id = file[i].search.id;
- fname = talloc_asprintf(mem_ctx, "f%d-", i);
+ fname = talloc_asprintf(tctx, "f%d-", i);
io2.search_next.out.count = 0;
- status = smb_raw_search_next(cli->tree, mem_ctx,
+ status = smb_raw_search_next(cli->tree, tctx,
&io2, (void *)&file3[i], single_search_callback);
if (io2.search_next.out.count != 1) {
printf("(%s) search next gave %d entries for dir %d - %s\n",
/*
testing of OS/2 style delete
*/
-static BOOL test_os2_delete(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_os2_delete(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
const int num_files = 700;
const int delete_count = 4;
ZERO_STRUCT(result);
- result.mem_ctx = mem_ctx;
+ result.tctx = tctx;
io.t2ffirst.level = RAW_SEARCH_TRANS2;
io.t2ffirst.data_level = RAW_SEARCH_DATA_EA_SIZE;
io.t2ffirst.in.storage_type = 0;
io.t2ffirst.in.pattern = BASEDIR "\\*";
- status = smb_raw_search_first(cli->tree, mem_ctx,
+ status = smb_raw_search_first(cli->tree, tctx,
&io, &result, multiple_search_callback);
CHECK_STATUS(status, NT_STATUS_OK);
do {
ZERO_STRUCT(result);
- result.mem_ctx = mem_ctx;
+ result.tctx = tctx;
- status = smb_raw_search_next(cli->tree, mem_ctx,
+ status = smb_raw_search_next(cli->tree, tctx,
&io2, &result, multiple_search_callback);
if (!NT_STATUS_IS_OK(status)) {
break;
/*
testing of the rather strange ea_list level
*/
-static BOOL test_ea_list(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_ea_list(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
int fnum;
BOOL ret = True;
setfile.generic.level = RAW_SFILEINFO_EA_SET;
setfile.generic.in.file.path = BASEDIR "\\file2.txt";
setfile.ea_set.in.num_eas = 2;
- setfile.ea_set.in.eas = talloc_array(mem_ctx, struct ea_struct, 2);
+ setfile.ea_set.in.eas = talloc_array(tctx, struct ea_struct, 2);
setfile.ea_set.in.eas[0].flags = 0;
setfile.ea_set.in.eas[0].name.s = "EA ONE";
setfile.ea_set.in.eas[0].value = data_blob_string_const("VALUE 1");
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(result);
- result.mem_ctx = mem_ctx;
+ result.tctx = tctx;
io.t2ffirst.level = RAW_SEARCH_TRANS2;
io.t2ffirst.data_level = RAW_SEARCH_DATA_EA_LIST;
io.t2ffirst.in.storage_type = 0;
io.t2ffirst.in.pattern = BASEDIR "\\*";
io.t2ffirst.in.num_names = 2;
- io.t2ffirst.in.ea_names = talloc_array(mem_ctx, struct ea_name, 2);
+ io.t2ffirst.in.ea_names = talloc_array(tctx, struct ea_name, 2);
io.t2ffirst.in.ea_names[0].name.s = "SECOND EA";
io.t2ffirst.in.ea_names[1].name.s = "THIRD EA";
- status = smb_raw_search_first(cli->tree, mem_ctx,
+ status = smb_raw_search_first(cli->tree, tctx,
&io, &result, multiple_search_callback);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(result.count, 2);
nxt.t2fnext.in.flags = FLAG_TRANS2_FIND_REQUIRE_RESUME | FLAG_TRANS2_FIND_CONTINUE;
nxt.t2fnext.in.last_name = result.list[1].ea_list.name.s;
nxt.t2fnext.in.num_names = 2;
- nxt.t2fnext.in.ea_names = talloc_array(mem_ctx, struct ea_name, 2);
+ nxt.t2fnext.in.ea_names = talloc_array(tctx, struct ea_name, 2);
nxt.t2fnext.in.ea_names[0].name.s = "SECOND EA";
nxt.t2fnext.in.ea_names[1].name.s = "THIRD EA";
- status = smb_raw_search_next(cli->tree, mem_ctx,
+ status = smb_raw_search_next(cli->tree, tctx,
&nxt, &result, multiple_search_callback);
CHECK_STATUS(status, NT_STATUS_OK);
/*
basic testing of all RAW_SEARCH_* calls using a single file
*/
-BOOL torture_raw_search(struct torture_context *torture)
+struct torture_suite *torture_raw_search(TALLOC_CTX *mem_ctx)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "SEARCH");
- mem_ctx = talloc_init("torture_search");
+ torture_suite_add_1smb_test(suite, "one file", test_one_file);
+ torture_suite_add_1smb_test(suite, "many files", test_many_files);
+ torture_suite_add_1smb_test(suite, "sorted", test_sorted);
+ torture_suite_add_1smb_test(suite, "modify search", test_modify_search);
+ torture_suite_add_1smb_test(suite, "many dirs", test_many_dirs);
+ torture_suite_add_1smb_test(suite, "os2 delete", test_os2_delete);
+ torture_suite_add_1smb_test(suite, "ea list", test_ea_list);
- ret &= test_one_file(cli, mem_ctx);
- ret &= test_many_files(cli, mem_ctx);
- ret &= test_sorted(cli, mem_ctx);
- ret &= test_modify_search(cli, mem_ctx);
- ret &= test_many_dirs(cli, mem_ctx);
- ret &= test_os2_delete(cli, mem_ctx);
- ret &= test_ea_list(cli, mem_ctx);
-
- torture_close_connection(cli);
- talloc_free(mem_ctx);
-
- return ret;
+ return suite;
}
/*
basic testing of seek calls
*/
-BOOL torture_raw_seek(struct torture_context *torture)
+bool torture_raw_seek(struct torture_context *torture, struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
+ bool ret = true;
- mem_ctx = talloc_init("torture_raw_seek");
-
- if (!test_seek(cli, mem_ctx)) {
- ret = False;
- }
+ ret &= test_seek(cli, torture);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
for each call we test that it succeeds, and where possible test
for consistency between the calls.
*/
-BOOL torture_raw_sfileinfo(struct torture_context *torture)
+bool torture_raw_sfileinfo(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
BOOL ret = True;
- TALLOC_CTX *mem_ctx;
int fnum_saved, d_fnum, fnum2, fnum = -1;
char *fnum_fname;
char *fnum_fname_new;
asprintf(&fnum_fname, BASEDIR "\\fnum_test_%d.txt", n);
asprintf(&fnum_fname_new, BASEDIR "\\fnum_test_new_%d.txt", n);
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_sfileinfo");
-
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
#define RECREATE_FILE(fname) do { \
if (fnum != -1) smbcli_close(cli->tree, fnum); \
- fnum = create_complex_file(cli, mem_ctx, fname); \
+ fnum = create_complex_file(cli, torture, fname); \
if (fnum == -1) { \
printf("(%s) ERROR: open of %s failed (%s)\n", \
__location__, fname, smbcli_errstr(cli->tree)); \
} \
finfo1.generic.level = RAW_FILEINFO_ALL_INFO; \
finfo1.generic.in.file.fnum = fnum; \
- status2 = smb_raw_fileinfo(cli->tree, mem_ctx, &finfo1); \
+ status2 = smb_raw_fileinfo(cli->tree, torture, &finfo1); \
if (!NT_STATUS_IS_OK(status2)) { \
printf("(%s) %s pathinfo - %s\n", __location__, #call, nt_errstr(status)); \
ret = False; \
} \
finfo1.generic.level = RAW_FILEINFO_ALL_INFO; \
finfo1.generic.in.file.path = path_fname; \
- status2 = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo1); \
+ status2 = smb_raw_pathinfo(cli->tree, torture, &finfo1); \
if (NT_STATUS_EQUAL(status2, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { \
finfo1.generic.in.file.path = path_fname_new; \
- status2 = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo1); \
+ status2 = smb_raw_pathinfo(cli->tree, torture, &finfo1); \
} \
if (!NT_STATUS_IS_OK(status2)) { \
printf("(%s) %s pathinfo - %s\n", __location__, #call, nt_errstr(status2)); \
finfo2.generic.level = RAW_FILEINFO_ ## call; \
if (check_fnum) { \
finfo2.generic.in.file.fnum = fnum; \
- status2 = smb_raw_fileinfo(cli->tree, mem_ctx, &finfo2); \
+ status2 = smb_raw_fileinfo(cli->tree, torture, &finfo2); \
} else { \
finfo2.generic.in.file.path = path_fname; \
- status2 = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo2); \
+ status2 = smb_raw_pathinfo(cli->tree, torture, &finfo2); \
if (NT_STATUS_EQUAL(status2, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { \
finfo2.generic.in.file.path = path_fname_new; \
- status2 = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo2); \
+ status2 = smb_raw_pathinfo(cli->tree, torture, &finfo2); \
} \
} \
if (!NT_STATUS_IS_OK(status2)) { \
printf("(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
(uint_t)value, (uint_t)finfo2.stype.out.field); \
- dump_all_info(mem_ctx, &finfo1); \
+ dump_all_info(torture, &finfo1); \
ret = False; \
}} while (0)
call_name, #stype, #field, \
(uint_t)value, \
(uint_t)nt_time_to_unix(finfo2.stype.out.field)); \
- printf("\t%s", timestring(mem_ctx, value)); \
- printf("\t%s\n", nt_time_string(mem_ctx, finfo2.stype.out.field)); \
- dump_all_info(mem_ctx, &finfo1); \
+ printf("\t%s", timestring(torture, value)); \
+ printf("\t%s\n", nt_time_string(torture, finfo2.stype.out.field)); \
+ dump_all_info(torture, &finfo1); \
ret = False; \
}} while (0)
call_name, #stype, #field, \
value, \
finfo2.stype.out.field); \
- dump_all_info(mem_ctx, &finfo1); \
+ dump_all_info(torture, &finfo1); \
ret = False; \
}} while (0)
printf("Failed to delete %s - %s\n", path_fname, smbcli_errstr(cli->tree));
}
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
* basic testing of all RAW_SFILEINFO_RENAME call
*/
-BOOL torture_raw_sfileinfo_rename(struct torture_context *torture)
+bool torture_raw_sfileinfo_rename(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
BOOL ret = True;
- TALLOC_CTX *mem_ctx;
int fnum_saved, d_fnum, fnum2, fnum = -1;
char *fnum_fname;
char *fnum_fname_new;
asprintf(&fnum_fname, BASEDIR "\\fnum_test_%d.txt", n);
asprintf(&fnum_fname_new, BASEDIR "\\fnum_test_new_%d.txt", n);
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_sfileinfo");
-
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
ZERO_STRUCT(sfinfo);
- smbcli_close(cli->tree, create_complex_file(cli, mem_ctx, fnum_fname_new));
- smbcli_close(cli->tree, create_complex_file(cli, mem_ctx, path_fname_new));
+ smbcli_close(cli->tree, create_complex_file(cli, torture, fnum_fname_new));
+ smbcli_close(cli->tree, create_complex_file(cli, torture, path_fname_new));
sfinfo.rename_information.in.overwrite = 0;
sfinfo.rename_information.in.root_fid = 0;
CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname_new);
printf("Trying rename with dest file open\n");
- fnum2 = create_complex_file(cli, mem_ctx, fnum_fname);
+ fnum2 = create_complex_file(cli, torture, fnum_fname);
sfinfo.rename_information.in.new_name = fnum_fname+strlen(BASEDIR)+1;
sfinfo.rename_information.in.overwrite = 1;
CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_ACCESS_DENIED);
CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname);
- fnum2 = create_complex_file(cli, mem_ctx, fnum_fname);
+ fnum2 = create_complex_file(cli, torture, fnum_fname);
sfinfo.rename_information.in.new_name = fnum_fname_new+strlen(BASEDIR)+1;
sfinfo.rename_information.in.overwrite = 0;
CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
printf("Failed to delete %s - %s\n", path_fname, smbcli_errstr(cli->tree));
}
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
look for the w2k3 setpathinfo STANDARD bug
*/
-BOOL torture_raw_sfileinfo_bug(struct torture_context *torture)
+bool torture_raw_sfileinfo_bug(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- TALLOC_CTX *mem_ctx;
const char *fname = "\\bug3.txt";
union smb_setfileinfo sfinfo;
NTSTATUS status;
int fnum;
- if (!torture_setting_bool(torture, "dangerous", False)) {
- printf("torture_raw_sfileinfo_bug disabled - enable dangerous tests to use\n");
- return True;
- }
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_sfileinfo");
+ if (!torture_setting_bool(torture, "dangerous", false))
+ torture_skip(torture,
+ "torture_raw_sfileinfo_bug disabled - enable dangerous tests to use\n");
- fnum = create_complex_file(cli, mem_ctx, fname);
+ fnum = create_complex_file(cli, torture, fname);
smbcli_close(cli->tree, fnum);
sfinfo.generic.level = RAW_SFILEINFO_STANDARD;
/*
basic testing of streams calls
*/
-BOOL torture_raw_streams(struct torture_context *torture)
+bool torture_raw_streams(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_streams");
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
- ret &= test_stream_io(cli, mem_ctx);
+ ret &= test_stream_io(cli, torture);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
/*
test unlink ops
*/
-static BOOL test_unlink(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_unlink(struct torture_context *tctx, struct smbcli_state *cli)
{
union smb_unlink io;
NTSTATUS status;
/*
test delete on close
*/
-static BOOL test_delete_on_close(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_delete_on_close(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_open op;
union smb_unlink io;
CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
printf("Testing with delete_on_close 0\n");
- fnum = create_complex_file(cli, mem_ctx, fname);
+ fnum = create_complex_file(cli, tctx, fname);
sfinfo.disposition_info.level = RAW_SFILEINFO_DISPOSITION_INFO;
sfinfo.disposition_info.in.file.fnum = fnum;
CHECK_STATUS(status, NT_STATUS_OK);
printf("Testing with delete_on_close 1\n");
- fnum = create_complex_file(cli, mem_ctx, fname);
+ fnum = create_complex_file(cli, tctx, fname);
sfinfo.disposition_info.in.file.fnum = fnum;
sfinfo.disposition_info.in.delete_on_close = 1;
status = smb_raw_setfileinfo(cli->tree, &sfinfo);
status = create_directory_handle(cli->tree, dname, &fnum);
CHECK_STATUS(status, NT_STATUS_OK);
- fnum2 = create_complex_file(cli, mem_ctx, inside);
+ fnum2 = create_complex_file(cli, tctx, inside);
sfinfo.disposition_info.in.file.fnum = fnum;
sfinfo.disposition_info.in.delete_on_close = 1;
CHECK_STATUS(status, NT_STATUS_OK);
smbcli_close(cli->tree, fnum);
- fnum2 = create_complex_file(cli, mem_ctx, inside);
+ fnum2 = create_complex_file(cli, tctx, inside);
smbcli_close(cli->tree, fnum2);
op.generic.level = RAW_OPEN_NTCREATEX;
op.ntcreatex.in.security_flags = 0;
op.ntcreatex.in.fname = dname;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum = op.ntcreatex.out.file.fnum;
CHECK_STATUS(status, NT_STATUS_OK);
smbcli_close(cli->tree, fnum);
- fnum2 = create_complex_file(cli, mem_ctx, inside);
+ fnum2 = create_complex_file(cli, tctx, inside);
smbcli_close(cli->tree, fnum2);
op.generic.level = RAW_OPEN_NTCREATEX;
op.ntcreatex.in.security_flags = 0;
op.ntcreatex.in.fname = dname;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum2 = op.ntcreatex.out.file.fnum;
smbcli_close(cli->tree, fnum);
- fnum = create_complex_file(cli, mem_ctx, inside);
+ fnum = create_complex_file(cli, tctx, inside);
smbcli_close(cli->tree, fnum);
/* we have a dir with a file in it, no handles open */
op.ntcreatex.in.security_flags = 0;
op.ntcreatex.in.fname = dname;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum = op.ntcreatex.out.file.fnum;
/* open without delete on close */
op.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
- status = smb_raw_open(cli->tree, mem_ctx, &op);
+ status = smb_raw_open(cli->tree, tctx, &op);
CHECK_STATUS(status, NT_STATUS_OK);
fnum2 = op.ntcreatex.out.file.fnum;
/*
basic testing of unlink calls
*/
-BOOL torture_raw_unlink(struct torture_context *torture)
+struct torture_suite *torture_raw_unlink(TALLOC_CTX *mem_ctx)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_unlink");
+ struct torture_suite *suite = torture_suite_create(mem_ctx,
+ "UNLINK");
- ret &= test_unlink(cli, mem_ctx);
- ret &= test_delete_on_close(cli, mem_ctx);
+ torture_suite_add_1smb_test(suite, "unlink", test_unlink);
+ torture_suite_add_1smb_test(suite, "delete_on_close", test_delete_on_close);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
- return ret;
+ return suite;
}
#define CHECK_ALL_INFO(v, field) do { \
finfo.all_info.level = RAW_FILEINFO_ALL_INFO; \
finfo.all_info.in.file.path = fname; \
- status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo); \
+ status = smb_raw_pathinfo(cli->tree, tctx, &finfo); \
CHECK_STATUS(status, NT_STATUS_OK); \
if ((v) != finfo.all_info.out.field) { \
printf("(%s) wrong value for field %s %.0f - %.0f\n", \
__location__, #field, (double)v, (double)finfo.all_info.out.field); \
- dump_all_info(mem_ctx, &finfo); \
+ dump_all_info(tctx, &finfo); \
ret = False; \
}} while (0)
/*
test write ops
*/
-static BOOL test_write(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_write(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_write io;
NTSTATUS status;
uint_t seed = time(NULL);
union smb_fileinfo finfo;
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
/*
test writex ops
*/
-static BOOL test_writex(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_writex(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_write io;
NTSTATUS status;
printf("dangerous not set - limiting range of test to 2^%d\n", max_bits);
}
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
/*
test write unlock ops
*/
-static BOOL test_writeunlock(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_writeunlock(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_write io;
NTSTATUS status;
uint_t seed = time(NULL);
union smb_fileinfo finfo;
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
/*
test write close ops
*/
-static BOOL test_writeclose(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_writeclose(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
union smb_write io;
NTSTATUS status;
uint_t seed = time(NULL);
union smb_fileinfo finfo;
- buf = talloc_zero_size(mem_ctx, maxsize);
+ buf = talloc_zero_size(tctx, maxsize);
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
/*
basic testing of write calls
*/
-BOOL torture_raw_write(struct torture_context *torture)
+struct torture_suite *torture_raw_write(TALLOC_CTX *mem_ctx)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_write");
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "WRITE");
- ret &= test_write(cli, mem_ctx);
- ret &= test_writeunlock(cli, mem_ctx);
- ret &= test_writeclose(cli, mem_ctx);
- ret &= test_writex(cli, mem_ctx);
+ torture_suite_add_1smb_test(suite, "write", test_write);
+ torture_suite_add_1smb_test(suite, "write unlock", test_writeunlock);
+ torture_suite_add_1smb_test(suite, "write close", test_writeclose);
+ torture_suite_add_1smb_test(suite, "writex", test_writex);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
- return ret;
+ return suite;
}
mem_ctx = talloc_init("torture_rpc_alter_context");
printf("opening LSA connection\n");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_lsarpc);
+ status = torture_rpc_connection(torture, &p, &ndr_table_lsarpc);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
return False;
mem_ctx = talloc_init("torture_rpc_srvsvc");
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_srvsvc);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_lsarpc);
+ status = torture_rpc_connection(torture, &p, &ndr_table_lsarpc);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
- test suite for dcom operations
-
- Copyright (C) Jelmer Vernooij 2004
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-#include "torture/torture.h"
-#include "torture/rpc/rpc.h"
-#include "librpc/gen_ndr/ndr_oxidresolver.h"
-
-BOOL torture_rpc_dcom(void)
-{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- mem_ctx = talloc_init("torture_rpc_dcom");
-
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_IOXIDResolver);
- if (!NT_STATUS_IS_OK(status)) {
- ret = False;
- }
-
- printf("\n");
-
- talloc_free(mem_ctx);
- return ret;
-}
return False;
}
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_drsuapi);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_drsuapi);
if (!NT_STATUS_IS_OK(status)) {
mem_ctx = talloc_init("torture_rpc_dssetup");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_dssetup);
+ status = torture_rpc_connection(torture, &p, &ndr_table_dssetup);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
mem_ctx = talloc_init("torture_rpc_epmapper");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_epmapper);
+ status = torture_rpc_connection(torture, &p, &ndr_table_epmapper);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
return False;
torture_comment(torture, "RPC-HANDLE-LSARPC\n");
- status = torture_rpc_connection(mem_ctx, &p1, &ndr_table_lsarpc);
+ status = torture_rpc_connection(torture, &p1, &ndr_table_lsarpc);
torture_assert_ntstatus_ok(torture, status, "opening lsa pipe1");
- status = torture_rpc_connection(mem_ctx, &p2, &ndr_table_lsarpc);
+ status = torture_rpc_connection(torture, &p2, &ndr_table_lsarpc);
torture_assert_ntstatus_ok(torture, status, "opening lsa pipe1");
qos.len = 0;
}
torture_comment(torture, "connect lsa pipe1\n");
- status = torture_rpc_connection(mem_ctx, &p1, &ndr_table_lsarpc);
+ status = torture_rpc_connection(torture, &p1, &ndr_table_lsarpc);
torture_assert_ntstatus_ok(torture, status, "opening lsa pipe1");
transport = p1->conn->transport.transport,
torture_comment(torture, "use assoc_group_id[0x%08X] for new connections\n", assoc_group_id);
torture_comment(torture, "connect lsa pipe2\n");
- status = torture_rpc_connection_transport(mem_ctx, &p2, &ndr_table_lsarpc,
+ status = torture_rpc_connection_transport(torture, &p2, &ndr_table_lsarpc,
transport,
assoc_group_id);
torture_assert_ntstatus_ok(torture, status, "opening lsa pipe2");
* connect p3 after the policy handle is opened
*/
torture_comment(torture, "connect lsa pipe3 after the policy handle is opened\n");
- status = torture_rpc_connection_transport(mem_ctx, &p3, &ndr_table_lsarpc,
+ status = torture_rpc_connection_transport(torture, &p3, &ndr_table_lsarpc,
transport,
assoc_group_id);
torture_assert_ntstatus_ok(torture, status, "opening lsa pipe3");
* and use the handle on it
*/
torture_comment(torture, "connect lsa pipe4 and use policy handle\n");
- status = torture_rpc_connection_transport(mem_ctx, &p4, &ndr_table_lsarpc,
+ status = torture_rpc_connection_transport(torture, &p4, &ndr_table_lsarpc,
transport,
assoc_group_id);
torture_assert_ntstatus_ok(torture, status, "opening lsa pipe4");
* now open p5
*/
torture_comment(torture, "connect lsa pipe5 - should fail\n");
- status = torture_rpc_connection_transport(mem_ctx, &p5, &ndr_table_lsarpc,
+ status = torture_rpc_connection_transport(torture, &p5, &ndr_table_lsarpc,
transport,
assoc_group_id);
torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
torture_comment(torture, "RPC-HANDLE-SAMR\n");
- status = torture_rpc_connection(mem_ctx, &p1, &ndr_table_samr);
+ status = torture_rpc_connection(torture, &p1, &ndr_table_samr);
torture_assert_ntstatus_ok(torture, status, "opening samr pipe1");
- status = torture_rpc_connection(mem_ctx, &p2, &ndr_table_samr);
+ status = torture_rpc_connection(torture, &p2, &ndr_table_samr);
torture_assert_ntstatus_ok(torture, status, "opening samr pipe1");
r.in.system_name = 0;
}
torture_comment(torture, "connect samr pipe1\n");
- status = torture_rpc_connection(mem_ctx, &p1, &ndr_table_samr);
+ status = torture_rpc_connection(torture, &p1, &ndr_table_samr);
torture_assert_ntstatus_ok(torture, status, "opening samr pipe1");
transport = p1->conn->transport.transport,
torture_comment(torture, "use assoc_group_id[0x%08X] for new connections\n", assoc_group_id);
torture_comment(torture, "connect lsa pipe2\n");
- status = torture_rpc_connection_transport(mem_ctx, &p2, &ndr_table_lsarpc,
+ status = torture_rpc_connection_transport(torture, &p2, &ndr_table_lsarpc,
transport,
assoc_group_id);
torture_assert_ntstatus_ok(torture, status, "opening lsa pipe2");
msleep(10);
torture_comment(torture, "connect samr pipe3 - should fail\n");
- status = torture_rpc_connection_transport(mem_ctx, &p3, &ndr_table_samr,
+ status = torture_rpc_connection_transport(torture, &p3, &ndr_table_samr,
transport,
assoc_group_id);
torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
"opening samr pipe3");
torture_comment(torture, "connect lsa pipe4 - should fail\n");
- status = torture_rpc_connection_transport(mem_ctx, &p4, &ndr_table_lsarpc,
+ status = torture_rpc_connection_transport(torture, &p4, &ndr_table_lsarpc,
transport,
assoc_group_id);
torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
"opening lsa pipe4");
torture_comment(torture, "connect samr pipe5 with assoc_group_id[0x%08X]- should fail\n", ++assoc_group_id);
- status = torture_rpc_connection_transport(mem_ctx, &p5, &ndr_table_samr,
+ status = torture_rpc_connection_transport(torture, &p5, &ndr_table_samr,
transport,
assoc_group_id);
torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
"opening samr pipe5");
torture_comment(torture, "connect lsa pipe6 with assoc_group_id[0x%08X]- should fail\n", ++assoc_group_id);
- status = torture_rpc_connection_transport(mem_ctx, &p6, &ndr_table_lsarpc,
+ status = torture_rpc_connection_transport(torture, &p6, &ndr_table_lsarpc,
transport,
assoc_group_id);
torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
torture_comment(torture, "RPC-HANDLE-RANDOM-ASSOC\n");
torture_comment(torture, "connect samr pipe1\n");
- status = torture_rpc_connection(mem_ctx, &p1, &ndr_table_samr);
+ status = torture_rpc_connection(torture, &p1, &ndr_table_samr);
torture_assert_ntstatus_ok(torture, status, "opening samr pipe1");
transport = p1->conn->transport.transport,
torture_comment(torture, "pip1 use assoc_group_id[0x%08X]\n", assoc_group_id);
torture_comment(torture, "connect samr pipe2 with assoc_group_id[0x%08X]- should fail\n", ++assoc_group_id);
- status = torture_rpc_connection_transport(mem_ctx, &p2, &ndr_table_samr,
+ status = torture_rpc_connection_transport(torture, &p2, &ndr_table_samr,
transport,
assoc_group_id);
torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
"opening samr pipe2");
torture_comment(torture, "connect samr pipe3 with assoc_group_id[0x%08X]- should fail\n", ++assoc_group_id);
- status = torture_rpc_connection_transport(mem_ctx, &p3, &ndr_table_samr,
+ status = torture_rpc_connection_transport(torture, &p3, &ndr_table_samr,
transport,
assoc_group_id);
torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
torture_comment(torture, "RPC-HANDLE-DRSUAPI\n");
- status = torture_rpc_connection(mem_ctx, &p1, &ndr_table_drsuapi);
+ status = torture_rpc_connection(torture, &p1, &ndr_table_drsuapi);
torture_assert_ntstatus_ok(torture, status, "opening drsuapi pipe1");
- status = torture_rpc_connection(mem_ctx, &p2, &ndr_table_drsuapi);
+ status = torture_rpc_connection(torture, &p2, &ndr_table_drsuapi);
torture_assert_ntstatus_ok(torture, status, "opening drsuapi pipe1");
GUID_from_string(DRSUAPI_DS_BIND_GUID, &bind_guid);
mem_ctx = talloc_init("torture_rpc_initshutdown");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_initshutdown);
+ status = torture_rpc_connection(torture, &p, &ndr_table_initshutdown);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
NTSTATUS status;
struct lsa_String string;
struct lsa_ForestTrustInformation info, *info_ptr;
- uint16_t unknown = 0;
printf("\nTesting lsaRQueryForestTrustInformation\n");
struct policy_handle *handle,
struct lsa_DomainListEx *domains)
{
- NTSTATUS status;
- int i,j;
+ int i;
BOOL ret = True;
for (i=0; i< domains->count; i++) {
mem_ctx = talloc_init("torture_rpc_lsa");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_lsarpc);
+ status = torture_rpc_connection(torture, &p, &ndr_table_lsarpc);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
return False;
mem_ctx = talloc_init("torture_rpc_lsa_get_user");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_lsarpc);
+ status = torture_rpc_connection(torture, &p, &ndr_table_lsarpc);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
return False;
mem_ctx = talloc_init("torture_rpc_lsa");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_lsarpc);
+ status = torture_rpc_connection(torture, &p, &ndr_table_lsarpc);
if (!NT_STATUS_IS_OK(status)) {
ret = False;
goto done;
/*
ask the server what interface IDs are available on this endpoint
*/
-BOOL test_inq_if_ids(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- BOOL (*per_id_test)(const struct ndr_interface_table *iface,
+BOOL test_inq_if_ids(struct torture_context *tctx,
+ struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+ BOOL (*per_id_test)(struct torture_context *,
+ const struct ndr_interface_table *iface,
TALLOC_CTX *mem_ctx,
struct ndr_syntax_id *id),
const void *priv)
ndr_interface_name(&id->uuid, id->if_version));
if (per_id_test) {
- per_id_test(priv, mem_ctx, id);
+ per_id_test(tctx, priv, mem_ctx, id);
}
}
lp_set_cmdline("torture:binding", dcerpc_binding_string(loop_ctx, b));
- status = torture_rpc_connection(loop_ctx, &p, &ndr_table_mgmt);
+ status = torture_rpc_connection(torture, &p, &ndr_table_mgmt);
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
printf("Interface not available - skipping\n");
talloc_free(loop_ctx);
ret = False;
}
- if (!test_inq_if_ids(p, loop_ctx, NULL, NULL)) {
+ if (!test_inq_if_ids(torture, p, loop_ctx, NULL, NULL)) {
ret = False;
}
machine_password = cli_credentials_get_password(machine_credentials);
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_netlogon);
+ status = torture_rpc_connection(torture, &p, &ndr_table_netlogon);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
return False;
mem_ctx = talloc_init("torture_rpc_oxidresolve");
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&premact,
&ndr_table_IRemoteActivation);
return False;
}
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_IOXIDResolver);
mem_ctx = talloc_init("torture_rpc_remact");
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_IRemoteActivation);
mem_ctx = talloc_init("torture_rpc_rot");
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_rot);
#include "lib/util/dlinklist.h"
/* open a rpc connection to the chosen binding string */
-_PUBLIC_ NTSTATUS torture_rpc_connection(TALLOC_CTX *parent_ctx,
+_PUBLIC_ NTSTATUS torture_rpc_connection(struct torture_context *tctx,
struct dcerpc_pipe **p,
const struct ndr_interface_table *table)
{
- NTSTATUS status;
- const char *binding = lp_parm_string(-1, "torture", "binding");
+ NTSTATUS status;
+ const char *binding = torture_setting_string(tctx, "binding", NULL);
if (!binding) {
printf("You must specify a ncacn binding string\n");
return NT_STATUS_INVALID_PARAMETER;
}
- status = dcerpc_pipe_connect(parent_ctx,
+ status = dcerpc_pipe_connect(tctx,
p, binding, table,
cmdline_credentials, NULL);
}
/* open a rpc connection to a specific transport */
-NTSTATUS torture_rpc_connection_transport(TALLOC_CTX *parent_ctx,
+NTSTATUS torture_rpc_connection_transport(struct torture_context *tctx,
struct dcerpc_pipe **p,
const struct ndr_interface_table *table,
enum dcerpc_transport_t transport,
uint32_t assoc_group_id)
{
NTSTATUS status;
- const char *binding = lp_parm_string(-1, "torture", "binding");
+ const char *binding = torture_setting_string(tctx, "binding", NULL);
struct dcerpc_binding *b;
- TALLOC_CTX *mem_ctx = talloc_named(parent_ctx, 0, "torture_rpc_connection_smb");
+ TALLOC_CTX *mem_ctx = talloc_named(tctx, 0, "torture_rpc_connection_smb");
if (!binding) {
printf("You must specify a ncacn binding string\n");
cmdline_credentials, NULL);
if (NT_STATUS_IS_OK(status)) {
- *p = talloc_reference(parent_ctx, *p);
+ *p = talloc_reference(tctx, *p);
} else {
*p = NULL;
}
torture_suite_add_simple_test(suite, "SCHANNEL", torture_rpc_schannel);
torture_suite_add_simple_test(suite, "SCHANNEL2", torture_rpc_schannel2);
torture_suite_add_simple_test(suite, "SRVSVC", torture_rpc_srvsvc);
- torture_suite_add_simple_test(suite, "SVCCTL", torture_rpc_svcctl);
+ torture_suite_add_suite(suite, torture_rpc_svcctl(suite));
torture_suite_add_simple_test(suite, "EPMAPPER", torture_rpc_epmapper);
torture_suite_add_simple_test(suite, "INITSHUTDOWN", torture_rpc_initshutdown);
torture_suite_add_simple_test(suite, "OXIDRESOLVE", torture_rpc_oxidresolve);
mem_ctx = talloc_init("torture_rpc_winreg");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_winreg);
+ status = torture_rpc_connection(torture, &p, &ndr_table_winreg);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
userdomain = torture_setting_string(torture, "userdomain", lp_workgroup());
- user_ctx = torture_create_testuser(TEST_USER_NAME,
+ user_ctx = torture_create_testuser(torture,
+ TEST_USER_NAME,
userdomain,
ACB_NORMAL,
(const char **)&user_password);
TEST_USER_NAME, 16 /* > 14 */, &user_password,
NULL, 0, False);
- user_ctx_wrong_wks = torture_create_testuser(TEST_USER_NAME_WRONG_WKS,
+ user_ctx_wrong_wks = torture_create_testuser(torture,
+ TEST_USER_NAME_WRONG_WKS,
userdomain,
ACB_NORMAL,
(const char **)&user_password_wrong_wks);
}
user_ctx_wrong_time
- = torture_create_testuser(TEST_USER_NAME_WRONG_TIME,
+ = torture_create_testuser(torture, TEST_USER_NAME_WRONG_TIME,
userdomain,
ACB_NORMAL,
(const char **)&user_password_wrong_time);
mem_ctx = talloc_init("torture_rpc_netlogon");
test_machine_account = talloc_asprintf(mem_ctx, "%s$", TEST_MACHINE_NAME);
- join_ctx = torture_create_testuser(test_machine_account, lp_workgroup(), ACB_SVRTRUST,
+ join_ctx = torture_create_testuser(torture, test_machine_account, lp_workgroup(), ACB_SVRTRUST,
&machine_password);
if (!join_ctx) {
talloc_free(mem_ctx);
}
test_wksta_machine_account = talloc_asprintf(mem_ctx, "%s$", TEST_WKSTA_MACHINE_NAME);
- join_ctx2 = torture_create_testuser(test_wksta_machine_account, lp_workgroup(), ACB_WSTRUST,
+ join_ctx2 = torture_create_testuser(torture, test_wksta_machine_account, lp_workgroup(), ACB_WSTRUST,
&wksta_machine_password);
if (!join_ctx2) {
talloc_free(mem_ctx);
return False;
}
- user_ctx = torture_create_testuser(TEST_USER_NAME,
+ user_ctx = torture_create_testuser(torture, TEST_USER_NAME,
lp_workgroup(),
ACB_NORMAL, NULL);
if (!user_ctx) {
}
- status = torture_rpc_connection(samsync_state,
+ status = torture_rpc_connection(torture,
&samsync_state->p_lsa,
&ndr_table_lsarpc);
/*
work out how many calls there are for an interface
*/
-static BOOL test_num_calls(const struct ndr_interface_table *iface,
+static BOOL test_num_calls(struct torture_context *tctx,
+ const struct ndr_interface_table *iface,
TALLOC_CTX *mem_ctx,
struct ndr_syntax_id *id)
{
tbl.name = iface->name;
tbl.syntax_id = *id;
- status = torture_rpc_connection(mem_ctx, &p, iface);
+ status = torture_rpc_connection(tctx, &p, iface);
if (!NT_STATUS_IS_OK(status)) {
char *uuid_str = GUID_string(mem_ctx, &id->uuid);
printf("Failed to connect to '%s' on '%s' - %s\n",
lp_set_cmdline("torture:binding", dcerpc_binding_string(mem_ctx, b));
- status = torture_rpc_connection(loop_ctx, &p, &ndr_table_mgmt);
+ status = torture_rpc_connection(torture, &p, &ndr_table_mgmt);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(loop_ctx);
ret = False;
continue;
}
- if (!test_inq_if_ids(p, mem_ctx, test_num_calls, l->table)) {
+ if (!test_inq_if_ids(torture, p, mem_ctx, test_num_calls, l->table)) {
ret = False;
}
}
mem_ctx = talloc_init("torture_rpc_lsa_secrets");
- status = torture_rpc_connection(mem_ctx,
+ status = torture_rpc_connection(torture,
&p,
&ndr_table_lsarpc);
if (!NT_STATUS_IS_OK(status)) {
return ret;
}
-BOOL torture_rpc_spoolss(struct torture_context *torture)
+bool torture_rpc_spoolss(struct torture_context *torture)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
+ NTSTATUS status;
+ struct dcerpc_pipe *p;
TALLOC_CTX *mem_ctx;
BOOL ret = True;
struct test_spoolss_context *ctx;
mem_ctx = talloc_init("torture_rpc_spoolss");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_spoolss);
+ status = torture_rpc_connection(torture, &p, &ndr_table_spoolss);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
return False;
mem_ctx = talloc_init("torture_rpc_srvsvc");
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_srvsvc);
+ status = torture_rpc_connection(torture, &p, &ndr_table_srvsvc);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(mem_ctx);
return False;
ret &= test_NetShareAddSetDel(p, mem_ctx);
ret &= test_NetNameValidate(p, mem_ctx);
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_srvsvc);
+ status = torture_rpc_connection(torture, &p, &ndr_table_srvsvc);
if (!binding) {
d_printf("You must specify a ncacn binding string\n");
#include "librpc/gen_ndr/ndr_svcctl_c.h"
#include "torture/rpc/rpc.h"
-static BOOL test_EnumServicesStatus(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *h)
+static bool test_OpenSCManager(struct dcerpc_pipe *p, struct torture_context *tctx, struct policy_handle *h)
+{
+ struct svcctl_OpenSCManagerW r;
+
+ r.in.MachineName = NULL;
+ r.in.DatabaseName = NULL;
+ r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
+ r.out.handle = h;
+
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_svcctl_OpenSCManagerW(p, tctx, &r),
+ "OpenSCManager failed!");
+
+ return true;
+}
+
+static bool test_CloseServiceHandle(struct dcerpc_pipe *p, struct torture_context *tctx, struct policy_handle *h)
+{
+ struct svcctl_CloseServiceHandle r;
+
+ r.in.handle = h;
+ r.out.handle = h;
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_svcctl_CloseServiceHandle(p, tctx, &r),
+ "CloseServiceHandle failed");
+
+ return true;
+}
+
+static bool test_EnumServicesStatus(struct torture_context *tctx, struct dcerpc_pipe *p)
{
struct svcctl_EnumServicesStatusW r;
+ struct policy_handle h;
int i;
NTSTATUS status;
uint32_t resume_handle = 0;
struct ENUM_SERVICE_STATUS *service = NULL;
- r.in.handle = h;
+ if (!test_OpenSCManager(p, tctx, &h))
+ return false;
+
+ r.in.handle = &h;
r.in.type = SERVICE_TYPE_WIN32;
r.in.state = SERVICE_STATE_ALL;
r.in.buf_size = 0;
r.out.services_returned = 0;
r.out.bytes_needed = 0;
- status = dcerpc_svcctl_EnumServicesStatusW(p, mem_ctx, &r);
+ status = dcerpc_svcctl_EnumServicesStatusW(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("ËnumServicesStatus failed!\n");
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "EnumServicesStatus failed!");
if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
r.in.buf_size = *r.out.bytes_needed;
- r.out.service = talloc_size(mem_ctx, *r.out.bytes_needed);
+ r.out.service = talloc_size(tctx, *r.out.bytes_needed);
- status = dcerpc_svcctl_EnumServicesStatusW(p, mem_ctx, &r);
+ status = dcerpc_svcctl_EnumServicesStatusW(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("ËnumServicesStatus failed!\n");
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "EnumServicesStatus failed!");
+ torture_assert_werr_ok(tctx, r.out.result, "EnumServicesStatus failed");
- if (!W_ERROR_IS_OK(r.out.result)) {
- printf("EnumServicesStatus failed\n");
- return False;
- }
service = (struct ENUM_SERVICE_STATUS *)r.out.service;
}
for(i = 0; i < *r.out.services_returned; i++) {
printf("Type: %d, State: %d\n", service[i].status.type, service[i].status.state);
}
-
- return True;
-}
-
-static BOOL test_OpenSCManager(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *h)
-{
- struct svcctl_OpenSCManagerW r;
- NTSTATUS status;
-
- r.in.MachineName = NULL;
- r.in.DatabaseName = NULL;
- r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
- r.out.handle = h;
- status = dcerpc_svcctl_OpenSCManagerW(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("OpenSCManager failed!\n");
- return False;
- }
-
- return True;
-}
+ if (!test_CloseServiceHandle(p, tctx, &h))
+ return false;
-static BOOL test_CloseServiceHandle(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *h)
-{
- struct svcctl_CloseServiceHandle r;
- NTSTATUS status;
- r.in.handle = h;
- r.out.handle = h;
- status = dcerpc_svcctl_CloseServiceHandle(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("CloseServiceHandle failed\n");
- return False;
- }
-
- return True;
+ return true;
}
-BOOL torture_rpc_svcctl(struct torture_context *torture)
+static bool test_SCManager(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- struct policy_handle h;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- mem_ctx = talloc_init("torture_rpc_svcctl");
-
- status = torture_rpc_connection(mem_ctx, &p, &ndr_table_svcctl);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(mem_ctx);
- return False;
- }
+ struct policy_handle h;
- if (!test_OpenSCManager(p, mem_ctx, &h)) {
- ret = False;
- }
+ if (!test_OpenSCManager(p, tctx, &h))
+ return false;
- if (!test_EnumServicesStatus(p, mem_ctx, &h)) {
- ret = False;
- }
+ if (!test_CloseServiceHandle(p, tctx, &h))
+ return false;
- if (!test_CloseServiceHandle(p, mem_ctx, &h)) {
- ret = False;
- }
+ return true;
+}
- talloc_free(mem_ctx);
+struct torture_suite *torture_rpc_svcctl(TALLOC_CTX *mem_ctx)
+{
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "SVCCTL");
+ struct torture_tcase *tcase;
+
+ tcase = torture_suite_add_rpc_iface_tcase(suite, "svcctl",
+ &ndr_table_svcctl);
+
+ torture_rpc_tcase_add_test(tcase, "SCManager",
+ test_SCManager);
+ torture_rpc_tcase_add_test(tcase, "EnumServicesStatus",
+ test_EnumServicesStatus);
- return ret;
+ return suite;
}
when finished
*/
-struct test_join *torture_create_testuser(const char *username,
+struct test_join *torture_create_testuser(struct torture_context *torture,
+ const char *username,
const char *domain,
uint16_t acct_type,
const char **random_password)
cmdline_credentials, NULL);
} else {
- status = torture_rpc_connection(join,
+ status = torture_rpc_connection(torture,
&join->p,
&ndr_table_samr);
}
git.samba.org / kai / samba.git / commitdiff