#include "system/wait.h"
#include "system/filesys.h"
#include "system/readline.h"
-#include "lib/smbreadline/smbreadline.h"
+#include "../libcli/smbreadline/smbreadline.h"
#include "libcli/libcli.h"
#include "lib/events/events.h"
#include "librpc/rpc/dcerpc.h"
#include "auth/gensec/gensec.h"
#include "param/param.h"
+#include "lib/util/samba_modules.h"
-#if HAVE_READLINE_HISTORY_H
+#ifdef HAVE_READLINE_HISTORY_H
#include <readline/history.h>
#endif
+static char *prefix_name(TALLOC_CTX *mem_ctx, const char *prefix, const char *name)
+{
+ if (prefix == NULL)
+ return talloc_strdup(mem_ctx, name);
+ else
+ return talloc_asprintf(mem_ctx, "%s.%s", prefix, name);
+}
+
+static void print_test_list(const struct torture_suite *suite, const char *prefix, const char *expr)
+{
+ struct torture_suite *o;
+ struct torture_tcase *t;
+ struct torture_test *p;
+
+ for (o = suite->children; o; o = o->next) {
+ char *name = prefix_name(NULL, prefix, o->name);
+ print_test_list(o, name, expr);
+ talloc_free(name);
+ }
+
+ for (t = suite->testcases; t; t = t->next) {
+ for (p = t->tests; p; p = p->next) {
+ char *name = talloc_asprintf(NULL, "%s.%s.%s", prefix, t->name, p->name);
+ if (strncmp(name, expr, strlen(expr)) == 0) {
+ printf("%s\n", name);
+ }
+ talloc_free(name);
+ }
+ }
+}
+
static bool run_matching(struct torture_context *torture,
const char *prefix,
const char *expr,
for (o = suite->children; o; o = o->next) {
char *name = NULL;
- if (prefix == NULL)
- name = talloc_strdup(torture, o->name);
- else
- name = talloc_asprintf(torture, "%s-%s", prefix, o->name);
+ name = prefix_name(torture, prefix, o->name);
if (gen_fnmatch(expr, name) == 0) {
*matched = true;
reload_charcnv(torture->lp_ctx);
- torture->active_testname = name;
if (restricted != NULL)
ret &= torture_run_suite_restricted(torture, o, restricted);
else
}
for (t = suite->testcases; t; t = t->next) {
- char *name = talloc_asprintf(torture, "%s-%s", prefix, t->name);
+ char *name = talloc_asprintf(torture, "%s.%s", prefix, t->name);
if (gen_fnmatch(expr, name) == 0) {
*matched = true;
reload_charcnv(torture->lp_ctx);
- torture->active_testname = name;
- ret &= torture_run_tcase(torture, t);
+ ret &= torture_run_tcase_restricted(torture, t, restricted);
}
for (p = t->tests; p; p = p->next) {
- name = talloc_asprintf(torture, "%s-%s-%s", prefix, t->name, p->name);
+ name = talloc_asprintf(torture, "%s.%s.%s", prefix, t->name, p->name);
if (gen_fnmatch(expr, name) == 0) {
*matched = true;
reload_charcnv(torture->lp_ctx);
- torture->active_testname = name;
- ret &= torture_run_test(torture, t, p);
+ ret &= torture_run_test_restricted(torture, t, p, restricted);
}
}
}
bool matched = false;
struct torture_suite *o;
+ torture_ui_report_time(torture);
+
if (strequal(name, "ALL")) {
if (restricted != NULL) {
printf("--load-list and ALL are incompatible\n");
return ret;
}
-bool torture_parse_target(struct loadparm_context *lp_ctx, const char *target)
+bool torture_parse_target(TALLOC_CTX *ctx,
+ struct loadparm_context *lp_ctx,
+ const char *target)
{
char *host = NULL, *share = NULL;
struct dcerpc_binding *binding_struct;
/* 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);
+ const char *h;
+
+ status = dcerpc_parse_binding(ctx, 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);
+
+ h = dcerpc_binding_get_string_option(binding_struct, "host");
+ host = discard_const_p(char, h);
+ if (host != NULL) {
+ lpcfg_set_cmdline(lp_ctx, "torture:host", host);
+ }
+
+ if (lpcfg_parm_string(lp_ctx, NULL, "torture", "share") == NULL)
+ lpcfg_set_cmdline(lp_ctx, "torture:share", "IPC$");
+ lpcfg_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);
+ lpcfg_set_cmdline(lp_ctx, "torture:host", host);
+ lpcfg_set_cmdline(lp_ctx, "torture:share", share);
+ lpcfg_set_cmdline(lp_ctx, "torture:binding", host);
}
return true;
/* retrievieng the userdn */
p = strchr_m(dns, '#');
if (!p) {
- lp_set_cmdline(lp_ctx, "torture:ldap_userdn", "");
- lp_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
- lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_userdn", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
return;
}
userdn = strndup(dns, p - dns);
- lp_set_cmdline(lp_ctx, "torture:ldap_userdn", userdn);
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_userdn", userdn);
/* retrieve the basedn */
d = p + 1;
p = strchr_m(d, '#');
if (!p) {
- lp_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
- lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
return;
}
basedn = strndup(d, p - d);
- lp_set_cmdline(lp_ctx, "torture:ldap_basedn", basedn);
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", basedn);
/* retrieve the secret */
p = p + 1;
if (!p) {
- lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
return;
}
secret = strdup(p);
- lp_set_cmdline(lp_ctx, "torture:ldap_secret", secret);
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", secret);
printf ("%s - %s - %s\n", userdn, basedn, secret);
/* Print the full test list, formatted into separate labelled test
* groups.
*/
-static void print_structured_test_list(void)
+static void print_structured_testsuite_list(void)
{
struct torture_suite *o;
struct torture_suite *s;
printf("\n ");
i = 0;
}
- i+=printf("%s-%s ", o->name, s->name);
+ i+=printf("%s.%s ", o->name, s->name);
}
for (t = o->testcases; t; t = t->next) {
printf("\n ");
i = 0;
}
- i+=printf("%s-%s ", o->name, t->name);
+ i+=printf("%s.%s ", o->name, t->name);
}
if (i) printf("\n");
printf("\nThe default test is ALL.\n");
}
-static void print_test_list(void)
+static void print_testsuite_list(void)
{
struct torture_suite *o;
struct torture_suite *s;
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);
+ printf("%s.%s\n", o->name, s->name);
}
for (t = o->testcases; t; t = t->next) {
- printf("%s-%s\n", o->name, t->name);
+ printf("%s.%s\n", o->name, t->name);
}
}
}
-void torture_print_tests(bool structured)
+void torture_print_testsuites(bool structured)
{
if (structured) {
- print_structured_test_list();
+ print_structured_testsuite_list();
} else {
- print_test_list();
+ print_testsuite_list();
}
}
-_NORETURN_ static void usage(poptContext pc)
+static void usage(poptContext pc)
{
poptPrintUsage(pc, stdout, 0);
printf("\n");
printf("Tests are:");
- print_structured_test_list();
+ print_structured_testsuite_list();
- exit(1);
}
_NORETURN_ static void max_runtime_handler(int sig)
exit(1);
}
-struct timeval last_suite_started;
-
-static void simple_suite_start(struct torture_context *ctx,
- 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)
-{
-
- 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)
-{
- switch (res) {
- case TORTURE_OK:
- if (reason)
- printf("OK: %s\n", reason);
- break;
- case TORTURE_FAIL:
- printf("TEST %s FAILED! - %s\n", context->active_test->name, reason);
- break;
- case TORTURE_ERROR:
- printf("ERROR IN TEST %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 simple_comment(struct torture_context *test,
- const char *comment)
-{
- printf("%s", comment);
-}
-
-static void simple_warning(struct torture_context *test,
- const char *comment)
-{
- fprintf(stderr, "WARNING: %s\n", comment);
-}
-
-static void simple_progress(struct torture_context *test,
- int offset, enum torture_progress_whence whence)
-{
-}
-
-const static struct torture_ui_ops std_ui_ops = {
- .comment = simple_comment,
- .warning = simple_warning,
- .suite_start = simple_suite_start,
- .suite_finish = simple_suite_finish,
- .test_result = simple_test_result,
- .progress = simple_progress,
-};
-
/****************************************************************************
main program
****************************************************************************/
-int main(int argc,char *argv[])
+int main(int argc, const char *argv[])
{
int opt, i;
bool correct = true;
int shell = false;
static const char *ui_ops_name = "subunit";
const char *basedir = NULL;
+ char *outputdir;
const char *extra_module = NULL;
- static int list_tests = 0;
+ static int list_tests = 0, list_testsuites = 0;
int num_extra_users = 0;
- char **restricted = NULL;
+ const char **restricted = NULL;
int num_restricted = -1;
+ const char *load_list = NULL;
enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS, OPT_LIST,
OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS,
- OPT_EXTRA_USER,OPT_LOAD_LIST,};
+ OPT_EXTRA_USER,};
+ TALLOC_CTX *mem_ctx = NULL;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"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, "NBench load file to use", NULL},
- {"list", 0, POPT_ARG_NONE, &list_tests, 0, "List available tests and exit", NULL },
+ {"list-suites", 0, POPT_ARG_NONE, &list_testsuites, 0, "List available testsuites and exit", NULL },
+ {"list", 0, POPT_ARG_NONE, &list_tests, 0, "List available tests in specified suites and exit", NULL },
{"unclist", 0, POPT_ARG_STRING, NULL, OPT_UNCLIST, "unclist", 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},
"set maximum time for smbtorture to live", "seconds"},
{"extra-user", 0, POPT_ARG_STRING, NULL, OPT_EXTRA_USER,
"extra user credentials", NULL},
- {"load-list", 0, POPT_ARG_STRING, NULL, OPT_LOAD_LIST,
+ {"load-list", 0, POPT_ARG_STRING, &load_list, 0,
"load a test id list from a text file", NULL},
POPT_COMMON_SAMBA
POPT_COMMON_CONNECTION
setlinebuf(stdout);
+ mem_ctx = talloc_named_const(NULL, 0, "torture_ctx");
+ if (mem_ctx == NULL) {
+ printf("Unable to allocate torture_ctx\n");
+ exit(1);
+ }
+
+ printf("smbtorture %s\n", samba_version_string());
+
/* we are never interested in SIGPIPE */
BlockSignals(true, SIGPIPE);
- pc = poptGetContext("smbtorture", argc, (const char **) argv, long_options,
+ pc = poptGetContext("smbtorture", argc, argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
poptSetOtherOptionHelp(pc, "<binding>|<unc> TEST1 TEST2 ...");
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_LOADFILE:
- lp_set_cmdline(cmdline_lp_ctx, "torture:loadfile", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:loadfile", poptGetOptArg(pc));
break;
case OPT_UNCLIST:
- lp_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
break;
case OPT_TIMELIMIT:
- lp_set_cmdline(cmdline_lp_ctx, "torture:timelimit", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:timelimit", poptGetOptArg(pc));
break;
case OPT_NUMPROGS:
- lp_set_cmdline(cmdline_lp_ctx, "torture:nprocs", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:nprocs", poptGetOptArg(pc));
break;
case OPT_DNS:
parse_dns(cmdline_lp_ctx, poptGetOptArg(pc));
break;
case OPT_DANGEROUS:
- lp_set_cmdline(cmdline_lp_ctx, "torture:dangerous", "Yes");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:dangerous", "Yes");
break;
case OPT_ASYNC:
- lp_set_cmdline(cmdline_lp_ctx, "torture:async", "Yes");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:async", "Yes");
break;
case OPT_SMB_PORTS:
- lp_set_cmdline(cmdline_lp_ctx, "smb ports", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "smb ports", poptGetOptArg(pc));
break;
case OPT_EXTRA_USER:
{
- char *option = talloc_asprintf(NULL, "torture:extra_user%u",
- ++num_extra_users);
+ char *option = talloc_asprintf(mem_ctx,
+ "torture:extra_user%u",
+ ++num_extra_users);
const char *value = poptGetOptArg(pc);
- lp_set_cmdline(cmdline_lp_ctx, option, value);
+ if (option == NULL) {
+ printf("talloc fail\n");
+ talloc_free(mem_ctx);
+ exit(1);
+ }
+ lpcfg_set_cmdline(cmdline_lp_ctx, option, value);
talloc_free(option);
}
break;
- case OPT_LOAD_LIST:
- restricted = file_lines_load(optarg, &num_restricted, 0,
- talloc_autofree_context());
- if (restricted == NULL) {
- printf("Unable to read load list file '%s'\n", optarg);
- exit(1);
- }
- break;
default:
if (opt < 0) {
printf("bad command line option %d\n", opt);
+ talloc_free(mem_ctx);
exit(1);
}
}
}
+ if (load_list != NULL) {
+ char **r;
+ r = file_lines_load(load_list, &num_restricted, 0, mem_ctx);
+ restricted = discard_const_p(const char *, r);
+ if (restricted == NULL) {
+ printf("Unable to read load list file '%s'\n", load_list);
+ talloc_free(mem_ctx);
+ exit(1);
+ }
+ }
+
if (strcmp(target, "samba3") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:samba3", "true");
- lp_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba3", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
} else if (strcmp(target, "samba4") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
+ } else if (strcmp(target, "samba4-ntvfs") == 0) {
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba4-ntvfs", "true");
} else if (strcmp(target, "winxp") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:winxp", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:winxp", "true");
} else if (strcmp(target, "w2k3") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:w2k3", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k3", "true");
} else if (strcmp(target, "w2k8") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:w2k8", "true");
- lp_set_cmdline(cmdline_lp_ctx,
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k8", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx,
"torture:invalid_lock_range_support", "false");
+ } else if (strcmp(target, "w2k12") == 0) {
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k12", "true");
} else if (strcmp(target, "win7") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:win7", "true");
- lp_set_cmdline(cmdline_lp_ctx, "torture:cn_max_buffer_size",
- "0x00010000");
- lp_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:win7", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
/* RAW-SEARCH for fails for inexplicable reasons against win7 */
- lp_set_cmdline(cmdline_lp_ctx, "torture:search_ea_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:search_ea_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:hide_on_access_denied",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:hide_on_access_denied",
"true");
} else if (strcmp(target, "onefs") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:onefs", "true");
- lp_set_cmdline(cmdline_lp_ctx, "torture:openx_deny_dos_support",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:onefs", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:openx_deny_dos_support",
"false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:range_not_locked_on_file_close", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:sacl_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:ea_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:smbexit_pdu_support",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:range_not_locked_on_file_close", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:sacl_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:ea_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:smbexit_pdu_support",
"false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:smblock_pdu_support",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:smblock_pdu_support",
"false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:2_step_break_to_none",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:2_step_break_to_none",
"true");
- lp_set_cmdline(cmdline_lp_ctx, "torture:deny_dos_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:deny_fcb_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:read_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:writeclose_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:raw_search_search", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:search_ea_size", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:deny_dos_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:deny_fcb_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:read_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:writeclose_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:raw_search_search", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:search_ea_size", "false");
}
if (max_runtime) {
}
if (extra_module != NULL) {
- init_module_fn fn = load_module(talloc_autofree_context(), poptGetOptArg(pc));
+ init_module_fn fn = load_module(poptGetOptArg(pc), false, NULL);
if (fn == NULL)
d_printf("Unable to load module from %s\n", poptGetOptArg(pc));
else {
- status = fn();
+ status = fn(mem_ctx);
if (NT_STATUS_IS_ERR(status)) {
d_printf("Error initializing module %s: %s\n",
poptGetOptArg(pc), nt_errstr(status));
}
}
} else {
- torture_init();
+ torture_init(mem_ctx);
}
- if (list_tests) {
- print_test_list();
+ if (list_testsuites) {
+ print_testsuite_list();
+ talloc_free(mem_ctx);
+ popt_free_cmdline_credentials();
return 0;
}
- if (torture_seed == 0) {
- torture_seed = time(NULL);
- }
- printf("Using seed %d\n", torture_seed);
- srandom(torture_seed);
-
argv_new = discard_const_p(char *, poptGetArgs(pc));
argc_new = argc;
}
}
+ if (list_tests) {
+ if (argc_new == 1) {
+ print_test_list(torture_root, NULL, "");
+ } else {
+ for (i=1;i<argc_new;i++) {
+ print_test_list(torture_root, NULL, argv_new[i]);
+ }
+ }
+ talloc_free(mem_ctx);
+ popt_free_cmdline_credentials();
+ return 0;
+ }
+
+ if (torture_seed == 0) {
+ torture_seed = time(NULL);
+ }
+ printf("Using seed %d\n", torture_seed);
+ srandom(torture_seed);
+
if (!strcmp(ui_ops_name, "simple")) {
- ui_ops = &std_ui_ops;
+ ui_ops = &torture_simple_ui_ops;
} else if (!strcmp(ui_ops_name, "subunit")) {
ui_ops = &torture_subunit_ui_ops;
} else {
printf("Unknown output format '%s'\n", ui_ops_name);
+ talloc_free(mem_ctx);
exit(1);
}
- results = torture_results_init(talloc_autofree_context(), ui_ops);
+ results = torture_results_init(mem_ctx, ui_ops);
- torture = torture_context_init(s4_event_context_init(talloc_autofree_context()),
+ torture = torture_context_init(s4_event_context_init(mem_ctx),
results);
if (basedir != NULL) {
if (basedir[0] != '/') {
fprintf(stderr, "Please specify an absolute path to --basedir\n");
+ talloc_free(mem_ctx);
return 1;
}
- torture->outputdir = basedir;
+ outputdir = talloc_asprintf(torture, "%s/smbtortureXXXXXX", basedir);
} else {
char *pwd = talloc_size(torture, PATH_MAX);
if (!getcwd(pwd, PATH_MAX)) {
fprintf(stderr, "Unable to determine current working directory\n");
+ talloc_free(mem_ctx);
return 1;
}
- torture->outputdir = pwd;
+ outputdir = talloc_asprintf(torture, "%s/smbtortureXXXXXX", pwd);
+ }
+ if (!outputdir) {
+ fprintf(stderr, "Could not allocate per-run output dir\n");
+ talloc_free(mem_ctx);
+ return 1;
+ }
+ torture->outputdir = mkdtemp(outputdir);
+ if (!torture->outputdir) {
+ perror("Failed to make temp output dir");
+ talloc_free(mem_ctx);
+ return 1;
}
torture->lp_ctx = cmdline_lp_ctx;
- gensec_init(cmdline_lp_ctx);
+ gensec_init();
if (shell) {
/* In shell mode, just ignore any remaining test names. */
if (argc_new < 3) {
printf("You must specify a test to run, or 'ALL'\n");
usage(pc);
- exit(1);
- }
-
- /* Take the target name or binding. */
- if (!torture_parse_target(cmdline_lp_ctx, argv_new[1])) {
+ torture->results->returncode = 1;
+ } else if (!torture_parse_target(torture,
+ cmdline_lp_ctx, argv_new[1])) {
+ /* Take the target name or binding. */
usage(pc);
- exit(1);
- }
-
- for (i=2;i<argc_new;i++) {
- if (!torture_run_named_tests(torture, argv_new[i],
- (const char **)restricted)) {
- correct = false;
+ torture->results->returncode = 1;
+ } else {
+ for (i=2;i<argc_new;i++) {
+ if (!torture_run_named_tests(torture, argv_new[i],
+ (const char **)restricted)) {
+ correct = false;
+ }
}
}
}
+ /* Now delete the temp dir we created */
+ torture_deltree_outputdir(torture);
+
if (torture->results->returncode && correct) {
+ talloc_free(mem_ctx);
+ popt_free_cmdline_credentials();
return(0);
} else {
+ talloc_free(mem_ctx);
return(1);
}
}
git.samba.org / samba.git / blobdiff