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 "system/readline.h"
  28 #include "lib/smbreadline/smbreadline.h"
  29 #include "libcli/libcli.h"
  30 #include "lib/ldb/include/ldb.h"
  31 #include "lib/events/events.h"
  32 #include "dynconfig.h"
  33
  34 #include "torture/torture.h"
  35 #include "build.h"
  36 #include "lib/util/dlinklist.h"
  37 #include "librpc/rpc/dcerpc.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 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         for (o = torture_root->children; o; o = o->next) {
 243                 printf("\n%s (%s):\n  ", o->description, o->name);
 244
 245                 i = 0;
 246                 for (s = o->children; s; s = s->next) {
 247                         if (i + strlen(o->name) + strlen(s->name) >= (MAX_COLS - 3)) {
 248                                 printf("\n  ");
 249                                 i = 0;
 250                         }
 251                         i+=printf("%s-%s ", o->name, s->name);
 252                 }
 253
 254                 for (t = o->testcases; t; t = t->next) {
 255                         if (i + strlen(o->name) + strlen(t->name) >= (MAX_COLS - 3)) {
 256                                 printf("\n  ");
 257                                 i = 0;
 258                         }
 259                         i+=printf("%s-%s ", o->name, t->name);
 260                 }
 261
 262                 if (i) printf("\n");
 263         }
 264
 265         printf("\nThe default test is ALL.\n");
 266
 267         exit(1);
 268 }
 269
 270 static void max_runtime_handler(int sig)
 271 {
 272         DEBUG(0,("maximum runtime exceeded for smbtorture - terminating\n"));
 273         exit(1);
 274 }
 275
 276 struct timeval last_suite_started;
 277
 278 static void simple_suite_start(struct torture_context *ctx,
 279                                                            struct torture_suite *suite)
 280 {
 281         last_suite_started = timeval_current();
 282         printf("Running %s\n", suite->name);
 283 }
 284
 285 static void simple_suite_finish(struct torture_context *ctx,
 286                                                            struct torture_suite *suite)
 287 {
 288
 289         printf("%s took %g secs\n\n", suite->name,
 290                    timeval_elapsed(&last_suite_started));
 291 }
 292
 293 static void simple_test_result (struct torture_context *context,
 294                                                                 enum torture_result res, const char *reason)
 295 {
 296         switch (res) {
 297         case TORTURE_OK:
 298                 if (reason)
 299                         printf("OK: %s\n", reason);
 300                 break;
 301         case TORTURE_FAIL:
 302                 printf("TEST %s FAILED! - %s\n", context->active_test->name, reason);
 303                 break;
 304         case TORTURE_ERROR:
 305                 printf("ERROR IN TEST %s! - %s\n", context->active_test->name, reason);
 306                 break;
 307         case TORTURE_SKIP:
 308                 printf("SKIP: %s - %s\n", context->active_test->name, reason);
 309                 break;
 310         }
 311 }
 312
 313 static void simple_comment (struct torture_context *test,
 314                                                         const char *comment)
 315 {
 316         printf("%s", comment);
 317 }
 318
 319 const static struct torture_ui_ops std_ui_ops = {
 320         .comment = simple_comment,
 321         .suite_start = simple_suite_start,
 322         .suite_finish = simple_suite_finish,
 323         .test_result = simple_test_result
 324 };
 325
 326 static void subunit_suite_start(struct torture_context *ctx,
 327                                                            struct torture_suite *suite)
 328 {
 329         printf("testsuite: %s\n", suite->name);
 330 }
 331
 332 static void subunit_test_start (struct torture_context *ctx,
 333                                                             struct torture_tcase *tcase,
 334                                                                 struct torture_test *test)
 335 {
 336         printf("test: %s\n", test->name);
 337 }
 338
 339 static void subunit_test_result (struct torture_context *context,
 340                                                                  enum torture_result res, const char *reason)
 341 {
 342         switch (res) {
 343         case TORTURE_OK:
 344                 printf("success: %s", context->active_test->name);
 345                 break;
 346         case TORTURE_FAIL:
 347                 printf("failure: %s", context->active_test->name);
 348                 break;
 349         case TORTURE_ERROR:
 350                 printf("error: %s", context->active_test->name);
 351                 break;
 352         case TORTURE_SKIP:
 353                 printf("skip: %s", context->active_test->name);
 354                 break;
 355         }
 356         if (reason)
 357                 printf(" [ %s ]", reason);
 358         printf("\n");
 359 }
 360
 361 static void subunit_comment (struct torture_context *test,
 362                                                          const char *comment)
 363 {
 364         fprintf(stderr, "%s", comment);
 365 }
 366
 367 const static struct torture_ui_ops subunit_ui_ops = {
 368         .comment = subunit_comment,
 369         .test_start = subunit_test_start,
 370         .test_result = subunit_test_result,
 371         .suite_start = subunit_suite_start
 372 };
 373
 374 static void harness_test_start (struct torture_context *ctx,
 375                                                             struct torture_tcase *tcase,
 376                                                                 struct torture_test *test)
 377 {
 378 }
 379
 380 static void harness_test_result (struct torture_context *context,
 381                                                                  enum torture_result res, const char *reason)
 382 {
 383         switch (res) {
 384         case TORTURE_OK:
 385                 printf("ok %s - %s\n", context->active_test->name, reason);
 386                 break;
 387         case TORTURE_FAIL:
 388         case TORTURE_ERROR:
 389                 printf("not ok %s - %s\n", context->active_test->name, reason);
 390                 break;
 391         case TORTURE_SKIP:
 392                 printf("skip %s - %s\n", context->active_test->name, reason);
 393                 break;
 394         }
 395 }
 396
 397 static void harness_comment (struct torture_context *test,
 398                                                          const char *comment)
 399 {
 400         printf("# %s\n", comment);
 401 }
 402
 403 const static struct torture_ui_ops harness_ui_ops = {
 404         .comment = harness_comment,
 405         .test_start = harness_test_start,
 406         .test_result = harness_test_result
 407 };
 408
 409 static void quiet_suite_start(struct torture_context *ctx,
 410                                                   struct torture_suite *suite)
 411 {
 412         int i;
 413         ctx->quiet = true;
 414         for (i = 1; i < ctx->level; i++) putchar('\t');
 415         printf("%s: ", suite->name);
 416         fflush(stdout);
 417 }
 418
 419 static void quiet_suite_finish(struct torture_context *ctx,
 420                                                   struct torture_suite *suite)
 421 {
 422         putchar('\n');
 423 }
 424
 425 static void quiet_test_result (struct torture_context *context,
 426                                                            enum torture_result res, const char *reason)
 427 {
 428         fflush(stdout);
 429         switch (res) {
 430         case TORTURE_OK: putchar('.'); break;
 431         case TORTURE_FAIL: putchar('F'); break;
 432         case TORTURE_ERROR: putchar('E'); break;
 433         case TORTURE_SKIP: putchar('I'); break;
 434         }
 435 }
 436
 437 const static struct torture_ui_ops quiet_ui_ops = {
 438         .suite_start = quiet_suite_start,
 439         .suite_finish = quiet_suite_finish,
 440         .test_result = quiet_test_result
 441 };
 442
 443 void run_shell(struct torture_context *tctx)
 444 {
 445         char *cline;
 446         int argc;
 447         const char **argv;
 448         int ret;
 449
 450         while (1) {
 451                 cline = smb_readline("torture> ", NULL, NULL);
 452
 453                 if (cline == NULL)
 454                         return;
 455
 456                 ret = poptParseArgvString(cline, &argc, &argv);
 457                 if (ret != 0) {
 458                         fprintf(stderr, "Error parsing line\n");
 459                         continue;
 460                 }
 461
 462                 if (!strcmp(argv[0], "quit")) {
 463                         return;
 464                 } else if (!strcmp(argv[0], "set")) {
 465                         if (argc < 3) {
 466                                 fprintf(stderr, "Usage: set <variable> <value>\n");
 467                         } else {
 468                                 char *name = talloc_asprintf(NULL, "torture:%s", argv[1]);
 469                                 lp_set_cmdline(name, argv[2]);
 470                                 talloc_free(name);
 471                         }
 472                 } else if (!strcmp(argv[0], "help")) {
 473                         fprintf(stderr, "Available commands:\n"
 474                                                         " help - This help command\n"
 475                                                         " run - Run test\n"
 476                                                         " set - Change variables\n"
 477                                                         "\n");
 478                 } else if (!strcmp(argv[0], "run")) {
 479                         if (argc < 2) {
 480                                 fprintf(stderr, "Usage: run TEST-NAME [OPTIONS...]\n");
 481                         } else {
 482                                 run_test(tctx, argv[1]);
 483                         }
 484                 }
 485         }
 486 }
 487
 488 /****************************************************************************
 489   main program
 490 ****************************************************************************/
 491 int main(int argc,char *argv[])
 492 {
 493         int opt, i;
 494         bool correct = true;
 495         int max_runtime=0;
 496         int argc_new;
 497         struct torture_context *torture;
 498         const struct torture_ui_ops *ui_ops;
 499         char **argv_new;
 500         poptContext pc;
 501         static const char *target = "other";
 502         struct dcerpc_binding *binding_struct;
 503         NTSTATUS status;
 504         int shell = False;
 505         static const char *ui_ops_name = "simple";
 506         static int list_tests = 0;
 507         enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS, OPT_LIST,
 508               OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS, OPT_BASEDIR};
 509
 510         struct poptOption long_options[] = {
 511                 POPT_AUTOHELP
 512                 {"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit, harness)", NULL },
 513                 {"smb-ports",   'p', POPT_ARG_STRING, NULL,     OPT_SMB_PORTS,  "SMB ports",    NULL},
 514                 {"basedir",       0, POPT_ARG_STRING, NULL, OPT_BASEDIR, "base directory", "BSAEDIR" },
 515                 {"seed",          0, POPT_ARG_INT,  &torture_seed,      0,      "seed",         NULL},
 516                 {"num-progs",     0, POPT_ARG_INT,  NULL,       OPT_NUMPROGS,   "num progs",    NULL},
 517                 {"num-ops",       0, POPT_ARG_INT,  &torture_numops,    0,      "num ops",      NULL},
 518                 {"entries",       0, POPT_ARG_INT,  &torture_entries,   0,      "entries",      NULL},
 519                 {"loadfile",      0, POPT_ARG_STRING,   NULL,   OPT_LOADFILE,   "loadfile",     NULL},
 520                 {"list",          0, POPT_ARG_NONE, &list_tests, 0, NULL, NULL },
 521                 {"unclist",       0, POPT_ARG_STRING,   NULL,   OPT_UNCLIST,    "unclist",      NULL},
 522                 {"timelimit",   't', POPT_ARG_INT,      NULL,   OPT_TIMELIMIT,  "timelimit",    NULL},
 523                 {"failures",    'f', POPT_ARG_INT,  &torture_failures,  0,      "failures",     NULL},
 524                 {"parse-dns",   'D', POPT_ARG_STRING,   NULL,   OPT_DNS,        "parse-dns",    NULL},
 525                 {"dangerous",   'X', POPT_ARG_NONE,     NULL,   OPT_DANGEROUS,
 526                  "run dangerous tests (eg. wiping out password database)", NULL},
 527                 {"shell",               0, POPT_ARG_NONE, &shell, True, "Run shell", NULL},
 528                 {"target",              'T', POPT_ARG_STRING, &target, 0, "samba3|samba4|other", NULL},
 529                 {"async",       'a', POPT_ARG_NONE,     NULL,   OPT_ASYNC,
 530                  "run async tests", NULL},
 531                 {"num-async",    0, POPT_ARG_INT,  &torture_numasync,  0,
 532                  "number of simultaneous async requests", NULL},
 533                 {"maximum-runtime", 0, POPT_ARG_INT, &max_runtime, 0,
 534                  "set maximum time for smbtorture to live", "seconds"},
 535                 POPT_COMMON_SAMBA
 536                 POPT_COMMON_CONNECTION
 537                 POPT_COMMON_CREDENTIALS
 538                 POPT_COMMON_VERSION
 539                 { NULL }
 540         };
 541
 542         setlinebuf(stdout);
 543
 544         /* we are never interested in SIGPIPE */
 545         BlockSignals(true, SIGPIPE);
 546
 547         pc = poptGetContext("smbtorture", argc, (const char **) argv, long_options,
 548                             POPT_CONTEXT_KEEP_FIRST);
 549
 550         poptSetOtherOptionHelp(pc, "<binding>|<unc> TEST1 TEST2 ...");
 551
 552         while((opt = poptGetNextOpt(pc)) != -1) {
 553                 switch (opt) {
 554                 case OPT_LOADFILE:
 555                         lp_set_cmdline("torture:loadfile", poptGetOptArg(pc));
 556                         break;
 557                 case OPT_UNCLIST:
 558                         lp_set_cmdline("torture:unclist", poptGetOptArg(pc));
 559                         break;
 560                 case OPT_TIMELIMIT:
 561                         lp_set_cmdline("torture:timelimit", poptGetOptArg(pc));
 562                         break;
 563                 case OPT_NUMPROGS:
 564                         lp_set_cmdline("torture:nprocs", poptGetOptArg(pc));
 565                         break;
 566                 case OPT_BASEDIR:
 567                         lp_set_cmdline("torture:basedir", poptGetOptArg(pc));
 568                         break;
 569                 case OPT_DNS:
 570                         parse_dns(poptGetOptArg(pc));
 571                         break;
 572                 case OPT_DANGEROUS:
 573                         lp_set_cmdline("torture:dangerous", "Yes");
 574                         break;
 575                 case OPT_ASYNC:
 576                         lp_set_cmdline("torture:async", "Yes");
 577                         break;
 578                 case OPT_SMB_PORTS:
 579                         lp_set_cmdline("smb ports", poptGetOptArg(pc));
 580                         break;
 581                 }
 582         }
 583
 584         if (strcmp(target, "samba3") == 0) {
 585                 lp_set_cmdline("torture:samba3", "true");
 586                 lp_set_cmdline("torture:knownfail", "samba3-knownfail");
 587         } else if (strcmp(target, "samba4") == 0) {
 588                 lp_set_cmdline("torture:samba4", "true");
 589                 lp_set_cmdline("torture:knownfail", "samba4-knownfail");
 590         }
 591
 592         if (max_runtime) {
 593                 /* this will only work if nobody else uses alarm(),
 594                    which means it won't work for some tests, but we
 595                    can't use the event context method we use for smbd
 596                    as so many tests create their own event
 597                    context. This will at least catch most cases. */
 598                 signal(SIGALRM, max_runtime_handler);
 599                 alarm(max_runtime);
 600         }
 601
 602         torture_init();
 603         ldb_global_init();
 604
 605         if (list_tests) {
 606                 print_test_list();
 607                 return 0;
 608         }
 609
 610         if (torture_seed == 0) {
 611                 torture_seed = time(NULL);
 612         }
 613         printf("Using seed %d\n", torture_seed);
 614         srandom(torture_seed);
 615
 616         argv_new = discard_const_p(char *, poptGetArgs(pc));
 617
 618         argc_new = argc;
 619         for (i=0; i<argc; i++) {
 620                 if (argv_new[i] == NULL) {
 621                         argc_new = i;
 622                         break;
 623                 }
 624         }
 625
 626         if (!(argc_new >= 3 || (shell && argc_new >= 2))) {
 627                 usage(pc);
 628                 exit(1);
 629         }
 630
 631         /* see if its a RPC transport specifier */
 632         status = dcerpc_parse_binding(talloc_autofree_context(), argv_new[1], &binding_struct);
 633         if (NT_STATUS_IS_OK(status)) {
 634                 lp_set_cmdline("torture:host", binding_struct->host);
 635                 lp_set_cmdline("torture:share", "IPC$");
 636                 lp_set_cmdline("torture:binding", argv_new[1]);
 637         } else {
 638                 char *binding = NULL;
 639                 char *host = NULL, *share = NULL;
 640
 641                 if (!smbcli_parse_unc(argv_new[1], NULL, &host, &share)) {
 642                         d_printf("Invalid option: %s is not a valid torture target (share or binding string)\n\n", argv_new[1]);
 643                         usage(pc);
 644                 }
 645
 646                 lp_set_cmdline("torture:host", host);
 647                 lp_set_cmdline("torture:share", share);
 648                 asprintf(&binding, "ncacn_np:%s", host);
 649                 lp_set_cmdline("torture:binding", binding);
 650         }
 651
 652         if (!strcmp(ui_ops_name, "simple")) {
 653                 ui_ops = &std_ui_ops;
 654         } else if (!strcmp(ui_ops_name, "subunit")) {
 655                 ui_ops = &subunit_ui_ops;
 656         } else if (!strcmp(ui_ops_name, "harness")) {
 657                 ui_ops = &harness_ui_ops;
 658         } else if (!strcmp(ui_ops_name, "quiet")) {
 659                 ui_ops = &quiet_ui_ops;
 660         } else {
 661                 printf("Unknown output format '%s'\n", ui_ops_name);
 662                 exit(1);
 663         }
 664
 665         torture = torture_context_init(talloc_autofree_context(),
 666                                 lp_parm_string(-1, "torture", "knownfail"), ui_ops);
 667
 668         if (argc_new == 0) {
 669                 printf("You must specify a test to run, or 'ALL'\n");
 670         } else if (shell) {
 671                 run_shell(torture);
 672         } else {
 673                 for (i=2;i<argc_new;i++) {
 674                         if (!run_test(torture, argv_new[i])) {
 675                                 correct = false;
 676                         }
 677                 }
 678         }
 679
 680         if (torture->returncode) {
 681                 return(0);
 682         } else {
 683                 return(1);
 684         }
 685 }