static bool test_server_role_default(struct torture_context *tctx) { struct loadparm_context *lp_ctx = loadparm_init(tctx); torture_assert_int_equal(tctx, lpcfg_server_role(lp_ctx), ROLE_STANDALONE, "ROLE should be standalone by default"); torture_assert_int_equal(tctx, lpcfg_security(lp_ctx), SEC_USER, "security should be user"); 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_strv_split_none(struct torture_context *tctx) { char *strv = NULL; int ret; /* NULL has 0 entries */ ret = strv_split(tctx, &strv, NULL, " "); torture_assert(tctx, ret == 0, "strv_split() on NULL failed"); torture_assert_int_equal(tctx, strv_count(strv), 0, "strv_split() on NULL failed"); TALLOC_FREE(strv); /* Empty string has 0 entries */ ret = strv_split(tctx, &strv, "", " "); torture_assert(tctx, ret == 0, "strv_split() on NULL failed"); torture_assert_int_equal(tctx, strv_count(strv), 0, "strv_split() on \"\" failed"); TALLOC_FREE(strv); /* String containing only separators has 0 entries */ ret = strv_split(tctx, &strv, "abcabcabc", "cba "); torture_assert(tctx, ret == 0, "strv_split() on NULL failed"); torture_assert_int_equal(tctx, strv_count(strv), 0, "strv_split() on seps-only failed"); TALLOC_FREE(strv); return true; }
/* * Test that a ticket obtained for the DNS service will be accepted on the Samba DLZ side * */ static bool test_dlz_bind9_gensec(struct torture_context *tctx, const char *mech) { NTSTATUS status; struct gensec_security *gensec_client_context; DATA_BLOB client_to_server, server_to_client; void *dbdata; const char *argv[] = { "samba_dlz", "-H", lpcfg_private_path(tctx, tctx->lp_ctx, "dns/sam.ldb"), NULL }; tctx_static = tctx; torture_assert_int_equal(tctx, dlz_create("samba_dlz", 3, discard_const_p(char *, argv), &dbdata, "log", dlz_bind9_log_wrapper, "writeable_zone", dlz_bind9_writeable_zone_hook, NULL), ISC_R_SUCCESS, "Failed to create samba_dlz"); torture_assert_int_equal(tctx, dlz_configure((void*)tctx, dbdata), ISC_R_SUCCESS, "Failed to configure samba_dlz"); status = gensec_client_start(tctx, &gensec_client_context, lpcfg_gensec_settings(tctx, tctx->lp_ctx)); torture_assert_ntstatus_ok(tctx, status, "gensec_client_start (client) failed"); status = gensec_set_target_hostname(gensec_client_context, torture_setting_string(tctx, "host", NULL)); torture_assert_ntstatus_ok(tctx, status, "gensec_set_target_hostname (client) failed"); status = gensec_set_credentials(gensec_client_context, cmdline_credentials); torture_assert_ntstatus_ok(tctx, status, "gensec_set_credentials (client) failed"); status = gensec_start_mech_by_sasl_name(gensec_client_context, mech); torture_assert_ntstatus_ok(tctx, status, "gensec_start_mech_by_sasl_name (client) failed"); server_to_client = data_blob(NULL, 0); /* Do one step of the client-server update dance */ status = gensec_update(gensec_client_context, tctx, tctx->ev, server_to_client, &client_to_server); if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {; torture_assert_ntstatus_ok(tctx, status, "gensec_update (client) failed"); } torture_assert_int_equal(tctx, dlz_ssumatch(cli_credentials_get_username(cmdline_credentials), lpcfg_dnsdomain(tctx->lp_ctx), "127.0.0.1", "type", "key", client_to_server.length, client_to_server.data, dbdata), ISC_R_SUCCESS, "Failed to check key for update rights samba_dlz"); dlz_destroy(dbdata); return true; }
static bool test_get_value(struct torture_context *tctx, const void *test_data) { WERROR error; struct hive_key *subkey; const struct hive_key *root = (const struct hive_key *)test_data; TALLOC_CTX *mem_ctx = tctx; uint32_t type; uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 }; DATA_BLOB db = { d, 4 }, data; error = hive_key_add_name(mem_ctx, root, "EYA Nested Key", NULL, NULL, &subkey); torture_assert_werr_ok(tctx, error, "hive_key_add_name"); error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data); torture_assert_werr_equal(tctx, error, WERR_BADFILE, "getting missing value"); error = hive_key_set_value(subkey, "Answer", REG_DWORD, db); torture_assert_werr_ok(tctx, error, "hive_key_set_value"); error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data); torture_assert_werr_ok(tctx, error, "getting value"); torture_assert_int_equal(tctx, data.length, 4, "value length"); torture_assert_int_equal(tctx, type, REG_DWORD, "value type"); torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data"); return true; }
static bool test_keyinfo_nums(struct torture_context *tctx, void *test_data) { uint32_t num_subkeys, num_values; struct hive_key *root = (struct hive_key *)test_data; WERROR error; struct hive_key *subkey; uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 }; DATA_BLOB db = { d, 4 }; error = hive_key_add_name(tctx, root, "Nested Keyll", NULL, NULL, &subkey); torture_assert_werr_ok(tctx, error, "hive_key_add_name"); error = hive_key_set_value(root, "Answer", REG_DWORD, db); torture_assert_werr_ok(tctx, error, "hive_key_set_value"); /* This is a new backend. There should be no subkeys and no * values */ error = hive_key_get_info(tctx, root, NULL, &num_subkeys, &num_values, NULL, NULL, NULL, NULL); torture_assert_werr_ok(tctx, error, "reg_key_num_subkeys()"); torture_assert_int_equal(tctx, num_subkeys, 1, "subkey count"); torture_assert_werr_ok(tctx, error, "reg_key_num_values"); torture_assert_int_equal(tctx, num_values, 1, "value count"); return true; }
static bool test_tolower_m(struct torture_context *tctx) { torture_assert_int_equal(tctx, tolower_m('C'), 'c', "c"); torture_assert_int_equal(tctx, tolower_m('z'), 'z', "z"); torture_assert_int_equal(tctx, tolower_m(0xFFFF4565), 0xFFFF4565, "0xFFFF4565"); return true; }
static bool test_keyinfo_nums(struct torture_context *tctx, void *test_data) { uint32_t num_subkeys, num_values; struct hive_key *root = (struct hive_key *)test_data; WERROR error; struct hive_key *subkey; char data[4]; SIVAL(data, 0, 42); error = hive_key_add_name(tctx, root, "Nested Keyll", NULL, NULL, &subkey); torture_assert_werr_ok(tctx, error, "hive_key_add_name"); error = hive_key_set_value(root, "Answer", REG_DWORD, data_blob_talloc(tctx, data, sizeof(data))); torture_assert_werr_ok(tctx, error, "hive_key_set_value"); /* This is a new backend. There should be no subkeys and no * values */ error = hive_key_get_info(tctx, root, NULL, &num_subkeys, &num_values, NULL, NULL, NULL, NULL); torture_assert_werr_ok(tctx, error, "reg_key_num_subkeys()"); torture_assert_int_equal(tctx, num_subkeys, 1, "subkey count"); torture_assert_werr_ok(tctx, error, "reg_key_num_values"); torture_assert_int_equal(tctx, num_values, 1, "value count"); return true; }
static bool find_single_info2(void *mem_ctx, struct torture_context *torture, struct smbcli_state *cli, const char *fname, struct unix_info2 *info2) { union smb_search_first search; NTSTATUS status; /* Set up a new search for a single item, not using resume keys. */ ZERO_STRUCT(search); search.t2ffirst.level = RAW_SEARCH_TRANS2; search.t2ffirst.data_level = SMB_FIND_UNIX_INFO2; search.t2ffirst.in.max_count = 1; search.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE; search.t2ffirst.in.pattern = fname; status = smb_raw_search_first(cli->tree, mem_ctx, &search, info2, search_callback); torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK, smbcli_errstr(cli->tree)); torture_assert_int_equal(torture, search.t2ffirst.out.count, 1, "expected exactly one result"); torture_assert_int_equal(torture, search.t2ffirst.out.end_of_search, 1, "expected end_of_search to be true"); return check_unix_info2(torture, info2); }
static bool torture_krb5_init_context(struct torture_context *tctx, enum torture_krb5_test test, struct smb_krb5_context **smb_krb5_context) { const char *host = torture_setting_string(tctx, "host", NULL); krb5_error_code k5ret; bool ok; struct torture_krb5_context *test_context = talloc_zero(tctx, struct torture_krb5_context); torture_assert(tctx, test_context != NULL, "Failed to allocate"); test_context->test = test; test_context->tctx = tctx; k5ret = smb_krb5_init_context(tctx, tctx->lp_ctx, smb_krb5_context); torture_assert_int_equal(tctx, k5ret, 0, "smb_krb5_init_context failed"); ok = interpret_string_addr_internal(&test_context->server, host, AI_NUMERICHOST); torture_assert(tctx, ok, "Failed to parse target server"); talloc_set_destructor(test_context, test_context_destructor); set_sockaddr_port(test_context->server->ai_addr, 88); k5ret = krb5_set_send_to_kdc_func((*smb_krb5_context)->krb5_context, smb_krb5_send_and_recv_func_override, test_context); torture_assert_int_equal(tctx, k5ret, 0, "krb5_set_send_to_kdc_func failed"); return true; }
static bool test_get_value(struct torture_context *tctx, const void *test_data) { WERROR error; struct hive_key *subkey; const struct hive_key *root = (const struct hive_key *)test_data; TALLOC_CTX *mem_ctx = tctx; char data[4]; uint32_t type; DATA_BLOB value; SIVAL(data, 0, 42); error = hive_key_add_name(mem_ctx, root, "EYA Nested Key", NULL, NULL, &subkey); torture_assert_werr_ok(tctx, error, "hive_key_add_name"); error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value); torture_assert_werr_equal(tctx, error, WERR_BADFILE, "getting missing value"); error = hive_key_set_value(subkey, "Answer", REG_DWORD, data_blob_talloc(mem_ctx, data, sizeof(data))); torture_assert_werr_ok(tctx, error, "hive_key_set_value"); error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value); torture_assert_werr_ok(tctx, error, "getting value"); torture_assert_int_equal(tctx, value.length, 4, "value length"); torture_assert_int_equal(tctx, type, REG_DWORD, "value type"); torture_assert_mem_equal(tctx, &data, value.data, sizeof(uint32_t), "value data"); return true; }
static BOOL test_PrinterData(struct torture_context *tctx, LPSTR servername, HANDLE handle) { BOOL ret = TRUE; DWORD i; DWORD type, type_ex; LPBYTE buffer, buffer_ex; DWORD size, size_ex; LPSTR valuenames[] = { SPLREG_DEFAULT_SPOOL_DIRECTORY, SPLREG_MAJOR_VERSION, SPLREG_MINOR_VERSION, SPLREG_DS_PRESENT, SPLREG_DNS_MACHINE_NAME, SPLREG_ARCHITECTURE, SPLREG_OS_VERSION }; for (i=0; i < ARRAY_SIZE(valuenames); i++) { ret &= test_GetPrinterData(tctx, servername, valuenames[i], handle, &type, &buffer, &size); ret &= test_GetPrinterDataEx(tctx, servername, "random", valuenames[i], handle, &type_ex, &buffer_ex, &size_ex); torture_assert_int_equal(tctx, type, type_ex, "type mismatch"); torture_assert_int_equal(tctx, size, size_ex, "size mismatch"); torture_assert_mem_equal(tctx, buffer, buffer_ex, size, "buffer mismatch"); free(buffer); free(buffer_ex); } return ret; }
static bool test_server_role_member_specified(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_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 openhklm_in_check(struct torture_context *tctx, struct winreg_OpenHKLM *r) { torture_assert(tctx, r->in.system_name != NULL, "system name pointer"); torture_assert_int_equal(tctx, *r->in.system_name, 34016, "system name"); torture_assert_int_equal(tctx, r->in.access_mask, 0x02000000, "access mask"); return true; }
static bool test_server_role_security_server(struct torture_context *tctx) { struct loadparm_context *lp_ctx = loadparm_init(tctx); torture_assert(tctx, lpcfg_set_option(lp_ctx, "security=server"), "lpcfg_set_option failed"); torture_assert_int_equal(tctx, lpcfg_server_role(lp_ctx), ROLE_STANDALONE, "ROLE should be STANDALONE"); torture_assert_int_equal(tctx, lpcfg_security(lp_ctx), SEC_SERVER, "security should be server"); return true; }
static bool test_server_role_security_domain(struct torture_context *tctx) { struct loadparm_context *lp_ctx = loadparm_init(tctx); torture_assert(tctx, lpcfg_set_option(lp_ctx, "security=domain"), "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_DOMAIN, "security should be domain"); return true; }
static bool test_server_role_dc_domain_logons(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_int_equal(tctx, lpcfg_server_role(lp_ctx), ROLE_DOMAIN_PDC, "ROLE should be PDC"); torture_assert_int_equal(tctx, lpcfg_security(lp_ctx), SEC_USER, "security should be user"); return true; }
static bool test_server_role_standalone_specified(struct torture_context *tctx) { struct loadparm_context *lp_ctx = loadparm_init(tctx); torture_assert(tctx, lpcfg_set_option(lp_ctx, "server role=standalone"), "lpcfg_set_option failed"); torture_assert_int_equal(tctx, lpcfg_server_role(lp_ctx), ROLE_STANDALONE, "ROLE should be standalone"); torture_assert_int_equal(tctx, lpcfg_security(lp_ctx), SEC_USER, "security should be USER"); return true; }
static bool openkey_in_check(struct torture_context *tctx, struct winreg_OpenKey *r) { torture_assert_int_equal(tctx, r->in.options, 0, "unknown"); torture_assert_int_equal(tctx, r->in.access_mask, 0x02000000, "access mask"); torture_assert_str_equal(tctx, r->in.keyname.name, "spottyfoot", "keyname"); /* FIXME: parent handle */ return true; }
static bool getkeysecurity_out_check(struct torture_context *tctx, struct winreg_GetKeySecurity *r) { torture_assert_int_equal(tctx, r->in.sd->size, 20, "sd size"); torture_assert_int_equal(tctx, r->in.sd->len, 20, "sd len"); torture_assert_werr_ok(tctx, r->out.result, "return code"); return true; }
static bool test_strlen_m_term_null(struct torture_context *tctx) { torture_assert_int_equal(tctx, strlen_m_term_null("foo"), 4, "simple len"); torture_assert_int_equal(tctx, strlen_m_term_null("foo\x83l"), 7, "extended len"); torture_assert_int_equal(tctx, strlen_m_term_null(""), 0, "empty"); torture_assert_int_equal(tctx, strlen_m_term_null(NULL), 0, "NULL"); return true; }
static bool test_count_chars_m(struct torture_context *tctx) { torture_assert_int_equal(tctx, count_chars_m("foo", 'o'), 2, "simple"); torture_assert_int_equal(tctx, count_chars_m("", 'o'), 0, "empty"); torture_assert_int_equal(tctx, count_chars_m("bla", 'o'), 0, "none"); torture_assert_int_equal(tctx, count_chars_m("bla", '\0'), 0, "null"); return true; }
static bool test_server_role_dc_specified(struct torture_context *tctx) { struct loadparm_context *lp_ctx = loadparm_init(tctx); torture_assert(tctx, lpcfg_set_option(lp_ctx, "server role=domain controller"), "lpcfg_set_option failed"); torture_assert_int_equal(tctx, lpcfg_server_role(lp_ctx), ROLE_DOMAIN_CONTROLLER, "ROLE should be DC"); torture_assert_int_equal(tctx, lpcfg_security(lp_ctx), SEC_USER, "security should be USER"); return true; }
static bool jobdel_in_check(struct torture_context *tctx, struct atsvc_JobDel *r) { torture_assert_str_equal(tctx, r->in.servername, "WIN2KDC1", "servername"); torture_assert_int_equal(tctx, r->in.min_job_id, 14, "min job id"); torture_assert_int_equal(tctx, r->in.max_job_id, 14, "max job id"); return true; }
static bool test_codepoint_cmpi(struct torture_context *tctx) { torture_assert_int_equal(tctx, codepoint_cmpi('a', 'a'), 0, "same char"); torture_assert_int_equal(tctx, codepoint_cmpi('A', 'a'), 0, "upcase version"); torture_assert_int_equal(tctx, codepoint_cmpi('b', 'a'), 1, "right diff"); torture_assert_int_equal(tctx, codepoint_cmpi('a', 'b'), -1, "right diff"); return true; }
static bool test_rpc_netservergetinfo(struct torture_context *tctx, struct smbcli_state *cli) { struct rap_WserverGetInfo r; struct dcerpc_pipe *p; struct dcerpc_binding_handle *b; struct srvsvc_NetSrvGetInfo s; union srvsvc_NetSrvInfo info; const char *server_name; torture_assert_ntstatus_ok(tctx, torture_rpc_connection(tctx, &p, &ndr_table_srvsvc), "failed to open srvsvc"); b = p->binding_handle; s.in.server_unc = NULL; s.in.level = 101; s.out.info = &info; torture_assert_ntstatus_ok(tctx, dcerpc_srvsvc_NetSrvGetInfo_r(b, tctx, &s), "srvsvc_NetSrvGetInfo level 101 failed"); torture_assert_werr_ok(tctx, s.out.result, "srvsvc_NetSrvGetInfo level 101 failed"); r.in.bufsize = 0xffff; r.in.level = 0; torture_assert_ntstatus_ok(tctx, smbcli_rap_netservergetinfo(cli->tree, tctx, &r), "rap_netservergetinfo level 0 failed"); torture_assert_int_equal(tctx, r.out.status, 0, "rap_netservergetinfo level 0 failed"); server_name = talloc_strndup(tctx, info.info101->server_name, 16); torture_assert_str_equal(tctx, (const char *)r.out.info.info0.name, server_name, "server name"); r.in.level = 1; torture_assert_ntstatus_ok(tctx, smbcli_rap_netservergetinfo(cli->tree, tctx, &r), "rap_netservergetinfo level 1 failed"); torture_assert_int_equal(tctx, r.out.status, 0, "rap_netservergetinfo level 1 failed"); torture_assert_str_equal(tctx, (const char *)r.out.info.info1.name, server_name, "server name"); torture_assert_int_equal(tctx, r.out.info.info1.version_major, info.info101->version_major, "version major"); torture_assert_int_equal(tctx, r.out.info.info1.version_minor, info.info101->version_minor, "version minor"); torture_assert_int_equal(tctx, r.out.info.info1.servertype, info.info101->server_type, "server_type"); torture_assert_str_equal(tctx, r.out.info.info1.comment, info.info101->comment, "comment"); talloc_free(p); return true; }
static bool netlogon_logon_request_resp_check(struct torture_context *tctx, struct nbt_netlogon_response2 *r) { torture_assert_int_equal(tctx, r->command, LOGON_RESPONSE2, "command"); torture_assert_str_equal(tctx, r->pdc_name, "\\\\MTHELENA", "pdc_name"); torture_assert_int_equal(tctx, r->lm20_token, 0xffff, "lm20_token"); return true; }
static bool map_out_check(struct torture_context *tctx, struct epm_Map *r) { torture_assert_int_equal(tctx, *r->out.num_towers, 1, "num towers"); torture_assert_int_equal(tctx, r->out.result, 0x4b, "return code"); /* FIXME: entry handle */ return true; }
static bool test_generate_random_str(struct torture_context *tctx) { TALLOC_CTX *mem_ctx = talloc_init(__FUNCTION__); char *r = generate_random_str(mem_ctx, 10); torture_assert_int_equal(tctx, strlen(r), 10, "right length generated"); r = generate_random_str(mem_ctx, 5); torture_assert_int_equal(tctx, strlen(r), 5, "right length generated"); 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; }