Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : SMB torture tester
4 : Copyright (C) Andrew Tridgell 1997-2003
5 : Copyright (C) Jelmer Vernooij 2006
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 "lib/cmdline/cmdline.h"
23 : #include "torture/rpc/torture_rpc.h"
24 : #include "torture/smbtorture.h"
25 : #include "librpc/ndr/ndr_table.h"
26 : #include "../lib/util/dlinklist.h"
27 :
28 536 : static bool torture_rpc_teardown (struct torture_context *tcase,
29 : void *data)
30 : {
31 536 : struct torture_rpc_tcase_data *tcase_data =
32 : (struct torture_rpc_tcase_data *)data;
33 536 : if (tcase_data->join_ctx != NULL)
34 100 : torture_leave_domain(tcase, tcase_data->join_ctx);
35 536 : talloc_free(tcase_data);
36 536 : return true;
37 : }
38 :
39 : /**
40 : * Obtain the DCE/RPC binding context associated with a torture context.
41 : *
42 : * @param tctx Torture context
43 : * @param binding Pointer to store DCE/RPC binding
44 : */
45 2777 : NTSTATUS torture_rpc_binding(struct torture_context *tctx,
46 : struct dcerpc_binding **binding)
47 : {
48 : NTSTATUS status;
49 2777 : const char *binding_string = torture_setting_string(tctx, "binding",
50 : NULL);
51 :
52 2777 : if (binding_string == NULL) {
53 0 : torture_comment(tctx,
54 : "You must specify a DCE/RPC binding string\n");
55 0 : return NT_STATUS_INVALID_PARAMETER;
56 : }
57 :
58 2777 : status = dcerpc_parse_binding(tctx, binding_string, binding);
59 2777 : if (NT_STATUS_IS_ERR(status)) {
60 0 : torture_comment(tctx,
61 : "Failed to parse dcerpc binding '%s'\n",
62 : binding_string);
63 0 : return status;
64 : }
65 :
66 2777 : return NT_STATUS_OK;
67 : }
68 :
69 : /**
70 : * open a rpc connection to the chosen binding string
71 : */
72 909 : _PUBLIC_ NTSTATUS torture_rpc_connection(struct torture_context *tctx,
73 : struct dcerpc_pipe **p,
74 : const struct ndr_interface_table *table)
75 : {
76 : NTSTATUS status;
77 : struct dcerpc_binding *binding;
78 :
79 909 : status = torture_rpc_binding(tctx, &binding);
80 909 : if (NT_STATUS_IS_ERR(status)) {
81 0 : return status;
82 : }
83 :
84 909 : return torture_rpc_connection_with_binding(tctx, binding, p, table);
85 : }
86 :
87 : /**
88 : * open a rpc connection to the chosen binding string
89 : */
90 909 : _PUBLIC_ NTSTATUS torture_rpc_connection_with_binding(struct torture_context *tctx,
91 : struct dcerpc_binding *binding,
92 : struct dcerpc_pipe **p,
93 : const struct ndr_interface_table *table)
94 : {
95 : NTSTATUS status;
96 :
97 909 : dcerpc_init();
98 :
99 909 : status = dcerpc_pipe_connect_b(tctx,
100 : p, binding, table,
101 : samba_cmdline_get_creds(),
102 : tctx->ev, tctx->lp_ctx);
103 :
104 909 : if (NT_STATUS_IS_ERR(status)) {
105 158 : torture_warning(tctx, "Failed to connect to remote server: %s %s\n",
106 : dcerpc_binding_string(tctx, binding), nt_errstr(status));
107 : }
108 :
109 909 : return status;
110 : }
111 :
112 : /**
113 : * open a rpc connection to a specific transport
114 : */
115 72 : NTSTATUS torture_rpc_connection_transport(struct torture_context *tctx,
116 : struct dcerpc_pipe **p,
117 : const struct ndr_interface_table *table,
118 : enum dcerpc_transport_t transport,
119 : uint32_t assoc_group_id,
120 : uint32_t extra_flags)
121 : {
122 : NTSTATUS status;
123 : struct dcerpc_binding *binding;
124 :
125 72 : *p = NULL;
126 :
127 72 : status = torture_rpc_binding(tctx, &binding);
128 72 : if (!NT_STATUS_IS_OK(status)) {
129 0 : return status;
130 : }
131 :
132 72 : status = dcerpc_binding_set_transport(binding, transport);
133 72 : if (!NT_STATUS_IS_OK(status)) {
134 0 : return status;
135 : }
136 :
137 72 : status = dcerpc_binding_set_assoc_group_id(binding, assoc_group_id);
138 72 : if (!NT_STATUS_IS_OK(status)) {
139 0 : return status;
140 : }
141 :
142 72 : status = dcerpc_binding_set_flags(binding, extra_flags, 0);
143 72 : if (!NT_STATUS_IS_OK(status)) {
144 0 : return status;
145 : }
146 :
147 72 : status = dcerpc_pipe_connect_b(tctx, p, binding, table,
148 : samba_cmdline_get_creds(),
149 : tctx->ev, tctx->lp_ctx);
150 72 : if (!NT_STATUS_IS_OK(status)) {
151 18 : *p = NULL;
152 18 : return status;
153 : }
154 :
155 54 : return NT_STATUS_OK;
156 : }
157 :
158 45 : static bool torture_rpc_setup_machine_workstation(struct torture_context *tctx,
159 : void **data)
160 : {
161 : NTSTATUS status;
162 : struct dcerpc_binding *binding;
163 45 : struct torture_rpc_tcase *tcase = talloc_get_type(tctx->active_tcase,
164 : struct torture_rpc_tcase);
165 : struct torture_rpc_tcase_data *tcase_data;
166 :
167 45 : status = torture_rpc_binding(tctx, &binding);
168 45 : if (NT_STATUS_IS_ERR(status))
169 0 : return false;
170 :
171 45 : *data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
172 45 : tcase_data->credentials = samba_cmdline_get_creds();
173 45 : tcase_data->join_ctx = torture_join_domain(tctx, tcase->machine_name,
174 : ACB_WSTRUST,
175 : &tcase_data->credentials);
176 45 : if (tcase_data->join_ctx == NULL)
177 0 : torture_fail(tctx, "Failed to join as WORKSTATION");
178 :
179 45 : status = dcerpc_pipe_connect_b(tctx,
180 : &(tcase_data->pipe),
181 : binding,
182 : tcase->table,
183 : tcase_data->credentials, tctx->ev, tctx->lp_ctx);
184 :
185 45 : torture_assert_ntstatus_ok(tctx, status, "Error connecting to server");
186 :
187 45 : return NT_STATUS_IS_OK(status);
188 : }
189 :
190 55 : static bool torture_rpc_setup_machine_bdc(struct torture_context *tctx,
191 : void **data)
192 : {
193 : NTSTATUS status;
194 : struct dcerpc_binding *binding;
195 55 : struct torture_rpc_tcase *tcase = talloc_get_type(tctx->active_tcase,
196 : struct torture_rpc_tcase);
197 : struct torture_rpc_tcase_data *tcase_data;
198 :
199 55 : status = torture_rpc_binding(tctx, &binding);
200 55 : if (NT_STATUS_IS_ERR(status))
201 0 : return false;
202 :
203 55 : *data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
204 55 : tcase_data->credentials = samba_cmdline_get_creds();
205 55 : tcase_data->join_ctx = torture_join_domain(tctx, tcase->machine_name,
206 : ACB_SVRTRUST,
207 : &tcase_data->credentials);
208 55 : if (tcase_data->join_ctx == NULL)
209 0 : torture_fail(tctx, "Failed to join as BDC");
210 :
211 55 : status = dcerpc_pipe_connect_b(tctx,
212 : &(tcase_data->pipe),
213 : binding,
214 : tcase->table,
215 : tcase_data->credentials, tctx->ev, tctx->lp_ctx);
216 :
217 55 : torture_assert_ntstatus_ok(tctx, status, "Error connecting to server");
218 :
219 55 : return NT_STATUS_IS_OK(status);
220 : }
221 :
222 8736 : _PUBLIC_ struct torture_rpc_tcase *torture_suite_add_machine_workstation_rpc_iface_tcase(
223 : struct torture_suite *suite,
224 : const char *name,
225 : const struct ndr_interface_table *table,
226 : const char *machine_name)
227 : {
228 8736 : struct torture_rpc_tcase *tcase = talloc(suite,
229 : struct torture_rpc_tcase);
230 :
231 8736 : torture_suite_init_rpc_tcase(suite, tcase, name, table);
232 :
233 8736 : tcase->machine_name = talloc_strdup(tcase, machine_name);
234 8736 : tcase->tcase.setup = torture_rpc_setup_machine_workstation;
235 8736 : tcase->tcase.teardown = torture_rpc_teardown;
236 :
237 8736 : return tcase;
238 : }
239 :
240 12080 : _PUBLIC_ struct torture_rpc_tcase *torture_suite_add_machine_bdc_rpc_iface_tcase(
241 : struct torture_suite *suite,
242 : const char *name,
243 : const struct ndr_interface_table *table,
244 : const char *machine_name)
245 : {
246 12080 : struct torture_rpc_tcase *tcase = talloc(suite,
247 : struct torture_rpc_tcase);
248 :
249 12080 : torture_suite_init_rpc_tcase(suite, tcase, name, table);
250 :
251 12080 : tcase->machine_name = talloc_strdup(tcase, machine_name);
252 12080 : tcase->tcase.setup = torture_rpc_setup_machine_bdc;
253 12080 : tcase->tcase.teardown = torture_rpc_teardown;
254 :
255 12080 : return tcase;
256 : }
257 :
258 54556 : _PUBLIC_ bool torture_suite_init_rpc_tcase(struct torture_suite *suite,
259 : struct torture_rpc_tcase *tcase,
260 : const char *name,
261 : const struct ndr_interface_table *table)
262 : {
263 54556 : if (!torture_suite_init_tcase(suite, (struct torture_tcase *)tcase, name))
264 0 : return false;
265 :
266 54556 : tcase->table = table;
267 :
268 54556 : return true;
269 : }
270 :
271 5 : static bool torture_rpc_setup_anonymous(struct torture_context *tctx,
272 : void **data)
273 : {
274 : NTSTATUS status;
275 : struct dcerpc_binding *binding;
276 : struct torture_rpc_tcase_data *tcase_data;
277 5 : struct torture_rpc_tcase *tcase = talloc_get_type(tctx->active_tcase,
278 : struct torture_rpc_tcase);
279 :
280 5 : status = torture_rpc_binding(tctx, &binding);
281 5 : if (NT_STATUS_IS_ERR(status))
282 0 : return false;
283 :
284 5 : *data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
285 5 : tcase_data->credentials = cli_credentials_init_anon(tctx);
286 :
287 5 : status = dcerpc_pipe_connect_b(tctx,
288 : &(tcase_data->pipe),
289 : binding,
290 : tcase->table,
291 : tcase_data->credentials, tctx->ev, tctx->lp_ctx);
292 :
293 5 : torture_assert_ntstatus_ok(tctx, status, "Error connecting to server");
294 :
295 5 : return NT_STATUS_IS_OK(status);
296 : }
297 :
298 433 : static bool torture_rpc_setup (struct torture_context *tctx, void **data)
299 : {
300 : NTSTATUS status;
301 433 : struct torture_rpc_tcase *tcase = talloc_get_type(
302 : tctx->active_tcase, struct torture_rpc_tcase);
303 : struct torture_rpc_tcase_data *tcase_data;
304 :
305 433 : *data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
306 433 : tcase_data->credentials = samba_cmdline_get_creds();
307 :
308 433 : status = torture_rpc_connection(tctx,
309 : &(tcase_data->pipe),
310 : tcase->table);
311 :
312 433 : torture_assert_ntstatus_ok(tctx, status, "Error connecting to server");
313 :
314 431 : return NT_STATUS_IS_OK(status);
315 : }
316 :
317 :
318 :
319 964 : _PUBLIC_ struct torture_rpc_tcase *torture_suite_add_anon_rpc_iface_tcase(struct torture_suite *suite,
320 : const char *name,
321 : const struct ndr_interface_table *table)
322 : {
323 964 : struct torture_rpc_tcase *tcase = talloc(suite, struct torture_rpc_tcase);
324 :
325 964 : torture_suite_init_rpc_tcase(suite, tcase, name, table);
326 :
327 964 : tcase->tcase.setup = torture_rpc_setup_anonymous;
328 964 : tcase->tcase.teardown = torture_rpc_teardown;
329 :
330 964 : return tcase;
331 : }
332 :
333 :
334 32776 : _PUBLIC_ struct torture_rpc_tcase *torture_suite_add_rpc_iface_tcase(struct torture_suite *suite,
335 : const char *name,
336 : const struct ndr_interface_table *table)
337 : {
338 32776 : struct torture_rpc_tcase *tcase = talloc(suite, struct torture_rpc_tcase);
339 :
340 32776 : torture_suite_init_rpc_tcase(suite, tcase, name, table);
341 :
342 32776 : tcase->tcase.setup = torture_rpc_setup;
343 32776 : tcase->tcase.teardown = torture_rpc_teardown;
344 :
345 32776 : return tcase;
346 : }
347 :
348 3147 : static bool torture_rpc_wrap_test(struct torture_context *tctx,
349 : struct torture_tcase *tcase,
350 : struct torture_test *test)
351 : {
352 : bool (*fn) (struct torture_context *, struct dcerpc_pipe *);
353 3147 : struct torture_rpc_tcase_data *tcase_data =
354 : (struct torture_rpc_tcase_data *)tcase->data;
355 :
356 3147 : fn = test->fn;
357 :
358 3147 : return fn(tctx, tcase_data->pipe);
359 : }
360 :
361 344 : static bool torture_rpc_wrap_test_ex(struct torture_context *tctx,
362 : struct torture_tcase *tcase,
363 : struct torture_test *test)
364 : {
365 : bool (*fn) (struct torture_context *, struct dcerpc_pipe *, const void *);
366 344 : struct torture_rpc_tcase_data *tcase_data =
367 : (struct torture_rpc_tcase_data *)tcase->data;
368 :
369 344 : fn = test->fn;
370 :
371 344 : return fn(tctx, tcase_data->pipe, test->data);
372 : }
373 :
374 :
375 431 : static bool torture_rpc_wrap_test_creds(struct torture_context *tctx,
376 : struct torture_tcase *tcase,
377 : struct torture_test *test)
378 : {
379 : bool (*fn) (struct torture_context *, struct dcerpc_pipe *, struct cli_credentials *);
380 431 : struct torture_rpc_tcase_data *tcase_data =
381 : (struct torture_rpc_tcase_data *)tcase->data;
382 :
383 431 : fn = test->fn;
384 :
385 431 : return fn(tctx, tcase_data->pipe, tcase_data->credentials);
386 : }
387 :
388 8 : static bool torture_rpc_wrap_test_join(struct torture_context *tctx,
389 : struct torture_tcase *tcase,
390 : struct torture_test *test)
391 : {
392 : bool (*fn) (struct torture_context *, struct dcerpc_pipe *, struct cli_credentials *, struct test_join *);
393 8 : struct torture_rpc_tcase_data *tcase_data =
394 : (struct torture_rpc_tcase_data *)tcase->data;
395 :
396 8 : fn = test->fn;
397 :
398 8 : return fn(tctx, tcase_data->pipe, tcase_data->credentials, tcase_data->join_ctx);
399 : }
400 :
401 192800 : _PUBLIC_ struct torture_test *torture_rpc_tcase_add_test(
402 : struct torture_rpc_tcase *tcase,
403 : const char *name,
404 : bool (*fn) (struct torture_context *, struct dcerpc_pipe *))
405 : {
406 : struct torture_test *test;
407 :
408 192800 : test = talloc(tcase, struct torture_test);
409 :
410 192800 : test->name = talloc_strdup(test, name);
411 192800 : test->description = NULL;
412 192800 : test->run = torture_rpc_wrap_test;
413 192800 : test->dangerous = false;
414 192800 : test->data = NULL;
415 192800 : test->fn = fn;
416 :
417 192800 : DLIST_ADD_END(tcase->tcase.tests, test);
418 :
419 192800 : return test;
420 : }
421 :
422 63684 : _PUBLIC_ struct torture_test *torture_rpc_tcase_add_test_creds(
423 : struct torture_rpc_tcase *tcase,
424 : const char *name,
425 : bool (*fn) (struct torture_context *, struct dcerpc_pipe *, struct cli_credentials *))
426 : {
427 : struct torture_test *test;
428 :
429 63684 : test = talloc(tcase, struct torture_test);
430 :
431 63684 : test->name = talloc_strdup(test, name);
432 63684 : test->description = NULL;
433 63684 : test->run = torture_rpc_wrap_test_creds;
434 63684 : test->dangerous = false;
435 63684 : test->data = NULL;
436 63684 : test->fn = fn;
437 :
438 63684 : DLIST_ADD_END(tcase->tcase.tests, test);
439 :
440 63684 : return test;
441 : }
442 :
443 1476 : _PUBLIC_ struct torture_test *torture_rpc_tcase_add_test_join(
444 : struct torture_rpc_tcase *tcase,
445 : const char *name,
446 : bool (*fn) (struct torture_context *, struct dcerpc_pipe *,
447 : struct cli_credentials *, struct test_join *))
448 : {
449 : struct torture_test *test;
450 :
451 1476 : test = talloc(tcase, struct torture_test);
452 :
453 1476 : test->name = talloc_strdup(test, name);
454 1476 : test->description = NULL;
455 1476 : test->run = torture_rpc_wrap_test_join;
456 1476 : test->dangerous = false;
457 1476 : test->data = NULL;
458 1476 : test->fn = fn;
459 :
460 1476 : DLIST_ADD_END(tcase->tcase.tests, test);
461 :
462 1476 : return test;
463 : }
464 :
465 13496 : _PUBLIC_ struct torture_test *torture_rpc_tcase_add_test_ex(
466 : struct torture_rpc_tcase *tcase,
467 : const char *name,
468 : bool (*fn) (struct torture_context *, struct dcerpc_pipe *,
469 : void *),
470 : void *userdata)
471 : {
472 : struct torture_test *test;
473 :
474 13496 : test = talloc(tcase, struct torture_test);
475 :
476 13496 : test->name = talloc_strdup(test, name);
477 13496 : test->description = NULL;
478 13496 : test->run = torture_rpc_wrap_test_ex;
479 13496 : test->dangerous = false;
480 13496 : test->data = userdata;
481 13496 : test->fn = fn;
482 :
483 13496 : DLIST_ADD_END(tcase->tcase.tests, test);
484 :
485 13496 : return test;
486 : }
487 :
488 0 : static bool torture_rpc_wrap_test_setup(struct torture_context *tctx,
489 : struct torture_tcase *tcase,
490 : struct torture_test *test)
491 : {
492 : bool (*fn)(struct torture_context *, struct dcerpc_pipe *, const void *);
493 0 : struct torture_rpc_tcase *rpc_tcase = talloc_get_type_abort(
494 : tctx->active_tcase, struct torture_rpc_tcase);
495 0 : struct torture_rpc_tcase_data *tcase_data = talloc_get_type_abort(
496 : tcase->data, struct torture_rpc_tcase_data);
497 0 : void *data = discard_const_p(void, test->data);
498 : bool ok;
499 :
500 0 : ok = rpc_tcase->setup_fn(tctx, tcase_data->pipe, data);
501 0 : if (!ok) {
502 0 : return false;
503 : }
504 :
505 0 : fn = test->fn;
506 :
507 0 : ok = fn(tctx, tcase_data->pipe, data);
508 0 : if (!ok) {
509 0 : return false;
510 : }
511 :
512 0 : ok = rpc_tcase->teardown_fn(tctx, tcase_data->pipe, data);
513 0 : if (!ok) {
514 0 : return false;
515 : }
516 :
517 0 : return true;
518 : }
519 :
520 0 : _PUBLIC_ struct torture_test *torture_rpc_tcase_add_test_setup(
521 : struct torture_rpc_tcase *tcase,
522 : const char *name,
523 : bool (*fn)(struct torture_context *,
524 : struct dcerpc_pipe *,
525 : void *),
526 : void *userdata)
527 : {
528 0 : struct torture_test *test = NULL;
529 :
530 0 : test = talloc(tcase, struct torture_test);
531 :
532 0 : test->name = talloc_strdup(test, name);
533 0 : test->description = NULL;
534 0 : test->run = torture_rpc_wrap_test_setup;
535 0 : test->dangerous = false;
536 0 : test->data = userdata;
537 0 : test->fn = fn;
538 :
539 0 : DLIST_ADD_END(tcase->tcase.tests, test);
540 :
541 0 : return test;
542 : }
543 :
544 0 : _PUBLIC_ struct torture_rpc_tcase *torture_suite_add_rpc_setup_tcase(
545 : struct torture_suite *suite,
546 : const char *name,
547 : const struct ndr_interface_table *table,
548 : bool (*setup_fn)(struct torture_context *,
549 : struct dcerpc_pipe *,
550 : void *),
551 : bool (*teardown_fn)(struct torture_context *,
552 : struct dcerpc_pipe *,
553 : void *))
554 : {
555 0 : struct torture_rpc_tcase *tcase = talloc(
556 : suite, struct torture_rpc_tcase);
557 :
558 0 : torture_suite_init_rpc_tcase(suite, tcase, name, table);
559 :
560 0 : tcase->setup_fn = setup_fn;
561 0 : tcase->teardown_fn = teardown_fn;
562 0 : tcase->tcase.setup = torture_rpc_setup;
563 0 : tcase->tcase.teardown = torture_rpc_teardown;
564 :
565 0 : return tcase;
566 : }
567 :
568 964 : NTSTATUS torture_rpc_init(TALLOC_CTX *ctx)
569 : {
570 964 : struct torture_suite *suite = torture_suite_create(ctx, "rpc");
571 :
572 964 : ndr_table_init();
573 :
574 964 : torture_suite_add_simple_test(suite, "lsa", torture_rpc_lsa);
575 964 : torture_suite_add_simple_test(suite, "lsalookup", torture_rpc_lsa_lookup);
576 964 : torture_suite_add_simple_test(suite, "lsa-getuser", torture_rpc_lsa_get_user);
577 964 : torture_suite_add_suite(suite, torture_rpc_lsa_lookup_sids(suite));
578 964 : torture_suite_add_suite(suite, torture_rpc_lsa_lookup_names(suite));
579 964 : torture_suite_add_suite(suite, torture_rpc_lsa_secrets(suite));
580 964 : torture_suite_add_suite(suite, torture_rpc_lsa_trusted_domains(suite));
581 964 : torture_suite_add_suite(suite, torture_rpc_lsa_forest_trust(suite));
582 964 : torture_suite_add_suite(suite, torture_rpc_lsa_privileges(suite));
583 964 : torture_suite_add_suite(suite, torture_rpc_echo(suite));
584 964 : torture_suite_add_suite(suite, torture_rpc_dfs(suite));
585 964 : torture_suite_add_suite(suite, torture_rpc_frsapi(suite));
586 964 : torture_suite_add_suite(suite, torture_rpc_unixinfo(suite));
587 964 : torture_suite_add_suite(suite, torture_rpc_eventlog(suite));
588 964 : torture_suite_add_suite(suite, torture_rpc_atsvc(suite));
589 964 : torture_suite_add_suite(suite, torture_rpc_wkssvc(suite));
590 964 : torture_suite_add_suite(suite, torture_rpc_handles(suite));
591 964 : torture_suite_add_suite(suite, torture_rpc_object_uuid(suite));
592 964 : torture_suite_add_suite(suite, torture_rpc_winreg(suite));
593 964 : torture_suite_add_suite(suite, torture_rpc_spoolss(suite));
594 : #ifdef WITH_NTVFS_FILESERVER
595 964 : torture_suite_add_suite(suite, torture_rpc_spoolss_notify(suite));
596 : #endif
597 964 : torture_suite_add_suite(suite, torture_rpc_spoolss_win(suite));
598 964 : torture_suite_add_suite(suite, torture_rpc_spoolss_driver(suite));
599 964 : torture_suite_add_suite(suite, torture_rpc_spoolss_access(suite));
600 964 : torture_suite_add_suite(suite, torture_rpc_iremotewinspool(suite));
601 964 : torture_suite_add_suite(suite, torture_rpc_iremotewinspool_drv(suite));
602 964 : torture_suite_add_simple_test(suite, "samr", torture_rpc_samr);
603 964 : torture_suite_add_simple_test(suite, "samr.users", torture_rpc_samr_users);
604 964 : torture_suite_add_simple_test(suite, "samr.passwords.default", torture_rpc_samr_passwords);
605 964 : torture_suite_add_suite(suite, torture_rpc_netlogon(suite));
606 964 : torture_suite_add_suite(suite, torture_rpc_netlogon_s3(suite));
607 964 : torture_suite_add_suite(suite, torture_rpc_netlogon_admin(suite));
608 964 : torture_suite_add_suite(suite, torture_rpc_netlogon_zerologon(suite));
609 964 : torture_suite_add_suite(suite, torture_rpc_netlogon_crypto_fips(suite));
610 964 : torture_suite_add_suite(suite, torture_rpc_remote_pac(suite));
611 964 : torture_suite_add_simple_test(suite, "samlogon", torture_rpc_samlogon);
612 964 : torture_suite_add_simple_test(suite, "samsync", torture_rpc_samsync);
613 964 : torture_suite_add_simple_test(suite, "schannel", torture_rpc_schannel);
614 964 : torture_suite_add_simple_test(suite, "schannel2", torture_rpc_schannel2);
615 964 : torture_suite_add_simple_test(suite, "bench-schannel1", torture_rpc_schannel_bench1);
616 964 : torture_suite_add_simple_test(suite, "schannel_anon_setpw", torture_rpc_schannel_anon_setpw);
617 964 : torture_suite_add_suite(suite, torture_rpc_srvsvc(suite));
618 964 : torture_suite_add_suite(suite, torture_rpc_svcctl(suite));
619 964 : torture_suite_add_suite(suite, torture_rpc_samr_accessmask(suite));
620 964 : torture_suite_add_suite(suite, torture_rpc_samr_handletype(suite));
621 964 : torture_suite_add_suite(suite, torture_rpc_samr_workstation_auth(suite));
622 964 : torture_suite_add_suite(suite, torture_rpc_samr_passwords_pwdlastset(suite));
623 964 : torture_suite_add_suite(suite, torture_rpc_samr_passwords_badpwdcount(suite));
624 964 : torture_suite_add_suite(suite, torture_rpc_samr_passwords_lockout(suite));
625 964 : torture_suite_add_suite(suite, torture_rpc_samr_passwords_validate(suite));
626 964 : torture_suite_add_suite(suite, torture_rpc_samr_user_privileges(suite));
627 964 : torture_suite_add_suite(suite, torture_rpc_samr_large_dc(suite));
628 964 : torture_suite_add_suite(suite, torture_rpc_samr_priv(suite));
629 964 : torture_suite_add_suite(suite, torture_rpc_epmapper(suite));
630 964 : torture_suite_add_suite(suite, torture_rpc_initshutdown(suite));
631 964 : torture_suite_add_suite(suite, torture_rpc_oxidresolve(suite));
632 964 : torture_suite_add_suite(suite, torture_rpc_remact(suite));
633 964 : torture_suite_add_simple_test(suite, "mgmt", torture_rpc_mgmt);
634 964 : torture_suite_add_simple_test(suite, "scanner", torture_rpc_scanner);
635 964 : torture_suite_add_simple_test(suite, "countcalls", torture_rpc_countcalls);
636 964 : torture_suite_add_simple_test(suite, "authcontext", torture_bind_authcontext);
637 964 : torture_suite_add_suite(suite, torture_rpc_samba3(suite));
638 964 : torture_rpc_drsuapi_tcase(suite);
639 964 : torture_rpc_drsuapi_w2k8_tcase(suite);
640 964 : torture_rpc_drsuapi_cracknames_tcase(suite);
641 964 : torture_suite_add_suite(suite, torture_rpc_dssetup(suite));
642 964 : torture_suite_add_suite(suite, torture_rpc_browser(suite));
643 964 : torture_suite_add_simple_test(suite, "altercontext", torture_rpc_alter_context);
644 964 : torture_suite_add_simple_test(suite, "join", torture_rpc_join);
645 964 : torture_drs_rpc_dsgetinfo_tcase(suite);
646 964 : torture_suite_add_simple_test(suite, "bench-rpc", torture_bench_rpc);
647 964 : torture_suite_add_simple_test(suite, "asyncbind", torture_async_bind);
648 964 : torture_suite_add_suite(suite, torture_rpc_ntsvcs(suite));
649 964 : torture_suite_add_suite(suite, torture_rpc_bind(suite));
650 : #ifdef AD_DC_BUILD_IS_ENABLED
651 964 : torture_suite_add_suite(suite, torture_rpc_backupkey(suite));
652 : #endif
653 964 : torture_suite_add_suite(suite, torture_rpc_fsrvp(suite));
654 964 : torture_suite_add_suite(suite, torture_rpc_clusapi(suite));
655 964 : torture_suite_add_suite(suite, torture_rpc_witness(suite));
656 964 : torture_suite_add_suite(suite, torture_rpc_mdssvc(suite));
657 :
658 964 : suite->description = talloc_strdup(suite, "DCE/RPC protocol and interface tests");
659 :
660 964 : torture_register_suite(ctx, suite);
661 :
662 964 : return NT_STATUS_OK;
663 : }
|
