Fix problems with event context not being the parent.
[gd/samba-autobuild/.git] / source4 / torture / smbtorture.c
index 02abe7f2a7cc4795ee19265f9373721f786d05ca..faae784e4b09db4418f01e16b080670e168f66df 100644 (file)
@@ -34,6 +34,9 @@
 #include "build.h"
 #include "lib/util/dlinklist.h"
 #include "librpc/rpc/dcerpc.h"
+#include "param/param.h"
+
+#include "auth/credentials/credentials.h"
 
 static bool run_matching(struct torture_context *torture,
                                                 const char *prefix, 
@@ -49,7 +52,7 @@ static bool run_matching(struct torture_context *torture,
                for (o = torture_root->children; o; o = o->next) {
                        if (gen_fnmatch(expr, o->name) == 0) {
                                *matched = true;
-                               init_iconv();
+                               reload_charcnv(torture->lp_ctx);
                                ret &= torture_run_suite(torture, o);
                                continue;
                        }
@@ -66,7 +69,7 @@ static bool run_matching(struct torture_context *torture,
 
                        if (gen_fnmatch(expr, name) == 0) {
                                *matched = true;
-                               init_iconv();
+                               reload_charcnv(torture->lp_ctx);
                                torture->active_testname = talloc_strdup(torture, prefix);
                                ret &= torture_run_suite(torture, c);
                                free(name);
@@ -82,7 +85,7 @@ static bool run_matching(struct torture_context *torture,
                        asprintf(&name, "%s-%s", prefix, t->name);
                        if (gen_fnmatch(expr, name) == 0) {
                                *matched = true;
-                               init_iconv();
+                               reload_charcnv(torture->lp_ctx);
                                torture->active_testname = talloc_strdup(torture, prefix);
                                ret &= torture_run_tcase(torture, t);
                                talloc_free(torture->active_testname);
@@ -122,7 +125,33 @@ static bool run_test(struct torture_context *torture, const char *name)
        return ret;
 }
 
-static void parse_dns(const char *dns)
+static bool parse_target(struct loadparm_context *lp_ctx, const char *target)
+{
+       char *host = NULL, *share = NULL;
+       struct dcerpc_binding *binding_struct;
+       NTSTATUS status;
+
+       /* see if its a RPC transport specifier */
+       if (!smbcli_parse_unc(target, NULL, &host, &share)) {
+               status = dcerpc_parse_binding(talloc_autofree_context(), target, &binding_struct);
+               if (NT_STATUS_IS_ERR(status)) {
+                       d_printf("Invalid option: %s is not a valid torture target (share or binding string)\n\n", target);
+                       return false;
+               }
+               lp_set_cmdline(lp_ctx, "torture:host", binding_struct->host);
+               if (lp_parm_string(lp_ctx, NULL, "torture", "share") == NULL)
+                       lp_set_cmdline(lp_ctx, "torture:share", "IPC$");
+               lp_set_cmdline(lp_ctx, "torture:binding", target);
+       } else {
+               lp_set_cmdline(lp_ctx, "torture:host", host);
+               lp_set_cmdline(lp_ctx, "torture:share", share);
+               lp_set_cmdline(lp_ctx, "torture:binding", host);
+       }
+
+       return true;
+}
+
+static void parse_dns(struct loadparm_context *lp_ctx, const char *dns)
 {
        char *userdn, *basedn, *secret;
        char *p, *d;
@@ -130,33 +159,33 @@ static void parse_dns(const char *dns)
        /* retrievieng the userdn */
        p = strchr_m(dns, '#');
        if (!p) {
-               lp_set_cmdline("torture:ldap_userdn", "");
-               lp_set_cmdline("torture:ldap_basedn", "");
-               lp_set_cmdline("torture:ldap_secret", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_userdn", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
                return;
        }
        userdn = strndup(dns, p - dns);
-       lp_set_cmdline("torture:ldap_userdn", userdn);
+       lp_set_cmdline(lp_ctx, "torture:ldap_userdn", userdn);
 
        /* retrieve the basedn */
        d = p + 1;
        p = strchr_m(d, '#');
        if (!p) {
-               lp_set_cmdline("torture:ldap_basedn", "");
-               lp_set_cmdline("torture:ldap_secret", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
                return;
        }
        basedn = strndup(d, p - d);
-       lp_set_cmdline("torture:ldap_basedn", basedn);
+       lp_set_cmdline(lp_ctx, "torture:ldap_basedn", basedn);
 
        /* retrieve the secret */
        p = p + 1;
        if (!p) {
-               lp_set_cmdline("torture:ldap_secret", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
                return;
        }
        secret = strdup(p);
-       lp_set_cmdline("torture:ldap_secret", secret);
+       lp_set_cmdline(lp_ctx, "torture:ldap_secret", secret);
 
        printf ("%s - %s - %s\n", userdn, basedn, secret);
 
@@ -168,6 +197,9 @@ static void print_test_list(void)
        struct torture_suite *s;
        struct torture_tcase *t;
 
+       if (torture_root == NULL)
+               return;
+
        for (o = torture_root->children; o; o = o->next) {
                for (s = o->children; s; s = s->next) {
                        printf("%s-%s\n", o->name, s->name);
@@ -179,7 +211,7 @@ static void print_test_list(void)
        }
 }
 
-static void usage(poptContext pc)
+_NORETURN_ static void usage(poptContext pc)
 {
        struct torture_suite *o;
        struct torture_suite *s;
@@ -238,6 +270,11 @@ static void usage(poptContext pc)
 
        printf("Tests are:");
 
+       if (torture_root == NULL) {
+           printf("NO TESTS LOADED\n");
+           exit(1);
+       }
+
        for (o = torture_root->children; o; o = o->next) {
                printf("\n%s (%s):\n  ", o->description, o->name);
 
@@ -266,7 +303,7 @@ static void usage(poptContext pc)
        exit(1);
 }
 
-static void max_runtime_handler(int sig)
+_NORETURN_ static void max_runtime_handler(int sig)
 {
        DEBUG(0,("maximum runtime exceeded for smbtorture - terminating\n"));
        exit(1);
@@ -275,22 +312,22 @@ static void max_runtime_handler(int sig)
 struct timeval last_suite_started;
 
 static void simple_suite_start(struct torture_context *ctx,
-                                                          struct torture_suite *suite)
+                              struct torture_suite *suite)
 {
        last_suite_started = timeval_current();
        printf("Running %s\n", suite->name);
 }
 
 static void simple_suite_finish(struct torture_context *ctx,
-                                                          struct torture_suite *suite)
+                               struct torture_suite *suite)
 {
 
        printf("%s took %g secs\n\n", suite->name, 
                   timeval_elapsed(&last_suite_started));
 }
 
-static void simple_test_result (struct torture_context *context, 
-                                                               enum torture_result res, const char *reason)
+static void simple_test_result(struct torture_context *context, 
+                              enum torture_result res, const char *reason)
 {
        switch (res) {
        case TORTURE_OK:
@@ -309,14 +346,14 @@ static void simple_test_result (struct torture_context *context,
        }
 }
 
-static void simple_comment (struct torture_context *test, 
-                                                       const char *comment)
+static void simple_comment(struct torture_context *test, 
+                          const char *comment)
 {
        printf("%s", comment);
 }
 
 static void simple_warning(struct torture_context *test, 
-                                                  const char *comment)
+                          const char *comment)
 {
        fprintf(stderr, "WARNING: %s\n", comment);
 }
@@ -335,20 +372,19 @@ static void subunit_init(struct torture_context *ctx)
 }
 
 static void subunit_suite_start(struct torture_context *ctx,
-                                                          struct torture_suite *suite)
+                               struct torture_suite *suite)
 {
-       printf("testsuite: %s\n", suite->name);
 }
 
-static void subunit_test_start (struct torture_context *ctx, 
-                                                           struct torture_tcase *tcase,
-                                                               struct torture_test *test)
+static void subunit_test_start(struct torture_context *ctx, 
+                              struct torture_tcase *tcase,
+                              struct torture_test *test)
 {
        printf("test: %s\n", test->name);
 }
 
-static void subunit_test_result (struct torture_context *context, 
-                                                                enum torture_result res, const char *reason)
+static void subunit_test_result(struct torture_context *context, 
+                               enum torture_result res, const char *reason)
 {
        switch (res) {
        case TORTURE_OK:
@@ -369,57 +405,29 @@ static void subunit_test_result (struct torture_context *context,
        printf("\n");
 }
 
-static void subunit_comment (struct torture_context *test, 
-                                                        const char *comment)
+static void subunit_comment(struct torture_context *test,
+                           const char *comment)
 {
        fprintf(stderr, "%s", comment);
 }
 
+static void subunit_warning(struct torture_context *test,
+                           const char *comment)
+{
+       fprintf(stderr, "WARNING!: %s\n", comment);
+}
+
 const static struct torture_ui_ops subunit_ui_ops = {
        .init = subunit_init,
        .comment = subunit_comment,
+       .warning = subunit_warning,
        .test_start = subunit_test_start,
        .test_result = subunit_test_result,
        .suite_start = subunit_suite_start
 };
 
-static void harness_test_start (struct torture_context *ctx, 
-                                                           struct torture_tcase *tcase,
-                                                               struct torture_test *test)
-{
-}
-
-static void harness_test_result (struct torture_context *context, 
-                                                                enum torture_result res, const char *reason)
-{
-       switch (res) {
-       case TORTURE_OK:
-               printf("ok %s - %s\n", context->active_test->name, reason);
-               break;
-       case TORTURE_FAIL:
-       case TORTURE_ERROR:
-               printf("not ok %s - %s\n", context->active_test->name, reason);
-               break;
-       case TORTURE_SKIP:
-               printf("skip %s - %s\n", context->active_test->name, reason);
-               break;
-       }
-}
-
-static void harness_comment (struct torture_context *test, 
-                                                        const char *comment)
-{
-       printf("# %s\n", comment);
-}
-
-const static struct torture_ui_ops harness_ui_ops = {
-       .comment = harness_comment,
-       .test_start = harness_test_start,
-       .test_result = harness_test_result
-};
-
 static void quiet_suite_start(struct torture_context *ctx,
-                                                 struct torture_suite *suite)
+                             struct torture_suite *suite)
 {
        int i;
        ctx->quiet = true;
@@ -429,13 +437,13 @@ static void quiet_suite_start(struct torture_context *ctx,
 }
 
 static void quiet_suite_finish(struct torture_context *ctx,
-                                                 struct torture_suite *suite)
+                              struct torture_suite *suite)
 {
        putchar('\n');
 }
 
-static void quiet_test_result (struct torture_context *context, 
-                                                          enum torture_result res, const char *reason)
+static void quiet_test_result(struct torture_context *context, 
+                             enum torture_result res, const char *reason)
 {
        fflush(stdout);
        switch (res) {
@@ -478,7 +486,7 @@ void run_shell(struct torture_context *tctx)
                                fprintf(stderr, "Usage: set <variable> <value>\n");
                        } else {
                                char *name = talloc_asprintf(NULL, "torture:%s", argv[1]);
-                               lp_set_cmdline(name, argv[2]);
+                               lp_set_cmdline(tctx->lp_ctx, name, argv[2]);
                                talloc_free(name);
                        }
                } else if (!strcmp(argv[0], "help")) {
@@ -494,6 +502,7 @@ void run_shell(struct torture_context *tctx)
                                run_test(tctx, argv[1]);
                        }
                }
+               free(cline);
        }
 }
 
@@ -511,32 +520,34 @@ int main(int argc,char *argv[])
        char **argv_new;
        poptContext pc;
        static const char *target = "other";
-       struct dcerpc_binding *binding_struct;
        NTSTATUS status;
-       int shell = False;
+       int shell = false;
        static const char *ui_ops_name = "simple";
+       const char *basedir = NULL;
+       const char *extra_module = NULL;
        static int list_tests = 0;
        enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS, OPT_LIST,
-             OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS, OPT_BASEDIR};
+             OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS};
        
        struct poptOption long_options[] = {
                POPT_AUTOHELP
-               {"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit, harness)", NULL },
+               {"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit)", NULL },
                {"smb-ports",   'p', POPT_ARG_STRING, NULL,     OPT_SMB_PORTS,  "SMB ports",    NULL},
-               {"basedir",       0, POPT_ARG_STRING, NULL, OPT_BASEDIR, "base directory", "BSAEDIR" },
-               {"seed",          0, POPT_ARG_INT,  &torture_seed,      0,      "seed",         NULL},
+               {"basedir",       0, POPT_ARG_STRING, &basedir, 0, "base directory", "BASEDIR" },
+               {"seed",          0, POPT_ARG_INT,  &torture_seed,      0,      "Seed to use for randomizer",   NULL},
                {"num-progs",     0, POPT_ARG_INT,  NULL,       OPT_NUMPROGS,   "num progs",    NULL},
                {"num-ops",       0, POPT_ARG_INT,  &torture_numops,    0,      "num ops",      NULL},
                {"entries",       0, POPT_ARG_INT,  &torture_entries,   0,      "entries",      NULL},
-               {"loadfile",      0, POPT_ARG_STRING,   NULL,   OPT_LOADFILE,   "loadfile",     NULL},
-               {"list",          0, POPT_ARG_NONE, &list_tests, 0, NULL, NULL },
+               {"loadfile",      0, POPT_ARG_STRING,   NULL,   OPT_LOADFILE,   "NBench load file to use",      NULL},
+               {"list",          0, POPT_ARG_NONE, &list_tests, 0, "List available tests and exit", NULL },
                {"unclist",       0, POPT_ARG_STRING,   NULL,   OPT_UNCLIST,    "unclist",      NULL},
-               {"timelimit",   't', POPT_ARG_INT,      NULL,   OPT_TIMELIMIT,  "timelimit",    NULL},
+               {"timelimit",   't', POPT_ARG_INT,      NULL,   OPT_TIMELIMIT,  "Set time limit (in seconds)",  NULL},
                {"failures",    'f', POPT_ARG_INT,  &torture_failures,  0,      "failures",     NULL},
                {"parse-dns",   'D', POPT_ARG_STRING,   NULL,   OPT_DNS,        "parse-dns",    NULL},
                {"dangerous",   'X', POPT_ARG_NONE,     NULL,   OPT_DANGEROUS,
                 "run dangerous tests (eg. wiping out password database)", NULL},
-               {"shell",               0, POPT_ARG_NONE, &shell, True, "Run shell", NULL},
+               {"load-module",  0,  POPT_ARG_STRING, &extra_module,     0, "load tests from DSO file",    "SOFILE"},
+               {"shell",               0, POPT_ARG_NONE, &shell, true, "Run shell", NULL},
                {"target",              'T', POPT_ARG_STRING, &target, 0, "samba3|samba4|other", NULL},
                {"async",       'a', POPT_ARG_NONE,     NULL,   OPT_ASYNC,
                 "run async tests", NULL},
@@ -564,39 +575,36 @@ int main(int argc,char *argv[])
        while((opt = poptGetNextOpt(pc)) != -1) {
                switch (opt) {
                case OPT_LOADFILE:
-                       lp_set_cmdline("torture:loadfile", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:loadfile", poptGetOptArg(pc));
                        break;
                case OPT_UNCLIST:
-                       lp_set_cmdline("torture:unclist", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
                        break;
                case OPT_TIMELIMIT:
-                       lp_set_cmdline("torture:timelimit", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:timelimit", poptGetOptArg(pc));
                        break;
                case OPT_NUMPROGS:
-                       lp_set_cmdline("torture:nprocs", poptGetOptArg(pc));
-                       break;
-               case OPT_BASEDIR:
-                       lp_set_cmdline("torture:basedir", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:nprocs", poptGetOptArg(pc));
                        break;
                case OPT_DNS:
-                       parse_dns(poptGetOptArg(pc));
+                       parse_dns(cmdline_lp_ctx, poptGetOptArg(pc));
                        break;
                case OPT_DANGEROUS:
-                       lp_set_cmdline("torture:dangerous", "Yes");
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:dangerous", "Yes");
                        break;
                case OPT_ASYNC:
-                       lp_set_cmdline("torture:async", "Yes");
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:async", "Yes");
                        break;
                case OPT_SMB_PORTS:
-                       lp_set_cmdline("smb ports", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "smb ports", poptGetOptArg(pc));
                        break;
                }
        }
 
        if (strcmp(target, "samba3") == 0) {
-               lp_set_cmdline("torture:samba3", "true");
+               lp_set_cmdline(cmdline_lp_ctx, "torture:samba3", "true");
        } else if (strcmp(target, "samba4") == 0) {
-               lp_set_cmdline("torture:samba4", "true");
+               lp_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
        }
 
        if (max_runtime) {
@@ -609,8 +617,21 @@ int main(int argc,char *argv[])
                alarm(max_runtime);
        }
 
-       torture_init();
-       ldb_global_init();
+       if (extra_module != NULL) {
+           init_module_fn fn = load_module(talloc_autofree_context(), poptGetOptArg(pc));
+
+           if (fn == NULL) 
+               d_printf("Unable to load module from %s\n", poptGetOptArg(pc));
+           else {
+               status = fn();
+               if (NT_STATUS_IS_ERR(status)) {
+                   d_printf("Error initializing module %s: %s\n", 
+                            poptGetOptArg(pc), nt_errstr(status));
+               }
+           }
+       } else { 
+               torture_init();
+       }
 
        if (list_tests) {
                print_test_list();
@@ -638,33 +659,15 @@ int main(int argc,char *argv[])
                exit(1);
        }
 
-       /* see if its a RPC transport specifier */
-       status = dcerpc_parse_binding(talloc_autofree_context(), argv_new[1], &binding_struct);
-       if (NT_STATUS_IS_OK(status)) {
-               lp_set_cmdline("torture:host", binding_struct->host);
-               lp_set_cmdline("torture:share", "IPC$");
-               lp_set_cmdline("torture:binding", argv_new[1]);
-       } else {
-               char *binding = NULL;
-               char *host = NULL, *share = NULL;
-
-               if (!smbcli_parse_unc(argv_new[1], NULL, &host, &share)) {
-                       d_printf("Invalid option: %s is not a valid torture target (share or binding string)\n\n", argv_new[1]);
-                       usage(pc);
-               }
-
-               lp_set_cmdline("torture:host", host);
-               lp_set_cmdline("torture:share", share);
-               asprintf(&binding, "ncacn_np:%s", host);
-               lp_set_cmdline("torture:binding", binding);
+       if (!parse_target(cmdline_lp_ctx, argv_new[1])) {
+               usage(pc);
+               exit(1);
        }
 
        if (!strcmp(ui_ops_name, "simple")) {
                ui_ops = &std_ui_ops;
        } else if (!strcmp(ui_ops_name, "subunit")) {
                ui_ops = &subunit_ui_ops;
-       } else if (!strcmp(ui_ops_name, "harness")) {
-               ui_ops = &harness_ui_ops;
        } else if (!strcmp(ui_ops_name, "quiet")) {
                ui_ops = &quiet_ui_ops;
        } else {
@@ -672,7 +675,23 @@ int main(int argc,char *argv[])
                exit(1);
        }
 
-       torture = torture_context_init(talloc_autofree_context(), ui_ops);
+       torture = torture_context_init(cli_credentials_get_event_context(cmdline_credentials), ui_ops);
+       if (basedir != NULL) {
+               if (basedir[0] != '/') {
+                       fprintf(stderr, "Please specify an absolute path to --basedir\n");
+                       return 1;
+               }
+               torture->outputdir = basedir;
+       } else {
+               char *pwd = talloc_size(torture, PATH_MAX);
+               if (!getcwd(pwd, PATH_MAX)) {
+                       fprintf(stderr, "Unable to determine current working directory\n");
+                       return 1;
+               }
+               torture->outputdir = pwd;
+       }
+
+       torture->lp_ctx = cmdline_lp_ctx;
 
        if (argc_new == 0) {
                printf("You must specify a test to run, or 'ALL'\n");
@@ -686,7 +705,7 @@ int main(int argc,char *argv[])
                }
        }
 
-       if (torture->returncode) {
+       if (torture->returncode && correct) {
                return(0);
        } else {
                return(1);