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