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; }