#include "includes.h"
-#define TEST_USERNAME "samrtorturetest"
+#define TEST_ACCOUNT_NAME "samrtorturetest"
#define TEST_ALIASNAME "samrtorturetestalias"
#define TEST_GROUPNAME "samrtorturetestgroup"
#define TEST_MACHINENAME "samrtorturetestmach$"
return True;
}
- r.in.handle = handle;
+ r.in.connect_handle = handle;
printf("testing samr_Shutdown\n");
NTSTATUS status;
struct samr_SetDsrmPassword r;
struct samr_Name name;
- struct samr_Hash hash;
+ struct samr_Password hash;
if (lp_parm_int(-1, "torture", "dangerous") != 1) {
printf("samr_SetDsrmPassword disabled - enable dangerous tests to use\n");
return False;
}
+ if (r.out.sdbuf == NULL) {
+ return False;
+ }
+
s.in.handle = handle;
s.in.sec_info = 7;
s.in.sdbuf = r.out.sdbuf;
union samr_UserInfo u;
BOOL ret = True;
- s.in.handle = handle;
+ s.in.user_handle = handle;
s.in.info = &u;
- s2.in.handle = handle;
+ s2.in.user_handle = handle;
s2.in.info = &u;
- q.in.handle = handle;
+ q.in.user_handle = handle;
q.out.info = &u;
q0 = q;
TEST_USERINFO_NAME(21, logon_script, 21, logon_script, "xx21-21 logon_script",
SAMR_FIELD_LOGON_SCRIPT);
- TEST_USERINFO_NAME(12, profile, 3, profile, "xx12-3 profile", 0);
- TEST_USERINFO_NAME(12, profile, 5, profile, "xx12-5 profile", 0);
- TEST_USERINFO_NAME(12, profile, 21, profile, "xx12-21 profile", 0);
- TEST_USERINFO_NAME(21, profile, 21, profile, "xx21-21 profile",
- SAMR_FIELD_PROFILE);
+ TEST_USERINFO_NAME(12, profile_path, 3, profile_path, "xx12-3 profile_path", 0);
+ TEST_USERINFO_NAME(12, profile_path, 5, profile_path, "xx12-5 profile_path", 0);
+ TEST_USERINFO_NAME(12, profile_path, 21, profile_path, "xx12-21 profile_path", 0);
+ TEST_USERINFO_NAME(21, profile_path, 21, profile_path, "xx21-21 profile_path",
+ SAMR_FIELD_PROFILE_PATH);
TEST_USERINFO_NAME(13, description, 1, description, "xx13-1 description", 0);
TEST_USERINFO_NAME(13, description, 5, description, "xx13-5 description", 0);
DATA_BLOB session_key;
char *newpass = samr_rand_pass(mem_ctx);
- s.in.handle = handle;
+ s.in.user_handle = handle;
s.in.info = &u;
s.in.level = 24;
encode_pw_buffer(u.info24.password.data, newpass, STR_UNICODE);
/* w2k3 ignores this length */
- u.info24.pw_len = str_charnum(newpass)*2;
+ u.info24.pw_len = strlen_m(newpass) * 2;
status = dcerpc_fetch_session_key(p, &session_key);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
- SamOEMhashBlob(u.info24.password.data, 516, &session_key);
+ arcfour_crypt_blob(u.info24.password.data, 516, &session_key);
printf("Testing SetUserInfo level 24 (set password)\n");
DATA_BLOB session_key;
char *newpass = samr_rand_pass(mem_ctx);
- s.in.handle = handle;
+ s.in.user_handle = handle;
s.in.info = &u;
s.in.level = 23;
return False;
}
- SamOEMhashBlob(u.info23.password.data, 516, &session_key);
+ arcfour_crypt_blob(u.info23.password.data, 516, &session_key);
printf("Testing SetUserInfo level 23 (set password)\n");
char *newpass = samr_rand_pass(mem_ctx);
struct MD5Context ctx;
- s.in.handle = handle;
+ s.in.user_handle = handle;
s.in.info = &u;
s.in.level = 26;
return False;
}
- generate_random_buffer((unsigned char *)confounder, 16, False);
+ generate_random_buffer((uint8_t *)confounder, 16);
MD5Init(&ctx);
MD5Update(&ctx, confounder, 16);
MD5Update(&ctx, session_key.data, session_key.length);
MD5Final(confounded_session_key.data, &ctx);
- SamOEMhashBlob(u.info26.password.data, 516, &confounded_session_key);
+ arcfour_crypt_blob(u.info26.password.data, 516, &confounded_session_key);
memcpy(&u.info26.password.data[516], confounder, 16);
printf("Testing SetUserInfo level 26 (set password ex)\n");
char *newpass = samr_rand_pass(mem_ctx);
struct MD5Context ctx;
- s.in.handle = handle;
+ s.in.user_handle = handle;
s.in.info = &u;
s.in.level = 25;
return False;
}
- generate_random_buffer((unsigned char *)confounder, 16, False);
+ generate_random_buffer((uint8_t *)confounder, 16);
MD5Init(&ctx);
MD5Update(&ctx, confounder, 16);
MD5Update(&ctx, session_key.data, session_key.length);
MD5Final(confounded_session_key.data, &ctx);
- SamOEMhashBlob(u.info25.password.data, 516, &confounded_session_key);
+ arcfour_crypt_blob(u.info25.password.data, 516, &confounded_session_key);
memcpy(&u.info25.password.data[516], confounder, 16);
printf("Testing SetUserInfo level 25 (set password ex)\n");
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing SetAliasInfo level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.alias_handle = handle;
r.in.level = levels[i];
switch (r.in.level) {
case 2 : init_samr_Name(&r.in.info.name,TEST_ALIASNAME); break;
ret = False;
}
- q.in.handle = handle;
+ q.in.alias_handle = handle;
q.in.level = levels[i];
status = dcerpc_samr_QueryAliasInfo(p, mem_ctx, &q);
printf("testing GetGroupsForUser\n");
- r.in.handle = user_handle;
+ r.in.user_handle = user_handle;
status = dcerpc_samr_GetGroupsForUser(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
struct samr_GetDomPwInfo r;
BOOL ret = True;
- printf("Testing GetDomPwInfo\n");
-
r.in.name = domain_name;
+ printf("Testing GetDomPwInfo with name %s\n", r.in.name->name);
+
+ status = dcerpc_samr_GetDomPwInfo(p, mem_ctx, &r);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("GetDomPwInfo failed - %s\n", nt_errstr(status));
+ ret = False;
+ }
+
+ r.in.name->name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
+ printf("Testing GetDomPwInfo with name %s\n", r.in.name->name);
+
+ status = dcerpc_samr_GetDomPwInfo(p, mem_ctx, &r);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("GetDomPwInfo failed - %s\n", nt_errstr(status));
+ ret = False;
+ }
+
+ r.in.name->name = "\\\\__NONAME__";
+ printf("Testing GetDomPwInfo with name %s\n", r.in.name->name);
+
+ status = dcerpc_samr_GetDomPwInfo(p, mem_ctx, &r);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("GetDomPwInfo failed - %s\n", nt_errstr(status));
+ ret = False;
+ }
+
+ r.in.name->name = "\\\\Builtin";
+ printf("Testing GetDomPwInfo with name %s\n", r.in.name->name);
status = dcerpc_samr_GetDomPwInfo(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
ret = False;
}
+
return ret;
}
printf("Testing GetUserPwInfo\n");
- r.in.handle = handle;
+ r.in.user_handle = handle;
status = dcerpc_samr_GetUserPwInfo(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
init_samr_Name(&sname[0], name);
- n.in.handle = domain_handle;
+ n.in.domain_handle = domain_handle;
n.in.num_names = 1;
n.in.names = sname;
status = dcerpc_samr_LookupNames(p, mem_ctx, &n);
return status;
}
- r.in.handle = domain_handle;
+ r.in.domain_handle = domain_handle;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
r.in.rid = rid;
- r.out.acct_handle = user_handle;
+ r.out.user_handle = user_handle;
status = dcerpc_samr_OpenUser(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
printf("OpenUser_byname(%s) failed - %s\n", name, nt_errstr(status));
return status;
}
+#if 0
+static BOOL test_ChangePasswordNT3(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+ struct policy_handle *handle)
+{
+ NTSTATUS status;
+ struct samr_ChangePasswordUser r;
+ BOOL ret = True;
+ struct samr_Password hash1, hash2, hash3, hash4, hash5, hash6;
+ struct policy_handle user_handle;
+ char *oldpass = "test";
+ char *newpass = "test2";
+ uint8_t old_nt_hash[16], new_nt_hash[16];
+ uint8_t old_lm_hash[16], new_lm_hash[16];
+
+ status = test_OpenUser_byname(p, mem_ctx, handle, "testuser", &user_handle);
+ if (!NT_STATUS_IS_OK(status)) {
+ return False;
+ }
+
+ printf("Testing ChangePasswordUser for user 'testuser'\n");
+
+ printf("old password: %s\n", oldpass);
+ printf("new password: %s\n", newpass);
+
+ E_md4hash(oldpass, old_nt_hash);
+ E_md4hash(newpass, new_nt_hash);
+ E_deshash(oldpass, old_lm_hash);
+ E_deshash(newpass, new_lm_hash);
+
+ E_old_pw_hash(new_lm_hash, old_lm_hash, hash1.hash);
+ E_old_pw_hash(old_lm_hash, new_lm_hash, hash2.hash);
+ E_old_pw_hash(new_nt_hash, old_nt_hash, hash3.hash);
+ E_old_pw_hash(old_nt_hash, new_nt_hash, hash4.hash);
+ E_old_pw_hash(old_lm_hash, new_nt_hash, hash5.hash);
+ E_old_pw_hash(old_nt_hash, new_lm_hash, hash6.hash);
+
+ r.in.handle = &user_handle;
+ r.in.lm_present = 1;
+ r.in.old_lm_crypted = &hash1;
+ r.in.new_lm_crypted = &hash2;
+ r.in.nt_present = 1;
+ r.in.old_nt_crypted = &hash3;
+ r.in.new_nt_crypted = &hash4;
+ r.in.cross1_present = 1;
+ r.in.nt_cross = &hash5;
+ r.in.cross2_present = 1;
+ r.in.lm_cross = &hash6;
+
+ status = dcerpc_samr_ChangePasswordUser(p, mem_ctx, &r);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("ChangePasswordUser failed - %s\n", nt_errstr(status));
+ ret = False;
+ }
+
+ if (!test_Close(p, mem_ctx, &user_handle)) {
+ ret = False;
+ }
+
+ return ret;
+}
+#endif
static BOOL test_ChangePasswordUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, char **password)
NTSTATUS status;
struct samr_ChangePasswordUser r;
BOOL ret = True;
- struct samr_Hash hash1, hash2, hash3, hash4, hash5, hash6;
+ struct samr_Password hash1, hash2, hash3, hash4, hash5, hash6;
struct policy_handle user_handle;
char *oldpass = *password;
char *newpass = samr_rand_pass(mem_ctx);
uint8_t old_nt_hash[16], new_nt_hash[16];
uint8_t old_lm_hash[16], new_lm_hash[16];
- status = test_OpenUser_byname(p, mem_ctx, handle, TEST_USERNAME, &user_handle);
+ status = test_OpenUser_byname(p, mem_ctx, handle, TEST_ACCOUNT_NAME, &user_handle);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
E_old_pw_hash(old_lm_hash, new_nt_hash, hash5.hash);
E_old_pw_hash(old_nt_hash, new_lm_hash, hash6.hash);
- r.in.handle = &user_handle;
+ r.in.user_handle = &user_handle;
r.in.lm_present = 1;
r.in.old_lm_crypted = &hash1;
r.in.new_lm_crypted = &hash2;
NTSTATUS status;
struct samr_OemChangePasswordUser2 r;
BOOL ret = True;
- struct samr_Hash lm_verifier;
+ struct samr_Password lm_verifier;
struct samr_CryptPassword lm_pass;
struct samr_AsciiName server, account;
char *oldpass = *password;
printf("Testing OemChangePasswordUser2\n");
server.name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
- account.name = TEST_USERNAME;
+ account.name = TEST_ACCOUNT_NAME;
E_deshash(oldpass, old_lm_hash);
E_deshash(newpass, new_lm_hash);
encode_pw_buffer(lm_pass.data, newpass, STR_ASCII);
- SamOEMhash(lm_pass.data, old_lm_hash, 516);
+ arcfour_crypt(lm_pass.data, old_lm_hash, 516);
E_old_pw_hash(new_lm_hash, old_lm_hash, lm_verifier.hash);
r.in.server = &server;
BOOL ret = True;
struct samr_Name server, account;
struct samr_CryptPassword nt_pass, lm_pass;
- struct samr_Hash nt_verifier, lm_verifier;
+ struct samr_Password nt_verifier, lm_verifier;
char *oldpass = *password;
char *newpass = samr_rand_pass(mem_ctx);
uint8_t old_nt_hash[16], new_nt_hash[16];
printf("Testing ChangePasswordUser2\n");
server.name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
- init_samr_Name(&account, TEST_USERNAME);
+ init_samr_Name(&account, TEST_ACCOUNT_NAME);
E_md4hash(oldpass, old_nt_hash);
E_md4hash(newpass, new_nt_hash);
E_deshash(newpass, new_lm_hash);
encode_pw_buffer(lm_pass.data, newpass, STR_ASCII|STR_TERMINATE);
- SamOEMhash(lm_pass.data, old_lm_hash, 516);
+ arcfour_crypt(lm_pass.data, old_lm_hash, 516);
E_old_pw_hash(new_lm_hash, old_lm_hash, lm_verifier.hash);
encode_pw_buffer(nt_pass.data, newpass, STR_UNICODE);
- SamOEMhash(nt_pass.data, old_nt_hash, 516);
+ arcfour_crypt(nt_pass.data, old_nt_hash, 516);
E_old_pw_hash(new_nt_hash, old_nt_hash, nt_verifier.hash);
r.in.server = &server;
BOOL ret = True;
struct samr_Name server, account;
struct samr_CryptPassword nt_pass, lm_pass;
- struct samr_Hash nt_verifier, lm_verifier;
+ struct samr_Password nt_verifier, lm_verifier;
char *oldpass = *password;
char *newpass = samr_rand_pass(mem_ctx);
uint8_t old_nt_hash[16], new_nt_hash[16];
printf("Testing ChangePasswordUser3\n");
server.name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
- init_samr_Name(&account, TEST_USERNAME);
+ init_samr_Name(&account, TEST_ACCOUNT_NAME);
E_md4hash(oldpass, old_nt_hash);
E_md4hash(newpass, new_nt_hash);
E_deshash(newpass, new_lm_hash);
encode_pw_buffer(lm_pass.data, newpass, STR_UNICODE);
- SamOEMhash(lm_pass.data, old_nt_hash, 516);
+ arcfour_crypt(lm_pass.data, old_nt_hash, 516);
E_old_pw_hash(new_lm_hash, old_lm_hash, lm_verifier.hash);
encode_pw_buffer(nt_pass.data, newpass, STR_UNICODE);
- SamOEMhash(nt_pass.data, old_nt_hash, 516);
+ arcfour_crypt(nt_pass.data, old_nt_hash, 516);
E_old_pw_hash(new_nt_hash, old_nt_hash, nt_verifier.hash);
r.in.server = &server;
printf("Testing GetMembersInAlias\n");
- r.in.handle = alias_handle;
+ r.in.alias_handle = alias_handle;
r.out.sids = &sids;
status = dcerpc_samr_GetMembersInAlias(p, mem_ctx, &r);
static BOOL test_AddMemberToAlias(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *alias_handle,
- struct policy_handle *domain_handle,
const struct dom_sid *domain_sid)
{
struct samr_AddAliasMember r;
sid = dom_sid_add_rid(mem_ctx, domain_sid, 512);
printf("testing AddAliasMember\n");
- r.in.handle = alias_handle;
+ r.in.alias_handle = alias_handle;
r.in.sid = sid;
status = dcerpc_samr_AddAliasMember(p, mem_ctx, &r);
ret = False;
}
- d.in.handle = alias_handle;
+ d.in.alias_handle = alias_handle;
d.in.sid = sid;
status = dcerpc_samr_DeleteAliasMember(p, mem_ctx, &d);
struct lsa_SidArray sids;
printf("testing AddMultipleMembersToAlias\n");
- a.in.handle = alias_handle;
+ a.in.alias_handle = alias_handle;
a.in.sids = &sids;
sids.num_sids = 3;
printf("testing RemoveMultipleMembersFromAlias\n");
- r.in.handle = alias_handle;
+ r.in.alias_handle = alias_handle;
r.in.sids = &sids;
status = dcerpc_samr_RemoveMultipleMembersFromAlias(p, mem_ctx, &r);
printf("Testing TestPrivateFunctionsUser\n");
- r.in.handle = user_handle;
+ r.in.user_handle = user_handle;
status = dcerpc_samr_TestPrivateFunctionsUser(p, mem_ctx, &r);
if (!NT_STATUS_EQUAL(NT_STATUS_NOT_IMPLEMENTED, status)) {
static BOOL test_alias_ops(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *alias_handle,
- struct policy_handle *domain_handle,
const struct dom_sid *domain_sid)
{
BOOL ret = True;
ret = False;
}
- if (!test_AddMemberToAlias(p, mem_ctx, alias_handle,
- domain_handle, domain_sid)) {
+ if (!test_AddMemberToAlias(p, mem_ctx, alias_handle, domain_sid)) {
ret = False;
}
{
NTSTATUS status;
struct samr_DeleteUser d;
- struct policy_handle acct_handle;
+ struct policy_handle user_handle;
uint32_t rid;
status = test_LookupName(p, mem_ctx, handle, name, &rid);
goto failed;
}
- status = test_OpenUser_byname(p, mem_ctx, handle, name, &acct_handle);
+ status = test_OpenUser_byname(p, mem_ctx, handle, name, &user_handle);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
}
- d.in.handle = &acct_handle;
- d.out.handle = &acct_handle;
+ d.in.user_handle = &user_handle;
+ d.out.user_handle = &user_handle;
status = dcerpc_samr_DeleteUser(p, mem_ctx, &d);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
goto failed;
}
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
r.in.rid = rid;
- r.out.acct_handle = &group_handle;
+ r.out.group_handle = &group_handle;
status = dcerpc_samr_OpenGroup(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
}
- d.in.handle = &group_handle;
- d.out.handle = &group_handle;
+ d.in.group_handle = &group_handle;
+ d.out.group_handle = &group_handle;
status = dcerpc_samr_DeleteDomainGroup(p, mem_ctx, &d);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
goto failed;
}
- r.in.handle = domain_handle;
+ r.in.domain_handle = domain_handle;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
r.in.rid = rid;
- r.out.acct_handle = &alias_handle;
+ r.out.alias_handle = &alias_handle;
status = dcerpc_samr_OpenAlias(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
}
- d.in.handle = &alias_handle;
- d.out.handle = &alias_handle;
+ d.in.alias_handle = &alias_handle;
+ d.out.alias_handle = &alias_handle;
status = dcerpc_samr_DeleteDomAlias(p, mem_ctx, &d);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
BOOL ret = True;
printf("Testing DeleteAlias\n");
- d.in.handle = alias_handle;
- d.out.handle = alias_handle;
+ d.in.alias_handle = alias_handle;
+ d.out.alias_handle = alias_handle;
status = dcerpc_samr_DeleteDomAlias(p, mem_ctx, &d);
if (!NT_STATUS_IS_OK(status)) {
BOOL ret = True;
init_samr_Name(&name, TEST_ALIASNAME);
- r.in.handle = domain_handle;
+ r.in.domain_handle = domain_handle;
r.in.aliasname = &name;
r.in.access_mask = SEC_RIGHT_MAXIMUM_ALLOWED;
- r.out.acct_handle = alias_handle;
+ r.out.alias_handle = alias_handle;
r.out.rid = &rid;
printf("Testing CreateAlias (%s)\n", r.in.aliasname->name);
return False;
}
- if (!test_alias_ops(p, mem_ctx, alias_handle, domain_handle, domain_sid)) {
+ if (!test_alias_ops(p, mem_ctx, alias_handle, domain_sid)) {
ret = False;
}
struct samr_Name name;
BOOL ret = True;
- init_samr_Name(&name, TEST_USERNAME);
+ init_samr_Name(&name, TEST_ACCOUNT_NAME);
- r.in.handle = domain_handle;
- r.in.username = &name;
+ r.in.domain_handle = domain_handle;
+ r.in.account_name = &name;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
- r.out.acct_handle = user_handle;
+ r.out.user_handle = user_handle;
r.out.rid = &rid;
- printf("Testing CreateUser(%s)\n", r.in.username->name);
+ printf("Testing CreateUser(%s)\n", r.in.account_name->name);
status = dcerpc_samr_CreateUser(p, mem_ctx, &r);
if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
- printf("Server refused create of '%s'\n", r.in.username->name);
+ printf("Server refused create of '%s'\n", r.in.account_name->name);
ZERO_STRUCTP(user_handle);
return True;
}
if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
- if (!test_DeleteUser_byname(p, mem_ctx, domain_handle, r.in.username->name)) {
+ if (!test_DeleteUser_byname(p, mem_ctx, domain_handle, r.in.account_name->name)) {
return False;
}
status = dcerpc_samr_CreateUser(p, mem_ctx, &r);
return False;
}
- q.in.handle = user_handle;
+ q.in.user_handle = user_handle;
q.in.level = 16;
status = dcerpc_samr_QueryUserInfo(p, mem_ctx, &q);
printf("Testing DeleteUser\n");
- d.in.handle = user_handle;
- d.out.handle = user_handle;
+ d.in.user_handle = user_handle;
+ d.out.user_handle = user_handle;
status = dcerpc_samr_DeleteUser(p, mem_ctx, &d);
if (!NT_STATUS_IS_OK(status)) {
struct samr_CreateUser2 r;
struct samr_QueryUserInfo q;
struct samr_DeleteUser d;
- struct policy_handle acct_handle;
+ struct policy_handle user_handle;
uint32_t rid;
struct samr_Name name;
BOOL ret = True;
const char *account_name;
NTSTATUS nt_status;
} account_types[] = {
- { ACB_NORMAL, TEST_USERNAME, NT_STATUS_OK },
- { ACB_NORMAL | ACB_DISABLED, TEST_USERNAME, NT_STATUS_INVALID_PARAMETER },
- { ACB_NORMAL | ACB_PWNOEXP, TEST_USERNAME, NT_STATUS_INVALID_PARAMETER },
+ { ACB_NORMAL, TEST_ACCOUNT_NAME, NT_STATUS_OK },
+ { ACB_NORMAL | ACB_DISABLED, TEST_ACCOUNT_NAME, NT_STATUS_INVALID_PARAMETER },
+ { ACB_NORMAL | ACB_PWNOEXP, TEST_ACCOUNT_NAME, NT_STATUS_INVALID_PARAMETER },
{ ACB_WSTRUST, TEST_MACHINENAME, NT_STATUS_OK },
{ ACB_WSTRUST | ACB_DISABLED, TEST_MACHINENAME, NT_STATUS_INVALID_PARAMETER },
{ ACB_WSTRUST | ACB_PWNOEXP, TEST_MACHINENAME, NT_STATUS_INVALID_PARAMETER },
{ ACB_DOMTRUST, TEST_DOMAINNAME, NT_STATUS_OK },
{ ACB_DOMTRUST | ACB_DISABLED, TEST_DOMAINNAME, NT_STATUS_INVALID_PARAMETER },
{ ACB_DOMTRUST | ACB_PWNOEXP, TEST_DOMAINNAME, NT_STATUS_INVALID_PARAMETER },
- { 0, TEST_USERNAME, NT_STATUS_INVALID_PARAMETER },
- { ACB_DISABLED, TEST_USERNAME, NT_STATUS_INVALID_PARAMETER },
+ { 0, TEST_ACCOUNT_NAME, NT_STATUS_INVALID_PARAMETER },
+ { ACB_DISABLED, TEST_ACCOUNT_NAME, NT_STATUS_INVALID_PARAMETER },
{ 0, NULL, NT_STATUS_INVALID_PARAMETER }
};
init_samr_Name(&name, account_types[i].account_name);
- r.in.handle = handle;
- r.in.username = &name;
+ r.in.domain_handle = handle;
+ r.in.account_name = &name;
r.in.acct_flags = acct_flags;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
- r.out.acct_handle = &acct_handle;
+ r.out.user_handle = &user_handle;
r.out.access_granted = &access_granted;
r.out.rid = &rid;
- printf("Testing CreateUser2(%s)\n", r.in.username->name);
+ printf("Testing CreateUser2(%s)\n", r.in.account_name->name);
status = dcerpc_samr_CreateUser2(p, mem_ctx, &r);
if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
- printf("Server refused create of '%s'\n", r.in.username->name);
+ printf("Server refused create of '%s'\n", r.in.account_name->name);
continue;
} else if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
- if (!test_DeleteUser_byname(p, mem_ctx, handle, r.in.username->name)) {
+ if (!test_DeleteUser_byname(p, mem_ctx, handle, r.in.account_name->name)) {
return False;
}
status = dcerpc_samr_CreateUser2(p, mem_ctx, &r);
}
if (NT_STATUS_IS_OK(status)) {
- q.in.handle = &acct_handle;
+ q.in.user_handle = &user_handle;
q.in.level = 16;
status = dcerpc_samr_QueryUserInfo(p, mem_ctx, &q);
}
}
- if (!test_user_ops(p, mem_ctx, &acct_handle)) {
+ if (!test_user_ops(p, mem_ctx, &user_handle)) {
ret = False;
}
printf("Testing DeleteUser (createuser2 test)\n");
- d.in.handle = &acct_handle;
- d.out.handle = &acct_handle;
+ d.in.user_handle = &user_handle;
+ d.out.user_handle = &user_handle;
status = dcerpc_samr_DeleteUser(p, mem_ctx, &d);
if (!NT_STATUS_IS_OK(status)) {
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryAliasInfo level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.alias_handle = handle;
r.in.level = levels[i];
status = dcerpc_samr_QueryAliasInfo(p, mem_ctx, &r);
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryGroupInfo level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.group_handle = handle;
r.in.level = levels[i];
status = dcerpc_samr_QueryGroupInfo(p, mem_ctx, &r);
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryGroupInfo level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.group_handle = handle;
r.in.level = levels[i];
status = dcerpc_samr_QueryGroupInfo(p, mem_ctx, &r);
printf("Testing SetGroupInfo level %u\n", levels[i]);
- s.in.handle = handle;
+ s.in.group_handle = handle;
s.in.level = levels[i];
s.in.info = r.out.info;
+#if 0
+ /* disabled this, as it changes the name only from the point of view of samr,
+ but leaves the name from the point of view of w2k3 internals (and ldap). This means
+ the name is still reserved, so creating the old name fails, but deleting by the old name
+ also fails */
if (s.in.level == 2) {
init_samr_Name(&s.in.info->name, "NewName");
}
+#endif
if (s.in.level == 4) {
init_samr_Name(&s.in.info->description, "test description");
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryUserInfo level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.user_handle = handle;
r.in.level = levels[i];
status = dcerpc_samr_QueryUserInfo(p, mem_ctx, &r);
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryUserInfo2 level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.user_handle = handle;
r.in.level = levels[i];
status = dcerpc_samr_QueryUserInfo2(p, mem_ctx, &r);
{
NTSTATUS status;
struct samr_OpenUser r;
- struct policy_handle acct_handle;
+ struct policy_handle user_handle;
BOOL ret = True;
printf("Testing OpenUser(%u)\n", rid);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
r.in.rid = rid;
- r.out.acct_handle = &acct_handle;
+ r.out.user_handle = &user_handle;
status = dcerpc_samr_OpenUser(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
- if (!test_QuerySecurity(p, mem_ctx, &acct_handle)) {
+ if (!test_QuerySecurity(p, mem_ctx, &user_handle)) {
ret = False;
}
- if (!test_QueryUserInfo(p, mem_ctx, &acct_handle)) {
+ if (!test_QueryUserInfo(p, mem_ctx, &user_handle)) {
ret = False;
}
- if (!test_QueryUserInfo2(p, mem_ctx, &acct_handle)) {
+ if (!test_QueryUserInfo2(p, mem_ctx, &user_handle)) {
ret = False;
}
- if (!test_GetUserPwInfo(p, mem_ctx, &acct_handle)) {
+ if (!test_GetUserPwInfo(p, mem_ctx, &user_handle)) {
ret = False;
}
- if (!test_GetGroupsForUser(p,mem_ctx, &acct_handle)) {
+ if (!test_GetGroupsForUser(p,mem_ctx, &user_handle)) {
ret = False;
}
- if (!test_Close(p, mem_ctx, &acct_handle)) {
+ if (!test_Close(p, mem_ctx, &user_handle)) {
ret = False;
}
{
NTSTATUS status;
struct samr_OpenGroup r;
- struct policy_handle acct_handle;
+ struct policy_handle group_handle;
BOOL ret = True;
printf("Testing OpenGroup(%u)\n", rid);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
r.in.rid = rid;
- r.out.acct_handle = &acct_handle;
+ r.out.group_handle = &group_handle;
status = dcerpc_samr_OpenGroup(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
- if (!test_QuerySecurity(p, mem_ctx, &acct_handle)) {
+ if (!test_QuerySecurity(p, mem_ctx, &group_handle)) {
ret = False;
}
- if (!test_QueryGroupInfo(p, mem_ctx, &acct_handle)) {
+ if (!test_QueryGroupInfo(p, mem_ctx, &group_handle)) {
ret = False;
}
- if (!test_Close(p, mem_ctx, &acct_handle)) {
+ if (!test_Close(p, mem_ctx, &group_handle)) {
ret = False;
}
{
NTSTATUS status;
struct samr_OpenAlias r;
- struct policy_handle acct_handle;
+ struct policy_handle alias_handle;
BOOL ret = True;
printf("Testing OpenAlias(%u)\n", rid);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
r.in.rid = rid;
- r.out.acct_handle = &acct_handle;
+ r.out.alias_handle = &alias_handle;
status = dcerpc_samr_OpenAlias(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
- if (!test_QuerySecurity(p, mem_ctx, &acct_handle)) {
+ if (!test_QuerySecurity(p, mem_ctx, &alias_handle)) {
ret = False;
}
- if (!test_QueryAliasInfo(p, mem_ctx, &acct_handle)) {
+ if (!test_QueryAliasInfo(p, mem_ctx, &alias_handle)) {
ret = False;
}
- if (!test_GetMembersInAlias(p, mem_ctx, &acct_handle)) {
+ if (!test_GetMembersInAlias(p, mem_ctx, &alias_handle)) {
ret = False;
}
- if (!test_Close(p, mem_ctx, &acct_handle)) {
+ if (!test_Close(p, mem_ctx, &alias_handle)) {
ret = False;
}
printf("Testing EnumDomainUsers\n");
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.resume_handle = &resume_handle;
r.in.acct_flags = 0;
r.in.max_size = (uint32_t)-1;
}
printf("Testing LookupNames\n");
- n.in.handle = handle;
+ n.in.domain_handle = handle;
n.in.num_names = r.out.sam->count;
n.in.names = talloc(mem_ctx, r.out.sam->count * sizeof(struct samr_Name));
for (i=0;i<r.out.sam->count;i++) {
printf("Testing LookupRids\n");
- lr.in.handle = handle;
+ lr.in.domain_handle = handle;
lr.in.num_rids = r.out.sam->count;
lr.in.rids = talloc(mem_ctx, r.out.sam->count * sizeof(uint32_t));
for (i=0;i<r.out.sam->count;i++) {
return ret;
}
+/*
+ try blasting the server with a bunch of sync requests
+*/
+static BOOL test_EnumDomainUsers_async(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+ struct policy_handle *handle)
+{
+ NTSTATUS status;
+ struct samr_EnumDomainUsers r;
+ uint32_t resume_handle=0;
+ int i;
+#define ASYNC_COUNT 100
+ struct rpc_request *req[ASYNC_COUNT];
+
+ if (lp_parm_int(-1, "torture", "dangerous") != 1) {
+ printf("samr async test disabled - enable dangerous tests to use\n");
+ return True;
+ }
+
+ printf("Testing EnumDomainUsers_async\n");
+
+ r.in.domain_handle = handle;
+ r.in.resume_handle = &resume_handle;
+ r.in.acct_flags = 0;
+ r.in.max_size = (uint32_t)-1;
+ r.out.resume_handle = &resume_handle;
+
+ for (i=0;i<ASYNC_COUNT;i++) {
+ req[i] = dcerpc_samr_EnumDomainUsers_send(p, mem_ctx, &r);
+ }
+
+ for (i=0;i<ASYNC_COUNT;i++) {
+ status = dcerpc_ndr_request_recv(req[i]);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("EnumDomainUsers[%d] failed - %s\n",
+ i, nt_errstr(status));
+ return False;
+ }
+ }
+
+ printf("%d async requests OK\n", i);
+
+ return True;
+}
+
static BOOL test_EnumDomainGroups(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *handle)
{
printf("Testing EnumDomainGroups\n");
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.resume_handle = &resume_handle;
r.in.max_size = (uint32_t)-1;
r.out.resume_handle = &resume_handle;
printf("Testing EnumDomainAliases\n");
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.resume_handle = &resume_handle;
- r.in.max_size = (uint32_t)-1;
+ r.in.acct_flags = (uint32_t)-1;
r.out.resume_handle = &resume_handle;
status = dcerpc_samr_EnumDomainAliases(p, mem_ctx, &r);
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing GetDisplayEnumerationIndex level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.level = levels[i];
- init_samr_Name(&r.in.name, TEST_USERNAME);
+ init_samr_Name(&r.in.name, TEST_ACCOUNT_NAME);
status = dcerpc_samr_GetDisplayEnumerationIndex(p, mem_ctx, &r);
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing GetDisplayEnumerationIndex2 level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.level = levels[i];
- init_samr_Name(&r.in.name, TEST_USERNAME);
+ init_samr_Name(&r.in.name, TEST_ACCOUNT_NAME);
status = dcerpc_samr_GetDisplayEnumerationIndex2(p, mem_ctx, &r);
if (ok_lvl[i] &&
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryDisplayInfo level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.level = levels[i];
r.in.start_idx = 0;
r.in.max_entries = 1000;
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryDisplayInfo2 level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.level = levels[i];
r.in.start_idx = 0;
r.in.max_entries = 1000;
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryDisplayInfo3 level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.level = levels[i];
r.in.start_idx = 0;
r.in.max_entries = 1000;
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryDomainInfo level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.level = levels[i];
status = dcerpc_samr_QueryDomainInfo(p, mem_ctx, &r);
printf("Testing SetDomainInfo level %u\n", levels[i]);
- s.in.handle = handle;
+ s.in.domain_handle = handle;
s.in.level = levels[i];
s.in.info = r.out.info;
for (i=0;i<ARRAY_SIZE(levels);i++) {
printf("Testing QueryDomainInfo2 level %u\n", levels[i]);
- r.in.handle = handle;
+ r.in.domain_handle = handle;
r.in.level = levels[i];
status = dcerpc_samr_QueryDomainInfo2(p, mem_ctx, &r);
return True;
}
-void add_string_to_array(TALLOC_CTX *mem_ctx,
- const char *str, const char ***strings, int *num)
-{
- *strings = talloc_realloc(mem_ctx, *strings,
- ((*num)+1) * sizeof(**strings));
-
- if (*strings == NULL)
- return;
-
- (*strings)[*num] = str;
- *num += 1;
-
- return;
-}
-
/* Test whether querydispinfo level 5 and enumdomgroups return the same
set of group names. */
static BOOL test_GroupList(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
printf("Testing coherency of querydispinfo vs enumdomgroups\n");
- q1.in.handle = handle;
+ q1.in.domain_handle = handle;
q1.in.resume_handle = &resume_handle;
q1.in.max_size = 5;
q1.out.resume_handle = &resume_handle;
return False;
}
- q2.in.handle = handle;
+ q2.in.domain_handle = handle;
q2.in.level = 5;
q2.in.start_idx = 0;
q2.in.max_entries = 5;
/* Querydisplayinfo returns ascii -- convert */
- namelen = convert_string_allocate(CH_DISPLAY, CH_UNIX,
- q2.out.info.info5.entries[i].account_name.name,
- q2.out.info.info5.entries[i].account_name.name_len,
- (void **)&name);
- name = realloc(name, namelen+1);
- name[namelen] = 0;
+ namelen = convert_string_talloc(mem_ctx, CH_DISPLAY, CH_UNIX,
+ q2.out.info.info5.entries[i].account_name.name,
+ q2.out.info.info5.entries[i].account_name.name_len,
+ (void **)&name);
for (j=0; j<num_names; j++) {
if (names[j] == NULL)
printf("Testing DeleteDomainGroup\n");
- d.in.handle = group_handle;
- d.out.handle = group_handle;
+ d.in.group_handle = group_handle;
+ d.out.group_handle = group_handle;
status = dcerpc_samr_DeleteDomainGroup(p, mem_ctx, &d);
if (!NT_STATUS_IS_OK(status)) {
printf("Testing TestPrivateFunctionsDomain\n");
- r.in.handle = domain_handle;
+ r.in.domain_handle = domain_handle;
status = dcerpc_samr_TestPrivateFunctionsDomain(p, mem_ctx, &r);
if (!NT_STATUS_EQUAL(NT_STATUS_NOT_IMPLEMENTED, status)) {
printf("Testing RidToSid\n");
- r.in.handle = domain_handle;
+ r.in.domain_handle = domain_handle;
r.in.rid = 512;
status = dcerpc_samr_RidToSid(p, mem_ctx, &r);
printf("Testing GetBootKeyInformation\n");
- r.in.handle = domain_handle;
+ r.in.domain_handle = domain_handle;
status = dcerpc_samr_GetBootKeyInformation(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
BOOL ret = True;
uint32_t rid;
- status = test_LookupName(p, mem_ctx, domain_handle, TEST_USERNAME, &rid);
+ status = test_LookupName(p, mem_ctx, domain_handle, TEST_ACCOUNT_NAME, &rid);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
- r.in.handle = group_handle;
+ r.in.group_handle = group_handle;
r.in.rid = rid;
r.in.flags = 0; /* ??? */
printf("Testing AddGroupMember and DeleteGroupMember\n");
- d.in.handle = group_handle;
+ d.in.group_handle = group_handle;
d.in.rid = rid;
status = dcerpc_samr_DeleteGroupMember(p, mem_ctx, &d);
/* this one is quite strange. I am using random inputs in the
hope of triggering an error that might give us a clue */
- s.in.handle = group_handle;
+ s.in.group_handle = group_handle;
s.in.unknown1 = random();
s.in.unknown2 = random();
return False;
}
- q.in.handle = group_handle;
+ q.in.group_handle = group_handle;
status = dcerpc_samr_QueryGroupMember(p, mem_ctx, &q);
if (!NT_STATUS_IS_OK(status)) {
init_samr_Name(&name, TEST_GROUPNAME);
- r.in.handle = domain_handle;
+ r.in.domain_handle = domain_handle;
r.in.name = &name;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
r.out.group_handle = group_handle;
return True;
}
- if (NT_STATUS_EQUAL(status, NT_STATUS_GROUP_EXISTS)) {
+ if (NT_STATUS_EQUAL(status, NT_STATUS_GROUP_EXISTS) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
if (!test_DeleteGroup_byname(p, mem_ctx, domain_handle, r.in.name->name)) {
return False;
}
NTSTATUS status;
struct samr_RemoveMemberFromForeignDomain r;
- r.in.handle = domain_handle;
+ r.in.domain_handle = domain_handle;
r.in.sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-12-34-56-78-9");
status = dcerpc_samr_RemoveMemberFromForeignDomain(p, mem_ctx, &r);
+static BOOL test_Connect(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+ struct policy_handle *handle);
static BOOL test_OpenDomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, struct dom_sid *sid)
printf("Testing OpenDomain\n");
- r.in.handle = handle;
+ r.in.connect_handle = handle;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
r.in.sid = sid;
r.out.domain_handle = &domain_handle;
return False;
}
- if (!test_RemoveMemberFromForeignDomain(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_CreateUser2(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_CreateUser(p, mem_ctx, &domain_handle, &user_handle)) {
- ret = False;
- }
-
- if (!test_CreateAlias(p, mem_ctx, &domain_handle, &alias_handle, sid)) {
- ret = False;
- }
-
- if (!test_CreateDomainGroup(p, mem_ctx, &domain_handle, &group_handle)) {
- ret = False;
- }
-
- if (!test_QuerySecurity(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_QueryDomainInfo(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_QueryDomainInfo2(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_EnumDomainUsers(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_EnumDomainGroups(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_EnumDomainAliases(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_QueryDisplayInfo(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_QueryDisplayInfo2(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_QueryDisplayInfo3(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_GetDisplayEnumerationIndex(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_GetDisplayEnumerationIndex2(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_GroupList(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_TestPrivateFunctionsDomain(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_RidToSid(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
-
- if (!test_GetBootKeyInformation(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
+ /* run the domain tests with the main handle closed - this tests
+ the servers reference counting */
+ ret &= test_Close(p, mem_ctx, handle);
+
+ ret &= test_QuerySecurity(p, mem_ctx, &domain_handle);
+ ret &= test_RemoveMemberFromForeignDomain(p, mem_ctx, &domain_handle);
+ ret &= test_CreateUser2(p, mem_ctx, &domain_handle);
+ ret &= test_CreateUser(p, mem_ctx, &domain_handle, &user_handle);
+ ret &= test_CreateAlias(p, mem_ctx, &domain_handle, &alias_handle, sid);
+ ret &= test_CreateDomainGroup(p, mem_ctx, &domain_handle, &group_handle);
+ ret &= test_QueryDomainInfo(p, mem_ctx, &domain_handle);
+ ret &= test_QueryDomainInfo2(p, mem_ctx, &domain_handle);
+ ret &= test_EnumDomainUsers(p, mem_ctx, &domain_handle);
+ ret &= test_EnumDomainUsers_async(p, mem_ctx, &domain_handle);
+ ret &= test_EnumDomainGroups(p, mem_ctx, &domain_handle);
+ ret &= test_EnumDomainAliases(p, mem_ctx, &domain_handle);
+ ret &= test_QueryDisplayInfo(p, mem_ctx, &domain_handle);
+ ret &= test_QueryDisplayInfo2(p, mem_ctx, &domain_handle);
+ ret &= test_QueryDisplayInfo3(p, mem_ctx, &domain_handle);
+ ret &= test_GetDisplayEnumerationIndex(p, mem_ctx, &domain_handle);
+ ret &= test_GetDisplayEnumerationIndex2(p, mem_ctx, &domain_handle);
+ ret &= test_GroupList(p, mem_ctx, &domain_handle);
+ ret &= test_TestPrivateFunctionsDomain(p, mem_ctx, &domain_handle);
+ ret &= test_RidToSid(p, mem_ctx, &domain_handle);
+ ret &= test_GetBootKeyInformation(p, mem_ctx, &domain_handle);
if (!policy_handle_empty(&user_handle) &&
!test_DeleteUser(p, mem_ctx, &user_handle)) {
ret = False;
}
- if (!test_Close(p, mem_ctx, &domain_handle)) {
- ret = False;
- }
+ ret &= test_Close(p, mem_ctx, &domain_handle);
+
+ /* reconnect the main handle */
+ ret &= test_Connect(p, mem_ctx, handle);
return ret;
}
printf("Testing LookupDomain(%s)\n", domain->name);
/* check for correct error codes */
- r.in.handle = handle;
+ r.in.connect_handle = handle;
r.in.domain = &n2;
n2.name = NULL;
ret = False;
}
- r.in.handle = handle;
+ r.in.connect_handle = handle;
r.in.domain = domain;
status = dcerpc_samr_LookupDomain(p, mem_ctx, &r);
int i;
BOOL ret = True;
- r.in.handle = handle;
+ r.in.connect_handle = handle;
r.in.resume_handle = &resume_handle;
r.in.buf_size = (uint32_t)-1;
r.out.resume_handle = &resume_handle;
struct samr_Connect4 r4;
struct samr_Connect5 r5;
union samr_ConnectInfo info;
- BOOL ret = True;
+ struct policy_handle h;
+ BOOL ret = True, got_handle = False;
printf("testing samr_Connect\n");
r.in.system_name = 0;
r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
- r.out.handle = handle;
+ r.out.connect_handle = &h;
status = dcerpc_samr_Connect(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
printf("Connect failed - %s\n", nt_errstr(status));
ret = False;
+ } else {
+ got_handle = True;
+ *handle = h;
}
printf("testing samr_Connect2\n");
r2.in.system_name = NULL;
r2.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
- r2.out.handle = handle;
+ r2.out.connect_handle = &h;
status = dcerpc_samr_Connect2(p, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
printf("Connect2 failed - %s\n", nt_errstr(status));
ret = False;
+ } else {
+ if (got_handle) {
+ test_Close(p, mem_ctx, handle);
+ }
+ got_handle = True;
+ *handle = h;
}
printf("testing samr_Connect3\n");
r3.in.system_name = NULL;
r3.in.unknown = 0;
r3.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
- r3.out.handle = handle;
+ r3.out.connect_handle = &h;
status = dcerpc_samr_Connect3(p, mem_ctx, &r3);
if (!NT_STATUS_IS_OK(status)) {
printf("Connect3 failed - %s\n", nt_errstr(status));
ret = False;
+ } else {
+ if (got_handle) {
+ test_Close(p, mem_ctx, handle);
+ }
+ got_handle = True;
+ *handle = h;
}
printf("testing samr_Connect4\n");
r4.in.system_name = "";
r4.in.unknown = 0;
r4.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
- r4.out.handle = handle;
+ r4.out.connect_handle = &h;
status = dcerpc_samr_Connect4(p, mem_ctx, &r4);
if (!NT_STATUS_IS_OK(status)) {
printf("Connect4 failed - %s\n", nt_errstr(status));
ret = False;
+ } else {
+ if (got_handle) {
+ test_Close(p, mem_ctx, handle);
+ }
+ got_handle = True;
+ *handle = h;
}
printf("testing samr_Connect5\n");
r5.in.level = 1;
r5.in.info = &info;
r5.out.info = &info;
- r5.out.handle = handle;
+ r5.out.connect_handle = &h;
status = dcerpc_samr_Connect5(p, mem_ctx, &r5);
if (!NT_STATUS_IS_OK(status)) {
printf("Connect5 failed - %s\n", nt_errstr(status));
ret = False;
+ } else {
+ if (got_handle) {
+ test_Close(p, mem_ctx, handle);
+ }
+ got_handle = True;
+ *handle = h;
}
return ret;