?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dns: The QCLASS is called IN, not IP
[Samba/gebeck_regimport.git] / source4 / torture / smbtorture.c
blob83816e8be55a25dfaf7c57ab5d39d24429910264
1 /*
2 Unix SMB/CIFS implementation.
3 SMB torture tester
4 Copyright (C) Andrew Tridgell 1997-2003
5 Copyright (C) Jelmer Vernooij 2006-2008
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/popt_common.h"
23 #include "system/time.h"
24 #include "system/wait.h"
25 #include "system/filesys.h"
26 #include "system/readline.h"
27 #include "../libcli/smbreadline/smbreadline.h"
28 #include "libcli/libcli.h"
29 #include "lib/events/events.h"
30
31 #include "torture/smbtorture.h"
32 #include "librpc/rpc/dcerpc.h"
33 #include "auth/gensec/gensec.h"
34 #include "param/param.h"
35
36 #if HAVE_READLINE_HISTORY_H
37 #include <readline/history.h>
38 #endif
39
40 static char *prefix_name(TALLOC_CTX *mem_ctx, const char *prefix, const char *name)
41 {
42 if (prefix == NULL)
43 return talloc_strdup(mem_ctx, name);
44 else
45 return talloc_asprintf(mem_ctx, "%s.%s", prefix, name);
46 }
47
48 static void print_test_list(const struct torture_suite *suite, const char *prefix, const char *expr)
49 {
50 struct torture_suite *o;
51 struct torture_tcase *t;
52 struct torture_test *p;
53
54 for (o = suite->children; o; o = o->next) {
55 char *name = prefix_name(NULL, prefix, o->name);
56 print_test_list(o, name, expr);
57 talloc_free(name);
58 }
59
60 for (t = suite->testcases; t; t = t->next) {
61 for (p = t->tests; p; p = p->next) {
62 char *name = talloc_asprintf(NULL, "%s.%s.%s", prefix, t->name, p->name);
63 if (strncmp(name, expr, strlen(expr)) == 0) {
64 printf("%s\n", name);
65 }
66 talloc_free(name);
67 }
68 }
69 }
70
71 static bool run_matching(struct torture_context *torture,
72 const char *prefix,
73 const char *expr,
74 const char **restricted,
75 struct torture_suite *suite,
76 bool *matched)
77 {
78 bool ret = true;
79 struct torture_suite *o;
80 struct torture_tcase *t;
81 struct torture_test *p;
82
83 for (o = suite->children; o; o = o->next) {
84 char *name = NULL;
85 name = prefix_name(torture, prefix, o->name);
86 if (gen_fnmatch(expr, name) == 0) {
87 *matched = true;
88 reload_charcnv(torture->lp_ctx);
89 if (restricted != NULL)
90 ret &= torture_run_suite_restricted(torture, o, restricted);
91 else
92 ret &= torture_run_suite(torture, o);
93 }
94 ret &= run_matching(torture, name, expr, restricted, o, matched);
95 }
96
97 for (t = suite->testcases; t; t = t->next) {
98 char *name = talloc_asprintf(torture, "%s.%s", prefix, t->name);
99 if (gen_fnmatch(expr, name) == 0) {
100 *matched = true;
101 reload_charcnv(torture->lp_ctx);
102 ret &= torture_run_tcase_restricted(torture, t, restricted);
103 }
104 for (p = t->tests; p; p = p->next) {
105 name = talloc_asprintf(torture, "%s.%s.%s", prefix, t->name, p->name);
106 if (gen_fnmatch(expr, name) == 0) {
107 *matched = true;
108 reload_charcnv(torture->lp_ctx);
109 ret &= torture_run_test_restricted(torture, t, p, restricted);
110 }
111 }
112 }
113
114 return ret;
115 }
116
117 #define MAX_COLS 80 /* FIXME: Determine this at run-time */
118
119 /****************************************************************************
120 run a specified test or "ALL"
121 ****************************************************************************/
122 bool torture_run_named_tests(struct torture_context *torture, const char *name,
123 const char **restricted)
124 {
125 bool ret = true;
126 bool matched = false;
127 struct torture_suite *o;
128
129 torture_ui_report_time(torture);
130
131 if (strequal(name, "ALL")) {
132 if (restricted != NULL) {
133 printf("--load-list and ALL are incompatible\n");
134 return false;
135 }
136 for (o = torture_root->children; o; o = o->next) {
137 ret &= torture_run_suite(torture, o);
138 }
139 return ret;
140 }
141
142 ret = run_matching(torture, NULL, name, restricted, torture_root, &matched);
143
144 if (!matched) {
145 printf("Unknown torture operation '%s'\n", name);
146 return false;
147 }
148
149 return ret;
150 }
151
152 bool torture_parse_target(struct loadparm_context *lp_ctx, const char *target)
153 {
154 char *host = NULL, *share = NULL;
155 struct dcerpc_binding *binding_struct;
156 NTSTATUS status;
157
158 /* see if its a RPC transport specifier */
159 if (!smbcli_parse_unc(target, NULL, &host, &share)) {
160 status = dcerpc_parse_binding(talloc_autofree_context(), target, &binding_struct);
161 if (NT_STATUS_IS_ERR(status)) {
162 d_printf("Invalid option: %s is not a valid torture target (share or binding string)\n\n", target);
163 return false;
164 }
165 lpcfg_set_cmdline(lp_ctx, "torture:host", binding_struct->host);
166 if (lpcfg_parm_string(lp_ctx, NULL, "torture", "share") == NULL)
167 lpcfg_set_cmdline(lp_ctx, "torture:share", "IPC$");
168 lpcfg_set_cmdline(lp_ctx, "torture:binding", target);
169 } else {
170 lpcfg_set_cmdline(lp_ctx, "torture:host", host);
171 lpcfg_set_cmdline(lp_ctx, "torture:share", share);
172 lpcfg_set_cmdline(lp_ctx, "torture:binding", host);
173 }
174
175 return true;
176 }
177
178 static void parse_dns(struct loadparm_context *lp_ctx, const char *dns)
179 {
180 char *userdn, *basedn, *secret;
181 char *p, *d;
182
183 /* retrievieng the userdn */
184 p = strchr_m(dns, '#');
185 if (!p) {
186 lpcfg_set_cmdline(lp_ctx, "torture:ldap_userdn", "");
187 lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
188 lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
189 return;
190 }
191 userdn = strndup(dns, p - dns);
192 lpcfg_set_cmdline(lp_ctx, "torture:ldap_userdn", userdn);
193
194 /* retrieve the basedn */
195 d = p + 1;
196 p = strchr_m(d, '#');
197 if (!p) {
198 lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
199 lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
200 return;
201 }
202 basedn = strndup(d, p - d);
203 lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", basedn);
204
205 /* retrieve the secret */
206 p = p + 1;
207 if (!p) {
208 lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
209 return;
210 }
211 secret = strdup(p);
212 lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", secret);
213
214 printf ("%s - %s - %s\n", userdn, basedn, secret);
215
216 }
217
218 /* Print the full test list, formatted into separate labelled test
219 * groups.
220 */
221 static void print_structured_testsuite_list(void)
222 {
223 struct torture_suite *o;
224 struct torture_suite *s;
225 struct torture_tcase *t;
226 int i;
227
228 if (torture_root == NULL) {
229 printf("NO TESTS LOADED\n");
230 return;
231 }
232
233 for (o = torture_root->children; o; o = o->next) {
234 printf("\n%s (%s):\n ", o->description, o->name);
235
236 i = 0;
237 for (s = o->children; s; s = s->next) {
238 if (i + strlen(o->name) + strlen(s->name) >= (MAX_COLS - 3)) {
239 printf("\n ");
240 i = 0;
241 }
242 i+=printf("%s.%s ", o->name, s->name);
243 }
244
245 for (t = o->testcases; t; t = t->next) {
246 if (i + strlen(o->name) + strlen(t->name) >= (MAX_COLS - 3)) {
247 printf("\n ");
248 i = 0;
249 }
250 i+=printf("%s.%s ", o->name, t->name);
251 }
252
253 if (i) printf("\n");
254 }
255
256 printf("\nThe default test is ALL.\n");
257 }
258
259 static void print_testsuite_list(void)
260 {
261 struct torture_suite *o;
262 struct torture_suite *s;
263 struct torture_tcase *t;
264
265 if (torture_root == NULL)
266 return;
267
268 for (o = torture_root->children; o; o = o->next) {
269 for (s = o->children; s; s = s->next) {
270 printf("%s.%s\n", o->name, s->name);
271 }
272
273 for (t = o->testcases; t; t = t->next) {
274 printf("%s.%s\n", o->name, t->name);
275 }
276 }
277 }
278
279 void torture_print_testsuites(bool structured)
280 {
281 if (structured) {
282 print_structured_testsuite_list();
283 } else {
284 print_testsuite_list();
285 }
286 }
287
288 static void usage(poptContext pc)
289 {
290 poptPrintUsage(pc, stdout, 0);
291 printf("\n");
292
293 printf("The binding format is:\n\n");
294
295 printf(" TRANSPORT:host[flags]\n\n");
296
297 printf(" where TRANSPORT is either ncacn_np for SMB, ncacn_ip_tcp for RPC/TCP\n");
298 printf(" or ncalrpc for local connections.\n\n");
299
300 printf(" 'host' is an IP or hostname or netbios name. If the binding string\n");
301 printf(" identifies the server side of an endpoint, 'host' may be an empty\n");
302 printf(" string.\n\n");
303
304 printf(" 'flags' can include a SMB pipe name if using the ncacn_np transport or\n");
305 printf(" a TCP port number if using the ncacn_ip_tcp transport, otherwise they\n");
306 printf(" will be auto-determined.\n\n");
307
308 printf(" other recognised flags are:\n\n");
309
310 printf(" sign : enable ntlmssp signing\n");
311 printf(" seal : enable ntlmssp sealing\n");
312 printf(" connect : enable rpc connect level auth (auth, but no sign or seal)\n");
313 printf(" validate: enable the NDR validator\n");
314 printf(" print: enable debugging of the packets\n");
315 printf(" bigendian: use bigendian RPC\n");
316 printf(" padcheck: check reply data for non-zero pad bytes\n\n");
317
318 printf(" For example, these all connect to the samr pipe:\n\n");
319
320 printf(" ncacn_np:myserver\n");
321 printf(" ncacn_np:myserver[samr]\n");
322 printf(" ncacn_np:myserver[\\pipe\\samr]\n");
323 printf(" ncacn_np:myserver[/pipe/samr]\n");
324 printf(" ncacn_np:myserver[samr,sign,print]\n");
325 printf(" ncacn_np:myserver[\\pipe\\samr,sign,seal,bigendian]\n");
326 printf(" ncacn_np:myserver[/pipe/samr,seal,validate]\n");
327 printf(" ncacn_np:\n");
328 printf(" ncacn_np:[/pipe/samr]\n\n");
329
330 printf(" ncacn_ip_tcp:myserver\n");
331 printf(" ncacn_ip_tcp:myserver[1024]\n");
332 printf(" ncacn_ip_tcp:myserver[1024,sign,seal]\n\n");
333
334 printf(" ncalrpc:\n\n");
335
336 printf("The UNC format is:\n\n");
337
338 printf(" //server/share\n\n");
339
340 printf("Tests are:");
341
342 print_structured_testsuite_list();
343
344 }
345
346 _NORETURN_ static void max_runtime_handler(int sig)
347 {
348 DEBUG(0,("maximum runtime exceeded for smbtorture - terminating\n"));
349 exit(1);
350 }
351
352 struct timeval last_suite_started;
353
354 static void simple_suite_start(struct torture_context *ctx,
355 struct torture_suite *suite)
356 {
357 last_suite_started = timeval_current();
358 printf("Running %s\n", suite->name);
359 }
360
361 static void simple_suite_finish(struct torture_context *ctx,
362 struct torture_suite *suite)
363 {
364
365 printf("%s took %g secs\n\n", suite->name,
366 timeval_elapsed(&last_suite_started));
367 }
368
369 static void simple_test_result(struct torture_context *context,
370 enum torture_result res, const char *reason)
371 {
372 switch (res) {
373 case TORTURE_OK:
374 if (reason)
375 printf("OK: %s\n", reason);
376 break;
377 case TORTURE_FAIL:
378 printf("TEST %s FAILED! - %s\n", context->active_test->name, reason);
379 break;
380 case TORTURE_ERROR:
381 printf("ERROR IN TEST %s! - %s\n", context->active_test->name, reason);
382 break;
383 case TORTURE_SKIP:
384 printf("SKIP: %s - %s\n", context->active_test->name, reason);
385 break;
386 }
387 }
388
389 static void simple_comment(struct torture_context *test,
390 const char *comment)
391 {
392 printf("%s", comment);
393 }
394
395 static void simple_warning(struct torture_context *test,
396 const char *comment)
397 {
398 fprintf(stderr, "WARNING: %s\n", comment);
399 }
400
401 static void simple_progress(struct torture_context *test,
402 int offset, enum torture_progress_whence whence)
403 {
404 }
405
406 const static struct torture_ui_ops std_ui_ops = {
407 .comment = simple_comment,
408 .warning = simple_warning,
409 .suite_start = simple_suite_start,
410 .suite_finish = simple_suite_finish,
411 .test_result = simple_test_result,
412 .progress = simple_progress,
413 };
414
415 /****************************************************************************
416 main program
417 ****************************************************************************/
418 int main(int argc,char *argv[])
419 {
420 int opt, i;
421 bool correct = true;
422 int max_runtime=0;
423 int argc_new;
424 struct torture_context *torture;
425 struct torture_results *results;
426 const struct torture_ui_ops *ui_ops;
427 char **argv_new;
428 poptContext pc;
429 static const char *target = "other";
430 NTSTATUS status;
431 int shell = false;
432 static const char *ui_ops_name = "subunit";
433 const char *basedir = NULL;
434 char *outputdir;
435 const char *extra_module = NULL;
436 static int list_tests = 0, list_testsuites = 0;
437 int num_extra_users = 0;
438 char **restricted = NULL;
439 int num_restricted = -1;
440 const char *load_list = NULL;
441 enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS, OPT_LIST,
442 OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS,
443 OPT_EXTRA_USER,};
444
445 struct poptOption long_options[] = {
446 POPT_AUTOHELP
447 {"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit)", NULL },
448 {"smb-ports", 'p', POPT_ARG_STRING, NULL, OPT_SMB_PORTS, "SMB ports", NULL},
449 {"basedir", 0, POPT_ARG_STRING, &basedir, 0, "base directory", "BASEDIR" },
450 {"seed", 0, POPT_ARG_INT, &torture_seed, 0, "Seed to use for randomizer", NULL},
451 {"num-progs", 0, POPT_ARG_INT, NULL, OPT_NUMPROGS, "num progs", NULL},
452 {"num-ops", 0, POPT_ARG_INT, &torture_numops, 0, "num ops", NULL},
453 {"entries", 0, POPT_ARG_INT, &torture_entries, 0, "entries", NULL},
454 {"loadfile", 0, POPT_ARG_STRING, NULL, OPT_LOADFILE, "NBench load file to use", NULL},
455 {"list-suites", 0, POPT_ARG_NONE, &list_testsuites, 0, "List available testsuites and exit", NULL },
456 {"list", 0, POPT_ARG_NONE, &list_tests, 0, "List available tests in specified suites and exit", NULL },
457 {"unclist", 0, POPT_ARG_STRING, NULL, OPT_UNCLIST, "unclist", NULL},
458 {"timelimit", 't', POPT_ARG_INT, NULL, OPT_TIMELIMIT, "Set time limit (in seconds)", NULL},
459 {"failures", 'f', POPT_ARG_INT, &torture_failures, 0, "failures", NULL},
460 {"parse-dns", 'D', POPT_ARG_STRING, NULL, OPT_DNS, "parse-dns", NULL},
461 {"dangerous", 'X', POPT_ARG_NONE, NULL, OPT_DANGEROUS,
462 "run dangerous tests (eg. wiping out password database)", NULL},
463 {"load-module", 0, POPT_ARG_STRING, &extra_module, 0, "load tests from DSO file", "SOFILE"},
464 {"shell", 0, POPT_ARG_NONE, &shell, true, "Run shell", NULL},
465 {"target", 'T', POPT_ARG_STRING, &target, 0, "samba3|samba4|other", NULL},
466 {"async", 'a', POPT_ARG_NONE, NULL, OPT_ASYNC,
467 "run async tests", NULL},
468 {"num-async", 0, POPT_ARG_INT, &torture_numasync, 0,
469 "number of simultaneous async requests", NULL},
470 {"maximum-runtime", 0, POPT_ARG_INT, &max_runtime, 0,
471 "set maximum time for smbtorture to live", "seconds"},
472 {"extra-user", 0, POPT_ARG_STRING, NULL, OPT_EXTRA_USER,
473 "extra user credentials", NULL},
474 {"load-list", 0, POPT_ARG_STRING, &load_list, 0,
475 "load a test id list from a text file", NULL},
476 POPT_COMMON_SAMBA
477 POPT_COMMON_CONNECTION
478 POPT_COMMON_CREDENTIALS
479 POPT_COMMON_VERSION
480 { NULL }
481 };
482
483 setlinebuf(stdout);
484
485 /* we are never interested in SIGPIPE */
486 BlockSignals(true, SIGPIPE);
487
488 pc = poptGetContext("smbtorture", argc, (const char **) argv, long_options,
489 POPT_CONTEXT_KEEP_FIRST);
490
491 poptSetOtherOptionHelp(pc, "<binding>|<unc> TEST1 TEST2 ...");
492
493 while((opt = poptGetNextOpt(pc)) != -1) {
494 switch (opt) {
495 case OPT_LOADFILE:
496 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:loadfile", poptGetOptArg(pc));
497 break;
498 case OPT_UNCLIST:
499 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
500 break;
501 case OPT_TIMELIMIT:
502 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:timelimit", poptGetOptArg(pc));
503 break;
504 case OPT_NUMPROGS:
505 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:nprocs", poptGetOptArg(pc));
506 break;
507 case OPT_DNS:
508 parse_dns(cmdline_lp_ctx, poptGetOptArg(pc));
509 break;
510 case OPT_DANGEROUS:
511 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:dangerous", "Yes");
512 break;
513 case OPT_ASYNC:
514 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:async", "Yes");
515 break;
516 case OPT_SMB_PORTS:
517 lpcfg_set_cmdline(cmdline_lp_ctx, "smb ports", poptGetOptArg(pc));
518 break;
519 case OPT_EXTRA_USER:
520 {
521 char *option = talloc_asprintf(NULL, "torture:extra_user%u",
522 ++num_extra_users);
523 const char *value = poptGetOptArg(pc);
524 lpcfg_set_cmdline(cmdline_lp_ctx, option, value);
525 talloc_free(option);
526 }
527 break;
528 default:
529 if (opt < 0) {
530 printf("bad command line option %d\n", opt);
531 exit(1);
532 }
533 }
534 }
535
536 if (load_list != NULL) {
537 restricted = file_lines_load(load_list, &num_restricted, 0,
538 talloc_autofree_context());
539 if (restricted == NULL) {
540 printf("Unable to read load list file '%s'\n", load_list);
541 exit(1);
542 }
543 }
544
545 if (strcmp(target, "samba3") == 0) {
546 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba3", "true");
547 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
548 } else if (strcmp(target, "samba4") == 0) {
549 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
550 } else if (strcmp(target, "winxp") == 0) {
551 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:winxp", "true");
552 } else if (strcmp(target, "w2k3") == 0) {
553 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k3", "true");
554 } else if (strcmp(target, "w2k8") == 0) {
555 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k8", "true");
556 lpcfg_set_cmdline(cmdline_lp_ctx,
557 "torture:invalid_lock_range_support", "false");
558 } else if (strcmp(target, "win7") == 0) {
559 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:win7", "true");
560 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:cn_max_buffer_size",
561 "0x00010000");
562 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
563 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
564
565 /* RAW-SEARCH for fails for inexplicable reasons against win7 */
566 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:search_ea_support", "false");
567
568 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:hide_on_access_denied",
569 "true");
570 } else if (strcmp(target, "onefs") == 0) {
571 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:onefs", "true");
572 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:openx_deny_dos_support",
573 "false");
574 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:range_not_locked_on_file_close", "false");
575 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:sacl_support", "false");
576 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:ea_support", "false");
577 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:smbexit_pdu_support",
578 "false");
579 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:smblock_pdu_support",
580 "false");
581 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:2_step_break_to_none",
582 "true");
583 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:deny_dos_support", "false");
584 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:deny_fcb_support", "false");
585 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:read_support", "false");
586 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:writeclose_support", "false");
587 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
588 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
589 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:raw_search_search", "false");
590 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:search_ea_size", "false");
591 }
592
593 if (max_runtime) {
594 /* this will only work if nobody else uses alarm(),
595 which means it won't work for some tests, but we
596 can't use the event context method we use for smbd
597 as so many tests create their own event
598 context. This will at least catch most cases. */
599 signal(SIGALRM, max_runtime_handler);
600 alarm(max_runtime);
601 }
602
603 if (extra_module != NULL) {
604 init_module_fn fn = load_module(talloc_autofree_context(), poptGetOptArg(pc));
605
606 if (fn == NULL)
607 d_printf("Unable to load module from %s\n", poptGetOptArg(pc));
608 else {
609 status = fn();
610 if (NT_STATUS_IS_ERR(status)) {
611 d_printf("Error initializing module %s: %s\n",
612 poptGetOptArg(pc), nt_errstr(status));
613 }
614 }
615 } else {
616 torture_init();
617 }
618
619 if (list_testsuites) {
620 print_testsuite_list();
621 return 0;
622 }
623
624 argv_new = discard_const_p(char *, poptGetArgs(pc));
625
626 argc_new = argc;
627 for (i=0; i<argc; i++) {
628 if (argv_new[i] == NULL) {
629 argc_new = i;
630 break;
631 }
632 }
633
634 if (list_tests) {
635 if (argc_new == 1) {
636 print_test_list(torture_root, NULL, "");
637 } else {
638 for (i=1;i<argc_new;i++) {
639 print_test_list(torture_root, NULL, argv_new[i]);
640 }
641 }
642 return 0;
643 }
644
645 if (torture_seed == 0) {
646 torture_seed = time(NULL);
647 }
648 printf("Using seed %d\n", torture_seed);
649 srandom(torture_seed);
650
651 if (!strcmp(ui_ops_name, "simple")) {
652 ui_ops = &std_ui_ops;
653 } else if (!strcmp(ui_ops_name, "subunit")) {
654 ui_ops = &torture_subunit_ui_ops;
655 } else {
656 printf("Unknown output format '%s'\n", ui_ops_name);
657 exit(1);
658 }
659
660 results = torture_results_init(talloc_autofree_context(), ui_ops);
661
662 torture = torture_context_init(s4_event_context_init(talloc_autofree_context()),
663 results);
664 if (basedir != NULL) {
665 if (basedir[0] != '/') {
666 fprintf(stderr, "Please specify an absolute path to --basedir\n");
667 return 1;
668 }
669 outputdir = talloc_asprintf(torture, "%s/smbtortureXXXXXX", basedir);
670 } else {
671 char *pwd = talloc_size(torture, PATH_MAX);
672 if (!getcwd(pwd, PATH_MAX)) {
673 fprintf(stderr, "Unable to determine current working directory\n");
674 return 1;
675 }
676 outputdir = talloc_asprintf(torture, "%s/smbtortureXXXXXX", pwd);
677 }
678 if (!outputdir) {
679 fprintf(stderr, "Could not allocate per-run output dir\n");
680 return 1;
681 }
682 torture->outputdir = mkdtemp(outputdir);
683 if (!torture->outputdir) {
684 perror("Failed to make temp output dir");
685 }
686
687 torture->lp_ctx = cmdline_lp_ctx;
688
689 gensec_init();
690
691 if (shell) {
692 /* In shell mode, just ignore any remaining test names. */
693 torture_shell(torture);
694 } else {
695
696 /* At this point, we should just have a target string,
697 * followed by a series of test names. Unless we are in
698 * shell mode, in which case we don't need anythig more.
699 */
700
701 if (argc_new < 3) {
702 printf("You must specify a test to run, or 'ALL'\n");
703 usage(pc);
704 torture->results->returncode = 1;
705 } else if (!torture_parse_target(cmdline_lp_ctx, argv_new[1])) {
706 /* Take the target name or binding. */
707 usage(pc);
708 torture->results->returncode = 1;
709 } else {
710 for (i=2;i<argc_new;i++) {
711 if (!torture_run_named_tests(torture, argv_new[i],
712 (const char **)restricted)) {
713 correct = false;
714 }
715 }
716 }
717 }
718
719 /* Now delete the temp dir we created */
720 torture_deltree_outputdir(torture);
721
722 if (torture->results->returncode && correct) {
723 return(0);
724 } else {
725 return(1);
726 }
727 }
reg import