bool torture_libsmbclient_options(struct torture_context *tctx)
{
SMBCCTX *ctx;
ctx = smbc_new_context();
torture_assert(tctx, ctx, "failed to get new context");
torture_assert(tctx, smbc_init_context(ctx), "failed to init context");
TEST_OPTION_INT(OptionDebugToStderr, true);
TEST_OPTION_INT(OptionFullTimeNames, true);
TEST_OPTION_INT(OptionOpenShareMode, SMBC_SHAREMODE_DENY_ALL);
/* FIXME: OptionUserData */
TEST_OPTION_INT(OptionSmbEncryptionLevel, SMBC_ENCRYPTLEVEL_REQUEST);
TEST_OPTION_INT(OptionCaseSensitive, false);
TEST_OPTION_INT(OptionBrowseMaxLmbCount, 2);
TEST_OPTION_INT(OptionUrlEncodeReaddirEntries, true);
TEST_OPTION_INT(OptionOneSharePerServer, true);
TEST_OPTION_INT(OptionUseKerberos, false);
TEST_OPTION_INT(OptionFallbackAfterKerberos, false);
TEST_OPTION_INT(OptionNoAutoAnonymousLogin, true);
TEST_OPTION_INT(OptionUseCCache, true);
smbc_free_context(ctx, 1);
return true;
}
static bool test_guid_from_string(struct torture_context *tctx)
{
struct GUID g1, exp;
torture_assert_ntstatus_ok(tctx,
GUID_from_string("00000001-0002-0003-0405-060708090a0b", &g1),
"invalid return code");
exp.time_low = 1;
exp.time_mid = 2;
exp.time_hi_and_version = 3;
exp.clock_seq[0] = 4;
exp.clock_seq[1] = 5;
exp.node[0] = 6;
exp.node[1] = 7;
exp.node[2] = 8;
exp.node[3] = 9;
exp.node[4] = 10;
exp.node[5] = 11;
torture_assert(tctx, GUID_equal(&g1, &exp), "UUID parsed incorrectly");
torture_assert_ntstatus_ok(tctx,
GUID_from_string("{00000001-0002-0003-0405-060708090a0b}", &g1),
"invalid return code");
torture_assert(tctx, GUID_equal(&g1, &exp), "UUID parsed incorrectly");
return true;
}
static bool test_afdgets(struct torture_context *tctx)
{
int fd;
char *line;
TALLOC_CTX *mem_ctx = tctx;
bool ret = false;
torture_assert(tctx, file_save(TEST_FILENAME, (const void *)TEST_DATA,
strlen(TEST_DATA)),
"saving file");
fd = open(TEST_FILENAME, O_RDONLY);
torture_assert(tctx, fd != -1, "opening file");
line = afdgets(fd, mem_ctx, 8);
torture_assert_goto(tctx, strcmp(line, TEST_LINE1) == 0, ret, done,
"line 1 mismatch");
line = afdgets(fd, mem_ctx, 8);
torture_assert_goto(tctx, strcmp(line, TEST_LINE2) == 0, ret, done,
"line 2 mismatch");
line = afdgets(fd, mem_ctx, 8);
torture_assert_goto(tctx, strcmp(line, TEST_LINE3) == 0, ret, done,
"line 3 mismatch");
ret = true;
done:
close(fd);
unlink(TEST_FILENAME);
return ret;
}
static bool test_Lookup_simple(struct torture_context *tctx,
struct dcerpc_pipe *p)
{
NTSTATUS status;
struct epm_Lookup r;
struct policy_handle entry_handle;
uint32_t num_ents = 0;
struct dcerpc_binding_handle *h = p->binding_handle;
ZERO_STRUCT(entry_handle);
torture_comment(tctx, "Testing epm_Lookup\n");
/* get all elements */
r.in.inquiry_type = RPC_C_EP_ALL_ELTS;
r.in.object = NULL;
r.in.interface_id = NULL;
r.in.vers_option = RPC_C_VERS_ALL;
r.in.entry_handle = &entry_handle;
r.in.max_ents = 10;
r.out.entry_handle = &entry_handle;
r.out.num_ents = &num_ents;
do {
int i;
status = dcerpc_epm_Lookup_r(h, tctx, &r);
if (!NT_STATUS_IS_OK(status) ||
r.out.result != EPMAPPER_STATUS_OK) {
break;
}
torture_comment(tctx,
"epm_Lookup returned %d events, entry_handle: %s\n",
*r.out.num_ents,
GUID_string(tctx, &entry_handle.uuid));
for (i = 0; i < *r.out.num_ents; i++) {
torture_comment(tctx,
"\n Found '%s'\n",
r.out.entries[i].annotation);
display_tower(tctx, &r.out.entries[i].tower->tower);
}
} while (NT_STATUS_IS_OK(status) &&
r.out.result == EPMAPPER_STATUS_OK &&
*r.out.num_ents == r.in.max_ents &&
!ndr_policy_handle_empty(&entry_handle));
torture_assert_ntstatus_ok(tctx, status, "epm_Lookup failed");
torture_assert(tctx, r.out.result == EPMAPPER_STATUS_NO_MORE_ENTRIES, "epm_Lookup failed");
torture_assert(tctx,
ndr_policy_handle_empty(&entry_handle),
"epm_Lookup failed - The policy handle should be emtpy.");
return true;
}
static bool whoami_sid_parse(void *mem_ctx,
struct torture_context *torture,
DATA_BLOB *data, size_t *offset,
struct dom_sid **psid)
{
size_t remain = data->length - *offset;
int i;
*psid = talloc_zero(mem_ctx, struct dom_sid);
torture_assert(torture, *psid != NULL, "out of memory");
torture_assert(torture, remain >= 8,
"invalid SID format");
(*psid)->sid_rev_num = CVAL(data->data, *offset);
(*psid)->num_auths = CVAL(data->data, *offset + 1);
memcpy((*psid)->id_auth, data->data + *offset + 2, 6);
(*offset) += 8;
remain = data->length - *offset;
torture_assert(torture, remain >= ((*psid)->num_auths * 4),
"invalid sub_auth byte count");
torture_assert(torture, (*psid)->num_auths >= 0,
"invalid sub_auth value");
torture_assert(torture, (*psid)->num_auths <= 15,
"invalid sub_auth value");
for (i = 0; i < (*psid)->num_auths; i++) {
(*psid)->sub_auths[i] = IVAL(data->data, *offset);
(*offset) += 4;
}
return true;
}
static bool test_file_load_save(struct torture_context *tctx)
{
size_t len;
char *data;
TALLOC_CTX *mem_ctx = tctx;
torture_assert(tctx, file_save(TEST_FILENAME, TEST_DATA, strlen(TEST_DATA)),
"saving file");
torture_assert_file_contains_text(tctx, TEST_FILENAME, TEST_DATA,
"file contents");
data = file_load(TEST_FILENAME, &len, 0, mem_ctx);
torture_assert(tctx, data, "loading file");
torture_assert_int_equal(tctx, len, strlen(TEST_DATA), "Length");
torture_assert_mem_equal(tctx, data, TEST_DATA, len, "Contents");
data = file_load(TEST_FILENAME, &len, 5, mem_ctx);
torture_assert_int_equal(tctx, len, 5, "Length");
torture_assert_mem_equal(tctx, data, TEST_DATA, len, "Contents");
unlink(TEST_FILENAME);
return true;
}
static bool test_free_ref_null_context(void)
{
void *p1, *p2, *p3;
int ret;
talloc_disable_null_tracking();
p1 = talloc_new(NULL);
p2 = talloc_new(NULL);
p3 = talloc_reference(p2, p1);
torture_assert("reference", p3 == p1, "failed: reference on null");
ret = talloc_free(p1);
torture_assert("ref free with null parent", ret == 0, "failed: free with null parent");
talloc_free(p2);
talloc_enable_null_tracking_no_autofree();
p1 = talloc_new(NULL);
p2 = talloc_new(NULL);
p3 = talloc_reference(p2, p1);
torture_assert("reference", p3 == p1, "failed: reference on null");
ret = talloc_free(p1);
torture_assert("ref free with null tracked parent", ret == 0, "failed: free with null parent");
talloc_free(p2);
return true;
}
static bool witness_GetInterfaceList_check(struct torture_context *tctx,
struct witness_GetInterfaceList *r)
{
struct witness_interfaceList *l;
torture_assert(tctx, r->out.interface_list, "r->out.interface_list");
l = *(r->out.interface_list);
torture_assert_int_equal(tctx, l->num_interfaces, 2, "l->num_interfaces");
torture_assert(tctx, l->interfaces, "l->interfaces");
torture_assert_str_equal(tctx, l->interfaces[0].group_name, "NODE2", "l->interfaces[0].group_name");
torture_assert_int_equal(tctx, l->interfaces[0].version, -1, "l->interfaces[0].version");
torture_assert_int_equal(tctx, l->interfaces[0].state, 1, "l->interfaces[0].state");
torture_assert_str_equal(tctx, l->interfaces[0].ipv4, "192.168.3.44", "l->interfaces[0].state");
torture_assert_int_equal(tctx, l->interfaces[0].flags, 5, "l->interfaces[0].flags");
torture_assert_str_equal(tctx, l->interfaces[1].group_name, "NODE1", "l->interfaces[0].group_name");
torture_assert_int_equal(tctx, l->interfaces[1].version, -1, "l->interfaces[0].version");
torture_assert_int_equal(tctx, l->interfaces[1].state, 1, "l->interfaces[0].state");
torture_assert_str_equal(tctx, l->interfaces[1].ipv4, "192.168.3.45", "l->interfaces[0].state");
torture_assert_int_equal(tctx, l->interfaces[1].flags, 1, "l->interfaces[0].flags");
torture_assert_werr_ok(tctx, r->out.result, "r->out.result");
return true;
}
static bool test_netprintq(struct torture_context *tctx,
struct smbcli_state *cli)
{
struct rap_NetPrintQEnum r;
int i;
r.in.level = 5;
r.in.bufsize = 8192;
torture_assert_ntstatus_ok(tctx,
smbcli_rap_netprintqenum(cli->tree, tctx, &r),
"failed to enum printq");
torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
"failed to enum printq");
for (i=0; i < r.out.count; i++) {
const char *printqname = r.out.info[i].info5.PrintQueueName;
torture_assert(tctx,
test_netprintq_pause(tctx, cli, printqname),
"failed to pause print queue");
torture_assert(tctx,
test_netprintq_resume(tctx, cli, printqname),
"failed to resume print queue");
}
return true;
}
static bool test_cmp(struct torture_context *tctx)
{
DATA_BLOB a = data_blob_string_const("bla");
DATA_BLOB b = data_blob_string_const("blae");
torture_assert(tctx, data_blob_cmp(&a, &b) != 0, "cmp different");
torture_assert(tctx, data_blob_cmp(&a, &a) == 0, "cmp self");
return true;
}
static bool test_null_time(struct torture_context *tctx)
{
torture_assert(tctx, null_time(0), "0");
torture_assert(tctx, null_time(0xFFFFFFFF), "0xFFFFFFFF");
torture_assert(tctx, null_time(-1), "-1");
torture_assert(tctx, !null_time(42), "42");
return true;
}
static bool test_set_cmdline(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
torture_assert(tctx, lpcfg_set_cmdline(lp_ctx, "workgroup", "werkgroep"), "lpcfg_set_cmdline failed");
torture_assert(tctx, lpcfg_do_global_parameter(lp_ctx, "workgroup", "barbla"), "lpcfg_set_option failed");
torture_assert_str_equal(tctx, "WERKGROEP", lpcfg_workgroup(lp_ctx), "workgroup");
return true;
}
static bool test_strhasupper(struct torture_context *tctx)
{
torture_assert(tctx, strhasupper("B"), "one up char");
torture_assert(tctx, strhasupper("aB"), "one low, one up char");
torture_assert(tctx, !strhasupper("a"), "one low char");
torture_assert(tctx, !strhasupper(""), "empty string");
torture_assert(tctx, !strhasupper("3"), "one digit");
return true;
}
static bool test_server_role_member_specified3(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
torture_assert(tctx, lpcfg_set_option(lp_ctx, "server role=member"), "lpcfg_set_option failed");
torture_assert(tctx, lpcfg_set_option(lp_ctx, "security=ads"), "lpcfg_set_option failed");
torture_assert_int_equal(tctx, lpcfg_server_role(lp_ctx), ROLE_DOMAIN_MEMBER, "ROLE should be member");
torture_assert_int_equal(tctx, lpcfg_security(lp_ctx), SEC_ADS, "security should be ads");
return true;
}
static bool test_server_role_dc_domain_logons_and_not_master(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
torture_assert(tctx, lpcfg_set_option(lp_ctx, "domain logons=true"), "lpcfg_set_option failed");
torture_assert(tctx, lpcfg_set_option(lp_ctx, "domain master=false"), "lpcfg_set_option failed");
torture_assert_int_equal(tctx, lpcfg_server_role(lp_ctx), ROLE_DOMAIN_BDC, "ROLE should be BDC");
torture_assert_int_equal(tctx, lpcfg_security(lp_ctx), SEC_USER, "security should be user");
return true;
}
/*
test realloc
*/
static bool test_realloc(void)
{
void *root, *p1, *p2;
printf("test: realloc\n# REALLOC\n");
root = talloc_new(NULL);
p1 = talloc_size(root, 10);
CHECK_SIZE("realloc", p1, 10);
p1 = talloc_realloc_size(NULL, p1, 20);
CHECK_SIZE("realloc", p1, 20);
talloc_new(p1);
p2 = talloc_realloc_size(p1, NULL, 30);
talloc_new(p1);
p2 = talloc_realloc_size(p1, p2, 40);
CHECK_SIZE("realloc", p2, 40);
CHECK_SIZE("realloc", root, 60);
CHECK_BLOCKS("realloc", p1, 4);
p1 = talloc_realloc_size(NULL, p1, 20);
CHECK_SIZE("realloc", p1, 60);
talloc_increase_ref_count(p2);
torture_assert("realloc", talloc_realloc_size(NULL, p2, 5) == NULL,
"failed: talloc_realloc() on a referenced pointer should fail\n");
CHECK_BLOCKS("realloc", p1, 4);
talloc_realloc_size(NULL, p2, 0);
talloc_realloc_size(NULL, p2, 0);
CHECK_BLOCKS("realloc", p1, 4);
talloc_realloc_size(p1, p2, 0);
CHECK_BLOCKS("realloc", p1, 3);
torture_assert("realloc", talloc_realloc_size(NULL, p1, 0x7fffffff) == NULL,
"failed: oversize talloc should fail\n");
talloc_realloc_size(NULL, p1, 0);
CHECK_BLOCKS("realloc", root, 4);
talloc_realloc_size(root, p1, 0);
CHECK_BLOCKS("realloc", root, 1);
CHECK_SIZE("realloc", root, 0);
talloc_free(root);
printf("success: realloc\n");
return true;
}
static bool test_wbc_users(struct torture_context *tctx)
{
const char *domain_name = NULL;
uint32_t num_users;
const char **users;
int i;
struct wbcInterfaceDetails *details;
torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
"%s", "wbcInterfaceDetails failed");
domain_name = talloc_strdup(tctx, details->netbios_domain);
wbcFreeMemory(details);
torture_assert_wbc_ok(tctx, wbcListUsers(domain_name, &num_users, &users),
"%s", "wbcListUsers failed");
torture_assert(tctx, !(num_users > 0 && !users),
"wbcListUsers returned invalid results");
for (i=0; i < MIN(num_users,100); i++) {
struct wbcDomainSid sid, *sids;
enum wbcSidType name_type;
char *domain;
char *name;
char *sid_string;
uint32_t num_sids;
torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, users[i], &sid, &name_type),
"wbcLookupName of %s failed", users[i]);
torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
"wbcLookupName expected WBC_SID_NAME_USER");
wbcSidToString(&sid, &sid_string);
torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
"wbcLookupSid of %s failed", sid_string);
torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
"wbcLookupSid of expected WBC_SID_NAME_USER");
torture_assert(tctx, name,
"wbcLookupSid returned no name");
wbcFreeMemory(domain);
wbcFreeMemory(name);
torture_assert_wbc_ok(tctx, wbcLookupUserSids(&sid, true, &num_sids, &sids),
"wbcLookupUserSids of %s failed", sid_string);
torture_assert_wbc_ok(
tctx, wbcGetDisplayName(&sid, &domain, &name,
&name_type),
"wbcGetDisplayName of %s failed", sid_string);
wbcFreeMemory(domain);
wbcFreeMemory(name);
wbcFreeMemory(sids);
wbcFreeMemory(sid_string);
}
wbcFreeMemory(users);
return true;
}
static bool test_lp_parm_double(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
torture_assert(tctx, lpcfg_set_option(lp_ctx, "some:thing=3.4"), "lpcfg_set_option failed");
torture_assert(tctx, lpcfg_parm_double(lp_ctx, NULL, "some", "thing", 2.0) == 3.4,
"invalid parametric option");
torture_assert(tctx, lpcfg_parm_double(lp_ctx, NULL, "some", "bla", 2.0) == 2.0,
"invalid parametric option");
return true;
}
static bool enumkey_out_check(struct torture_context *tctx, struct winreg_EnumKey *r)
{
torture_assert_int_equal(tctx, r->out.name->size, 1044, "name size");
torture_assert_int_equal(tctx, r->out.name->length, 8, "name len");
torture_assert(tctx, r->out.keyclass != NULL, "keyclass pointer");
torture_assert(tctx, r->out.keyclass->name == NULL, "keyclass");
torture_assert(tctx, r->out.last_changed_time != NULL, "last_changed_time pointer");
/* FIXME: *last_changed_time */
return true;
}
static bool enumkey_in_check(struct torture_context *tctx, struct winreg_EnumKey *r)
{
torture_assert_int_equal(tctx, r->in.enum_index, 0, "enum index");
torture_assert_int_equal(tctx, r->in.name->size, 1044, "name size");
torture_assert_int_equal(tctx, r->in.name->length, 0, "name len");
torture_assert(tctx, r->in.keyclass != NULL, "keyclass pointer");
torture_assert(tctx, r->in.keyclass->name == NULL, "keyclass");
torture_assert(tctx, r->in.last_changed_time != NULL, "last_changed_time != NULL");
return true;
}
static bool notifychangekeyvalue_in_check(struct torture_context *tctx, struct winreg_NotifyChangeKeyValue *r)
{
torture_assert_int_equal(tctx, r->in.watch_subtree, 1, "watch subtree");
torture_assert_int_equal(tctx, r->in.notify_filter, 0, "notify filter");
torture_assert_int_equal(tctx, r->in.unknown, 0, "unknown");
torture_assert(tctx, r->in.string1.name == NULL, "string1");
torture_assert(tctx, r->in.string2.name == NULL, "string2");
torture_assert_int_equal(tctx, r->in.unknown2, 0, "unknown2");
return true;
}
static bool createkey_out_check(struct torture_context *tctx,
struct winreg_CreateKey *r)
{
torture_assert(tctx, GUID_all_zero(&r->out.new_handle->uuid), "new_handle");
torture_assert(tctx, r->out.action_taken == NULL, "action_taken pointer");
torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM,
"return code");
return true;
}
static bool test_lp_parm_bool(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
torture_assert(tctx, lpcfg_set_option(lp_ctx, "some:thing=true"), "lpcfg_set_option failed");
torture_assert(tctx, lpcfg_parm_bool(lp_ctx, NULL, "some", "thing", false) == true,
"invalid parametric option");
torture_assert(tctx, lpcfg_parm_bool(lp_ctx, NULL, "some", "bla", true) == true,
"invalid parametric option");
return true;
}
/*
This test checks that
1) the server does not allow an unlink on a file that is open
*/
BOOL torture_unlinktest(struct torture_context *tctx, struct smbcli_state *cli)
{
const char *fname = BASEDIR "\\unlink.tst";
int fnum;
BOOL correct = True;
union smb_open io;
NTSTATUS status;
torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
talloc_asprintf(tctx, "Failed setting up %s", BASEDIR));
cli->session->pid = 1;
torture_comment(tctx, "Opening a file\n");
fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
torture_assert(tctx, fnum != -1, talloc_asprintf(tctx, "open of %s failed (%s)", fname, smbcli_errstr(cli->tree)));
torture_comment(tctx, "Unlinking a open file\n");
torture_assert(tctx, !NT_STATUS_IS_OK(smbcli_unlink(cli->tree, fname)),
"server allowed unlink on an open file");
correct = check_error(__location__, cli, ERRDOS, ERRbadshare,
NT_STATUS_SHARING_VIOLATION);
smbcli_close(cli->tree, fnum);
smbcli_unlink(cli->tree, fname);
torture_comment(tctx, "testing unlink after ntcreatex with DELETE access\n");
io.ntcreatex.level = RAW_OPEN_NTCREATEX;
io.ntcreatex.in.root_fid = 0;
io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
io.ntcreatex.in.file_attr = 0;
io.ntcreatex.in.alloc_size = 0;
io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_IMPERSONATION;
io.ntcreatex.in.security_flags = 0;
io.ntcreatex.in.fname = fname;
io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE;
io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
status = smb_raw_open(cli->tree, cli, &io);
torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "failed to open %s", fname));
torture_assert(tctx, !NT_STATUS_IS_OK(smbcli_unlink(cli->tree, fname)),
"server allowed unlink on an open file");
correct = check_error(__location__, cli, ERRDOS, ERRbadshare,
NT_STATUS_SHARING_VIOLATION);
return correct;
}
static bool queryinfokey_out_check(struct torture_context *tctx, struct winreg_QueryInfoKey *r)
{
torture_assert(tctx, r->out.classname != NULL, "class out");
torture_assert(tctx, r->out.classname->name != NULL, "class out name");
torture_assert_str_equal(tctx, r->out.classname->name, "", "class out name");
torture_assert_int_equal(tctx, *r->out.num_subkeys, 0, "num subkeys");
torture_assert_int_equal(tctx, *r->out.max_subkeylen, 0, "subkey length");
torture_assert_int_equal(tctx, *r->out.max_classlen, 140, "subkey size");
torture_assert_werr_ok(tctx, r->out.result, "return code");
return true;
}
static bool test_next_token_quote_wrong(struct torture_context *tctx)
{
const char *teststr = "\"foo bar bla";
char buf[20];
torture_assert(tctx, next_token(&teststr, buf, " ", 20), "finding token works");
torture_assert_str_equal(tctx, buf, "foo bar bla", "token matches");
torture_assert_str_equal(tctx, teststr, "", "ptr modified correctly");
torture_assert(tctx, !next_token(&teststr, buf, " ", 20), "finding token doesn't work");
return true;
}
static bool jobenum_in_check(struct torture_context *tctx,
struct atsvc_JobEnum *r)
{
torture_assert(tctx, r->in.servername != NULL, "servername ptr");
torture_assert_str_equal(tctx, r->in.servername, "WIN2KDC1", "servername");
torture_assert_int_equal(tctx, r->in.ctr->entries_read, 0, "ctr entries read");
torture_assert(tctx, r->in.ctr->first_entry == NULL, "ctr entries first_entry");
torture_assert_int_equal(tctx, r->in.preferred_max_len, -1, "preferred max len");
torture_assert(tctx, r->in.resume_handle != NULL, "resume handle ptr");
torture_assert_int_equal(tctx, *r->in.resume_handle, 0, "resume handle");
return true;
}
static bool createkey_in_check(struct torture_context *tctx,
struct winreg_CreateKey *r)
{
torture_assert_str_equal(tctx, r->in.name.name, "spottyfoot", "name");
torture_assert(tctx, r->in.keyclass.name == NULL, "keyclass");
torture_assert_int_equal(tctx, r->in.options, 0, "option");
torture_assert_int_equal(tctx, r->in.access_mask, 0x2000000, "access mask");
torture_assert(tctx, r->in.secdesc == NULL, "secdesc");
torture_assert(tctx, r->in.action_taken == NULL, "action_taken");
return true;
}
static bool torture_rpc_spoolss_access_teardown_common(struct torture_context *tctx, struct torture_access_context *t)
{
if (t->user.testuser) {
torture_leave_domain(tctx, t->user.testuser);
}
/* remove membership ? */
if (t->user.num_builtin_memberships) {
}
/* remove privs ? */
if (t->user.num_privs) {
}
/* restore sd */
if (t->user.sd && t->printername) {
struct policy_handle handle;
struct spoolss_SetPrinterInfoCtr info_ctr;
struct spoolss_SetPrinterInfo3 info3;
struct spoolss_DevmodeContainer devmode_ctr;
struct sec_desc_buf secdesc_ctr;
struct dcerpc_pipe *spoolss_pipe;
struct dcerpc_binding_handle *b;
torture_assert_ntstatus_ok(tctx,
torture_rpc_connection(tctx, &spoolss_pipe, &ndr_table_spoolss),
"Error connecting to server");
b = spoolss_pipe->binding_handle;
ZERO_STRUCT(info_ctr);
ZERO_STRUCT(info3);
ZERO_STRUCT(devmode_ctr);
ZERO_STRUCT(secdesc_ctr);
info_ctr.level = 3;
info_ctr.info.info3 = &info3;
secdesc_ctr.sd = t->sd_orig;
torture_assert(tctx,
test_openprinter_handle(tctx, spoolss_pipe, "", t->printername, "", SEC_FLAG_MAXIMUM_ALLOWED, WERR_OK, &handle),
"failed to open printer");
torture_assert(tctx,
test_SetPrinter(tctx, b, &handle, &info_ctr, &devmode_ctr, &secdesc_ctr, 0),
"failed to set sd");
talloc_free(spoolss_pipe);
}
return true;
}
/* Test the rate at which the server will accept connections. */
bool torture_bench_treeconnect(struct torture_context *tctx)
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
int timelimit = torture_setting_int(tctx, "timelimit",
TIME_LIMIT_SECS);
int nprocs = torture_setting_int(tctx, "nprocs", 4);
int *curr_counts = map_count_buffer(nprocs, sizeof(int));
int *last_counts = talloc_array(NULL, int, nprocs);
struct timeval now, last, start;
int i, delta;
torture_assert(tctx, nprocs > 0, "bad proc count");
torture_assert(tctx, timelimit > 0, "bad timelimit");
torture_assert(tctx, curr_counts, "allocation failure");
torture_assert(tctx, last_counts, "allocation failure");
start = last = timeval_current();
for (i = 0; i < nprocs; ++i) {
fork_tcon_client(tctx, &curr_counts[i], timelimit, host, share);
}
while (children_remain()) {
sleep(1);
now = timeval_current();
for (i = 0, delta = 0; i < nprocs; ++i) {
delta += curr_counts[i] - last_counts[i];
}
printf("%u connections/sec\n",
(unsigned)rate_convert_secs(delta, &last, &now));
memcpy(last_counts, curr_counts, nprocs * sizeof(int));
last = timeval_current();
}
now = timeval_current();
for (i = 0, delta = 0; i < nprocs; ++i) {
delta += curr_counts[i];
}
printf("TOTAL: %u connections/sec over %u secs\n",
(unsigned)rate_convert_secs(delta, &start, &now),
timelimit);
return true;
}