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