static void pwd_sub(char *buf)
{
all_string_sub(buf,"\\n","\n",0);
all_string_sub(buf,"\\r","\r",0);
all_string_sub(buf,"\\s"," ",0);
all_string_sub(buf,"\\t","\t",0);
}
/**
Something really nasty happened - panic !
**/
_PUBLIC_ _NORETURN_ void smb_panic(const char *why)
{
int result;
if (panic_action && *panic_action) {
char pidstr[20];
char cmdstring[200];
safe_strcpy(cmdstring, panic_action, sizeof(cmdstring));
snprintf(pidstr, sizeof(pidstr), "%u", getpid());
all_string_sub(cmdstring, "%PID%", pidstr, sizeof(cmdstring));
if (progname) {
all_string_sub(cmdstring, "%PROG%", progname, sizeof(cmdstring));
}
DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmdstring));
result = system(cmdstring);
if (result == -1)
DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
strerror(errno)));
else
DEBUG(0, ("smb_panic(): action returned status %d\n",
WEXITSTATUS(result)));
}
DEBUG(0,("PANIC: %s\n", why));
call_backtrace();
#ifdef SIGABRT
CatchSignal(SIGABRT,SIGNAL_CAST SIG_DFL);
#endif
abort();
}
static char *reg_test(char *pattern, char *file)
{
static fstring ret;
pstring rpattern;
regex_t preg;
pattern = 1+strrchr(pattern,'\\');
file = 1+strrchr(file,'\\');
fstrcpy(ret,"---");
if (strcmp(file,"..") == 0) file = ".";
if (strcmp(pattern,".") == 0) return ret;
if (strcmp(pattern,"") == 0) {
ret[2] = '+';
return ret;
}
pstrcpy(rpattern,"^");
pstrcat(rpattern, pattern);
all_string_sub(rpattern,".", "[.]", 0);
all_string_sub(rpattern,"?", ".{1}", 0);
all_string_sub(rpattern,"*", ".*", 0);
all_string_sub(rpattern+strlen(rpattern)-1,">", "([^.]?|[.]?$)", 0);
all_string_sub(rpattern,">", "[^.]?", 0);
all_string_sub(rpattern,"<[.]", ".*[.]", 0);
all_string_sub(rpattern,"<\"", "(.*[.]|.*$)", 0);
all_string_sub(rpattern,"<", "([^.]*|[^.]*[.]|[.][^.]*|[.].*[.])", 0);
if (strlen(pattern)>1) {
all_string_sub(rpattern+strlen(rpattern)-1,"\"", "[.]?", 0);
}
all_string_sub(rpattern,"\"", "([.]|$)", 0);
pstrcat(rpattern,"$");
/* printf("pattern=[%s] rpattern=[%s]\n", pattern, rpattern); */
regcomp(&preg, rpattern, REG_ICASE|REG_NOSUB|REG_EXTENDED);
if (regexec(&preg, ".", 0, NULL, 0) == 0) {
ret[0] = '+';
ret[1] = '+';
}
if (regexec(&preg, file, 0, NULL, 0) == 0) {
ret[2] = '+';
}
regfree(&preg);
return ret;
}
static char *tstring(time_t t)
{
static pstring buf;
pstrcpy(buf, asctime(LocalTime(&t)));
all_string_sub(buf," "," ",sizeof(buf));
return buf;
}
/* load a msg file into the tdb */
static bool load_msg(const char *msg_file)
{
char **lines;
int num_lines, i;
char *msgid, *msgstr;
TDB_DATA data;
lines = file_lines_load(msg_file, &num_lines, 0, NULL);
if (!lines) {
return False;
}
if (tdb_lockall(tdb) != 0) {
TALLOC_FREE(lines);
return False;
}
/* wipe the db */
tdb_wipe_all(tdb);
msgid = NULL;
for (i=0;i<num_lines;i++) {
if (strncmp(lines[i], "msgid \"", 7) == 0) {
msgid = lines[i] + 7;
}
if (msgid && strncmp(lines[i], "msgstr \"", 8) == 0) {
msgstr = lines[i] + 8;
trim_char(msgid, '\0', '\"');
trim_char(msgstr, '\0', '\"');
if (*msgstr == 0) {
msgstr = msgid;
}
all_string_sub(msgid, "\\n", "\n", 0);
all_string_sub(msgstr, "\\n", "\n", 0);
data = string_term_tdb_data(msgstr);
tdb_store_bystring(tdb, msgid, data, 0);
msgid = NULL;
}
}
TALLOC_FREE(lines);
tdb_unlockall(tdb);
return True;
}
/* load a msg file into the tdb */
static BOOL load_msg(const char *msg_file)
{
char **lines;
int num_lines, i;
char *msgid, *msgstr;
TDB_DATA key, data;
lines = file_lines_load(msg_file, &num_lines);
if (!lines) {
return False;
}
if (tdb_lockall(tdb) != 0) return False;
/* wipe the db */
tdb_traverse(tdb, tdb_traverse_delete_fn, NULL);
msgid = NULL;
for (i=0;i<num_lines;i++) {
if (strncmp(lines[i], "msgid \"", 7) == 0) {
msgid = lines[i] + 7;
}
if (msgid && strncmp(lines[i], "msgstr \"", 8) == 0) {
msgstr = lines[i] + 8;
trim_char(msgid, '\0', '\"');
trim_char(msgstr, '\0', '\"');
if (*msgstr == 0) {
msgstr = msgid;
}
all_string_sub(msgid, "\\n", "\n", 0);
all_string_sub(msgstr, "\\n", "\n", 0);
key.dptr = msgid;
key.dsize = strlen(msgid)+1;
data.dptr = msgstr;
data.dsize = strlen(msgstr)+1;
tdb_store(tdb, key, data, 0);
msgid = NULL;
}
}
file_lines_free(lines);
tdb_unlockall(tdb);
return True;
}
void sync_browse_lists(struct work_record *work,
char *name, int nm_type,
struct in_addr ip, bool local, bool servers)
{
struct sync_record *s;
static int counter;
START_PROFILE(sync_browse_lists);
/* Check we're not trying to sync with ourselves. This can
happen if we are a domain *and* a local master browser. */
if (ismyip_v4(ip)) {
done:
END_PROFILE(sync_browse_lists);
return;
}
s = SMB_MALLOC_P(struct sync_record);
if (!s) goto done;
ZERO_STRUCTP(s);
unstrcpy(s->workgroup, work->work_group);
unstrcpy(s->server, name);
s->ip = ip;
if (asprintf(&s->fname, "%s/sync.%d", lp_lockdir(), counter++) < 0) {
SAFE_FREE(s);
goto done;
}
/* Safe to use as 0 means no size change. */
all_string_sub(s->fname,"//", "/", 0);
DLIST_ADD(syncs, s);
/* the parent forks and returns, leaving the child to do the
actual sync and call END_PROFILE*/
CatchChild();
if ((s->pid = sys_fork())) return;
BlockSignals( False, SIGTERM );
DEBUG(2,("Initiating browse sync for %s to %s(%s)\n",
work->work_group, name, inet_ntoa(ip)));
fp = x_fopen(s->fname,O_WRONLY|O_CREAT|O_TRUNC, 0644);
if (!fp) {
END_PROFILE(sync_browse_lists);
_exit(1);
}
sync_child(name, nm_type, work->work_group, ip, local, servers,
s->fname);
x_fclose(fp);
END_PROFILE(sync_browse_lists);
_exit(0);
}
/* return a DNS name in the for aa.bb.cc from the DN
"dc=AA,dc=BB,dc=CC". caller must free
*/
char *ads_build_domain(const char *dn)
{
char *dnsdomain = NULL;
/* result should always be shorter than the DN */
if ( (dnsdomain = SMB_STRDUP( dn )) == NULL ) {
DEBUG(0,("ads_build_domain: malloc() failed!\n"));
return NULL;
}
if (!strlower_m( dnsdomain )) {
SAFE_FREE(dnsdomain);
return NULL;
}
all_string_sub( dnsdomain, "dc=", "", 0);
all_string_sub( dnsdomain, ",", ".", 0 );
return dnsdomain;
}
/*****************************************************
parse a smb path into its components.
server is one of
1) the name of the SMB server
2) WORKGROUP#1D for share listing
3) WORKGROUP#__ for workgroup listing
share is the share on the server to query
path is the SMB path on the server
return the full path (ie. add cwd if needed)
*******************************************************/
char *smbw_parse_path(const char *fname, char *server, char *share, char *path)
{
static pstring s;
char *p;
int len;
fstring workgroup;
/* add cwd if necessary */
if (fname[0] != '/') {
slprintf(s, sizeof(s), "%s/%s", smbw_cwd, fname);
} else {
pstrcpy(s, fname);
}
clean_fname(s);
/* see if it has the right prefix */
len = strlen(smbw_prefix)-1;
if (strncmp(s,smbw_prefix,len) ||
(s[len] != '/' && s[len] != 0)) return s;
/* ok, its for us. Now parse out the workgroup, share etc. */
p = s+len;
if (*p == '/') p++;
if (!next_token(&p, workgroup, "/", sizeof(fstring))) {
/* we're in /smb - give a list of workgroups */
slprintf(server,sizeof(fstring), "%s#01", smbw_find_workgroup());
fstrcpy(share,"IPC$");
pstrcpy(path,"");
return s;
}
if (!next_token(&p, server, "/", sizeof(fstring))) {
/* we are in /smb/WORKGROUP */
slprintf(server,sizeof(fstring), "%s#1D", workgroup);
fstrcpy(share,"IPC$");
pstrcpy(path,"");
}
if (!next_token(&p, share, "/", sizeof(fstring))) {
/* we are in /smb/WORKGROUP/SERVER */
fstrcpy(share,"IPC$");
pstrcpy(path,"");
}
pstrcpy(path, p);
all_string_sub(path, "/", "\\", 0);
return s;
}
void ical_property_RESOURCES(struct exchange2ical *exchange2ical)
{
char *NonSendableBcc = NULL;
icalproperty *prop;
/* Sanity check */
if (!exchange2ical->NonSendableBcc) return;
NonSendableBcc = talloc_strdup(exchange2ical->mem_ctx, exchange2ical->NonSendableBcc);
all_string_sub(NonSendableBcc, ";", ",", 0);
prop = icalproperty_new_resources(NonSendableBcc);
icalcomponent_add_property(exchange2ical->vevent, prop);
talloc_free(NonSendableBcc);
}
/*
convert a windows path to a unix path - don't do any manging or case sensitive handling
*/
char *cifspsx_unix_path(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req, const char *name)
{
struct cifspsx_private *p = ntvfs->private_data;
char *ret;
char *name_lower = strlower_talloc(p, name);
if (*name != '\\') {
ret = talloc_asprintf(req, "%s/%s", p->connectpath, name_lower);
} else {
ret = talloc_asprintf(req, "%s%s", p->connectpath, name_lower);
}
all_string_sub(ret, "\\", "/", 0);
talloc_free(name_lower);
return ret;
}
/*
convert a windows path to a unix path - don't do any manging or case sensitive handling
*/
char *svfs_unix_path(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req, const char *name)
{
struct svfs_private *p = ntvfs->private_data;
char *ret;
if (*name != '\\') {
ret = talloc_asprintf(req, "%s/%s", p->connectpath, name);
} else {
ret = talloc_asprintf(req, "%s%s", p->connectpath, name);
}
all_string_sub(ret, "\\", "/", 0);
strlower(ret + strlen(p->connectpath));
return ret;
}
/* This hardcoded value should go into a ldb database! */
const char *dcesrv_common_get_share_path(TALLOC_CTX *mem_ctx, struct dcesrv_context *dce_ctx, struct share_config *scfg)
{
const char *sharetype;
char *p;
sharetype = share_string_option(scfg, SHARE_TYPE, SHARE_TYPE_DEFAULT);
if (sharetype && strcasecmp(sharetype, "IPC") == 0) {
return talloc_strdup(mem_ctx, "");
}
p = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PATH, ""));
if (!p) {
return NULL;
}
if (p[0] == '\0') {
return p;
}
all_string_sub(p, "/", "\\", 0);
return talloc_asprintf(mem_ctx, "C:%s", p);
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
char *share[NSERVERS];
int opt;
char *p;
int seed, server;
setlinebuf(stdout);
load_case_tables();
if (argc < 3 || argv[1][0] == '-') {
usage();
exit(1);
}
setup_logging(argv[0], DEBUG_STDOUT);
for (server=0;server<NSERVERS;server++) {
share[server] = argv[1+server];
all_string_sub(share[server],"/","\\",0);
}
argc -= NSERVERS;
argv += NSERVERS;
lp_load_global(get_dyn_CONFIGFILE());
load_interfaces();
if (getenv("USER")) {
fstrcpy(username[0],getenv("USER"));
fstrcpy(username[1],getenv("USER"));
}
seed = time(NULL);
while ((opt = getopt(argc, argv, "U:s:ho:aAW:OkR:B:M:EZ")) != EOF) {
switch (opt) {
case 'k':
#ifdef HAVE_KRB5
use_kerberos = True;
#else
d_printf("No kerberos support compiled in\n");
exit(1);
#endif
break;
case 'U':
got_user = 1;
if (got_pass == 2) {
d_printf("Max of 2 usernames\n");
exit(1);
}
fstrcpy(username[got_pass],optarg);
p = strchr_m(username[got_pass],'%');
if (p) {
*p = 0;
fstrcpy(password[got_pass], p+1);
got_pass++;
}
break;
case 'R':
lock_range = strtol(optarg, NULL, 0);
break;
case 'B':
lock_base = strtol(optarg, NULL, 0);
break;
case 'M':
min_length = strtol(optarg, NULL, 0);
break;
case 's':
seed = atoi(optarg);
break;
case 'u':
hide_unlock_fails = True;
break;
case 'o':
numops = atoi(optarg);
break;
case 'O':
use_oplocks = True;
break;
case 'a':
showall = True;
break;
case 'A':
analyze = True;
break;
case 'Z':
zero_zero = True;
break;
case 'E':
exact_error_codes = True;
break;
case 'h':
usage();
exit(1);
default:
printf("Unknown option %c (%d)\n", (char)opt, opt);
exit(1);
}
}
if(use_kerberos && !got_user) got_pass = True;
argc -= optind;
argv += optind;
DEBUG(0,("seed=%u\n", seed));
srandom(seed);
test_locks(share);
return(0);
}
static BOOL chat_with_program(char *passwordprogram,char *name,char *chatsequence, BOOL as_root)
{
char *slavedev;
int master;
pid_t pid, wpid;
int wstat;
BOOL chstat = False;
/* allocate a pseudo-terminal device */
if ((master = findpty (&slavedev)) < 0) {
DEBUG(3,("Cannot Allocate pty for password change: %s\n",name));
return(False);
}
/*
* We need to temporarily stop CatchChild from eating
* SIGCLD signals as it also eats the exit status code. JRA.
*/
CatchChildLeaveStatus();
#ifdef __uClinux__
/* Hmmm, need to check this one further... */
DEBUG(0,("%s(%d): vfork()ing\n",__FILE__,__LINE__));
if ((pid = vfork()) < 0) {
#else
if ((pid = fork()) < 0) {
#endif
DEBUG(3,("Cannot fork() child for password change: %s\n",name));
close(master);
CatchChild();
return(False);
}
/* we now have a pty */
if (pid > 0){ /* This is the parent process */
if ((chstat = talktochild(master, chatsequence)) == False) {
DEBUG(3,("Child failed to change password: %s\n",name));
kill(pid, SIGKILL); /* be sure to end this process */
}
while((wpid = sys_waitpid(pid, &wstat, 0)) < 0) {
if(errno == EINTR) {
errno = 0;
continue;
}
break;
}
if (wpid < 0) {
DEBUG(3,("The process is no longer waiting!\n\n"));
close(master);
CatchChild();
return(False);
}
/*
* Go back to ignoring children.
*/
CatchChild();
close(master);
if (pid != wpid) {
DEBUG(3,("We were waiting for the wrong process ID\n"));
return(False);
}
if (WIFEXITED(wstat) == 0) {
DEBUG(3,("The process exited while we were waiting\n"));
return(False);
}
if (WEXITSTATUS(wstat) != 0) {
DEBUG(3,("The status of the process exiting was %d\n", wstat));
return(False);
}
} else {
/* CHILD */
/*
* Lose any oplock capabilities.
*/
set_process_capability(KERNEL_OPLOCK_CAPABILITY, False);
set_inherited_process_capability(KERNEL_OPLOCK_CAPABILITY, False);
/* make sure it doesn't freeze */
alarm(20);
if (as_root)
become_root(False);
DEBUG(3,("Dochild for user %s (uid=%d,gid=%d)\n",name,(int)getuid(),(int)getgid()));
chstat = dochild(master, slavedev, name, passwordprogram, as_root);
/*
* The child should never return from dochild() ....
*/
DEBUG(0,("chat_with_program: Error: dochild() returned %d\n", chstat ));
exit(1);
}
if (chstat)
DEBUG(3,("Password change %ssuccessful for user %s\n", (chstat?"":"un"), name));
return (chstat);
}
BOOL chgpasswd(char *name,char *oldpass,char *newpass, BOOL as_root)
{
pstring passwordprogram;
pstring chatsequence;
size_t i;
size_t len;
strlower(name);
DEBUG(3,("Password change for user: %s\n",name));
#if DEBUG_PASSWORD
DEBUG(100,("Passwords: old=%s new=%s\n",oldpass,newpass));
#endif
/* Take the passed information and test it for minimum criteria */
/* Minimum password length */
if (strlen(newpass) < lp_min_passwd_length()) /* too short, must be at least MINPASSWDLENGTH */
{
DEBUG(0,("Password Change: user %s, New password is shorter than minimum password length = %d\n",
name, lp_min_passwd_length()));
return (False); /* inform the user */
}
/* Password is same as old password */
if (strcmp(oldpass,newpass) == 0) /* don't allow same password */
{
DEBUG(2,("Password Change: %s, New password is same as old\n",name)); /* log the attempt */
return (False); /* inform the user */
}
pstrcpy(passwordprogram,lp_passwd_program());
pstrcpy(chatsequence,lp_passwd_chat());
if (!*chatsequence) {
DEBUG(2,("Null chat sequence - no password changing\n"));
return(False);
}
if (!*passwordprogram) {
DEBUG(2,("Null password program - no password changing\n"));
return(False);
}
/*
* Check the old and new passwords don't contain any control
* characters.
*/
len = strlen(oldpass);
for(i = 0; i < len; i++) {
if (iscntrl((int)oldpass[i])) {
DEBUG(0,("chat_with_program: oldpass contains control characters (disallowed).\n"));
return False;
}
}
len = strlen(newpass);
for(i = 0; i < len; i++) {
if (iscntrl((int)newpass[i])) {
DEBUG(0,("chat_with_program: newpass contains control characters (disallowed).\n"));
return False;
}
}
pstring_sub(passwordprogram,"%u",name);
/* note that we do NOT substitute the %o and %n in the password program
as this would open up a security hole where the user could use
a new password containing shell escape characters */
pstring_sub(chatsequence,"%u",name);
all_string_sub(chatsequence,"%o",oldpass,sizeof(pstring));
all_string_sub(chatsequence,"%n",newpass,sizeof(pstring));
return(chat_with_program(passwordprogram,name,chatsequence, as_root));
}
int find_service(fstring service)
{
int iService;
struct smbd_server_connection *sconn = smbd_server_conn;
all_string_sub(service,"\\","/",0);
iService = lp_servicenumber(service);
/* now handle the special case of a home directory */
if (iService < 0) {
char *phome_dir = get_user_home_dir(talloc_tos(), service);
if(!phome_dir) {
/*
* Try mapping the servicename, it may
* be a Windows to unix mapped user name.
*/
if(map_username(sconn, service))
phome_dir = get_user_home_dir(
talloc_tos(), service);
}
DEBUG(3,("checking for home directory %s gave %s\n",service,
phome_dir?phome_dir:"(NULL)"));
iService = add_home_service(service,service /* 'username' */, phome_dir);
}
/* If we still don't have a service, attempt to add it as a printer. */
if (iService < 0) {
int iPrinterService;
if ((iPrinterService = lp_servicenumber(PRINTERS_NAME)) < 0) {
iPrinterService = load_registry_service(PRINTERS_NAME);
}
if (iPrinterService) {
DEBUG(3,("checking whether %s is a valid printer name...\n", service));
if (pcap_printername_ok(service)) {
DEBUG(3,("%s is a valid printer name\n", service));
DEBUG(3,("adding %s as a printer service\n", service));
lp_add_printer(service, iPrinterService);
iService = lp_servicenumber(service);
if (iService < 0) {
DEBUG(0,("failed to add %s as a printer service!\n", service));
}
} else {
DEBUG(3,("%s is not a valid printer name\n", service));
}
}
}
/* Check for default vfs service? Unsure whether to implement this */
if (iService < 0) {
}
if (iService < 0) {
iService = load_registry_service(service);
}
/* Is it a usershare service ? */
if (iService < 0 && *lp_usershare_path()) {
/* Ensure the name is canonicalized. */
strlower_m(service);
iService = load_usershare_service(service);
}
/* just possibly it's a default service? */
if (iService < 0) {
char *pdefservice = lp_defaultservice();
if (pdefservice && *pdefservice && !strequal(pdefservice,service) && !strstr_m(service,"..")) {
/*
* We need to do a local copy here as lp_defaultservice()
* returns one of the rotating lp_string buffers that
* could get overwritten by the recursive find_service() call
* below. Fix from Josef Hinteregger <*****@*****.**>.
*/
char *defservice = SMB_STRDUP(pdefservice);
if (!defservice) {
goto fail;
}
/* Disallow anything except explicit share names. */
if (strequal(defservice,HOMES_NAME) ||
strequal(defservice, PRINTERS_NAME) ||
strequal(defservice, "IPC$")) {
SAFE_FREE(defservice);
goto fail;
}
iService = find_service(defservice);
if (iService >= 0) {
all_string_sub(service, "_","/",0);
iService = lp_add_service(service, iService);
}
SAFE_FREE(defservice);
}
}
if (iService >= 0) {
if (!VALID_SNUM(iService)) {
DEBUG(0,("Invalid snum %d for %s\n",iService, service));
iService = -1;
}
}
fail:
if (iService < 0)
DEBUG(3,("find_service() failed to find service %s\n", service));
return (iService);
}
/* run a test that simulates an approximate netbench client load */
static bool run_netbench(struct torture_context *tctx, struct smbcli_state *cli, int client)
{
int torture_nprocs = torture_setting_int(tctx, "nprocs", 4);
int i;
char line[1024];
char *cname;
FILE *f;
bool correct = true;
double target_rate = torture_setting_double(tctx, "targetrate", 0);
int n;
if (target_rate != 0 && client == 0) {
printf("Targetting %.4f MByte/sec\n", target_rate);
}
nb_setup(cli, client);
if (torture_nprocs == 1) {
if (!read_only) {
NB_RETRY(torture_setup_dir(cli, "\\clients"));
}
}
asprintf(&cname, "client%d", client+1);
f = fopen(loadfile, "r");
if (!f) {
perror(loadfile);
return false;
}
again:
nbio_time_reset();
while (fgets(line, sizeof(line)-1, f)) {
NTSTATUS status;
const char **params0, **params;
nbench_line_count++;
line[strlen(line)-1] = 0;
all_string_sub(line,"client1", cname, sizeof(line));
params = params0 = str_list_make_shell(NULL, line, " ");
i = str_list_length(params);
if (i > 0 && isdigit(params[0][0])) {
double targett = strtod(params[0], NULL);
if (target_rate != 0) {
nbio_target_rate(target_rate);
} else {
nbio_time_delay(targett);
}
params++;
i--;
} else if (target_rate != 0) {
nbio_target_rate(target_rate);
}
if (i < 2 || params[0][0] == '#') continue;
if (!strncmp(params[0],"SMB", 3)) {
printf("ERROR: You are using a dbench 1 load file\n");
nb_exit(1);
}
if (strncmp(params[i-1], "NT_STATUS_", 10) != 0 &&
strncmp(params[i-1], "0x", 2) != 0) {
printf("Badly formed status at line %d\n", nbench_line_count);
talloc_free(params);
continue;
}
/* accept numeric or string status codes */
if (strncmp(params[i-1], "0x", 2) == 0) {
status = NT_STATUS(strtoul(params[i-1], NULL, 16));
} else {
status = nt_status_string_to_code(params[i-1]);
}
DEBUG(9,("run_netbench(%d): %s %s\n", client, params[0], params[1]));
if (!strcmp(params[0],"NTCreateX")) {
NB_RETRY(nb_createx(params[1], ival(params[2]), ival(params[3]),
ival(params[4]), status));
} else if (!strcmp(params[0],"Close")) {
NB_RETRY(nb_close(ival(params[1]), status));
} else if (!read_only && !strcmp(params[0],"Rename")) {
NB_RETRY(nb_rename(params[1], params[2], status, n>0));
} else if (!read_only && !strcmp(params[0],"Unlink")) {
NB_RETRY(nb_unlink(params[1], ival(params[2]), status, n>0));
} else if (!read_only && !strcmp(params[0],"Deltree")) {
NB_RETRY(nb_deltree(params[1], n>0));
} else if (!read_only && !strcmp(params[0],"Rmdir")) {
NB_RETRY(nb_rmdir(params[1], status, n>0));
} else if (!read_only && !strcmp(params[0],"Mkdir")) {
NB_RETRY(nb_mkdir(params[1], status, n>0));
} else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
NB_RETRY(nb_qpathinfo(params[1], ival(params[2]), status));
} else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
NB_RETRY(nb_qfileinfo(ival(params[1]), ival(params[2]), status));
} else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
NB_RETRY(nb_qfsinfo(ival(params[1]), status));
} else if (!read_only && !strcmp(params[0],"SET_FILE_INFORMATION")) {
NB_RETRY(nb_sfileinfo(ival(params[1]), ival(params[2]), status));
} else if (!strcmp(params[0],"FIND_FIRST")) {
NB_RETRY(nb_findfirst(params[1], ival(params[2]),
ival(params[3]), ival(params[4]), status));
} else if (!read_only && !strcmp(params[0],"WriteX")) {
NB_RETRY(nb_writex(ival(params[1]),
ival(params[2]), ival(params[3]), ival(params[4]),
status));
} else if (!read_only && !strcmp(params[0],"Write")) {
NB_RETRY(nb_write(ival(params[1]),
ival(params[2]), ival(params[3]), ival(params[4]),
status));
} else if (!strcmp(params[0],"LockX")) {
NB_RETRY(nb_lockx(ival(params[1]),
ival(params[2]), ival(params[3]), status));
} else if (!strcmp(params[0],"UnlockX")) {
NB_RETRY(nb_unlockx(ival(params[1]),
ival(params[2]), ival(params[3]), status));
} else if (!strcmp(params[0],"ReadX")) {
NB_RETRY(nb_readx(ival(params[1]),
ival(params[2]), ival(params[3]), ival(params[4]),
status));
} else if (!strcmp(params[0],"Flush")) {
NB_RETRY(nb_flush(ival(params[1]), status));
} else if (!strcmp(params[0],"Sleep")) {
nb_sleep(ival(params[1]), status);
} else {
printf("[%d] Unknown operation %s\n", nbench_line_count, params[0]);
}
if (n > nb_max_retries) {
printf("Maximum reconnect retries reached for op '%s'\n", params[0]);
nb_exit(1);
}
talloc_free(params0);
if (nb_tick()) goto done;
}
rewind(f);
goto again;
done:
fclose(f);
if (!read_only && torture_nprocs == 1) {
smbcli_deltree(cli->tree, "\\clients");
}
if (!torture_close_connection(cli)) {
correct = false;
}
return correct;
}
BOOL chgpasswd(char *name,char *oldpass,char *newpass, BOOL as_root)
{
pstring passwordprogram;
pstring chatsequence;
size_t i;
size_t len;
strlower(name);
DEBUG(3,("Password change for user: %s\n",name));
#if DEBUG_PASSWORD
DEBUG(100,("Passwords: old=%s new=%s\n",oldpass,newpass));
#endif
/* Take the passed information and test it for minimum criteria */
/* Minimum password length */
if (strlen(newpass) < lp_min_passwd_length()) /* too short, must be at least MINPASSWDLENGTH */
{
DEBUG(0,("Password Change: user %s, New password is shorter than minimum password length = %d\n",
name, lp_min_passwd_length()));
return (False); /* inform the user */
}
/* Password is same as old password */
if (strcmp(oldpass,newpass) == 0) /* don't allow same password */
{
DEBUG(2,("Password Change: %s, New password is same as old\n",name)); /* log the attempt */
return (False); /* inform the user */
}
pstrcpy(passwordprogram,lp_passwd_program());
pstrcpy(chatsequence,lp_passwd_chat());
if (!*chatsequence) {
DEBUG(2,("Null chat sequence - no password changing\n"));
return(False);
}
if (!*passwordprogram) {
DEBUG(2,("Null password program - no password changing\n"));
return(False);
}
/*
* Check the old and new passwords don't contain any control
* characters.
*/
len = strlen(oldpass);
for(i = 0; i < len; i++) {
if (iscntrl((int)oldpass[i])) {
DEBUG(0,("chat_with_program: oldpass contains control characters (disallowed).\n"));
return False;
}
}
len = strlen(newpass);
for(i = 0; i < len; i++) {
if (iscntrl((int)newpass[i])) {
DEBUG(0,("chat_with_program: newpass contains control characters (disallowed).\n"));
return False;
}
}
pstring_sub(passwordprogram,"%u",name);
/* note that we do NOT substitute the %o and %n in the password program
as this would open up a security hole where the user could use
a new password containing shell escape characters */
pstring_sub(chatsequence,"%u",name);
all_string_sub(chatsequence,"%o",oldpass,sizeof(pstring));
all_string_sub(chatsequence,"%n",newpass,sizeof(pstring));
return(chat_with_program(passwordprogram,name,chatsequence, as_root));
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
char *share1, *share2;
struct cli_state *cli1, *cli2;
extern char *optarg;
extern int optind;
extern FILE *dbf;
int opt;
char *p;
int seed;
setlinebuf(stdout);
dbf = stderr;
if (argv[1][0] == '-' || argc < 3) {
usage();
exit(1);
}
share1 = argv[1];
share2 = argv[2];
all_string_sub(share1,"/","\\",0);
all_string_sub(share2,"/","\\",0);
setup_logging(argv[0],True);
argc -= 2;
argv += 2;
TimeInit();
charset_initialise();
if (getenv("USER")) {
pstrcpy(username,getenv("USER"));
}
seed = time(NULL);
while ((opt = getopt(argc, argv, "U:s:hm:f:a")) != EOF) {
switch (opt) {
case 'U':
pstrcpy(username,optarg);
p = strchr(username,'%');
if (p) {
*p = 0;
pstrcpy(password, p+1);
got_pass = 1;
}
break;
case 's':
seed = atoi(optarg);
break;
case 'h':
usage();
exit(1);
case 'm':
maskchars = optarg;
break;
case 'f':
filechars = optarg;
break;
case 'a':
showall = 1;
break;
default:
printf("Unknown option %c (%d)\n", (char)opt, opt);
exit(1);
}
}
argc -= optind;
argv += optind;
DEBUG(0,("seed=%d\n", seed));
srandom(seed);
cli1 = connect_one(share1);
if (!cli1) {
DEBUG(0,("Failed to connect to %s\n", share1));
exit(1);
}
cli2 = connect_one(share2);
if (!cli2) {
DEBUG(0,("Failed to connect to %s\n", share2));
exit(1);
}
test_mask(argc, argv, cli1, cli2);
return(0);
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
char *share1, *share2, *nfspath1, *nfspath2;
extern char *optarg;
extern int optind;
int opt;
char *p;
int seed;
setlinebuf(stdout);
dbf = x_stderr;
if (argc < 5 || argv[1][0] == '-') {
usage();
exit(1);
}
share1 = argv[1];
share2 = argv[2];
nfspath1 = argv[3];
nfspath2 = argv[4];
all_string_sub(share1,"/","\\",0);
all_string_sub(share2,"/","\\",0);
setup_logging(argv[0], DEBUG_STDOUT);
argc -= 4;
argv += 4;
lp_load();
if (getenv("USER")) {
fstrcpy(username,getenv("USER"));
}
seed = time(NULL);
while ((opt = getopt(argc, argv, "U:s:ho:aAW:O")) != EOF) {
switch (opt) {
case 'U':
fstrcpy(username,optarg);
p = strchr_m(username,'%');
if (p) {
*p = 0;
fstrcpy(password, p+1);
got_pass = 1;
}
break;
case 's':
seed = atoi(optarg);
break;
case 'u':
hide_unlock_fails = True;
break;
case 'o':
numops = atoi(optarg);
break;
case 'O':
use_oplocks = True;
break;
case 'a':
showall = True;
break;
case 'A':
analyze = True;
break;
case 'h':
usage();
exit(1);
default:
printf("Unknown option %c (%d)\n", (char)opt, opt);
exit(1);
}
}
argc -= optind;
argv += optind;
DEBUG(0,("seed=%u\n", seed));
srandom(seed);
locking_init(1);
test_locks(share1, share2, nfspath1, nfspath2);
return(0);
}
void child_run(struct child_struct *child0, const char *loadfile)
{
int i;
char line[MAX_PARM_LEN], fname[MAX_PARM_LEN], fname2[MAX_PARM_LEN];
char **sparams, **params;
char *p;
const char *status;
gzFile *gzf;
pid_t parent = getppid();
double targett;
struct child_struct *child;
int have_random = 0;
unsigned loop_count = 0;
z_off_t loop_start = 0;
gzf = gzopen(loadfile, "r");
if (gzf == NULL) {
perror(loadfile);
exit(1);
}
for (child=child0;child<child0+options.clients_per_process;child++) {
child->line = 0;
asprintf(&child->cname,"client%d", child->id);
}
sparams = calloc(20, sizeof(char *));
for (i=0;i<20;i++) {
sparams[i] = malloc(MAX_PARM_LEN);
memset(sparams[i], 0, MAX_PARM_LEN);
}
again:
for (child=child0;child<child0+options.clients_per_process;child++) {
nb_time_reset(child);
}
while (gzgets(gzf, line, sizeof(line)-1)) {
unsigned repeat_count = 1;
for (child=child0;child<child0+options.clients_per_process;child++) {
if (child->done) goto done;
child->line++;
}
params = sparams;
if (kill(parent, 0) == -1) {
exit(1);
}
loop_again:
/* if this is a "LOOP <xxx>" line,
* remember the current file position and move to the next line
*/
if (strncmp(line, "LOOP", 4) == 0) {
if (sscanf(line, "LOOP %u\n", &loop_count) != 1) {
fprintf(stderr, "Incorrect LOOP at line %d\n", child0->line);
goto done;
}
for (child=child0;child<child0+options.clients_per_process;child++) {
child->line++;
}
loop_start = gztell(gzf);
gzgets(gzf, line, sizeof(line)-1);
goto loop_again;
}
if (strncmp(line, "ENDLOOP", 7) == 0) {
loop_count--;
gzgets(gzf, line, sizeof(line)-1);
if (loop_count > 0) {
gzseek(gzf, loop_start, SEEK_SET);
}
gzgets(gzf, line, sizeof(line)-1);
goto loop_again;
}
/* if this is a "REPEAT <xxx>" line, just replace the
* currently read line with the next line
*/
if (strncmp(line, "REPEAT", 6) == 0) {
if (sscanf(line, "REPEAT %u\n", &repeat_count) != 1) {
fprintf(stderr, "Incorrect REPEAT at line %d\n", child0->line);
goto done;
}
for (child=child0;child<child0+options.clients_per_process;child++) {
child->line++;
}
gzgets(gzf, line, sizeof(line)-1);
}
/* WRITEPATTERN */
if (strncmp(line, "WRITEPATTERN", 12) == 0) {
char *ptr = rw_buf;
int count = RWBUFSIZE;
while (count > 0) {
int len;
len = count;
if (len > strlen(line +13)) {
len = strlen(line +13);
}
memcpy(ptr, line+13, len);
ptr += len;
count -= len;
}
goto again;
}
/* RANDOMSTRING */
if (strncmp(line, "RANDOMSTRING", 12) == 0) {
have_random = 1;
if (parse_randomstring(line) != 0) {
fprintf(stderr, "Incorrect RANDOMSTRING at line %d\n", child0->line);
goto done;
}
goto again;
}
line[strlen(line)-1] = 0;
all_string_sub(line,"\\", "/");
all_string_sub(line," /", " ");
/* substitute all $<digit> stored strings */
while (have_random && (p = index(line, '$')) != NULL) {
char sstr[3], *nstr;
unsigned int idx;
idx = *(p+1) - '0';
if (idx >= MAX_RND_STR) {
fprintf(stderr, "$%d is an invalid filename/string\n", idx);
goto done;
}
sstr[0] = '$';
sstr[1] = idx+'0';
sstr[2] = '\0';
nstr = get_random_string(idx);
all_string_sub(line, sstr, nstr);
}
p = line;
for (i=0;
i<19 && next_token(&p, params[i], " ");
i++) ;
params[i][0] = 0;
if (i < 2 || params[0][0] == '#') continue;
if (!strncmp(params[0],"SMB", 3)) {
printf("ERROR: You are using a dbench 1 load file\n");
exit(1);
}
if (i > 0 && isdigit(params[0][0])) {
targett = strtod(params[0], NULL);
params++;
i--;
} else {
targett = 0.0;
}
if (strncmp(params[i-1], "NT_STATUS_", 10) != 0 &&
strncmp(params[i-1], "0x", 2) != 0 &&
strncmp(params[i-1], "SUCCESS", 7) != 0 &&
strncmp(params[i-1], "ERROR", 7) != 0 &&
strncmp(params[i-1], "*", 1) != 0) {
printf("Badly formed status at line %d\n", child->line);
continue;
}
status = params[i-1];
for (child=child0;child<child0+options.clients_per_process;child++) {
unsigned child_repeat_count = repeat_count;
int pcount = 1;
fname[0] = 0;
fname2[0] = 0;
if (i>1 && params[1][0] == '/') {
snprintf(fname, sizeof(fname), "%s%s", child->directory, params[1]);
all_string_sub(fname,"client1", child->cname);
pcount++;
}
if (i>2 && params[2][0] == '/') {
snprintf(fname2, sizeof(fname2), "%s%s", child->directory, params[2]);
all_string_sub(fname2,"client1", child->cname);
pcount++;
}
if (options.targetrate != 0 || targett == 0.0) {
nb_target_rate(child, options.targetrate);
} else {
nb_time_delay(child, targett);
}
while (child_repeat_count--) {
child_op(child, params[0], fname, fname2, params+pcount, status);
}
}
}
if (options.run_once) {
goto done;
}
gzrewind(gzf);
goto again;
done:
gzclose(gzf);
for (child=child0;child<child0+options.clients_per_process;child++) {
child->cleanup = 1;
fflush(stdout);
if (!options.skip_cleanup) {
nb_ops->cleanup(child);
}
child->cleanup_finished = 1;
if(child->cname){
free(child->cname);
child->cname = NULL;
}
}
}
/*****************************************************
initialise structures
*******************************************************/
void smbw_init(void)
{
extern BOOL in_client;
static int initialised;
static pstring servicesf = CONFIGFILE;
extern FILE *dbf;
char *p;
int eno;
pstring line;
if (initialised) return;
initialised = 1;
eno = errno;
smbw_busy++;
DEBUGLEVEL = 0;
AllowDebugChange = False;
setup_logging("smbsh",True);
dbf = stderr;
if ((p=smbw_getshared("LOGFILE"))) {
dbf = sys_fopen(p, "a");
}
smbw_file_bmap = bitmap_allocate(SMBW_MAX_OPEN);
if (!smbw_file_bmap) {
exit(1);
}
charset_initialise();
in_client = True;
load_interfaces();
if ((p=smbw_getshared("SERVICESF"))) {
pstrcpy(servicesf, p);
}
lp_load(servicesf,True,False,False);
codepage_initialise(lp_client_code_page());
get_myname(global_myname);
if ((p=smbw_getshared("DEBUG"))) {
DEBUGLEVEL = atoi(p);
}
if ((p=smbw_getshared("RESOLVE_ORDER"))) {
lp_set_name_resolve_order(p);
}
if ((p=smbw_getshared("PREFIX"))) {
slprintf(smbw_prefix,sizeof(fstring)-1, "/%s/", p);
all_string_sub(smbw_prefix,"//", "/", 0);
DEBUG(2,("SMBW_PREFIX is %s\n", smbw_prefix));
}
slprintf(line,sizeof(line)-1,"PWD_%d", (int)getpid());
p = smbw_getshared(line);
if (!p) {
sys_getwd(smbw_cwd);
}
pstrcpy(smbw_cwd, p);
DEBUG(4,("Initial cwd is %s\n", smbw_cwd));
smbw_busy--;
set_maxfiles(SMBW_MAX_OPEN);
BlockSignals(True,SIGPIPE);
errno = eno;
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
char *share[NSERVERS];
int opt;
int seed, server;
int username_count=0;
struct tevent_context *ev;
struct loadparm_context *lp_ctx;
poptContext pc;
int argc_new, i;
char **argv_new;
enum {OPT_UNCLIST=1000};
struct poptOption long_options[] = {
POPT_AUTOHELP
{"seed", 0, POPT_ARG_INT, &seed, 0, "Seed to use for randomizer", NULL},
{"num-ops", 0, POPT_ARG_INT, &numops, 0, "num ops", NULL},
{"lockrange", 0, POPT_ARG_INT, &lock_range,0, "locking range", NULL},
{"lockbase", 0, POPT_ARG_INT, &lock_base, 0, "locking base", NULL},
{"minlength", 0, POPT_ARG_INT, &min_length,0, "min lock length", NULL},
{"hidefails", 0, POPT_ARG_NONE, &hide_unlock_fails,0,"hide unlock fails", NULL},
{"oplocks", 0, POPT_ARG_NONE, &use_oplocks,0, "use oplocks", NULL},
{"showall", 0, POPT_ARG_NONE, &showall, 0, "display all operations", NULL},
{"analyse", 0, POPT_ARG_NONE, &analyze, 0, "do backtrack analysis", NULL},
{"zerozero", 0, POPT_ARG_NONE, &zero_zero, 0, "do zero/zero lock", NULL},
{"exacterrors", 0, POPT_ARG_NONE, &exact_error_codes,0,"use exact error codes", NULL},
{"unclist", 0, POPT_ARG_STRING, NULL, OPT_UNCLIST, "unclist", NULL},
{ "user", 'U', POPT_ARG_STRING, NULL, 'U', "Set the network username", "[DOMAIN/]USERNAME[%PASSWORD]" },
POPT_COMMON_SAMBA
POPT_COMMON_CONNECTION
POPT_COMMON_CREDENTIALS
POPT_COMMON_VERSION
{ NULL }
};
setlinebuf(stdout);
seed = time(NULL);
pc = poptGetContext("locktest", argc, (const char **) argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
poptSetOtherOptionHelp(pc, "<unc1> <unc2>");
lp_ctx = cmdline_lp_ctx;
servers[0] = cli_credentials_init(talloc_autofree_context());
servers[1] = cli_credentials_init(talloc_autofree_context());
cli_credentials_guess(servers[0], lp_ctx);
cli_credentials_guess(servers[1], lp_ctx);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_UNCLIST:
lp_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
break;
case 'U':
if (username_count == 2) {
usage(pc);
exit(1);
}
cli_credentials_parse_string(servers[username_count], poptGetOptArg(pc), CRED_SPECIFIED);
username_count++;
break;
}
}
argv_new = discard_const_p(char *, poptGetArgs(pc));
argc_new = argc;
for (i=0; i<argc; i++) {
if (argv_new[i] == NULL) {
argc_new = i;
break;
}
}
if (!(argc_new >= 3)) {
usage(pc);
exit(1);
}
setup_logging("locktest", DEBUG_STDOUT);
for (server=0;server<NSERVERS;server++) {
share[server] = argv_new[1+server];
all_string_sub(share[server],"/","\\",0);
}
lp_ctx = cmdline_lp_ctx;
if (username_count == 0) {
usage(pc);
return -1;
}
if (username_count == 1) {
servers[1] = servers[0];
}
ev = s4_event_context_init(talloc_autofree_context());
gensec_init(lp_ctx);
DEBUG(0,("seed=%u base=%d range=%d min_length=%d\n",
seed, lock_base, lock_range, min_length));
srandom(seed);
return test_locks(ev, lp_ctx, NULL, share);
}
/****************************************************************************
find a service entry
****************************************************************************/
int find_service(char *service)
{
int iService;
all_string_sub(service,"\\","/",0);
iService = lp_servicenumber(service);
/* now handle the special case of a home directory */
if (iService < 0)
{
int iHomeService;
/* We check that the HOMES_NAME exists before calling expensive
functions like get_user_home_dir */
if ((iHomeService = lp_servicenumber(HOMES_NAME)) >= 0)
{
char *phome_dir = get_user_home_dir(service);
if(!phome_dir)
{
/*
* Try mapping the servicename, it may
* be a Windows to unix mapped user name.
*/
if(map_username(service))
phome_dir = get_user_home_dir(service);
}
DEBUG(3,("checking for home directory %s gave %s\n",service,
phome_dir?phome_dir:"(NULL)"));
if (phome_dir)
{
lp_add_home(service,iHomeService,phome_dir);
iService = lp_servicenumber(service);
}
}
}
#ifdef PRINTING
/* If we still don't have a service, attempt to add it as a printer. */
if (iService < 0)
{
int iPrinterService;
if ((iPrinterService = lp_servicenumber(PRINTERS_NAME)) >= 0)
{
char *pszTemp;
DEBUG(3,("checking whether %s is a valid printer name...\n", service));
pszTemp = PRINTCAP;
if ((pszTemp != NULL) && pcap_printername_ok(service, pszTemp))
{
DEBUG(3,("%s is a valid printer name\n", service));
DEBUG(3,("adding %s as a printer service\n", service));
lp_add_printer(service,iPrinterService);
iService = lp_servicenumber(service);
if (iService < 0)
DEBUG(0,("failed to add %s as a printer service!\n", service));
}
else
DEBUG(3,("%s is not a valid printer name\n", service));
}
}
#endif
/* just possibly it's a default service? */
if (iService < 0)
{
char *pdefservice = lp_defaultservice();
if (pdefservice && *pdefservice &&
!strequal(pdefservice,service) &&
!strstr(service,".."))
{
/*
* We need to do a local copy here as lp_defaultservice()
* returns one of the rotating lp_string buffers that
* could get overwritten by the recursive find_service() call
* below. Fix from Josef Hinteregger <*****@*****.**>.
*/
pstring defservice;
pstrcpy(defservice, pdefservice);
iService = find_service(defservice);
if (iService >= 0)
{
all_string_sub(service,"_","/",0);
iService = lp_add_service(service,iService);
}
}
}
if (iService >= 0)
if (!VALID_SNUM(iService))
{
DEBUG(0,("Invalid snum %d for %s\n",iService,service));
iService = -1;
}
if (iService < 0)
DEBUG(3,("find_service() failed to find service %s\n", service));
return (iService);
}