| 1 |
/* |
| 2 |
Unix SMB/CIFS implementation. |
| 3 |
Test suite for libnet calls. |
| 4 |
|
| 5 |
Copyright (C) Rafal Szczesniak 2005 |
| 6 |
|
| 7 |
This program is free software; you can redistribute it and/or modify |
| 8 |
it under the terms of the GNU General Public License as published by |
| 9 |
the Free Software Foundation; either version 3 of the License, or |
| 10 |
(at your option) any later version. |
| 11 |
|
| 12 |
This program is distributed in the hope that it will be useful, |
| 13 |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 |
GNU General Public License for more details. |
| 16 |
|
| 17 |
You should have received a copy of the GNU General Public License |
| 18 |
along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 19 |
*/ |
| 20 |
|
| 21 |
#include "includes.h" |
| 22 |
#include "torture/rpc/torture_rpc.h" |
| 23 |
#include "torture/libnet/usertest.h" |
| 24 |
#include "libnet/libnet.h" |
| 25 |
#include "librpc/gen_ndr/ndr_samr_c.h" |
| 26 |
#include "param/param.h" |
| 27 |
|
| 28 |
#include "torture/libnet/proto.h" |
| 29 |
|
| 30 |
|
| 31 |
static bool test_useradd(struct torture_context *tctx, |
| 32 |
struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, |
| 33 |
struct policy_handle *domain_handle, |
| 34 |
const char *name) |
| 35 |
{ |
| 36 |
NTSTATUS status; |
| 37 |
bool ret = true; |
| 38 |
struct libnet_rpc_useradd user; |
| 39 |
|
| 40 |
user.in.domain_handle = *domain_handle; |
| 41 |
user.in.username = name; |
| 42 |
|
| 43 |
torture_comment(tctx, "Testing libnet_rpc_useradd\n"); |
| 44 |
|
| 45 |
status = libnet_rpc_useradd(tctx->ev, p->binding_handle, mem_ctx, &user); |
| 46 |
if (!NT_STATUS_IS_OK(status)) { |
| 47 |
torture_comment(tctx, "Failed to call libnet_rpc_useradd - %s\n", nt_errstr(status)); |
| 48 |
return false; |
| 49 |
} |
| 50 |
|
| 51 |
return ret; |
| 52 |
} |
| 53 |
|
| 54 |
|
| 55 |
static bool test_useradd_async(struct torture_context *tctx, |
| 56 |
struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, |
| 57 |
struct policy_handle *handle, const char* username) |
| 58 |
{ |
| 59 |
NTSTATUS status; |
| 60 |
struct composite_context *c; |
| 61 |
struct libnet_rpc_useradd user; |
| 62 |
|
| 63 |
user.in.domain_handle = *handle; |
| 64 |
user.in.username = username; |
| 65 |
|
| 66 |
torture_comment(tctx, "Testing async libnet_rpc_useradd\n"); |
| 67 |
|
| 68 |
c = libnet_rpc_useradd_send(mem_ctx, tctx->ev, p->binding_handle, |
| 69 |
&user, msg_handler); |
| 70 |
if (!c) { |
| 71 |
torture_comment(tctx, "Failed to call async libnet_rpc_useradd\n"); |
| 72 |
return false; |
| 73 |
} |
| 74 |
|
| 75 |
status = libnet_rpc_useradd_recv(c, mem_ctx, &user); |
| 76 |
if (!NT_STATUS_IS_OK(status)) { |
| 77 |
torture_comment(tctx, "Calling async libnet_rpc_useradd failed - %s\n", nt_errstr(status)); |
| 78 |
return false; |
| 79 |
} |
| 80 |
|
| 81 |
return true; |
| 82 |
|
| 83 |
} |
| 84 |
|
| 85 |
static bool test_usermod(struct torture_context *tctx, struct dcerpc_pipe *p, |
| 86 |
TALLOC_CTX *mem_ctx, |
| 87 |
struct policy_handle *handle, int num_changes, |
| 88 |
struct libnet_rpc_usermod *mod, char **username) |
| 89 |
{ |
| 90 |
const char* logon_scripts[] = { "start_login.cmd", "login.bat", "start.cmd" }; |
| 91 |
const char* home_dirs[] = { "\\\\srv\\home", "\\\\homesrv\\home\\user", "\\\\pdcsrv\\domain" }; |
| 92 |
const char* home_drives[] = { "H:", "z:", "I:", "J:", "n:" }; |
| 93 |
const char *homedir, *homedrive, *logonscript; |
| 94 |
const uint32_t flags[] = { (ACB_DISABLED | ACB_NORMAL | ACB_PW_EXPIRED), |
| 95 |
(ACB_NORMAL | ACB_PWNOEXP), |
| 96 |
(ACB_NORMAL | ACB_PW_EXPIRED) }; |
| 97 |
|
| 98 |
NTSTATUS status; |
| 99 |
struct timeval now; |
| 100 |
enum test_fields testfld; |
| 101 |
int i; |
| 102 |
|
| 103 |
ZERO_STRUCT(*mod); |
| 104 |
srandom((unsigned)time(NULL)); |
| 105 |
|
| 106 |
mod->in.username = talloc_strdup(mem_ctx, *username); |
| 107 |
mod->in.domain_handle = *handle; |
| 108 |
|
| 109 |
torture_comment(tctx, "modifying user (%d simultaneous change(s))\n", |
| 110 |
num_changes); |
| 111 |
|
| 112 |
torture_comment(tctx, "fields to change: ["); |
| 113 |
|
| 114 |
for (i = 0; i < num_changes && i <= USER_FIELD_LAST; i++) { |
| 115 |
const char *fldname; |
| 116 |
|
| 117 |
testfld = (random() % USER_FIELD_LAST) + 1; |
| 118 |
|
| 119 |
GetTimeOfDay(&now); |
| 120 |
|
| 121 |
switch (testfld) { |
| 122 |
case acct_name: |
| 123 |
continue_if_field_set(mod->in.change.account_name); |
| 124 |
mod->in.change.account_name = talloc_asprintf(mem_ctx, TEST_CHG_ACCOUNTNAME, |
| 125 |
(int)(random() % 100)); |
| 126 |
mod->in.change.fields |= USERMOD_FIELD_ACCOUNT_NAME; |
| 127 |
fldname = "account_name"; |
| 128 |
*username = talloc_strdup(mem_ctx, mod->in.change.account_name); |
| 129 |
break; |
| 130 |
|
| 131 |
case acct_full_name: |
| 132 |
continue_if_field_set(mod->in.change.full_name); |
| 133 |
mod->in.change.full_name = talloc_asprintf(mem_ctx, TEST_CHG_FULLNAME, |
| 134 |
(int)random(), (int)random()); |
| 135 |
mod->in.change.fields |= USERMOD_FIELD_FULL_NAME; |
| 136 |
fldname = "full_name"; |
| 137 |
break; |
| 138 |
|
| 139 |
case acct_description: |
| 140 |
continue_if_field_set(mod->in.change.description); |
| 141 |
mod->in.change.description = talloc_asprintf(mem_ctx, TEST_CHG_DESCRIPTION, |
| 142 |
random()); |
| 143 |
mod->in.change.fields |= USERMOD_FIELD_DESCRIPTION; |
| 144 |
fldname = "description"; |
| 145 |
break; |
| 146 |
|
| 147 |
case acct_home_directory: |
| 148 |
continue_if_field_set(mod->in.change.home_directory); |
| 149 |
homedir = home_dirs[random() % (sizeof(home_dirs)/sizeof(char*))]; |
| 150 |
mod->in.change.home_directory = talloc_strdup(mem_ctx, homedir); |
| 151 |
mod->in.change.fields |= USERMOD_FIELD_HOME_DIRECTORY; |
| 152 |
fldname = "home_directory"; |
| 153 |
break; |
| 154 |
|
| 155 |
case acct_home_drive: |
| 156 |
continue_if_field_set(mod->in.change.home_drive); |
| 157 |
homedrive = home_drives[random() % (sizeof(home_drives)/sizeof(char*))]; |
| 158 |
mod->in.change.home_drive = talloc_strdup(mem_ctx, homedrive); |
| 159 |
mod->in.change.fields |= USERMOD_FIELD_HOME_DRIVE; |
| 160 |
fldname = "home_drive"; |
| 161 |
break; |
| 162 |
|
| 163 |
case acct_comment: |
| 164 |
continue_if_field_set(mod->in.change.comment); |
| 165 |
mod->in.change.comment = talloc_asprintf(mem_ctx, TEST_CHG_COMMENT, |
| 166 |
random(), random()); |
| 167 |
mod->in.change.fields |= USERMOD_FIELD_COMMENT; |
| 168 |
fldname = "comment"; |
| 169 |
break; |
| 170 |
|
| 171 |
case acct_logon_script: |
| 172 |
continue_if_field_set(mod->in.change.logon_script); |
| 173 |
logonscript = logon_scripts[random() % (sizeof(logon_scripts)/sizeof(char*))]; |
| 174 |
mod->in.change.logon_script = talloc_strdup(mem_ctx, logonscript); |
| 175 |
mod->in.change.fields |= USERMOD_FIELD_LOGON_SCRIPT; |
| 176 |
fldname = "logon_script"; |
| 177 |
break; |
| 178 |
|
| 179 |
case acct_profile_path: |
| 180 |
continue_if_field_set(mod->in.change.profile_path); |
| 181 |
mod->in.change.profile_path = talloc_asprintf(mem_ctx, TEST_CHG_PROFILEPATH, |
| 182 |
(long int)random(), (unsigned int)random()); |
| 183 |
mod->in.change.fields |= USERMOD_FIELD_PROFILE_PATH; |
| 184 |
fldname = "profile_path"; |
| 185 |
break; |
| 186 |
|
| 187 |
case acct_expiry: |
| 188 |
continue_if_field_set(mod->in.change.acct_expiry); |
| 189 |
now = timeval_add(&now, (random() % (31*24*60*60)), 0); |
| 190 |
mod->in.change.acct_expiry = (struct timeval *)talloc_memdup(mem_ctx, &now, sizeof(now)); |
| 191 |
mod->in.change.fields |= USERMOD_FIELD_ACCT_EXPIRY; |
| 192 |
fldname = "acct_expiry"; |
| 193 |
break; |
| 194 |
|
| 195 |
case acct_flags: |
| 196 |
continue_if_field_set(mod->in.change.acct_flags); |
| 197 |
mod->in.change.acct_flags = flags[random() % ARRAY_SIZE(flags)]; |
| 198 |
mod->in.change.fields |= USERMOD_FIELD_ACCT_FLAGS; |
| 199 |
fldname = "acct_flags"; |
| 200 |
break; |
| 201 |
|
| 202 |
default: |
| 203 |
fldname = talloc_asprintf(mem_ctx, "unknown_field (%d)", testfld); |
| 204 |
break; |
| 205 |
} |
| 206 |
|
| 207 |
torture_comment(tctx, ((i < num_changes - 1) ? "%s," : "%s"), fldname); |
| 208 |
} |
| 209 |
torture_comment(tctx, "]\n"); |
| 210 |
|
| 211 |
status = libnet_rpc_usermod(tctx->ev, p->binding_handle, mem_ctx, mod); |
| 212 |
torture_assert_ntstatus_ok(tctx, status, "Failed to call sync libnet_rpc_usermod"); |
| 213 |
|
| 214 |
return true; |
| 215 |
} |
| 216 |
|
| 217 |
|
| 218 |
static bool test_userdel(struct torture_context *tctx, |
| 219 |
struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, |
| 220 |
struct policy_handle *handle, const char *username) |
| 221 |
{ |
| 222 |
NTSTATUS status; |
| 223 |
struct libnet_rpc_userdel user; |
| 224 |
|
| 225 |
ZERO_STRUCT(user); |
| 226 |
|
| 227 |
user.in.domain_handle = *handle; |
| 228 |
user.in.username = username; |
| 229 |
|
| 230 |
status = libnet_rpc_userdel(tctx->ev, p->binding_handle, mem_ctx, &user); |
| 231 |
if (!NT_STATUS_IS_OK(status)) { |
| 232 |
torture_comment(tctx, "Failed to call sync libnet_rpc_userdel - %s\n", nt_errstr(status)); |
| 233 |
return false; |
| 234 |
} |
| 235 |
|
| 236 |
return true; |
| 237 |
} |
| 238 |
|
| 239 |
|
| 240 |
#define CMP_LSA_STRING_FLD(fld, flags) \ |
| 241 |
if ((mod->in.change.fields & flags) && \ |
| 242 |
!strequal(i->fld.string, mod->in.change.fld)) { \ |
| 243 |
torture_comment(tctx, "'%s' field does not match\n", #fld); \ |
| 244 |
torture_comment(tctx, "received: '%s'\n", i->fld.string); \ |
| 245 |
torture_comment(tctx, "expected: '%s'\n", mod->in.change.fld); \ |
| 246 |
return false; \ |
| 247 |
} |
| 248 |
|
| 249 |
|
| 250 |
#define CMP_TIME_FLD(fld, flags) \ |
| 251 |
if (mod->in.change.fields & flags) { \ |
| 252 |
nttime_to_timeval(&t, i->fld); \ |
| 253 |
if (timeval_compare(&t, mod->in.change.fld)) { \ |
| 254 |
torture_comment(tctx, "'%s' field does not match\n", #fld); \ |
| 255 |
torture_comment(tctx, "received: '%s (+%ld us)'\n", \ |
| 256 |
timestring(mem_ctx, t.tv_sec), (long)t.tv_usec); \ |
| 257 |
torture_comment(tctx, "expected: '%s (+%ld us)'\n", \ |
| 258 |
timestring(mem_ctx, mod->in.change.fld->tv_sec), \ |
| 259 |
(long)mod->in.change.fld->tv_usec); \ |
| 260 |
return false; \ |
| 261 |
} \ |
| 262 |
} |
| 263 |
|
| 264 |
#define CMP_NUM_FLD(fld, flags) \ |
| 265 |
if ((mod->in.change.fields & flags) && \ |
| 266 |
(i->fld != mod->in.change.fld)) { \ |
| 267 |
torture_comment(tctx, "'%s' field does not match\n", #fld); \ |
| 268 |
torture_comment(tctx, "received: '%04x'\n", i->fld); \ |
| 269 |
torture_comment(tctx, "expected: '%04x'\n", mod->in.change.fld); \ |
| 270 |
return false; \ |
| 271 |
} |
| 272 |
|
| 273 |
|
| 274 |
static bool test_compare(struct torture_context *tctx, |
| 275 |
struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, |
| 276 |
struct policy_handle *handle, struct libnet_rpc_usermod *mod, |
| 277 |
const char *username) |
| 278 |
{ |
| 279 |
NTSTATUS status; |
| 280 |
struct libnet_rpc_userinfo info; |
| 281 |
struct samr_UserInfo21 *i; |
| 282 |
struct timeval t; |
| 283 |
|
| 284 |
ZERO_STRUCT(info); |
| 285 |
|
| 286 |
info.in.username = username; |
| 287 |
info.in.domain_handle = *handle; |
| 288 |
info.in.level = 21; /* the most rich infolevel available */ |
| 289 |
|
| 290 |
status = libnet_rpc_userinfo(tctx->ev, p->binding_handle, mem_ctx, &info); |
| 291 |
torture_assert_ntstatus_ok(tctx, status, "Failed to call sync libnet_rpc_userinfo"); |
| 292 |
|
| 293 |
i = &info.out.info.info21; |
| 294 |
|
| 295 |
CMP_LSA_STRING_FLD(account_name, USERMOD_FIELD_ACCOUNT_NAME); |
| 296 |
CMP_LSA_STRING_FLD(full_name, USERMOD_FIELD_FULL_NAME); |
| 297 |
CMP_LSA_STRING_FLD(description, USERMOD_FIELD_DESCRIPTION); |
| 298 |
CMP_LSA_STRING_FLD(comment, USERMOD_FIELD_COMMENT); |
| 299 |
CMP_LSA_STRING_FLD(logon_script, USERMOD_FIELD_LOGON_SCRIPT); |
| 300 |
CMP_LSA_STRING_FLD(profile_path, USERMOD_FIELD_PROFILE_PATH); |
| 301 |
CMP_LSA_STRING_FLD(home_directory, USERMOD_FIELD_HOME_DIRECTORY); |
| 302 |
CMP_LSA_STRING_FLD(home_drive, USERMOD_FIELD_HOME_DRIVE); |
| 303 |
CMP_TIME_FLD(acct_expiry, USERMOD_FIELD_ACCT_EXPIRY); |
| 304 |
CMP_NUM_FLD(acct_flags, USERMOD_FIELD_ACCT_FLAGS) |
| 305 |
|
| 306 |
return true; |
| 307 |
} |
| 308 |
|
| 309 |
|
| 310 |
bool torture_useradd(struct torture_context *torture) |
| 311 |
{ |
| 312 |
NTSTATUS status; |
| 313 |
struct dcerpc_pipe *p; |
| 314 |
struct policy_handle h; |
| 315 |
struct lsa_String domain_name; |
| 316 |
struct dom_sid2 sid; |
| 317 |
const char *name = TEST_USERNAME; |
| 318 |
TALLOC_CTX *mem_ctx; |
| 319 |
bool ret = true; |
| 320 |
struct dcerpc_binding_handle *b; |
| 321 |
|
| 322 |
mem_ctx = talloc_init("test_useradd"); |
| 323 |
|
| 324 |
status = torture_rpc_connection(torture, |
| 325 |
&p, |
| 326 |
&ndr_table_samr); |
| 327 |
|
| 328 |
torture_assert_ntstatus_ok(torture, status, "RPC connect failed"); |
| 329 |
b = p->binding_handle; |
| 330 |
|
| 331 |
domain_name.string = lpcfg_workgroup(torture->lp_ctx); |
| 332 |
if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) { |
| 333 |
ret = false; |
| 334 |
goto done; |
| 335 |
} |
| 336 |
|
| 337 |
if (!test_useradd(torture, p, mem_ctx, &h, name)) { |
| 338 |
ret = false; |
| 339 |
goto done; |
| 340 |
} |
| 341 |
|
| 342 |
if (!test_user_cleanup(torture, b, mem_ctx, &h, name)) { |
| 343 |
ret = false; |
| 344 |
goto done; |
| 345 |
} |
| 346 |
|
| 347 |
if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) { |
| 348 |
ret = false; |
| 349 |
goto done; |
| 350 |
} |
| 351 |
|
| 352 |
if (!test_useradd_async(torture, p, mem_ctx, &h, name)) { |
| 353 |
ret = false; |
| 354 |
goto done; |
| 355 |
} |
| 356 |
|
| 357 |
if (!test_user_cleanup(torture, b, mem_ctx, &h, name)) { |
| 358 |
ret = false; |
| 359 |
goto done; |
| 360 |
} |
| 361 |
|
| 362 |
done: |
| 363 |
talloc_free(mem_ctx); |
| 364 |
return ret; |
| 365 |
} |
| 366 |
|
| 367 |
|
| 368 |
bool torture_userdel(struct torture_context *torture) |
| 369 |
{ |
| 370 |
NTSTATUS status; |
| 371 |
struct dcerpc_pipe *p; |
| 372 |
struct policy_handle h; |
| 373 |
struct lsa_String domain_name; |
| 374 |
struct dom_sid2 sid; |
| 375 |
uint32_t rid; |
| 376 |
const char *name = TEST_USERNAME; |
| 377 |
TALLOC_CTX *mem_ctx; |
| 378 |
bool ret = true; |
| 379 |
struct dcerpc_binding_handle *b; |
| 380 |
|
| 381 |
mem_ctx = talloc_init("test_userdel"); |
| 382 |
|
| 383 |
status = torture_rpc_connection(torture, |
| 384 |
&p, |
| 385 |
&ndr_table_samr); |
| 386 |
|
| 387 |
if (!NT_STATUS_IS_OK(status)) { |
| 388 |
return false; |
| 389 |
} |
| 390 |
b = p->binding_handle; |
| 391 |
|
| 392 |
domain_name.string = lpcfg_workgroup(torture->lp_ctx); |
| 393 |
if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) { |
| 394 |
ret = false; |
| 395 |
goto done; |
| 396 |
} |
| 397 |
|
| 398 |
if (!test_user_create(torture, b, mem_ctx, &h, name, &rid)) { |
| 399 |
ret = false; |
| 400 |
goto done; |
| 401 |
} |
| 402 |
|
| 403 |
if (!test_userdel(torture, p, mem_ctx, &h, name)) { |
| 404 |
ret = false; |
| 405 |
goto done; |
| 406 |
} |
| 407 |
|
| 408 |
done: |
| 409 |
talloc_free(mem_ctx); |
| 410 |
return ret; |
| 411 |
} |
| 412 |
|
| 413 |
|
| 414 |
bool torture_usermod(struct torture_context *torture) |
| 415 |
{ |
| 416 |
NTSTATUS status; |
| 417 |
struct dcerpc_pipe *p; |
| 418 |
struct policy_handle h; |
| 419 |
struct lsa_String domain_name; |
| 420 |
struct dom_sid2 sid; |
| 421 |
uint32_t rid; |
| 422 |
int i; |
| 423 |
char *name; |
| 424 |
TALLOC_CTX *mem_ctx; |
| 425 |
bool ret = true; |
| 426 |
struct dcerpc_binding_handle *b; |
| 427 |
|
| 428 |
mem_ctx = talloc_init("test_userdel"); |
| 429 |
|
| 430 |
status = torture_rpc_connection(torture, |
| 431 |
&p, |
| 432 |
&ndr_table_samr); |
| 433 |
|
| 434 |
torture_assert_ntstatus_ok(torture, status, "RPC connect"); |
| 435 |
b = p->binding_handle; |
| 436 |
|
| 437 |
domain_name.string = lpcfg_workgroup(torture->lp_ctx); |
| 438 |
name = talloc_strdup(mem_ctx, TEST_USERNAME); |
| 439 |
|
| 440 |
if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) { |
| 441 |
ret = false; |
| 442 |
goto done; |
| 443 |
} |
| 444 |
|
| 445 |
if (!test_user_create(torture, b, mem_ctx, &h, name, &rid)) { |
| 446 |
ret = false; |
| 447 |
goto done; |
| 448 |
} |
| 449 |
|
| 450 |
for (i = USER_FIELD_FIRST; i <= USER_FIELD_LAST; i++) { |
| 451 |
struct libnet_rpc_usermod m; |
| 452 |
|
| 453 |
if (!test_usermod(torture, p, mem_ctx, &h, i, &m, &name)) { |
| 454 |
ret = false; |
| 455 |
goto cleanup; |
| 456 |
} |
| 457 |
|
| 458 |
if (!test_compare(torture, p, mem_ctx, &h, &m, name)) { |
| 459 |
ret = false; |
| 460 |
goto cleanup; |
| 461 |
} |
| 462 |
} |
| 463 |
|
| 464 |
cleanup: |
| 465 |
if (!test_user_cleanup(torture, b, mem_ctx, &h, TEST_USERNAME)) { |
| 466 |
ret = false; |
| 467 |
goto done; |
| 468 |
} |
| 469 |
|
| 470 |
done: |
| 471 |
talloc_free(mem_ctx); |
| 472 |
return ret; |
| 473 |
} |