r25026: Move param/param.h out of includes.h
[kai/samba-autobuild/.git] / source4 / torture / smbtorture.c
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/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 "lib/smbreadline/smbreadline.h"
28 #include "libcli/libcli.h"
29 #include "lib/ldb/include/ldb.h"
30 #include "lib/events/events.h"
31 #include "dynconfig.h"
32
33 #include "torture/torture.h"
34 #include "build.h"
35 #include "lib/util/dlinklist.h"
36 #include "librpc/rpc/dcerpc.h"
37 #include "param/param.h"
38
39 static bool run_matching(struct torture_context *torture,
40                                                  const char *prefix, 
41                                                  const char *expr,
42                                                  struct torture_suite *suite,
43                                                  bool *matched)
44 {
45         bool ret = true;
46
47         if (suite == NULL) {
48                 struct torture_suite *o;
49
50                 for (o = torture_root->children; o; o = o->next) {
51                         if (gen_fnmatch(expr, o->name) == 0) {
52                                 *matched = true;
53                                 init_iconv();
54                                 ret &= torture_run_suite(torture, o);
55                                 continue;
56                         }
57
58                         ret &= run_matching(torture, o->name, expr, o, matched);
59                 }
60         } else {
61                 char *name;
62                 struct torture_suite *c;
63                 struct torture_tcase *t;
64
65                 for (c = suite->children; c; c = c->next) {
66                         asprintf(&name, "%s-%s", prefix, c->name);
67
68                         if (gen_fnmatch(expr, name) == 0) {
69                                 *matched = true;
70                                 init_iconv();
71                                 torture->active_testname = talloc_strdup(torture, prefix);
72                                 ret &= torture_run_suite(torture, c);
73                                 free(name);
74                                 continue;
75                         }
76                         
77                         ret &= run_matching(torture, name, expr, c, matched);
78
79                         free(name);
80                 }
81
82                 for (t = suite->testcases; t; t = t->next) {
83                         asprintf(&name, "%s-%s", prefix, t->name);
84                         if (gen_fnmatch(expr, name) == 0) {
85                                 *matched = true;
86                                 init_iconv();
87                                 torture->active_testname = talloc_strdup(torture, prefix);
88                                 ret &= torture_run_tcase(torture, t);
89                                 talloc_free(torture->active_testname);
90                         }
91                         free(name);
92                 }
93         }
94
95         return ret;
96 }
97
98 #define MAX_COLS 80 /* FIXME: Determine this at run-time */
99
100 /****************************************************************************
101 run a specified test or "ALL"
102 ****************************************************************************/
103 static bool run_test(struct torture_context *torture, const char *name)
104 {
105         bool ret = true;
106         bool matched = false;
107         struct torture_suite *o;
108
109         if (strequal(name, "ALL")) {
110                 for (o = torture_root->children; o; o = o->next) {
111                         ret &= torture_run_suite(torture, o);
112                 }
113                 return ret;
114         }
115
116         ret = run_matching(torture, NULL, name, NULL, &matched);
117
118         if (!matched) {
119                 printf("Unknown torture operation '%s'\n", name);
120                 return false;
121         }
122
123         return ret;
124 }
125
126 static void parse_dns(const char *dns)
127 {
128         char *userdn, *basedn, *secret;
129         char *p, *d;
130
131         /* retrievieng the userdn */
132         p = strchr_m(dns, '#');
133         if (!p) {
134                 lp_set_cmdline("torture:ldap_userdn", "");
135                 lp_set_cmdline("torture:ldap_basedn", "");
136                 lp_set_cmdline("torture:ldap_secret", "");
137                 return;
138         }
139         userdn = strndup(dns, p - dns);
140         lp_set_cmdline("torture:ldap_userdn", userdn);
141
142         /* retrieve the basedn */
143         d = p + 1;
144         p = strchr_m(d, '#');
145         if (!p) {
146                 lp_set_cmdline("torture:ldap_basedn", "");
147                 lp_set_cmdline("torture:ldap_secret", "");
148                 return;
149         }
150         basedn = strndup(d, p - d);
151         lp_set_cmdline("torture:ldap_basedn", basedn);
152
153         /* retrieve the secret */
154         p = p + 1;
155         if (!p) {
156                 lp_set_cmdline("torture:ldap_secret", "");
157                 return;
158         }
159         secret = strdup(p);
160         lp_set_cmdline("torture:ldap_secret", secret);
161
162         printf ("%s - %s - %s\n", userdn, basedn, secret);
163
164 }
165
166 static void print_test_list(void)
167 {
168         struct torture_suite *o;
169         struct torture_suite *s;
170         struct torture_tcase *t;
171
172         for (o = torture_root->children; o; o = o->next) {
173                 for (s = o->children; s; s = s->next) {
174                         printf("%s-%s\n", o->name, s->name);
175                 }
176
177                 for (t = o->testcases; t; t = t->next) {
178                         printf("%s-%s\n", o->name, t->name);
179                 }
180         }
181 }
182
183 _NORETURN_ static void usage(poptContext pc)
184 {
185         struct torture_suite *o;
186         struct torture_suite *s;
187         struct torture_tcase *t;
188         int i;
189
190         poptPrintUsage(pc, stdout, 0);
191         printf("\n");
192
193         printf("The binding format is:\n\n");
194
195         printf("  TRANSPORT:host[flags]\n\n");
196
197         printf("  where TRANSPORT is either ncacn_np for SMB, ncacn_ip_tcp for RPC/TCP\n");
198         printf("  or ncalrpc for local connections.\n\n");
199
200         printf("  'host' is an IP or hostname or netbios name. If the binding string\n");
201         printf("  identifies the server side of an endpoint, 'host' may be an empty\n");
202         printf("  string.\n\n");
203
204         printf("  'flags' can include a SMB pipe name if using the ncacn_np transport or\n");
205         printf("  a TCP port number if using the ncacn_ip_tcp transport, otherwise they\n");
206         printf("  will be auto-determined.\n\n");
207
208         printf("  other recognised flags are:\n\n");
209
210         printf("    sign : enable ntlmssp signing\n");
211         printf("    seal : enable ntlmssp sealing\n");
212         printf("    connect : enable rpc connect level auth (auth, but no sign or seal)\n");
213         printf("    validate: enable the NDR validator\n");
214         printf("    print: enable debugging of the packets\n");
215         printf("    bigendian: use bigendian RPC\n");
216         printf("    padcheck: check reply data for non-zero pad bytes\n\n");
217
218         printf("  For example, these all connect to the samr pipe:\n\n");
219
220         printf("    ncacn_np:myserver\n");
221         printf("    ncacn_np:myserver[samr]\n");
222         printf("    ncacn_np:myserver[\\pipe\\samr]\n");
223         printf("    ncacn_np:myserver[/pipe/samr]\n");
224         printf("    ncacn_np:myserver[samr,sign,print]\n");
225         printf("    ncacn_np:myserver[\\pipe\\samr,sign,seal,bigendian]\n");
226         printf("    ncacn_np:myserver[/pipe/samr,seal,validate]\n");
227         printf("    ncacn_np:\n");
228         printf("    ncacn_np:[/pipe/samr]\n\n");
229
230         printf("    ncacn_ip_tcp:myserver\n");
231         printf("    ncacn_ip_tcp:myserver[1024]\n");
232         printf("    ncacn_ip_tcp:myserver[1024,sign,seal]\n\n");
233
234         printf("    ncalrpc:\n\n");
235
236         printf("The UNC format is:\n\n");
237
238         printf("  //server/share\n\n");
239
240         printf("Tests are:");
241
242         if (torture_root == NULL) {
243             printf("NO TESTS LOADED\n");
244             exit(1);
245         }
246
247         for (o = torture_root->children; o; o = o->next) {
248                 printf("\n%s (%s):\n  ", o->description, o->name);
249
250                 i = 0;
251                 for (s = o->children; s; s = s->next) {
252                         if (i + strlen(o->name) + strlen(s->name) >= (MAX_COLS - 3)) {
253                                 printf("\n  ");
254                                 i = 0;
255                         }
256                         i+=printf("%s-%s ", o->name, s->name);
257                 }
258
259                 for (t = o->testcases; t; t = t->next) {
260                         if (i + strlen(o->name) + strlen(t->name) >= (MAX_COLS - 3)) {
261                                 printf("\n  ");
262                                 i = 0;
263                         }
264                         i+=printf("%s-%s ", o->name, t->name);
265                 }
266
267                 if (i) printf("\n");
268         }
269
270         printf("\nThe default test is ALL.\n");
271
272         exit(1);
273 }
274
275 _NORETURN_ static void max_runtime_handler(int sig)
276 {
277         DEBUG(0,("maximum runtime exceeded for smbtorture - terminating\n"));
278         exit(1);
279 }
280
281 struct timeval last_suite_started;
282
283 static void simple_suite_start(struct torture_context *ctx,
284                                                            struct torture_suite *suite)
285 {
286         last_suite_started = timeval_current();
287         printf("Running %s\n", suite->name);
288 }
289
290 static void simple_suite_finish(struct torture_context *ctx,
291                                                            struct torture_suite *suite)
292 {
293
294         printf("%s took %g secs\n\n", suite->name, 
295                    timeval_elapsed(&last_suite_started));
296 }
297
298 static void simple_test_result (struct torture_context *context, 
299                                                                 enum torture_result res, const char *reason)
300 {
301         switch (res) {
302         case TORTURE_OK:
303                 if (reason)
304                         printf("OK: %s\n", reason);
305                 break;
306         case TORTURE_FAIL:
307                 printf("TEST %s FAILED! - %s\n", context->active_test->name, reason);
308                 break;
309         case TORTURE_ERROR:
310                 printf("ERROR IN TEST %s! - %s\n", context->active_test->name, reason); 
311                 break;
312         case TORTURE_SKIP:
313                 printf("SKIP: %s - %s\n", context->active_test->name, reason);
314                 break;
315         }
316 }
317
318 static void simple_comment (struct torture_context *test, 
319                                                         const char *comment)
320 {
321         printf("%s", comment);
322 }
323
324 static void simple_warning(struct torture_context *test, 
325                                                    const char *comment)
326 {
327         fprintf(stderr, "WARNING: %s\n", comment);
328 }
329
330 const static struct torture_ui_ops std_ui_ops = {
331         .comment = simple_comment,
332         .warning = simple_warning,
333         .suite_start = simple_suite_start,
334         .suite_finish = simple_suite_finish,
335         .test_result = simple_test_result
336 };
337
338 static void subunit_init(struct torture_context *ctx) 
339 {
340         /* FIXME: register segv and bus handler */
341 }
342
343 static void subunit_suite_start(struct torture_context *ctx,
344                                                            struct torture_suite *suite)
345 {
346 }
347
348 static void subunit_test_start (struct torture_context *ctx, 
349                                                             struct torture_tcase *tcase,
350                                                                 struct torture_test *test)
351 {
352         printf("test: %s\n", test->name);
353 }
354
355 static void subunit_test_result (struct torture_context *context, 
356                                                                  enum torture_result res, const char *reason)
357 {
358         switch (res) {
359         case TORTURE_OK:
360                 printf("success: %s", context->active_test->name);
361                 break;
362         case TORTURE_FAIL:
363                 printf("failure: %s", context->active_test->name);
364                 break;
365         case TORTURE_ERROR:
366                 printf("error: %s", context->active_test->name);
367                 break;
368         case TORTURE_SKIP:
369                 printf("skip: %s", context->active_test->name);
370                 break;
371         }
372         if (reason)
373                 printf(" [\n%s\n]", reason);
374         printf("\n");
375 }
376
377 static void subunit_comment (struct torture_context *test, 
378                                                          const char *comment)
379 {
380         fprintf(stderr, "%s", comment);
381 }
382
383 const static struct torture_ui_ops subunit_ui_ops = {
384         .init = subunit_init,
385         .comment = subunit_comment,
386         .test_start = subunit_test_start,
387         .test_result = subunit_test_result,
388         .suite_start = subunit_suite_start
389 };
390
391 static void quiet_suite_start(struct torture_context *ctx,
392                                                   struct torture_suite *suite)
393 {
394         int i;
395         ctx->quiet = true;
396         for (i = 1; i < ctx->level; i++) putchar('\t');
397         printf("%s: ", suite->name);
398         fflush(stdout);
399 }
400
401 static void quiet_suite_finish(struct torture_context *ctx,
402                                                   struct torture_suite *suite)
403 {
404         putchar('\n');
405 }
406
407 static void quiet_test_result (struct torture_context *context, 
408                                                            enum torture_result res, const char *reason)
409 {
410         fflush(stdout);
411         switch (res) {
412         case TORTURE_OK: putchar('.'); break;
413         case TORTURE_FAIL: putchar('F'); break;
414         case TORTURE_ERROR: putchar('E'); break;
415         case TORTURE_SKIP: putchar('I'); break;
416         }
417 }
418
419 const static struct torture_ui_ops quiet_ui_ops = {
420         .suite_start = quiet_suite_start,
421         .suite_finish = quiet_suite_finish,
422         .test_result = quiet_test_result
423 };
424
425 void run_shell(struct torture_context *tctx)
426 {
427         char *cline;
428         int argc;
429         const char **argv;
430         int ret;
431
432         while (1) {
433                 cline = smb_readline("torture> ", NULL, NULL);
434
435                 if (cline == NULL)
436                         return;
437         
438                 ret = poptParseArgvString(cline, &argc, &argv);
439                 if (ret != 0) {
440                         fprintf(stderr, "Error parsing line\n");
441                         continue;
442                 }
443
444                 if (!strcmp(argv[0], "quit")) {
445                         return;
446                 } else if (!strcmp(argv[0], "set")) {
447                         if (argc < 3) {
448                                 fprintf(stderr, "Usage: set <variable> <value>\n");
449                         } else {
450                                 char *name = talloc_asprintf(NULL, "torture:%s", argv[1]);
451                                 lp_set_cmdline(name, argv[2]);
452                                 talloc_free(name);
453                         }
454                 } else if (!strcmp(argv[0], "help")) {
455                         fprintf(stderr, "Available commands:\n"
456                                                         " help - This help command\n"
457                                                         " run - Run test\n"
458                                                         " set - Change variables\n"
459                                                         "\n");
460                 } else if (!strcmp(argv[0], "run")) {
461                         if (argc < 2) {
462                                 fprintf(stderr, "Usage: run TEST-NAME [OPTIONS...]\n");
463                         } else {
464                                 run_test(tctx, argv[1]);
465                         }
466                 }
467         }
468 }
469
470 /****************************************************************************
471   main program
472 ****************************************************************************/
473 int main(int argc,char *argv[])
474 {
475         int opt, i;
476         bool correct = true;
477         int max_runtime=0;
478         int argc_new;
479         struct torture_context *torture;
480         const struct torture_ui_ops *ui_ops;
481         char **argv_new;
482         poptContext pc;
483         static const char *target = "other";
484         struct dcerpc_binding *binding_struct;
485         NTSTATUS status;
486         int shell = False;
487         static const char *ui_ops_name = "simple";
488         const char *basedir = NULL;
489         const char *extra_module = NULL;
490         static int list_tests = 0;
491         char *host = NULL, *share = NULL;
492         enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS, OPT_LIST,
493               OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS};
494         
495         struct poptOption long_options[] = {
496                 POPT_AUTOHELP
497                 {"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit)", NULL },
498                 {"smb-ports",   'p', POPT_ARG_STRING, NULL,     OPT_SMB_PORTS,  "SMB ports",    NULL},
499                 {"basedir",       0, POPT_ARG_STRING, &basedir, 0, "base directory", "BASEDIR" },
500                 {"seed",          0, POPT_ARG_INT,  &torture_seed,      0,      "seed",         NULL},
501                 {"num-progs",     0, POPT_ARG_INT,  NULL,       OPT_NUMPROGS,   "num progs",    NULL},
502                 {"num-ops",       0, POPT_ARG_INT,  &torture_numops,    0,      "num ops",      NULL},
503                 {"entries",       0, POPT_ARG_INT,  &torture_entries,   0,      "entries",      NULL},
504                 {"loadfile",      0, POPT_ARG_STRING,   NULL,   OPT_LOADFILE,   "loadfile",     NULL},
505                 {"list",          0, POPT_ARG_NONE, &list_tests, 0, NULL, NULL },
506                 {"unclist",       0, POPT_ARG_STRING,   NULL,   OPT_UNCLIST,    "unclist",      NULL},
507                 {"timelimit",   't', POPT_ARG_INT,      NULL,   OPT_TIMELIMIT,  "timelimit",    NULL},
508                 {"failures",    'f', POPT_ARG_INT,  &torture_failures,  0,      "failures",     NULL},
509                 {"parse-dns",   'D', POPT_ARG_STRING,   NULL,   OPT_DNS,        "parse-dns",    NULL},
510                 {"dangerous",   'X', POPT_ARG_NONE,     NULL,   OPT_DANGEROUS,
511                  "run dangerous tests (eg. wiping out password database)", NULL},
512                 {"load-module",  0,  POPT_ARG_STRING, &extra_module,     0, "load tests from DSO file",    "SOFILE"},
513                 {"shell",               0, POPT_ARG_NONE, &shell, True, "Run shell", NULL},
514                 {"target",              'T', POPT_ARG_STRING, &target, 0, "samba3|samba4|other", NULL},
515                 {"async",       'a', POPT_ARG_NONE,     NULL,   OPT_ASYNC,
516                  "run async tests", NULL},
517                 {"num-async",    0, POPT_ARG_INT,  &torture_numasync,  0,
518                  "number of simultaneous async requests", NULL},
519                 {"maximum-runtime", 0, POPT_ARG_INT, &max_runtime, 0, 
520                  "set maximum time for smbtorture to live", "seconds"},
521                 POPT_COMMON_SAMBA
522                 POPT_COMMON_CONNECTION
523                 POPT_COMMON_CREDENTIALS
524                 POPT_COMMON_VERSION
525                 { NULL }
526         };
527
528         setlinebuf(stdout);
529
530         /* we are never interested in SIGPIPE */
531         BlockSignals(true, SIGPIPE);
532
533         pc = poptGetContext("smbtorture", argc, (const char **) argv, long_options, 
534                             POPT_CONTEXT_KEEP_FIRST);
535
536         poptSetOtherOptionHelp(pc, "<binding>|<unc> TEST1 TEST2 ...");
537
538         while((opt = poptGetNextOpt(pc)) != -1) {
539                 switch (opt) {
540                 case OPT_LOADFILE:
541                         lp_set_cmdline("torture:loadfile", poptGetOptArg(pc));
542                         break;
543                 case OPT_UNCLIST:
544                         lp_set_cmdline("torture:unclist", poptGetOptArg(pc));
545                         break;
546                 case OPT_TIMELIMIT:
547                         lp_set_cmdline("torture:timelimit", poptGetOptArg(pc));
548                         break;
549                 case OPT_NUMPROGS:
550                         lp_set_cmdline("torture:nprocs", poptGetOptArg(pc));
551                         break;
552                 case OPT_DNS:
553                         parse_dns(poptGetOptArg(pc));
554                         break;
555                 case OPT_DANGEROUS:
556                         lp_set_cmdline("torture:dangerous", "Yes");
557                         break;
558                 case OPT_ASYNC:
559                         lp_set_cmdline("torture:async", "Yes");
560                         break;
561                 case OPT_SMB_PORTS:
562                         lp_set_cmdline("smb ports", poptGetOptArg(pc));
563                         break;
564                 }
565         }
566
567         if (strcmp(target, "samba3") == 0) {
568                 lp_set_cmdline("torture:samba3", "true");
569         } else if (strcmp(target, "samba4") == 0) {
570                 lp_set_cmdline("torture:samba4", "true");
571         }
572
573         if (max_runtime) {
574                 /* this will only work if nobody else uses alarm(),
575                    which means it won't work for some tests, but we
576                    can't use the event context method we use for smbd
577                    as so many tests create their own event
578                    context. This will at least catch most cases. */
579                 signal(SIGALRM, max_runtime_handler);
580                 alarm(max_runtime);
581         }
582
583         ldb_global_init();
584
585         if (extra_module != NULL) {
586             init_module_fn fn = load_module(talloc_autofree_context(), poptGetOptArg(pc));
587
588             if (fn == NULL) 
589                 d_printf("Unable to load module from %s\n", poptGetOptArg(pc));
590             else {
591                 status = fn();
592                 if (NT_STATUS_IS_ERR(status)) {
593                     d_printf("Error initializing module %s: %s\n", 
594                              poptGetOptArg(pc), nt_errstr(status));
595                 }
596             }
597         } else { 
598                 torture_init();
599         }
600
601         if (list_tests) {
602                 print_test_list();
603                 return 0;
604         }
605
606         if (torture_seed == 0) {
607                 torture_seed = time(NULL);
608         } 
609         printf("Using seed %d\n", torture_seed);
610         srandom(torture_seed);
611
612         argv_new = discard_const_p(char *, poptGetArgs(pc));
613
614         argc_new = argc;
615         for (i=0; i<argc; i++) {
616                 if (argv_new[i] == NULL) {
617                         argc_new = i;
618                         break;
619                 }
620         }
621
622         if (!(argc_new >= 3 || (shell && argc_new >= 2))) {
623                 usage(pc);
624                 exit(1);
625         }
626
627         /* see if its a RPC transport specifier */
628         if (!smbcli_parse_unc(argv_new[1], NULL, &host, &share)) {
629                 status = dcerpc_parse_binding(talloc_autofree_context(), argv_new[1], &binding_struct);
630                 if (NT_STATUS_IS_ERR(status)) {
631                         d_printf("Invalid option: %s is not a valid torture target (share or binding string)\n\n", argv_new[1]);
632                         usage(pc);
633                         return false;
634                 }
635                 lp_set_cmdline("torture:host", binding_struct->host);
636                 lp_set_cmdline("torture:share", "IPC$");
637                 lp_set_cmdline("torture:binding", argv_new[1]);
638         } else {
639                 lp_set_cmdline("torture:host", host);
640                 lp_set_cmdline("torture:share", share);
641                 lp_set_cmdline("torture:binding", host);
642         }
643
644         if (!strcmp(ui_ops_name, "simple")) {
645                 ui_ops = &std_ui_ops;
646         } else if (!strcmp(ui_ops_name, "subunit")) {
647                 ui_ops = &subunit_ui_ops;
648         } else if (!strcmp(ui_ops_name, "quiet")) {
649                 ui_ops = &quiet_ui_ops;
650         } else {
651                 printf("Unknown output format '%s'\n", ui_ops_name);
652                 exit(1);
653         }
654
655         torture = torture_context_init(talloc_autofree_context(), ui_ops);
656         if (basedir != NULL) {
657                 if (basedir[0] != '/') {
658                         fprintf(stderr, "Please specify an absolute path to --basedir\n");
659                         return 1;
660                 }
661                 torture->outputdir = basedir;
662         } else {
663                 char *pwd = talloc_size(torture, PATH_MAX);
664                 if (!getcwd(pwd, PATH_MAX)) {
665                         fprintf(stderr, "Unable to determine current working directory\n");
666                         return 1;
667                 }
668                 torture->outputdir = pwd;
669         }
670
671         if (argc_new == 0) {
672                 printf("You must specify a test to run, or 'ALL'\n");
673         } else if (shell) {
674                 run_shell(torture);
675         } else {
676                 for (i=2;i<argc_new;i++) {
677                         if (!run_test(torture, argv_new[i])) {
678                                 correct = false;
679                         }
680                 }
681         }
682
683         if (torture->returncode && correct) {
684                 return(0);
685         } else {
686                 return(1);
687         }
688 }