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 "system/readline.h"
#include "lib/smbreadline/smbreadline.h"
#include "libcli/libcli.h"
-#include "lib/ldb/include/ldb.h"
#include "lib/events/events.h"
-#include "dynconfig.h"
-#include "torture/torture.h"
-#include "lib/util/dlinklist.h"
+#include "torture/smbtorture.h"
#include "librpc/rpc/dcerpc.h"
+#include "auth/gensec/gensec.h"
#include "param/param.h"
-#include "auth/credentials/credentials.h"
static bool run_matching(struct torture_context *torture,
const char *prefix,
const char *expr,
+ char **restricted,
struct torture_suite *suite,
bool *matched)
{
bool ret = true;
+ struct torture_suite *o;
+ struct torture_tcase *t;
- if (suite == NULL) {
- struct torture_suite *o;
-
- for (o = torture_root->children; o; o = o->next) {
- if (gen_fnmatch(expr, o->name) == 0) {
- *matched = true;
- reload_charcnv(torture->lp_ctx);
+ 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);
+ 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
ret &= torture_run_suite(torture, o);
- continue;
- }
-
- ret &= run_matching(torture, o->name, expr, o, matched);
- }
- } else {
- char *name;
- struct torture_suite *c;
- struct torture_tcase *t;
-
- for (c = suite->children; c; c = c->next) {
- asprintf(&name, "%s-%s", prefix, c->name);
-
- if (gen_fnmatch(expr, name) == 0) {
- *matched = true;
- reload_charcnv(torture->lp_ctx);
- torture->active_testname = talloc_strdup(torture, prefix);
- ret &= torture_run_suite(torture, c);
- free(name);
- continue;
- }
-
- ret &= run_matching(torture, name, expr, c, matched);
-
- free(name);
}
+ ret &= run_matching(torture, name, expr, restricted, o, matched);
+ }
- for (t = suite->testcases; t; t = t->next) {
- asprintf(&name, "%s-%s", prefix, t->name);
- if (gen_fnmatch(expr, name) == 0) {
- *matched = true;
- reload_charcnv(torture->lp_ctx);
- torture->active_testname = talloc_strdup(torture, prefix);
- ret &= torture_run_tcase(torture, t);
- talloc_free(torture->active_testname);
- }
- free(name);
+ for (t = suite->testcases; t; t = t->next) {
+ 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);
}
}
/****************************************************************************
run a specified test or "ALL"
****************************************************************************/
-static bool run_test(struct torture_context *torture, const char *name)
+static bool run_test(struct torture_context *torture, const char *name,
+ char **restricted)
{
bool ret = true;
bool matched = false;
struct torture_suite *o;
if (strequal(name, "ALL")) {
+ if (restricted != NULL) {
+ printf("--load-list and ALL are incompatible\n");
+ return false;
+ }
for (o = torture_root->children; o; o = o->next) {
ret &= torture_run_suite(torture, o);
}
return ret;
}
- ret = run_matching(torture, NULL, name, NULL, &matched);
+ ret = run_matching(torture, NULL, name, restricted, torture_root, &matched);
if (!matched) {
printf("Unknown torture operation '%s'\n", name);
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
-};
-
-static void subunit_init(struct torture_context *ctx)
-{
- /* FIXME: register segv and bus handler */
-}
-
-static void subunit_suite_start(struct torture_context *ctx,
- struct torture_suite *suite)
-{
-}
-
-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)
-{
- switch (res) {
- case TORTURE_OK:
- printf("success: %s", context->active_test->name);
- break;
- case TORTURE_FAIL:
- printf("failure: %s", context->active_test->name);
- break;
- case TORTURE_ERROR:
- printf("error: %s", context->active_test->name);
- break;
- case TORTURE_SKIP:
- printf("skip: %s", context->active_test->name);
- break;
- }
- if (reason)
- printf(" [\n%s\n]", reason);
- printf("\n");
-}
-
-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)
-{
- int i;
- ctx->quiet = true;
- for (i = 1; i < ctx->level; i++) putchar('\t');
- printf("%s: ", suite->name);
- fflush(stdout);
-}
-
-static void quiet_suite_finish(struct torture_context *ctx,
- struct torture_suite *suite)
-{
- putchar('\n');
-}
-
-static void quiet_test_result(struct torture_context *context,
- enum torture_result res, const char *reason)
-{
- fflush(stdout);
- switch (res) {
- case TORTURE_OK: putchar('.'); break;
- case TORTURE_FAIL: putchar('F'); break;
- case TORTURE_ERROR: putchar('E'); break;
- case TORTURE_SKIP: putchar('I'); break;
- }
-}
-
-const static struct torture_ui_ops quiet_ui_ops = {
- .suite_start = quiet_suite_start,
- .suite_finish = quiet_suite_finish,
- .test_result = quiet_test_result
+ .test_result = simple_test_result,
+ .progress = simple_progress,
};
-void run_shell(struct torture_context *tctx)
-{
- char *cline;
- int argc;
- const char **argv;
- int ret;
-
- while (1) {
- cline = smb_readline("torture> ", NULL, NULL);
-
- if (cline == NULL)
- return;
-
- ret = poptParseArgvString(cline, &argc, &argv);
- if (ret != 0) {
- fprintf(stderr, "Error parsing line\n");
- continue;
- }
-
- if (!strcmp(argv[0], "quit")) {
- return;
- } else if (!strcmp(argv[0], "set")) {
- if (argc < 3) {
- fprintf(stderr, "Usage: set <variable> <value>\n");
- } else {
- char *name = talloc_asprintf(NULL, "torture:%s", argv[1]);
- lp_set_cmdline(tctx->lp_ctx, name, argv[2]);
- talloc_free(name);
- }
- } else if (!strcmp(argv[0], "help")) {
- fprintf(stderr, "Available commands:\n"
- " help - This help command\n"
- " run - Run test\n"
- " set - Change variables\n"
- "\n");
- } else if (!strcmp(argv[0], "run")) {
- if (argc < 2) {
- fprintf(stderr, "Usage: run TEST-NAME [OPTIONS...]\n");
- } else {
- run_test(tctx, argv[1]);
- }
- }
- free(cline);
- }
-}
/****************************************************************************
main program
int max_runtime=0;
int argc_new;
struct torture_context *torture;
+ struct torture_results *results;
const struct torture_ui_ops *ui_ops;
char **argv_new;
poptContext pc;
static const char *target = "other";
NTSTATUS status;
- int shell = false;
- static const char *ui_ops_name = "simple";
+ static const char *ui_ops_name = "subunit";
const char *basedir = NULL;
const char *extra_module = NULL;
static int list_tests = 0;
+ int num_extra_users = 0;
+ char **restricted = NULL;
+ int num_restricted = -1;
enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS, OPT_LIST,
- OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS};
-
+ OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS,
+ OPT_EXTRA_USER,OPT_LOAD_LIST,};
+
struct poptOption long_options[] = {
POPT_AUTOHELP
{"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit)", NULL },
{"dangerous", 'X', POPT_ARG_NONE, NULL, OPT_DANGEROUS,
"run dangerous tests (eg. wiping out password database)", 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},
+ {"load-list", 0, POPT_ARG_STRING, NULL, OPT_LOAD_LIST,
+ "load a test id list from a text file", NULL},
POPT_COMMON_SAMBA
POPT_COMMON_CONNECTION
POPT_COMMON_CREDENTIALS
case OPT_SMB_PORTS:
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);
+ const char *value = poptGetOptArg(pc);
+ lp_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:
+ printf("bad command line option\n");
+ 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");
} else if (strcmp(target, "samba4") == 0) {
lp_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
+ } else if (strcmp(target, "winxp") == 0) {
+ lp_set_cmdline(cmdline_lp_ctx, "torture:winxp", "true");
+ } else if (strcmp(target, "w2k3") == 0) {
+ lp_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,
+ "torture:invalid_lock_range_support", "false");
+ } 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");
+
+ /* RAW-SEARCH for fails for inexplicable reasons against win7 */
+ lp_set_cmdline(cmdline_lp_ctx, "torture:search_ea_support", "false");
+
+ lp_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",
+ "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",
+ "false");
+ lp_set_cmdline(cmdline_lp_ctx, "torture:smblock_pdu_support",
+ "false");
+ lp_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");
}
if (max_runtime) {
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));
+ 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 (!(argc_new >= 3 || (shell && argc_new >= 2))) {
+ if (!(argc_new >= 3)) {
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, "quiet")) {
- ui_ops = &quiet_ui_ops;
+ ui_ops = &torture_subunit_ui_ops;
} else {
printf("Unknown output format '%s'\n", ui_ops_name);
exit(1);
}
- torture = torture_context_init(event_context_init(NULL), ui_ops);
+ results = torture_results_init(talloc_autofree_context(), ui_ops);
+
+ torture = torture_context_init(s4_event_context_init(talloc_autofree_context()),
+ results);
if (basedir != NULL) {
if (basedir[0] != '/') {
fprintf(stderr, "Please specify an absolute path to --basedir\n");
torture->lp_ctx = cmdline_lp_ctx;
+ gensec_init(cmdline_lp_ctx);
+
if (argc_new == 0) {
- printf("You must specify a test to run, or 'ALL'\n");
- } else if (shell) {
- run_shell(torture);
+ printf("You must specify a testsuite to run, or 'ALL'\n");
} else {
for (i=2;i<argc_new;i++) {
- if (!run_test(torture, argv_new[i])) {
+ if (!run_test(torture, argv_new[i], restricted)) {
correct = false;
}
}
}
- if (torture->returncode && correct) {
+ if (torture->results->returncode && correct) {
return(0);
} else {
return(1);
git.samba.org / samba.git / blobdiff