Unix SMB/CIFS implementation.
SMB torture tester
Copyright (C) Andrew Tridgell 1997-2003
- Copyright (C) Jelmer Vernooij 2006
+ Copyright (C) Jelmer Vernooij 2006-2008
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "libcli/libcli.h"
#include "lib/ldb/include/ldb.h"
#include "lib/events/events.h"
-#include "dynconfig.h"
+#include "dynconfig/dynconfig.h"
-#include "torture/torture.h"
-#include "build.h"
-#include "lib/util/dlinklist.h"
+#include "torture/smbtorture.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,
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;
}
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);
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);
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;
/* 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);
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);
}
}
-static void usage(poptContext pc)
+_NORETURN_ static void usage(poptContext pc)
{
struct torture_suite *o;
struct torture_suite *s;
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);
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);
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:
}
}
-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);
}
}
static void subunit_suite_start(struct torture_context *ctx,
- struct torture_suite *suite)
+ struct torture_suite *suite)
{
}
-static void subunit_test_start (struct torture_context *ctx,
- struct torture_tcase *tcase,
- struct torture_test *test)
+static void subunit_print_testname(struct torture_context *ctx,
+ struct torture_tcase *tcase,
+ struct torture_test *test)
{
- printf("test: %s\n", test->name);
+ if (!strcmp(tcase->name, test->name)) {
+ printf("%s", test->name);
+ } else {
+ printf("%s.%s", tcase->name, test->name);
+ }
}
-static void subunit_test_result (struct torture_context *context,
- enum torture_result res, const char *reason)
+static void subunit_test_start(struct torture_context *ctx,
+ struct torture_tcase *tcase,
+ struct torture_test *test)
+{
+ printf("test: ");
+ subunit_print_testname(ctx, tcase, test);
+ printf("\n");
+}
+
+static void subunit_test_result(struct torture_context *context,
+ enum torture_result res, const char *reason)
{
switch (res) {
case TORTURE_OK:
- printf("success: %s", context->active_test->name);
+ printf("success: ");
break;
case TORTURE_FAIL:
- printf("failure: %s", context->active_test->name);
+ printf("failure: ");
break;
case TORTURE_ERROR:
- printf("error: %s", context->active_test->name);
+ printf("error: ");
break;
case TORTURE_SKIP:
- printf("skip: %s", context->active_test->name);
+ printf("skip: ");
break;
}
+ subunit_print_testname(context, context->active_tcase, context->active_test);
+
if (reason)
printf(" [\n%s\n]", reason);
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 quiet_suite_start(struct torture_context *ctx,
- struct torture_suite *suite)
+ struct torture_suite *suite)
{
int i;
ctx->quiet = true;
}
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) {
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")) {
run_test(tctx, argv[1]);
}
}
+ free(cline);
}
}
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;
+ int num_extra_users = 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,OPT_EXTRA_USER};
struct poptOption long_options[] = {
POPT_AUTOHELP
{"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},
"number of simultaneous async requests", NULL},
{"maximum-runtime", 0, POPT_ARG_INT, &max_runtime, 0,
"set maximum time for smbtorture to live", "seconds"},
+ {"extra-user", 0, POPT_ARG_STRING, NULL, OPT_EXTRA_USER,
+ "extra user credentials", NULL},
POPT_COMMON_SAMBA
POPT_COMMON_CONNECTION
POPT_COMMON_CREDENTIALS
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;
+ case OPT_EXTRA_USER:
+ {
+ char *option = talloc_asprintf(NULL, "torture:extra_user%u",
+ ++num_extra_users);
+ char *value = poptGetOptArg(pc);
+ lp_set_cmdline(cmdline_lp_ctx, option, value);
+ talloc_free(option);
+ }
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) {
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();
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")) {
exit(1);
}
- torture = torture_context_init(talloc_autofree_context(), ui_ops);
+ torture = torture_context_init(s4_event_context_init(NULL), 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");
}
}
- if (torture->returncode) {
+ if (torture->returncode && correct) {
return(0);
} else {
return(1);
git.samba.org / bbaumbach / samba-autobuild / .git / blobdiff