source: trunk/server/source4/torture/rpc/drsuapi.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 28.0 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 DRSUapi tests
5
6 Copyright (C) Andrew Tridgell 2003
7 Copyright (C) Stefan (metze) Metzmacher 2004
8 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2006
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22*/
23
24#include "includes.h"
25#include "librpc/gen_ndr/ndr_drsuapi_c.h"
26#include "torture/rpc/torture_rpc.h"
27#include "param/param.h"
28
29#define TEST_MACHINE_NAME "torturetest"
30
31bool test_DsBind(struct dcerpc_pipe *p,
32 struct torture_context *tctx,
33 struct DsPrivate *priv)
34{
35 NTSTATUS status;
36 struct drsuapi_DsBind r;
37 struct drsuapi_DsBindInfo28 *bind_info28;
38 struct drsuapi_DsBindInfoCtr bind_info_ctr;
39
40 ZERO_STRUCT(bind_info_ctr);
41 bind_info_ctr.length = 28;
42
43 bind_info28 = &bind_info_ctr.info.info28;
44 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
45 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION;
46 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI;
47 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2;
48 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS;
49 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1;
50 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
51 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
52 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
53 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
54 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2;
55 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD;
56 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND;
57 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO;
58 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION;
59 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01;
60 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP;
61 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
62 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
63 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
64 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
65 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS;
66 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8;
67 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5;
68 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6;
69 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
70 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
71 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
72
73 GUID_from_string(DRSUAPI_DS_BIND_GUID, &priv->bind_guid);
74
75 r.in.bind_guid = &priv->bind_guid;
76 r.in.bind_info = &bind_info_ctr;
77 r.out.bind_handle = &priv->bind_handle;
78
79 torture_comment(tctx, "Testing DsBind\n");
80
81 status = dcerpc_drsuapi_DsBind_r(p->binding_handle, tctx, &r);
82 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsBind");
83
84 /* cache server supported extensions, i.e. bind_info */
85 priv->srv_bind_info = r.out.bind_info->info.info28;
86
87 return true;
88}
89
90static bool test_DsGetDomainControllerInfo(struct torture_context *tctx,
91 struct DsPrivate *priv)
92{
93 NTSTATUS status;
94 struct dcerpc_pipe *p = priv->drs_pipe;
95 struct drsuapi_DsGetDomainControllerInfo r;
96 union drsuapi_DsGetDCInfoCtr ctr;
97 int32_t level_out = 0;
98 bool found = false;
99 int i, j, k;
100
101 struct {
102 const char *name;
103 WERROR expected;
104 } names[] = {
105 {
106 .name = torture_join_dom_netbios_name(priv->join),
107 .expected = WERR_OK
108 },
109 {
110 .name = torture_join_dom_dns_name(priv->join),
111 .expected = WERR_OK
112 },
113 {
114 .name = "__UNKNOWN_DOMAIN__",
115 .expected = WERR_DS_OBJ_NOT_FOUND
116 },
117 {
118 .name = "unknown.domain.samba.example.com",
119 .expected = WERR_DS_OBJ_NOT_FOUND
120 },
121 };
122 int levels[] = {1, 2};
123 int level;
124
125 for (i=0; i < ARRAY_SIZE(levels); i++) {
126 for (j=0; j < ARRAY_SIZE(names); j++) {
127 union drsuapi_DsGetDCInfoRequest req;
128 level = levels[i];
129 r.in.bind_handle = &priv->bind_handle;
130 r.in.level = 1;
131 r.in.req = &req;
132
133 r.in.req->req1.domain_name = names[j].name;
134 r.in.req->req1.level = level;
135
136 r.out.ctr = &ctr;
137 r.out.level_out = &level_out;
138
139 torture_comment(tctx,
140 "Testing DsGetDomainControllerInfo level %d on domainname '%s'\n",
141 r.in.req->req1.level, r.in.req->req1.domain_name);
142
143 status = dcerpc_drsuapi_DsGetDomainControllerInfo_r(p->binding_handle, tctx, &r);
144 torture_assert_ntstatus_ok(tctx, status,
145 "dcerpc_drsuapi_DsGetDomainControllerInfo with dns domain failed");
146 torture_assert_werr_equal(tctx,
147 r.out.result, names[j].expected,
148 "DsGetDomainControllerInfo level with dns domain failed");
149
150 if (!W_ERROR_IS_OK(r.out.result)) {
151 /* If this was an error, we can't read the result structure */
152 continue;
153 }
154
155 torture_assert_int_equal(tctx,
156 r.in.req->req1.level, *r.out.level_out,
157 "dcerpc_drsuapi_DsGetDomainControllerInfo in/out level differs");
158
159 switch (level) {
160 case 1:
161 for (k=0; k < r.out.ctr->ctr1.count; k++) {
162 if (strcasecmp_m(r.out.ctr->ctr1.array[k].netbios_name,
163 torture_join_netbios_name(priv->join)) == 0) {
164 found = true;
165 break;
166 }
167 }
168 break;
169 case 2:
170 for (k=0; k < r.out.ctr->ctr2.count; k++) {
171 if (strcasecmp_m(r.out.ctr->ctr2.array[k].netbios_name,
172 torture_join_netbios_name(priv->join)) == 0) {
173 found = true;
174 priv->dcinfo = r.out.ctr->ctr2.array[k];
175 break;
176 }
177 }
178 break;
179 }
180 torture_assert(tctx, found,
181 "dcerpc_drsuapi_DsGetDomainControllerInfo: Failed to find the domain controller we just created during the join");
182 }
183 }
184
185 r.in.bind_handle = &priv->bind_handle;
186 r.in.level = 1;
187
188 r.out.ctr = &ctr;
189 r.out.level_out = &level_out;
190
191 r.in.req->req1.domain_name = "__UNKNOWN_DOMAIN__"; /* This is clearly ignored for this level */
192 r.in.req->req1.level = -1;
193
194 torture_comment(tctx, "Testing DsGetDomainControllerInfo level %d on domainname '%s'\n",
195 r.in.req->req1.level, r.in.req->req1.domain_name);
196
197 status = dcerpc_drsuapi_DsGetDomainControllerInfo_r(p->binding_handle, tctx, &r);
198
199 torture_assert_ntstatus_ok(tctx, status,
200 "dcerpc_drsuapi_DsGetDomainControllerInfo with dns domain failed");
201 torture_assert_werr_ok(tctx, r.out.result,
202 "DsGetDomainControllerInfo with dns domain failed");
203
204 {
205 const char *dc_account = talloc_asprintf(tctx, "%s\\%s$",
206 torture_join_dom_netbios_name(priv->join),
207 priv->dcinfo.netbios_name);
208 torture_comment(tctx, "%s: Enum active LDAP sessions searching for %s\n", __func__, dc_account);
209 for (k=0; k < r.out.ctr->ctr01.count; k++) {
210 if (strcasecmp_m(r.out.ctr->ctr01.array[k].client_account,
211 dc_account)) {
212 found = true;
213 break;
214 }
215 }
216 torture_assert(tctx, found,
217 "dcerpc_drsuapi_DsGetDomainControllerInfo level: Failed to find the domain controller in last logon records");
218 }
219
220
221 return true;
222}
223
224static bool test_DsWriteAccountSpn(struct torture_context *tctx,
225 struct DsPrivate *priv)
226{
227 NTSTATUS status;
228 struct dcerpc_pipe *p = priv->drs_pipe;
229 struct drsuapi_DsWriteAccountSpn r;
230 union drsuapi_DsWriteAccountSpnRequest req;
231 struct drsuapi_DsNameString names[2];
232 union drsuapi_DsWriteAccountSpnResult res;
233 uint32_t level_out;
234
235 r.in.bind_handle = &priv->bind_handle;
236 r.in.level = 1;
237 r.in.req = &req;
238
239 torture_comment(tctx, "Testing DsWriteAccountSpn\n");
240
241 r.in.req->req1.operation = DRSUAPI_DS_SPN_OPERATION_ADD;
242 r.in.req->req1.unknown1 = 0;
243 r.in.req->req1.object_dn = priv->dcinfo.computer_dn;
244 r.in.req->req1.count = 2;
245 r.in.req->req1.spn_names = names;
246 names[0].str = talloc_asprintf(tctx, "smbtortureSPN/%s",priv->dcinfo.netbios_name);
247 names[1].str = talloc_asprintf(tctx, "smbtortureSPN/%s",priv->dcinfo.dns_name);
248
249 r.out.res = &res;
250 r.out.level_out = &level_out;
251
252 status = dcerpc_drsuapi_DsWriteAccountSpn_r(p->binding_handle, tctx, &r);
253 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsWriteAccountSpn");
254
255 r.in.req->req1.operation = DRSUAPI_DS_SPN_OPERATION_DELETE;
256 r.in.req->req1.unknown1 = 0;
257
258 status = dcerpc_drsuapi_DsWriteAccountSpn_r(p->binding_handle, tctx, &r);
259 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsWriteAccountSpn");
260
261 return true;
262}
263
264static bool test_DsReplicaGetInfo(struct torture_context *tctx,
265 struct DsPrivate *priv)
266{
267 NTSTATUS status;
268 struct dcerpc_pipe *p = priv->drs_pipe;
269 struct drsuapi_DsReplicaGetInfo r;
270 union drsuapi_DsReplicaGetInfoRequest req;
271 union drsuapi_DsReplicaInfo info;
272 enum drsuapi_DsReplicaInfoType info_type;
273 int i;
274 struct {
275 int32_t level;
276 int32_t infotype;
277 const char *obj_dn;
278 } array[] = {
279 {
280 DRSUAPI_DS_REPLICA_GET_INFO,
281 DRSUAPI_DS_REPLICA_INFO_NEIGHBORS,
282 NULL
283 },{
284 DRSUAPI_DS_REPLICA_GET_INFO,
285 DRSUAPI_DS_REPLICA_INFO_CURSORS,
286 NULL
287 },{
288 DRSUAPI_DS_REPLICA_GET_INFO,
289 DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA,
290 NULL
291 },{
292 DRSUAPI_DS_REPLICA_GET_INFO,
293 DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES,
294 NULL
295 },{
296 DRSUAPI_DS_REPLICA_GET_INFO,
297 DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES,
298 NULL
299 },{
300 DRSUAPI_DS_REPLICA_GET_INFO,
301 DRSUAPI_DS_REPLICA_INFO_PENDING_OPS,
302 NULL
303 },{
304 DRSUAPI_DS_REPLICA_GET_INFO2,
305 DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA,
306 NULL
307 },{
308 DRSUAPI_DS_REPLICA_GET_INFO2,
309 DRSUAPI_DS_REPLICA_INFO_CURSORS2,
310 NULL
311 },{
312 DRSUAPI_DS_REPLICA_GET_INFO2,
313 DRSUAPI_DS_REPLICA_INFO_CURSORS3,
314 NULL
315 },{
316 DRSUAPI_DS_REPLICA_GET_INFO2,
317 DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2,
318 NULL
319 },{
320 DRSUAPI_DS_REPLICA_GET_INFO2,
321 DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2,
322 NULL
323 },{
324 DRSUAPI_DS_REPLICA_GET_INFO2,
325 DRSUAPI_DS_REPLICA_INFO_REPSTO,
326 NULL
327 },{
328 DRSUAPI_DS_REPLICA_GET_INFO2,
329 DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS,
330 "__IGNORED__"
331 },{
332 DRSUAPI_DS_REPLICA_GET_INFO2,
333 DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1,
334 NULL
335 },{
336 DRSUAPI_DS_REPLICA_GET_INFO2,
337 DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS,
338 NULL
339 }
340 };
341
342 if (torture_setting_bool(tctx, "samba4", false)) {
343 torture_comment(tctx, "skipping DsReplicaGetInfo test against Samba4\n");
344 return true;
345 }
346
347 r.in.bind_handle = &priv->bind_handle;
348 r.in.req = &req;
349
350 for (i=0; i < ARRAY_SIZE(array); i++) {
351 const char *object_dn;
352
353 torture_comment(tctx, "Testing DsReplicaGetInfo level %d infotype %d\n",
354 array[i].level, array[i].infotype);
355
356 object_dn = (array[i].obj_dn ? array[i].obj_dn : priv->domain_obj_dn);
357
358 r.in.level = array[i].level;
359 switch(r.in.level) {
360 case DRSUAPI_DS_REPLICA_GET_INFO:
361 r.in.req->req1.info_type = array[i].infotype;
362 r.in.req->req1.object_dn = object_dn;
363 ZERO_STRUCT(r.in.req->req1.source_dsa_guid);
364 break;
365 case DRSUAPI_DS_REPLICA_GET_INFO2:
366 r.in.req->req2.info_type = array[i].infotype;
367 r.in.req->req2.object_dn = object_dn;
368 ZERO_STRUCT(r.in.req->req2.source_dsa_guid);
369 r.in.req->req2.flags = 0;
370 r.in.req->req2.attribute_name = NULL;
371 r.in.req->req2.value_dn_str = NULL;
372 r.in.req->req2.enumeration_context = 0;
373 break;
374 }
375
376 r.out.info = &info;
377 r.out.info_type = &info_type;
378
379 status = dcerpc_drsuapi_DsReplicaGetInfo_r(p->binding_handle, tctx, &r);
380 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsReplicaGetInfo");
381 if (NT_STATUS_EQUAL(status, NT_STATUS_RPC_ENUM_VALUE_OUT_OF_RANGE)) {
382 torture_comment(tctx,
383 "DsReplicaGetInfo level %d and/or infotype %d not supported by server\n",
384 array[i].level, array[i].infotype);
385 } else {
386 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsReplicaGetInfo");
387 }
388 }
389
390 return true;
391}
392
393static bool test_DsReplicaSync(struct torture_context *tctx,
394 struct DsPrivate *priv)
395{
396 NTSTATUS status;
397 struct dcerpc_pipe *p = priv->drs_pipe;
398 int i;
399 struct drsuapi_DsReplicaSync r;
400 union drsuapi_DsReplicaSyncRequest sync_req;
401 struct drsuapi_DsReplicaObjectIdentifier nc;
402 struct GUID null_guid;
403 struct dom_sid null_sid;
404 struct {
405 int32_t level;
406 } array[] = {
407 {
408 1
409 }
410 };
411
412 if (!torture_setting_bool(tctx, "dangerous", false)) {
413 torture_comment(tctx, "DsReplicaSync disabled - enable dangerous tests to use\n");
414 return true;
415 }
416
417 if (torture_setting_bool(tctx, "samba4", false)) {
418 torture_comment(tctx, "skipping DsReplicaSync test against Samba4\n");
419 return true;
420 }
421
422 ZERO_STRUCT(null_guid);
423 ZERO_STRUCT(null_sid);
424
425 r.in.bind_handle = &priv->bind_handle;
426
427 for (i=0; i < ARRAY_SIZE(array); i++) {
428 torture_comment(tctx, "Testing DsReplicaSync level %d\n",
429 array[i].level);
430
431 r.in.level = array[i].level;
432 switch(r.in.level) {
433 case 1:
434 nc.guid = null_guid;
435 nc.sid = null_sid;
436 nc.dn = priv->domain_obj_dn?priv->domain_obj_dn:"";
437
438 sync_req.req1.naming_context = &nc;
439 sync_req.req1.source_dsa_guid = priv->dcinfo.ntds_guid;
440 sync_req.req1.source_dsa_dns = NULL;
441 sync_req.req1.options = 16;
442
443 r.in.req = &sync_req;
444 break;
445 }
446
447 status = dcerpc_drsuapi_DsReplicaSync_r(p->binding_handle, tctx, &r);
448 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsReplicaSync");
449 }
450
451 return true;
452}
453
454static bool test_DsReplicaUpdateRefs(struct torture_context *tctx,
455 struct DsPrivate *priv)
456{
457 NTSTATUS status;
458 struct dcerpc_pipe *p = priv->drs_pipe;
459 struct drsuapi_DsReplicaUpdateRefs r;
460 struct drsuapi_DsReplicaObjectIdentifier nc;
461 struct GUID null_guid;
462 struct GUID dest_dsa_guid;
463 const char *dest_dsa_guid_str;
464 struct dom_sid null_sid;
465
466 ZERO_STRUCT(null_guid);
467 ZERO_STRUCT(null_sid);
468 dest_dsa_guid = GUID_random();
469 dest_dsa_guid_str = GUID_string(tctx, &dest_dsa_guid);
470
471 r.in.bind_handle = &priv->bind_handle;
472 r.in.level = 1; /* Only version 1 is defined presently */
473
474 /* setup NC */
475 nc.guid = priv->domain_obj_dn ? null_guid : priv->domain_guid;
476 nc.sid = null_sid;
477 nc.dn = priv->domain_obj_dn ? priv->domain_obj_dn : "";
478
479 /* default setup for request */
480 r.in.req.req1.naming_context = &nc;
481 r.in.req.req1.dest_dsa_dns_name = talloc_asprintf(tctx, "%s._msdn.%s",
482 dest_dsa_guid_str,
483 priv->domain_dns_name);
484 r.in.req.req1.dest_dsa_guid = dest_dsa_guid;
485
486 /* 1. deleting replica dest should fail */
487 torture_comment(tctx, "delete: %s\n", r.in.req.req1.dest_dsa_dns_name);
488 r.in.req.req1.options = DRSUAPI_DRS_DEL_REF;
489 status = dcerpc_drsuapi_DsReplicaUpdateRefs_r(p->binding_handle, tctx, &r);
490 torture_drsuapi_assert_call_werr(tctx, p,
491 status, WERR_DS_DRA_REF_NOT_FOUND, &r,
492 "dcerpc_drsuapi_DsReplicaUpdateRefs");
493
494 /* 2. hopefully adding random replica dest should succeed */
495 torture_comment(tctx, "add : %s\n", r.in.req.req1.dest_dsa_dns_name);
496 r.in.req.req1.options = DRSUAPI_DRS_ADD_REF;
497 status = dcerpc_drsuapi_DsReplicaUpdateRefs_r(p->binding_handle, tctx, &r);
498 torture_drsuapi_assert_call_werr(tctx, p,
499 status, WERR_OK, &r,
500 "dcerpc_drsuapi_DsReplicaUpdateRefs");
501
502 /* 3. try adding same replica dest - should fail */
503 torture_comment(tctx, "add : %s\n", r.in.req.req1.dest_dsa_dns_name);
504 r.in.req.req1.options = DRSUAPI_DRS_ADD_REF;
505 status = dcerpc_drsuapi_DsReplicaUpdateRefs_r(p->binding_handle, tctx, &r);
506 torture_drsuapi_assert_call_werr(tctx, p,
507 status, WERR_DS_DRA_REF_ALREADY_EXISTS, &r,
508 "dcerpc_drsuapi_DsReplicaUpdateRefs");
509
510 /* 4. try resetting same replica dest - should succeed */
511 torture_comment(tctx, "reset : %s\n", r.in.req.req1.dest_dsa_dns_name);
512 r.in.req.req1.options = DRSUAPI_DRS_DEL_REF | DRSUAPI_DRS_ADD_REF;
513 status = dcerpc_drsuapi_DsReplicaUpdateRefs_r(p->binding_handle, tctx, &r);
514 torture_drsuapi_assert_call_werr(tctx, p,
515 status, WERR_OK, &r,
516 "dcerpc_drsuapi_DsReplicaUpdateRefs");
517
518 /* 5. delete random replicate added at step 2. */
519 torture_comment(tctx, "delete : %s\n", r.in.req.req1.dest_dsa_dns_name);
520 r.in.req.req1.options = DRSUAPI_DRS_DEL_REF;
521 status = dcerpc_drsuapi_DsReplicaUpdateRefs_r(p->binding_handle, tctx, &r);
522 torture_drsuapi_assert_call_werr(tctx, p,
523 status, WERR_OK, &r,
524 "dcerpc_drsuapi_DsReplicaUpdateRefs");
525
526 /* 6. try replace on non-existing replica dest - should succeed */
527 torture_comment(tctx, "replace: %s\n", r.in.req.req1.dest_dsa_dns_name);
528 r.in.req.req1.options = DRSUAPI_DRS_DEL_REF | DRSUAPI_DRS_ADD_REF;
529 status = dcerpc_drsuapi_DsReplicaUpdateRefs_r(p->binding_handle, tctx, &r);
530 torture_drsuapi_assert_call_werr(tctx, p,
531 status, WERR_OK, &r,
532 "dcerpc_drsuapi_DsReplicaUpdateRefs");
533
534 /* 7. delete random replicate added at step 6. */
535 torture_comment(tctx, "delete : %s\n", r.in.req.req1.dest_dsa_dns_name);
536 r.in.req.req1.options = DRSUAPI_DRS_DEL_REF;
537 status = dcerpc_drsuapi_DsReplicaUpdateRefs_r(p->binding_handle, tctx, &r);
538 torture_drsuapi_assert_call_werr(tctx, p,
539 status, WERR_OK, &r,
540 "dcerpc_drsuapi_DsReplicaUpdateRefs");
541
542 return true;
543}
544
545static bool test_DsGetNCChanges(struct torture_context *tctx,
546 struct DsPrivate *priv)
547{
548 NTSTATUS status;
549 struct dcerpc_pipe *p = priv->drs_pipe;
550 int i;
551 struct drsuapi_DsGetNCChanges r;
552 union drsuapi_DsGetNCChangesRequest req;
553 union drsuapi_DsGetNCChangesCtr ctr;
554 struct drsuapi_DsReplicaObjectIdentifier nc;
555 struct GUID null_guid;
556 struct dom_sid null_sid;
557 uint32_t level_out;
558 struct {
559 uint32_t level;
560 } array[] = {
561 {
562 5
563 },
564 {
565 8
566 }
567 };
568
569 if (torture_setting_bool(tctx, "samba4", false)) {
570 torture_comment(tctx, "skipping DsGetNCChanges test against Samba4\n");
571 return true;
572 }
573
574 ZERO_STRUCT(null_guid);
575 ZERO_STRUCT(null_sid);
576
577 for (i=0; i < ARRAY_SIZE(array); i++) {
578 torture_comment(tctx,
579 "Testing DsGetNCChanges level %d\n",
580 array[i].level);
581
582 r.in.bind_handle = &priv->bind_handle;
583 r.in.level = array[i].level;
584 r.out.level_out = &level_out;
585 r.out.ctr = &ctr;
586
587 switch (r.in.level) {
588 case 5:
589 nc.guid = null_guid;
590 nc.sid = null_sid;
591 nc.dn = priv->domain_obj_dn ? priv->domain_obj_dn : "";
592
593 r.in.req = &req;
594 r.in.req->req5.destination_dsa_guid = GUID_random();
595 r.in.req->req5.source_dsa_invocation_id = null_guid;
596 r.in.req->req5.naming_context = &nc;
597 r.in.req->req5.highwatermark.tmp_highest_usn = 0;
598 r.in.req->req5.highwatermark.reserved_usn = 0;
599 r.in.req->req5.highwatermark.highest_usn = 0;
600 r.in.req->req5.uptodateness_vector = NULL;
601 r.in.req->req5.replica_flags = 0;
602 if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "compression", false)) {
603 r.in.req->req5.replica_flags |= DRSUAPI_DRS_USE_COMPRESSION;
604 }
605 r.in.req->req5.max_object_count = 0;
606 r.in.req->req5.max_ndr_size = 0;
607 r.in.req->req5.extended_op = DRSUAPI_EXOP_NONE;
608 r.in.req->req5.fsmo_info = 0;
609
610 break;
611 case 8:
612 nc.guid = null_guid;
613 nc.sid = null_sid;
614 nc.dn = priv->domain_obj_dn ? priv->domain_obj_dn : "";
615
616 r.in.req = &req;
617 r.in.req->req8.destination_dsa_guid = GUID_random();
618 r.in.req->req8.source_dsa_invocation_id = null_guid;
619 r.in.req->req8.naming_context = &nc;
620 r.in.req->req8.highwatermark.tmp_highest_usn = 0;
621 r.in.req->req8.highwatermark.reserved_usn = 0;
622 r.in.req->req8.highwatermark.highest_usn = 0;
623 r.in.req->req8.uptodateness_vector = NULL;
624 r.in.req->req8.replica_flags = 0;
625 if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "compression", false)) {
626 r.in.req->req8.replica_flags |= DRSUAPI_DRS_USE_COMPRESSION;
627 }
628 if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "neighbour_writeable", true)) {
629 r.in.req->req8.replica_flags |= DRSUAPI_DRS_WRIT_REP;
630 }
631 r.in.req->req8.replica_flags |= DRSUAPI_DRS_INIT_SYNC
632 | DRSUAPI_DRS_PER_SYNC
633 | DRSUAPI_DRS_GET_ANC
634 | DRSUAPI_DRS_NEVER_SYNCED
635 ;
636 r.in.req->req8.max_object_count = 402;
637 r.in.req->req8.max_ndr_size = 402116;
638 r.in.req->req8.extended_op = DRSUAPI_EXOP_NONE;
639 r.in.req->req8.fsmo_info = 0;
640 r.in.req->req8.partial_attribute_set = NULL;
641 r.in.req->req8.partial_attribute_set_ex = NULL;
642 r.in.req->req8.mapping_ctr.num_mappings = 0;
643 r.in.req->req8.mapping_ctr.mappings = NULL;
644
645 break;
646 }
647
648 status = dcerpc_drsuapi_DsGetNCChanges_r(p->binding_handle, tctx, &r);
649 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsGetNCChanges");
650 }
651
652 return true;
653}
654
655bool test_QuerySitesByCost(struct torture_context *tctx,
656 struct DsPrivate *priv)
657{
658 NTSTATUS status;
659 struct dcerpc_pipe *p = priv->drs_pipe;
660 struct drsuapi_QuerySitesByCost r;
661 union drsuapi_QuerySitesByCostRequest req;
662
663 const char *my_site = "Default-First-Site-Name";
664 const char *remote_site1 = "smbtorture-nonexisting-site1";
665 const char *remote_site2 = "smbtorture-nonexisting-site2";
666
667 req.req1.site_from = talloc_strdup(tctx, my_site);
668 req.req1.num_req = 2;
669 req.req1.site_to = talloc_zero_array(tctx, const char *, 2);
670 req.req1.site_to[0] = talloc_strdup(tctx, remote_site1);
671 req.req1.site_to[1] = talloc_strdup(tctx, remote_site2);
672 req.req1.flags = 0;
673
674 r.in.bind_handle = &priv->bind_handle;
675 r.in.level = 1;
676 r.in.req = &req;
677
678 status = dcerpc_drsuapi_QuerySitesByCost_r(p->binding_handle, tctx, &r);
679 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_QuerySitesByCost");
680
681 if (W_ERROR_IS_OK(r.out.result)) {
682 torture_assert_werr_equal(tctx,
683 r.out.ctr->ctr1.info[0].error_code, WERR_DS_OBJ_NOT_FOUND,
684 "dcerpc_drsuapi_QuerySitesByCost");
685 torture_assert_werr_equal(tctx,
686 r.out.ctr->ctr1.info[1].error_code, WERR_DS_OBJ_NOT_FOUND,
687 "dcerpc_drsuapi_QuerySitesByCost expected error_code WERR_DS_OBJ_NOT_FOUND");
688
689 torture_assert_int_equal(tctx,
690 r.out.ctr->ctr1.info[0].site_cost, -1,
691 "dcerpc_drsuapi_QuerySitesByCost");
692 torture_assert_int_equal(tctx,
693 r.out.ctr->ctr1.info[1].site_cost, -1,
694 "dcerpc_drsuapi_QuerySitesByCost exptected site cost");
695 }
696
697 return true;
698
699
700}
701
702bool test_DsUnbind(struct dcerpc_pipe *p,
703 struct torture_context *tctx,
704 struct DsPrivate *priv)
705{
706 NTSTATUS status;
707 struct drsuapi_DsUnbind r;
708
709 r.in.bind_handle = &priv->bind_handle;
710 r.out.bind_handle = &priv->bind_handle;
711
712 torture_comment(tctx, "Testing DsUnbind\n");
713
714 status = dcerpc_drsuapi_DsUnbind_r(p->binding_handle, tctx, &r);
715 torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsUnbind");
716
717 return true;
718}
719
720
721/**
722 * Helper func to collect DC information for testing purposes.
723 * This function is almost identical to test_DsGetDomainControllerInfo
724 */
725bool torture_rpc_drsuapi_get_dcinfo(struct torture_context *torture,
726 struct DsPrivate *priv)
727{
728 NTSTATUS status;
729 int32_t level_out = 0;
730 struct drsuapi_DsGetDomainControllerInfo r;
731 union drsuapi_DsGetDCInfoCtr ctr;
732 int j, k;
733 const char *names[] = {
734 torture_join_dom_netbios_name(priv->join),
735 torture_join_dom_dns_name(priv->join)};
736
737 for (j=0; j < ARRAY_SIZE(names); j++) {
738 union drsuapi_DsGetDCInfoRequest req;
739 struct dcerpc_binding_handle *b = priv->drs_pipe->binding_handle;
740 r.in.bind_handle = &priv->bind_handle;
741 r.in.level = 1;
742 r.in.req = &req;
743
744 r.in.req->req1.domain_name = names[j];
745 r.in.req->req1.level = 2;
746
747 r.out.ctr = &ctr;
748 r.out.level_out = &level_out;
749
750 status = dcerpc_drsuapi_DsGetDomainControllerInfo_r(b, torture, &r);
751 if (!NT_STATUS_IS_OK(status)) {
752 continue;
753 }
754 if (!W_ERROR_IS_OK(r.out.result)) {
755 /* If this was an error, we can't read the result structure */
756 continue;
757 }
758
759 for (k=0; k < r.out.ctr->ctr2.count; k++) {
760 if (strcasecmp_m(r.out.ctr->ctr2.array[k].netbios_name,
761 torture_join_netbios_name(priv->join)) == 0) {
762 priv->dcinfo = r.out.ctr->ctr2.array[k];
763 return true;
764 }
765 }
766 }
767
768 return false;
769}
770
771/**
772 * Common test case setup function to be used
773 * in DRS suit of test when appropriate
774 */
775bool torture_drsuapi_tcase_setup_common(struct torture_context *tctx, struct DsPrivate *priv)
776{
777 NTSTATUS status;
778 struct cli_credentials *machine_credentials;
779
780 torture_assert(tctx, priv, "Invalid argument");
781
782 torture_comment(tctx, "Create DRSUAPI pipe\n");
783 status = torture_rpc_connection(tctx,
784 &priv->drs_pipe,
785 &ndr_table_drsuapi);
786 torture_assert(tctx, NT_STATUS_IS_OK(status), "Unable to connect to DRSUAPI pipe");
787
788 torture_comment(tctx, "About to join domain\n");
789 priv->join = torture_join_domain(tctx, TEST_MACHINE_NAME, ACB_SVRTRUST,
790 &machine_credentials);
791 torture_assert(tctx, priv->join, "Failed to join as BDC");
792
793 if (!test_DsBind(priv->drs_pipe, tctx, priv)) {
794 /* clean up */
795 torture_drsuapi_tcase_teardown_common(tctx, priv);
796 torture_fail(tctx, "Failed execute test_DsBind()");
797 }
798
799 /* try collect some information for testing */
800 torture_rpc_drsuapi_get_dcinfo(tctx, priv);
801
802 return true;
803}
804
805/**
806 * Common test case teardown function to be used
807 * in DRS suit of test when appropriate
808 */
809bool torture_drsuapi_tcase_teardown_common(struct torture_context *tctx, struct DsPrivate *priv)
810{
811 if (priv->join) {
812 torture_leave_domain(tctx, priv->join);
813 }
814
815 return true;
816}
817
818/**
819 * Test case setup for DRSUAPI test case
820 */
821static bool torture_drsuapi_tcase_setup(struct torture_context *tctx, void **data)
822{
823 struct DsPrivate *priv;
824
825 *data = priv = talloc_zero(tctx, struct DsPrivate);
826
827 return torture_drsuapi_tcase_setup_common(tctx, priv);
828}
829
830/**
831 * Test case tear-down for DRSUAPI test case
832 */
833static bool torture_drsuapi_tcase_teardown(struct torture_context *tctx, void *data)
834{
835 bool ret;
836 struct DsPrivate *priv = talloc_get_type(data, struct DsPrivate);
837
838 ret = torture_drsuapi_tcase_teardown_common(tctx, priv);
839
840 talloc_free(priv);
841 return ret;
842}
843
844/**
845 * DRSUAPI test case implementation
846 */
847void torture_rpc_drsuapi_tcase(struct torture_suite *suite)
848{
849 typedef bool (*run_func) (struct torture_context *test, void *tcase_data);
850
851 struct torture_test *test;
852 struct torture_tcase *tcase = torture_suite_add_tcase(suite, "drsuapi");
853
854 torture_tcase_set_fixture(tcase, torture_drsuapi_tcase_setup,
855 torture_drsuapi_tcase_teardown);
856
857#if 0
858 test = torture_tcase_add_simple_test(tcase, "QuerySitesByCost", (run_func)test_QuerySitesByCost);
859#endif
860
861 test = torture_tcase_add_simple_test(tcase, "DsGetDomainControllerInfo", (run_func)test_DsGetDomainControllerInfo);
862
863 test = torture_tcase_add_simple_test(tcase, "DsCrackNames", (run_func)test_DsCrackNames);
864
865 test = torture_tcase_add_simple_test(tcase, "DsWriteAccountSpn", (run_func)test_DsWriteAccountSpn);
866
867 test = torture_tcase_add_simple_test(tcase, "DsReplicaGetInfo", (run_func)test_DsReplicaGetInfo);
868
869 test = torture_tcase_add_simple_test(tcase, "DsReplicaSync", (run_func)test_DsReplicaSync);
870
871 test = torture_tcase_add_simple_test(tcase, "DsReplicaUpdateRefs", (run_func)test_DsReplicaUpdateRefs);
872
873 test = torture_tcase_add_simple_test(tcase, "DsGetNCChanges", (run_func)test_DsGetNCChanges);
874}
Note: See TracBrowser for help on using the repository browser.