/* Unix SMB/CIFS implementation. test suite for netlogon rpc operations Copyright (C) Andrew Tridgell 2003 Copyright (C) Andrew Bartlett 2003-2004 Copyright (C) Tim Potter 2003 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 2 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, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "includes.h" #include "lib/events/events.h" #include "librpc/gen_ndr/ndr_netlogon.h" #include "auth/auth.h" #include "lib/cmdline/popt_common.h" static const char *machine_password; #define TEST_MACHINE_NAME "torturetest" static BOOL test_LogonUasLogon(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_LogonUasLogon r; r.in.server_name = NULL; r.in.account_name = cli_credentials_get_username(cmdline_credentials); r.in.workstation = TEST_MACHINE_NAME; printf("Testing LogonUasLogon\n"); status = dcerpc_netr_LogonUasLogon(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("LogonUasLogon - %s\n", nt_errstr(status)); return False; } return True; } static BOOL test_LogonUasLogoff(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_LogonUasLogoff r; r.in.server_name = NULL; r.in.account_name = cli_credentials_get_username(cmdline_credentials); r.in.workstation = TEST_MACHINE_NAME; printf("Testing LogonUasLogoff\n"); status = dcerpc_netr_LogonUasLogoff(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("LogonUasLogoff - %s\n", nt_errstr(status)); return False; } return True; } static BOOL test_SetupCredentials(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, const char *machine_name, const char *plain_pass, struct creds_CredentialState **creds_out) { NTSTATUS status; struct netr_ServerReqChallenge r; struct netr_ServerAuthenticate a; struct netr_Credential credentials1, credentials2, credentials3; struct creds_CredentialState *creds; struct samr_Password mach_password; printf("Testing ServerReqChallenge\n"); creds = talloc(mem_ctx, struct creds_CredentialState); if (!creds) { return False; } r.in.server_name = NULL; r.in.computer_name = machine_name; r.in.credentials = &credentials1; r.out.credentials = &credentials2; generate_random_buffer(credentials1.data, sizeof(credentials1.data)); status = dcerpc_netr_ServerReqChallenge(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerReqChallenge - %s\n", nt_errstr(status)); return False; } E_md4hash(plain_pass, mach_password.hash); a.in.server_name = NULL; a.in.account_name = talloc_asprintf(mem_ctx, "%s$", machine_name); a.in.secure_channel_type = SEC_CHAN_BDC; a.in.computer_name = machine_name; a.in.credentials = &credentials3; a.out.credentials = &credentials3; creds_client_init(creds, &credentials1, &credentials2, &mach_password, &credentials3, 0); printf("Testing ServerAuthenticate\n"); status = dcerpc_netr_ServerAuthenticate(p, mem_ctx, &a); if (!NT_STATUS_IS_OK(status)) { printf("ServerAuthenticate - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &credentials3)) { printf("Credential chaining failed\n"); return False; } *creds_out = creds; return True; } static BOOL test_SetupCredentials2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint32_t negotiate_flags, const char *machine_name, const char *plain_pass, int sec_chan_type, struct creds_CredentialState **creds_out) { NTSTATUS status; struct netr_ServerReqChallenge r; struct netr_ServerAuthenticate2 a; struct netr_Credential credentials1, credentials2, credentials3; struct creds_CredentialState *creds; struct samr_Password mach_password; printf("Testing ServerReqChallenge\n"); creds = talloc(mem_ctx, struct creds_CredentialState); if (!creds) { return False; } r.in.server_name = NULL; r.in.computer_name = machine_name; r.in.credentials = &credentials1; r.out.credentials = &credentials2; generate_random_buffer(credentials1.data, sizeof(credentials1.data)); status = dcerpc_netr_ServerReqChallenge(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerReqChallenge - %s\n", nt_errstr(status)); return False; } E_md4hash(plain_pass, mach_password.hash); a.in.server_name = NULL; a.in.account_name = talloc_asprintf(mem_ctx, "%s$", machine_name); a.in.secure_channel_type = sec_chan_type; a.in.computer_name = machine_name; a.in.negotiate_flags = &negotiate_flags; a.out.negotiate_flags = &negotiate_flags; a.in.credentials = &credentials3; a.out.credentials = &credentials3; creds_client_init(creds, &credentials1, &credentials2, &mach_password, &credentials3, negotiate_flags); printf("Testing ServerAuthenticate2\n"); status = dcerpc_netr_ServerAuthenticate2(p, mem_ctx, &a); if (!NT_STATUS_IS_OK(status)) { printf("ServerAuthenticate2 - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &credentials3)) { printf("Credential chaining failed\n"); return False; } printf("negotiate_flags=0x%08x\n", negotiate_flags); *creds_out = creds; return True; } static BOOL test_SetupCredentials3(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, uint32_t negotiate_flags, const char *machine_name, const char *plain_pass, struct creds_CredentialState **creds_out) { NTSTATUS status; struct netr_ServerReqChallenge r; struct netr_ServerAuthenticate3 a; struct netr_Credential credentials1, credentials2, credentials3; struct creds_CredentialState *creds; struct samr_Password mach_password; uint32_t rid; printf("Testing ServerReqChallenge\n"); creds = talloc(mem_ctx, struct creds_CredentialState); if (!creds) { return False; } r.in.server_name = NULL; r.in.computer_name = machine_name; r.in.credentials = &credentials1; r.out.credentials = &credentials2; generate_random_buffer(credentials1.data, sizeof(credentials1.data)); status = dcerpc_netr_ServerReqChallenge(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerReqChallenge - %s\n", nt_errstr(status)); return False; } E_md4hash(plain_pass, mach_password.hash); a.in.server_name = NULL; a.in.account_name = talloc_asprintf(mem_ctx, "%s$", machine_name); a.in.secure_channel_type = SEC_CHAN_BDC; a.in.computer_name = machine_name; a.in.negotiate_flags = &negotiate_flags; a.in.credentials = &credentials3; a.out.credentials = &credentials3; a.out.negotiate_flags = &negotiate_flags; a.out.rid = &rid; creds_client_init(creds, &credentials1, &credentials2, &mach_password, &credentials3, negotiate_flags); printf("Testing ServerAuthenticate3\n"); status = dcerpc_netr_ServerAuthenticate3(p, mem_ctx, &a); if (!NT_STATUS_IS_OK(status)) { printf("ServerAuthenticate3 - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &credentials3)) { printf("Credential chaining failed\n"); return False; } printf("negotiate_flags=0x%08x\n", negotiate_flags); *creds_out = creds; return True; } /* try a change password for our machine account */ static BOOL test_SetPassword(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_ServerPasswordSet r; const char *password; struct creds_CredentialState *creds; if (!test_SetupCredentials(p, mem_ctx, TEST_MACHINE_NAME, machine_password, &creds)) { return False; } r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); r.in.account_name = talloc_asprintf(mem_ctx, "%s$", TEST_MACHINE_NAME); r.in.secure_channel_type = SEC_CHAN_BDC; r.in.computer_name = TEST_MACHINE_NAME; password = generate_random_str(mem_ctx, 8); E_md4hash(password, r.in.new_password.hash); creds_des_encrypt(creds, &r.in.new_password); printf("Testing ServerPasswordSet on machine account\n"); printf("Changing machine account password to '%s'\n", password); creds_client_authenticator(creds, &r.in.credential); status = dcerpc_netr_ServerPasswordSet(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerPasswordSet - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &r.out.return_authenticator.cred)) { printf("Credential chaining failed\n"); } /* by changing the machine password twice we test the credentials chaining fully, and we verify that the server allows the password to be set to the same value twice in a row (match win2k3) */ printf("Testing a second ServerPasswordSet on machine account\n"); printf("Changing machine account password to '%s' (same as previous run)\n", password); creds_client_authenticator(creds, &r.in.credential); status = dcerpc_netr_ServerPasswordSet(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerPasswordSet (2) - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &r.out.return_authenticator.cred)) { printf("Credential chaining failed\n"); } machine_password = password; if (!test_SetupCredentials(p, mem_ctx, TEST_MACHINE_NAME, machine_password, &creds)) { printf("ServerPasswordSet failed to actually change the password\n"); return False; } return True; } /* try a change password for our machine account */ static BOOL test_SetPassword2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_ServerPasswordSet2 r; const char *password; struct creds_CredentialState *creds; struct samr_CryptPassword password_buf; if (!test_SetupCredentials(p, mem_ctx, TEST_MACHINE_NAME, machine_password, &creds)) { return False; } r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); r.in.account_name = talloc_asprintf(mem_ctx, "%s$", TEST_MACHINE_NAME); r.in.secure_channel_type = SEC_CHAN_BDC; r.in.computer_name = TEST_MACHINE_NAME; password = generate_random_str(mem_ctx, 8); encode_pw_buffer(password_buf.data, password, STR_UNICODE); creds_arcfour_crypt(creds, password_buf.data, 516); memcpy(r.in.new_password.data, password_buf.data, 512); r.in.new_password.length = IVAL(password_buf.data, 512); printf("Testing ServerPasswordSet2 on machine account\n"); printf("Changing machine account password to '%s'\n", password); creds_client_authenticator(creds, &r.in.credential); status = dcerpc_netr_ServerPasswordSet2(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerPasswordSet2 - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &r.out.return_authenticator.cred)) { printf("Credential chaining failed\n"); } machine_password = password; if (!lp_parm_bool(-1, "torture", "dangerous", False)) { printf("Not testing ability to set password to '', enable dangerous tests to perform this test\n"); } else { /* by changing the machine password to "" * we check if the server uses password restrictions * for ServerPasswordSet2 * (win2k3 accepts "") */ password = ""; encode_pw_buffer(password_buf.data, password, STR_UNICODE); creds_arcfour_crypt(creds, password_buf.data, 516); memcpy(r.in.new_password.data, password_buf.data, 512); r.in.new_password.length = IVAL(password_buf.data, 512); printf("Testing ServerPasswordSet2 on machine account\n"); printf("Changing machine account password to '%s'\n", password); creds_client_authenticator(creds, &r.in.credential); status = dcerpc_netr_ServerPasswordSet2(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerPasswordSet2 - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &r.out.return_authenticator.cred)) { printf("Credential chaining failed\n"); } machine_password = password; } if (!test_SetupCredentials(p, mem_ctx, TEST_MACHINE_NAME, machine_password, &creds)) { printf("ServerPasswordSet failed to actually change the password\n"); return False; } /* now try a random password */ password = generate_random_str(mem_ctx, 8); encode_pw_buffer(password_buf.data, password, STR_UNICODE); creds_arcfour_crypt(creds, password_buf.data, 516); memcpy(r.in.new_password.data, password_buf.data, 512); r.in.new_password.length = IVAL(password_buf.data, 512); printf("Testing second ServerPasswordSet2 on machine account\n"); printf("Changing machine account password to '%s'\n", password); creds_client_authenticator(creds, &r.in.credential); status = dcerpc_netr_ServerPasswordSet2(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerPasswordSet2 (2) - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &r.out.return_authenticator.cred)) { printf("Credential chaining failed\n"); } /* by changing the machine password twice we test the credentials chaining fully, and we verify that the server allows the password to be set to the same value twice in a row (match win2k3) */ printf("Testing a second ServerPasswordSet2 on machine account\n"); printf("Changing machine account password to '%s' (same as previous run)\n", password); creds_client_authenticator(creds, &r.in.credential); status = dcerpc_netr_ServerPasswordSet2(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("ServerPasswordSet (3) - %s\n", nt_errstr(status)); return False; } if (!creds_client_check(creds, &r.out.return_authenticator.cred)) { printf("Credential chaining failed\n"); } machine_password = password; if (!test_SetupCredentials(p, mem_ctx, TEST_MACHINE_NAME, machine_password, &creds)) { printf("ServerPasswordSet failed to actually change the password\n"); return False; } return True; } /* try a netlogon SamLogon */ static BOOL test_SamLogon(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_LogonSamLogon r; struct netr_Authenticator auth, auth2; struct netr_NetworkInfo ninfo; const char *username = cli_credentials_get_username(cmdline_credentials); const char *password = cli_credentials_get_password(cmdline_credentials); struct creds_CredentialState *creds; int i; BOOL ret = True; if (!test_SetupCredentials(p, mem_ctx, TEST_MACHINE_NAME, machine_password, &creds)) { return False; } ninfo.identity_info.domain_name.string = cli_credentials_get_domain(cmdline_credentials); ninfo.identity_info.parameter_control = 0; ninfo.identity_info.logon_id_low = 0; ninfo.identity_info.logon_id_high = 0; ninfo.identity_info.account_name.string = username; ninfo.identity_info.workstation.string = TEST_MACHINE_NAME; generate_random_buffer(ninfo.challenge, sizeof(ninfo.challenge)); ninfo.nt.length = 24; ninfo.nt.data = talloc_size(mem_ctx, 24); SMBNTencrypt(password, ninfo.challenge, ninfo.nt.data); ninfo.lm.length = 24; ninfo.lm.data = talloc_size(mem_ctx, 24); SMBencrypt(password, ninfo.challenge, ninfo.lm.data); r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); r.in.workstation = TEST_MACHINE_NAME; r.in.credential = &auth; r.in.return_authenticator = &auth2; r.in.logon_level = 2; r.in.logon.network = &ninfo; for (i=2;i<=3;i++) { ZERO_STRUCT(auth2); creds_client_authenticator(creds, &auth); r.in.validation_level = i; printf("Testing SamLogon with validation level %d\n", i); status = dcerpc_netr_LogonSamLogon(p, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { printf("LogonSamLogon - %s\n", nt_errstr(status)); ret = False; } if (!creds_client_check(creds, &r.out.return_authenticator->cred)) { printf("Credential chaining failed\n"); } } r.in.credential = NULL; for (i=2;i<=3;i++) { r.in.validation_level = i; printf("Testing SamLogon with validation level %d\n", i); status = dcerpc_netr_LogonSamLogon(p, mem_ctx, &r); if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { printf("LogonSamLogon expected INVALID_PARAMETER, got: %s\n", nt_errstr(status)); ret = False; } } return ret; } /* we remember the sequence numbers so we can easily do a DatabaseDelta */ static uint64_t sequence_nums[3]; /* try a netlogon DatabaseSync */ static BOOL test_DatabaseSync(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_DatabaseSync r; struct creds_CredentialState *creds; const uint32_t database_ids[] = {SAM_DATABASE_DOMAIN, SAM_DATABASE_BUILTIN, SAM_DATABASE_PRIVS}; int i; BOOL ret = True; if (!test_SetupCredentials(p, mem_ctx, TEST_MACHINE_NAME, machine_password, &creds)) { return False; } r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); r.in.computername = TEST_MACHINE_NAME; r.in.preferredmaximumlength = (uint32_t)-1; ZERO_STRUCT(r.in.return_authenticator); for (i=0;inum_deltas > 0 && r.out.delta_enum_array->delta_enum[0].delta_type == NETR_DELTA_DOMAIN && r.out.delta_enum_array->delta_enum[0].delta_union.domain) { sequence_nums[r.in.database_id] = r.out.delta_enum_array->delta_enum[0].delta_union.domain->sequence_num; printf("\tsequence_nums[%d]=%llu\n", r.in.database_id, (unsigned long long)sequence_nums[r.in.database_id]); } } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)); } return ret; } /* try a netlogon DatabaseDeltas */ static BOOL test_DatabaseDeltas(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_DatabaseDeltas r; struct creds_CredentialState *creds; const uint32_t database_ids[] = {0, 1, 2}; int i; BOOL ret = True; if (!test_SetupCredentials(p, mem_ctx, TEST_MACHINE_NAME, machine_password, &creds)) { return False; } r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); r.in.computername = TEST_MACHINE_NAME; r.in.preferredmaximumlength = (uint32_t)-1; ZERO_STRUCT(r.in.return_authenticator); for (i=0;iasync.private; if (NT_STATUS_IS_OK(req->status)) { (*counter)++; } } static BOOL test_GetDomainInfo_async(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_LogonGetDomainInfo r; struct netr_DomainQuery1 q1; struct netr_Authenticator a; #define ASYNC_COUNT 100 struct creds_CredentialState *creds; struct creds_CredentialState *creds_async[ASYNC_COUNT]; struct rpc_request *req[ASYNC_COUNT]; int i; int *async_counter = talloc(mem_ctx, int); if (!lp_parm_bool(-1, "torture", "dangerous", False)) { printf("test_GetDomainInfo_async disabled - enable dangerous tests to use\n"); return True; } if (!test_SetupCredentials3(p, mem_ctx, NETLOGON_NEG_AUTH2_ADS_FLAGS, TEST_MACHINE_NAME, machine_password, &creds)) { return False; } ZERO_STRUCT(r); r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); r.in.computer_name = TEST_MACHINE_NAME; r.in.level = 1; r.in.credential = &a; r.in.return_authenticator = &a; r.out.return_authenticator = &a; r.in.query.query1 = &q1; ZERO_STRUCT(q1); /* this should really be the fully qualified name */ q1.workstation_domain = TEST_MACHINE_NAME; q1.workstation_site = "Default-First-Site-Name"; q1.blob2.length = 0; q1.blob2.size = 0; q1.blob2.data = NULL; q1.product.string = "product string"; printf("Testing netr_LogonGetDomainInfo - async count %d\n", ASYNC_COUNT); *async_counter = 0; for (i=0;iasync.callback = async_callback; req[i]->async.private = async_counter; /* even with this flush per request a w2k3 server seems to clag with multiple outstanding requests. bleergh. */ if (event_loop_once(dcerpc_event_context(p)) != 0) { return False; } } for (i=0;iconn->transport.transport != NCACN_NP) { return True; } printf("Torturing GetDCName\n"); status = dcerpc_parse_binding(mem_ctx, p->conn->binding_string, &b); if (!NT_STATUS_IS_OK(status)) { printf("Failed to parse dcerpc binding '%s'\n", p->conn->binding_string); return False; } status = dcerpc_secondary_connection(p, &p2, b); if (!NT_STATUS_IS_OK(status)) { printf("Failed to create secondary connection\n"); return False; } status = dcerpc_bind_auth_none(p2, DCERPC_LSARPC_UUID, DCERPC_LSARPC_VERSION); if (!NT_STATUS_IS_OK(status)) { printf("Failed to create bind on secondary connection\n"); return False; } qos.len = 0; qos.impersonation_level = 2; qos.context_mode = 1; qos.effective_only = 0; attr.len = 0; attr.root_dir = NULL; attr.object_name = NULL; attr.attributes = 0; attr.sec_desc = NULL; attr.sec_qos = &qos; o.in.system_name = "\\"; o.in.attr = &attr; o.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED; o.out.handle = &lsa_handle; status = dcerpc_lsa_OpenPolicy2(p2, mem_ctx, &o); if (!NT_STATUS_IS_OK(status)) { printf("OpenPolicy2 failed - %s\n", nt_errstr(status)); return False; } t.in.handle = &lsa_handle; t.in.resume_handle = &resume_handle; t.in.max_size = 1000; t.out.domains = &domains; t.out.resume_handle = &resume_handle; status = dcerpc_lsa_EnumTrustDom(p2, mem_ctx, &t); if ((!NT_STATUS_IS_OK(status) && (!NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)))) { printf("Could not list domains\n"); return False; } talloc_free(p2); d.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); for (i=0; iname.string; status = dcerpc_netr_GetAnyDCName(p, mem_ctx, &d); if (!NT_STATUS_IS_OK(status)) { printf("GetAnyDCName - %s\n", nt_errstr(status)); continue; } printf("\tDC for domain %s is %s\n", info->name.string, d.out.dcname ? d.out.dcname : "unknown"); } return ret; } BOOL torture_rpc_netlogon(void) { NTSTATUS status; struct dcerpc_pipe *p; TALLOC_CTX *mem_ctx; BOOL ret = True; struct test_join *join_ctx; mem_ctx = talloc_init("torture_rpc_netlogon"); join_ctx = torture_join_domain(TEST_MACHINE_NAME, lp_workgroup(), ACB_SVRTRUST, &machine_password); if (!join_ctx) { talloc_free(mem_ctx); printf("Failed to join as BDC\n"); return False; } status = torture_rpc_connection(mem_ctx, &p, DCERPC_NETLOGON_NAME, DCERPC_NETLOGON_UUID, DCERPC_NETLOGON_VERSION); if (!NT_STATUS_IS_OK(status)) { talloc_free(mem_ctx); return False; } ret &= test_LogonUasLogon(p, mem_ctx); ret &= test_LogonUasLogoff(p, mem_ctx); ret &= test_SamLogon(p, mem_ctx); ret &= test_SetPassword(p, mem_ctx); ret &= test_SetPassword2(p, mem_ctx); ret &= test_GetDomainInfo(p, mem_ctx); ret &= test_DatabaseSync(p, mem_ctx); ret &= test_DatabaseDeltas(p, mem_ctx); ret &= test_AccountDeltas(p, mem_ctx); ret &= test_AccountSync(p, mem_ctx); ret &= test_GetDcName(p, mem_ctx); ret &= test_ManyGetDCName(p, mem_ctx); ret &= test_LogonControl(p, mem_ctx); ret &= test_GetAnyDCName(p, mem_ctx); ret &= test_LogonControl2(p, mem_ctx); ret &= test_DatabaseSync2(p, mem_ctx); ret &= test_LogonControl2Ex(p, mem_ctx); ret &= test_DsrEnumerateDomainTrusts(p, mem_ctx); ret &= test_GetDomainInfo_async(p, mem_ctx); ret &= test_netr_DrsGetDCNameEx2(p, mem_ctx); talloc_free(mem_ctx); torture_leave_domain(join_ctx); return ret; }