-/*
- add to build farm
- add masktest and locktest too
- add -W flag
- convert to popt_common
-*/
-
/*
Unix SMB/CIFS implementation.
generic testing tool
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
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "librpc/gen_ndr/security.h"
#include "auth/credentials/credentials.h"
+#include "libcli/resolve/resolve.h"
#include "auth/gensec/gensec.h"
+#include "param/param.h"
+#include "dynconfig.h"
#define NSERVERS 2
#define NINSTANCES 2
/* global options */
static struct gentest_options {
- BOOL showall;
- BOOL analyze;
- BOOL analyze_always;
- BOOL analyze_continuous;
+ bool showall;
+ bool analyze;
+ bool analyze_always;
+ bool analyze_continuous;
uint_t max_open_handles;
uint_t seed;
uint_t numops;
- BOOL use_oplocks;
+ bool use_oplocks;
char **ignore_patterns;
const char *seeds_file;
- BOOL use_preset_seeds;
- BOOL fast_reconnect;
+ bool use_preset_seeds;
+ bool fast_reconnect;
} options;
/* mapping between open handles on the server and local handles */
static struct {
- BOOL active;
+ bool active;
uint_t instance;
uint_t server_fnum[NSERVERS];
const char *name;
/* the seeds and flags for each operation */
static struct {
uint_t seed;
- BOOL disabled;
+ bool disabled;
} *op_parms;
/* oplock break info */
static struct {
- BOOL got_break;
+ bool got_break;
uint16_t fnum;
uint16_t handle;
uint8_t level;
- BOOL do_close;
+ bool do_close;
} oplocks[NSERVERS][NINSTANCES];
/* change notify reply info */
#define BAD_HANDLE 0xFFFE
-static BOOL oplock_handler(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private);
+static bool oplock_handler(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private);
static void idle_func(struct smbcli_transport *transport, void *private);
/*
check if a string should be ignored. This is used as the basis
for all error ignore settings
*/
-static BOOL ignore_pattern(const char *str)
+static bool ignore_pattern(const char *str)
{
int i;
- if (!options.ignore_patterns) return False;
+ if (!options.ignore_patterns) return false;
for (i=0;options.ignore_patterns[i];i++) {
if (strcmp(options.ignore_patterns[i], str) == 0 ||
gen_fnmatch(options.ignore_patterns[i], str) == 0) {
DEBUG(2,("Ignoring '%s'\n", str));
- return True;
+ return true;
}
}
- return False;
+ return false;
}
/*****************************************************
connect to the servers
*******************************************************/
-static BOOL connect_servers_fast(void)
+static bool connect_servers_fast(void)
{
int h, i;
for (i=0;i<NSERVERS;i++) {
if (NT_STATUS_IS_ERR((smbcli_close(servers[i].cli[open_handles[h].instance]->tree,
open_handles[h].server_fnum[i])))) {
- return False;
+ return false;
}
- open_handles[h].active = False;
+ open_handles[h].active = false;
}
}
- return True;
+ return true;
}
/*****************************************************
connect to the servers
*******************************************************/
-static BOOL connect_servers(void)
+static bool connect_servers(struct loadparm_context *lp_ctx)
{
int i, j;
if (options.fast_reconnect && servers[0].cli[0]) {
if (connect_servers_fast()) {
- return True;
+ return true;
}
}
for (i=0;i<NSERVERS;i++) {
for (j=0;j<NINSTANCES;j++) {
+ struct smbcli_options smb_options;
NTSTATUS status;
printf("Connecting to \\\\%s\\%s as %s - instance %d\n",
servers[i].server_name, servers[i].share_name,
cli_credentials_set_workstation(servers[i].credentials,
"gentest", CRED_SPECIFIED);
+ lp_smbcli_options(lp_ctx, &smb_options);
status = smbcli_full_connection(NULL, &servers[i].cli[j],
servers[i].server_name,
+ lp_smb_ports(lp_ctx),
servers[i].share_name, NULL,
- servers[i].credentials, NULL);
+ servers[i].credentials,
+ lp_resolve_context(lp_ctx),
+ NULL, &smb_options);
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to connect to \\\\%s\\%s - %s\n",
servers[i].server_name, servers[i].share_name,
nt_errstr(status));
- return False;
+ return false;
}
smbcli_oplock_handler(servers[i].cli[j]->transport, oplock_handler, NULL);
}
}
- return True;
+ return true;
}
/*
for (i=0;i<NSERVERS;i++) {
open_handles[h].server_fnum[i] = fnums[i];
open_handles[h].instance = instance;
- open_handles[h].active = True;
+ open_handles[h].active = true;
open_handles[h].name = name;
}
num_open_handles++;
for (h=0;h<options.max_open_handles;h++) {
if (instance == open_handles[h].instance &&
open_handles[h].server_fnum[0] == fnums[0]) {
- open_handles[h].active = False;
+ open_handles[h].active = false;
num_open_handles--;
printf("CLOSE num_open_handles=%d h=%d s1=0x%x s2=0x%x (%s)\n",
num_open_handles, h,
}
/*
- return True with 'chance' probability as a percentage
+ return true with 'chance' probability as a percentage
*/
-static BOOL gen_chance(uint_t chance)
+static bool gen_chance(uint_t chance)
{
return ((random() % 100) <= chance);
}
static uint16_t gen_root_fid(int instance)
{
if (gen_chance(5)) return gen_fnum(instance);
- if (gen_chance(2)) return BAD_HANDLE;
return 0;
}
/*
generate a boolean
*/
-static BOOL gen_bool(void)
+static bool gen_bool(void)
{
return gen_bits_mask2(0x1, 0xFF);
}
/*
the oplock handler will either ack the break or close the file
*/
-static BOOL oplock_handler(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private)
+static bool oplock_handler(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private)
{
union smb_close io;
int i, j;
- BOOL do_close;
+ bool do_close;
struct smbcli_tree *tree = NULL;
struct smbcli_request *req;
for (j=0;j<NINSTANCES;j++) {
if (transport == servers[i].cli[j]->transport &&
tid == servers[i].cli[j]->tree->tid) {
- oplocks[i][j].got_break = True;
+ oplocks[i][j].got_break = true;
oplocks[i][j].fnum = fnum;
oplocks[i][j].handle = fnum_to_handle(i, j, fnum);
oplocks[i][j].level = level;
if (!tree) {
printf("Oplock break not for one of our trees!?\n");
- return False;
+ return false;
}
if (!do_close) {
if (req == NULL) {
printf("WARNING: close failed in oplock_handler_close\n");
- return False;
+ return false;
}
req->async.fn = oplock_handler_close_recv;
req->async.private = NULL;
- return True;
+ return true;
}
/*
compare NTSTATUS, using checking ignored patterns
*/
-static BOOL compare_status(NTSTATUS status1, NTSTATUS status2)
+static bool compare_status(NTSTATUS status1, NTSTATUS status2)
{
- if (NT_STATUS_EQUAL(status1, status2)) return True;
+ if (NT_STATUS_EQUAL(status1, status2)) return true;
/* one code being an error and the other OK is always an error */
- if (NT_STATUS_IS_OK(status1) || NT_STATUS_IS_OK(status2)) return False;
+ if (NT_STATUS_IS_OK(status1) || NT_STATUS_IS_OK(status2)) return false;
/* if we are ignoring one of the status codes then consider this a match */
if (ignore_pattern(nt_errstr(status1)) ||
ignore_pattern(nt_errstr(status2))) {
- return True;
+ return true;
}
- return False;
+ return false;
}
/*
check that the same oplock breaks have been received by all instances
*/
-static BOOL check_oplocks(const char *call)
+static bool check_oplocks(const char *call)
{
int i, j;
int tries = 0;
oplocks[i][j].got_break,
oplocks[i][j].handle,
oplocks[i][j].level);
- return False;
+ return false;
}
}
}
break;
}
}
- return True;
+ return true;
}
/*
check that the same change notify info has been received by all instances
*/
-static BOOL check_notifies(const char *call)
+static bool check_notifies(const char *call)
{
int i, j;
int tries = 0;
printf("Notify count inconsistent %d %d\n",
notifies[0][j].notify_count,
notifies[i][j].notify_count);
- return False;
+ return false;
}
if (notifies[0][j].notify_count == 0) continue;
printf("Notify status mismatch - %s - %s\n",
nt_errstr(notifies[0][j].status),
nt_errstr(notifies[i][j].status));
- return False;
+ return false;
}
if (!NT_STATUS_IS_OK(notifies[0][j].status)) {
printf("Notify action %d inconsistent %d %d\n", n,
not1.nttrans.out.changes[n].action,
not2.nttrans.out.changes[n].action);
- return False;
+ return false;
}
if (strcmp(not1.nttrans.out.changes[n].name.s,
not2.nttrans.out.changes[n].name.s)) {
printf("Notify name %d inconsistent %s %s\n", n,
not1.nttrans.out.changes[n].name.s,
not2.nttrans.out.changes[n].name.s);
- return False;
+ return false;
}
if (not1.nttrans.out.changes[n].name.private_length !=
not2.nttrans.out.changes[n].name.private_length) {
printf("Notify name length %d inconsistent %d %d\n", n,
not1.nttrans.out.changes[n].name.private_length,
not2.nttrans.out.changes[n].name.private_length);
- return False;
+ return false;
}
}
}
ZERO_STRUCT(notifies);
- return True;
+ return true;
}
if (!compare_status(status[i], status[0])) { \
printf("status different in %s - %s %s\n", #call, \
nt_errstr(status[0]), nt_errstr(status[i])); \
- return False; \
+ return false; \
} \
} \
- if (!check_oplocks(#call)) return False; \
- if (!check_notifies(#call)) return False; \
+ if (!check_oplocks(#call)) return false; \
+ if (!check_notifies(#call)) return false; \
if (!NT_STATUS_IS_OK(status[0])) { \
- return True; \
+ return true; \
} \
} while(0)
if (parm[0].field != parm[1].field && !ignore_pattern(#field)) { \
printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
(int)parm[0].field, (int)parm[1].field); \
- return False; \
+ return false; \
} \
} while(0)
#define CHECK_WSTR_EQUAL(field) do { \
if ((!parm[0].field.s && parm[1].field.s) || (parm[0].field.s && !parm[1].field.s)) { \
printf("%s is NULL!\n", #field); \
- return False; \
+ return false; \
} \
if (parm[0].field.s && strcmp(parm[0].field.s, parm[1].field.s) != 0 && !ignore_pattern(#field)) { \
printf("Mismatch in %s - %s %s\n", #field, \
parm[0].field.s, parm[1].field.s); \
- return False; \
+ return false; \
} \
CHECK_EQUAL(field.private_length); \
} while(0)
#define CHECK_BLOB_EQUAL(field) do { \
if (memcmp(parm[0].field.data, parm[1].field.data, parm[0].field.length) != 0 && !ignore_pattern(#field)) { \
printf("Mismatch in %s\n", #field); \
- return False; \
+ return false; \
} \
CHECK_EQUAL(field.length); \
} while(0)
!ignore_pattern(#field)) { \
printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
(int)parm[0].field, (int)parm[1].field); \
- return False; \
+ return false; \
} \
} while(0)
printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
(int)nt_time_to_unix(parm[0].field), \
(int)nt_time_to_unix(parm[1].field)); \
- return False; \
+ return false; \
} \
} while(0)
/*
generate openx operations
*/
-static BOOL handler_openx(int instance)
+static bool handler_openx(int instance)
{
union smb_open parm[NSERVERS];
NTSTATUS status[NSERVERS];
/* open creates a new file handle */
ADD_HANDLE(parm[0].openx.in.fname, openx.out.file.fnum);
- return True;
+ return true;
}
/*
generate open operations
*/
-static BOOL handler_open(int instance)
+static bool handler_open(int instance)
{
union smb_open parm[NSERVERS];
NTSTATUS status[NSERVERS];
/* open creates a new file handle */
ADD_HANDLE(parm[0].openold.in.fname, openold.out.file.fnum);
- return True;
+ return true;
}
/*
generate ntcreatex operations
*/
-static BOOL handler_ntcreatex(int instance)
+static bool handler_ntcreatex(int instance)
{
union smb_open parm[NSERVERS];
NTSTATUS status[NSERVERS];
/* ntcreatex creates a new file handle */
ADD_HANDLE(parm[0].ntcreatex.in.fname, ntcreatex.out.file.fnum);
- return True;
+ return true;
}
/*
generate close operations
*/
-static BOOL handler_close(int instance)
+static bool handler_close(int instance)
{
union smb_close parm[NSERVERS];
NTSTATUS status[NSERVERS];
REMOVE_HANDLE(close.in.file.fnum);
- return True;
+ return true;
}
/*
generate unlink operations
*/
-static BOOL handler_unlink(int instance)
+static bool handler_unlink(int instance)
{
union smb_unlink parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_COPY_PARM;
GEN_CALL(smb_raw_unlink(tree, &parm[i]));
- return True;
+ return true;
}
/*
generate chkpath operations
*/
-static BOOL handler_chkpath(int instance)
+static bool handler_chkpath(int instance)
{
union smb_chkpath parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_COPY_PARM;
GEN_CALL(smb_raw_chkpath(tree, &parm[i]));
- return True;
+ return true;
}
/*
generate mkdir operations
*/
-static BOOL handler_mkdir(int instance)
+static bool handler_mkdir(int instance)
{
union smb_mkdir parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_COPY_PARM;
GEN_CALL(smb_raw_mkdir(tree, &parm[i]));
- return True;
+ return true;
}
/*
generate rmdir operations
*/
-static BOOL handler_rmdir(int instance)
+static bool handler_rmdir(int instance)
{
struct smb_rmdir parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_COPY_PARM;
GEN_CALL(smb_raw_rmdir(tree, &parm[i]));
- return True;
+ return true;
}
/*
generate rename operations
*/
-static BOOL handler_rename(int instance)
+static bool handler_rename(int instance)
{
union smb_rename parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_COPY_PARM;
GEN_CALL(smb_raw_rename(tree, &parm[i]));
- return True;
+ return true;
}
/*
generate ntrename operations
*/
-static BOOL handler_ntrename(int instance)
+static bool handler_ntrename(int instance)
{
union smb_rename parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_COPY_PARM;
GEN_CALL(smb_raw_rename(tree, &parm[i]));
- return True;
+ return true;
}
/*
generate seek operations
*/
-static BOOL handler_seek(int instance)
+static bool handler_seek(int instance)
{
union smb_seek parm[NSERVERS];
NTSTATUS status[NSERVERS];
CHECK_EQUAL(lseek.out.offset);
- return True;
+ return true;
}
/*
generate readx operations
*/
-static BOOL handler_readx(int instance)
+static bool handler_readx(int instance)
{
union smb_read parm[NSERVERS];
NTSTATUS status[NSERVERS];
parm[0].readx.in.maxcnt = gen_io_count();
parm[0].readx.in.remaining = gen_io_count();
parm[0].readx.in.read_for_execute = gen_bool();
- parm[0].readx.out.data = talloc_size(current_op.mem_ctx,
+ parm[0].readx.out.data = talloc_array(current_op.mem_ctx, uint8_t,
MAX(parm[0].readx.in.mincnt, parm[0].readx.in.maxcnt));
GEN_COPY_PARM;
CHECK_EQUAL(readx.out.compaction_mode);
CHECK_EQUAL(readx.out.nread);
- return True;
+ return true;
}
/*
generate writex operations
*/
-static BOOL handler_writex(int instance)
+static bool handler_writex(int instance)
{
union smb_write parm[NSERVERS];
NTSTATUS status[NSERVERS];
parm[0].writex.in.wmode = gen_bits_mask(0xFFFF);
parm[0].writex.in.remaining = gen_io_count();
parm[0].writex.in.count = gen_io_count();
- parm[0].writex.in.data = talloc_zero_size(current_op.mem_ctx, parm[0].writex.in.count);
+ parm[0].writex.in.data = talloc_zero_array(current_op.mem_ctx, uint8_t, parm[0].writex.in.count);
GEN_COPY_PARM;
GEN_SET_FNUM(writex.in.file.fnum);
CHECK_EQUAL(writex.out.nwritten);
CHECK_EQUAL(writex.out.remaining);
- return True;
+ return true;
}
/*
generate lockingx operations
*/
-static BOOL handler_lockingx(int instance)
+static bool handler_lockingx(int instance)
{
union smb_lock parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_SET_FNUM(lockx.in.file.fnum);
GEN_CALL(smb_raw_lock(tree, &parm[i]));
- return True;
+ return true;
}
/*
/*
compare returned fileinfo structures
*/
-static BOOL cmp_fileinfo(int instance,
+static bool cmp_fileinfo(int instance,
union smb_fileinfo parm[NSERVERS],
NTSTATUS status[NSERVERS])
{
switch (parm[0].generic.level) {
case RAW_FILEINFO_GENERIC:
- return False;
+ return false;
case RAW_FILEINFO_GETATTR:
CHECK_EQUAL(getattr.out.attrib);
case RAW_FILEINFO_UNIX_BASIC:
case RAW_FILEINFO_UNIX_LINK:
case RAW_FILEINFO_SMB2_ALL_EAS:
- case RAW_FILEINFO_SMB2_ALL_INFORMATION:
+ case RAW_FILEINFO_SMB2_ALL_INFORMATION:
+ case RAW_FILEINFO_UNIX_INFO2:
break;
}
- return True;
+ return true;
}
/*
generate qpathinfo operations
*/
-static BOOL handler_qpathinfo(int instance)
+static bool handler_qpathinfo(int instance)
{
union smb_fileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
/*
generate qfileinfo operations
*/
-static BOOL handler_qfileinfo(int instance)
+static bool handler_qfileinfo(int instance)
{
union smb_fileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
case RAW_SFILEINFO_1032:
case RAW_SFILEINFO_1039:
case RAW_SFILEINFO_1040:
+ case RAW_SFILEINFO_UNIX_INFO2:
/* Untested */
break;
}
/*
generate setpathinfo operations
*/
-static BOOL handler_spathinfo(int instance)
+static bool handler_spathinfo(int instance)
{
union smb_setfileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_CALL(smb_raw_setpathinfo(tree, &parm[i]));
- return True;
+ return true;
}
/*
generate setfileinfo operations
*/
-static BOOL handler_sfileinfo(int instance)
+static bool handler_sfileinfo(int instance)
{
union smb_setfileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
GEN_SET_FNUM(generic.in.file.fnum);
GEN_CALL(smb_raw_setfileinfo(tree, &parm[i]));
- return True;
+ return true;
}
/*
generate change notify operations
*/
-static BOOL handler_notify(int instance)
+static bool handler_notify(int instance)
{
union smb_notify parm[NSERVERS];
int n;
req->async.fn = async_notify;
}
- return True;
+ return true;
}
/*
*/
static struct {
const char *name;
- BOOL (*handler)(int instance);
+ bool (*handler)(int instance);
int count, success_count;
} gen_ops[] = {
{"OPEN", handler_open},
run the test with the current set of op_parms parameters
return the number of operations that completed successfully
*/
-static int run_test(void)
+static int run_test(struct loadparm_context *lp_ctx)
{
int op, i;
- if (!connect_servers()) {
+ if (!connect_servers(lp_ctx)) {
printf("Failed to connect to servers\n");
exit(1);
}
for (op=0; op<options.numops; op++) {
int instance, which_op;
- BOOL ret;
+ bool ret;
if (op_parms[op].disabled) continue;
perform a backtracking analysis of the minimal set of operations
to generate an error
*/
-static void backtrack_analyze(void)
+static void backtrack_analyze(struct loadparm_context *lp_ctx)
{
int chunk, ret;
/* mark this range as disabled */
max = MIN(options.numops, base+chunk);
for (i=base;i<max; i++) {
- op_parms[i].disabled = True;
+ op_parms[i].disabled = true;
}
printf("Testing %d ops with %d-%d disabled\n",
options.numops, base, max-1);
- ret = run_test();
+ ret = run_test(lp_ctx);
printf("Completed %d of %d ops\n", ret, options.numops);
for (i=base;i<max; i++) {
- op_parms[i].disabled = False;
+ op_parms[i].disabled = false;
}
if (ret == options.numops) {
/* this chunk is needed */
} while (chunk > 0);
printf("Reduced to %d ops\n", options.numops);
- ret = run_test();
+ ret = run_test(lp_ctx);
if (ret != options.numops - 1) {
printf("Inconsistent result? ret=%d numops=%d\n", ret, options.numops);
}
/*
start the main gentest process
*/
-static BOOL start_gentest(void)
+static bool start_gentest(struct loadparm_context *lp_ctx)
{
int op;
int ret;
}
}
- ret = run_test();
+ ret = run_test(lp_ctx);
if (ret != options.numops && options.analyze) {
options.numops = ret+1;
- backtrack_analyze();
+ backtrack_analyze(lp_ctx);
} else if (options.analyze_always) {
- backtrack_analyze();
+ backtrack_analyze(lp_ctx);
} else if (options.analyze_continuous) {
- while (run_test() == options.numops) ;
+ while (run_test(lp_ctx) == options.numops) ;
}
return ret == options.numops;
/**
split a UNC name into server and share names
*/
-static BOOL split_unc_name(const char *unc, char **server, char **share)
+static bool split_unc_name(const char *unc, char **server, char **share)
{
char *p = strdup(unc);
- if (!p) return False;
+ if (!p) return false;
all_string_sub(p, "\\", "/", 0);
- if (strncmp(p, "//", 2) != 0) return False;
+ if (strncmp(p, "//", 2) != 0) return false;
(*server) = p+2;
p = strchr(*server, '/');
- if (!p) return False;
+ if (!p) return false;
*p = 0;
(*share) = p+1;
- return True;
+ return true;
}
{
int opt;
int i, username_count=0;
- BOOL ret;
+ bool ret;
+ struct loadparm_context *lp_ctx;
setlinebuf(stdout);
argc -= NSERVERS;
argv += NSERVERS;
- lp_load();
+ lp_ctx = loadparm_init(talloc_autofree_context());
+ lp_load(lp_ctx, dyn_CONFIGFILE);
servers[0].credentials = cli_credentials_init(talloc_autofree_context());
servers[1].credentials = cli_credentials_init(talloc_autofree_context());
- cli_credentials_guess(servers[0].credentials);
- cli_credentials_guess(servers[1].credentials);
+ cli_credentials_guess(servers[0].credentials, lp_ctx);
+ cli_credentials_guess(servers[1].credentials, lp_ctx);
options.seed = time(NULL);
options.numops = 1000;
options.seeds_file = optarg;
break;
case 'L':
- options.use_preset_seeds = True;
+ options.use_preset_seeds = true;
break;
case 'F':
- options.fast_reconnect = True;
+ options.fast_reconnect = true;
break;
case 'o':
options.numops = atoi(optarg);
break;
case 'O':
- options.use_oplocks = True;
+ options.use_oplocks = true;
break;
case 'a':
- options.showall = True;
+ options.showall = true;
break;
case 'A':
- options.analyze = True;
+ options.analyze = true;
break;
case 'X':
- options.analyze_always = True;
+ options.analyze_always = true;
break;
case 'C':
- options.analyze_continuous = True;
+ options.analyze_continuous = true;
break;
case 'i':
options.ignore_patterns = file_lines_load(optarg, NULL, NULL);
}
}
- gensec_init();
+ gensec_init(lp_ctx);
if (username_count == 0) {
usage();
printf("seed=%u\n", options.seed);
- ret = start_gentest();
+ ret = start_gentest(lp_ctx);
if (ret) {
printf("gentest completed - no errors\n");
git.samba.org / ira / wip.git / blobdiff