diff options
Diffstat (limited to 'source3/client/client.c')
| -rw-r--r-- | source3/client/client.c | 691 |
1 files changed, 394 insertions, 297 deletions
diff --git a/source3/client/client.c b/source3/client/client.c index 180aa493ba..292da56497 100644 --- a/source3/client/client.c +++ b/source3/client/client.c @@ -35,12 +35,12 @@ pstring cd_path = ""; static pstring service; static pstring desthost; extern pstring global_myname; -extern pstring myhostname; static pstring password; static pstring username; static pstring workgroup; static char *cmdstr; static BOOL got_pass; +static int io_bufsize = 65520; extern struct in_addr ipzero; extern pstring scope; @@ -149,18 +149,16 @@ static int readfile(char *b, int size, int n, FILE *f) return(fread(b,size,n,f)); i = 0; - while (i < n) { + while (i < (n - 1) && (i < BUFFER_SIZE)) { if ((c = getc(f)) == EOF) { break; } if (c == '\n') { /* change all LFs to CR/LF */ b[i++] = '\r'; - n++; } - if(i < n) - b[i++] = c; + b[i++] = c; } return(i); @@ -327,7 +325,7 @@ static void display_finfo(file_info *finfo) { if (do_this_one(finfo)) { time_t t = finfo->mtime; /* the time is assumed to be passed as GMT */ - DEBUG(0,(" %-30s%7.7s%8.0f %s", + DEBUG(0,(" %-30s%7.7s %8.0f %s", CNV_LANG(finfo->name), attrib_string(finfo->mode), (double)finfo->size, @@ -349,10 +347,128 @@ static void do_du(file_info *finfo) static BOOL do_list_recurse; static BOOL do_list_dirs; -static int do_list_attr; +static char *do_list_queue = 0; +static long do_list_queue_size = 0; +static long do_list_queue_start = 0; +static long do_list_queue_end = 0; static void (*do_list_fn)(file_info *); /**************************************************************************** +functions for do_list_queue + ****************************************************************************/ + +/* + * The do_list_queue is a NUL-separated list of strings stored in a + * char*. Since this is a FIFO, we keep track of the beginning and + * ending locations of the data in the queue. When we overflow, we + * double the size of the char*. When the start of the data passes + * the midpoint, we move everything back. This is logically more + * complex than a linked list, but easier from a memory management + * angle. In any memory error condition, do_list_queue is reset. + * Functions check to ensure that do_list_queue is non-NULL before + * accessing it. + */ +static void reset_do_list_queue(void) +{ + if (do_list_queue) + { + free(do_list_queue); + } + do_list_queue = 0; + do_list_queue_size = 0; + do_list_queue_start = 0; + do_list_queue_end = 0; +} + +static void init_do_list_queue(void) +{ + reset_do_list_queue(); + do_list_queue_size = 1024; + do_list_queue = malloc(do_list_queue_size); + if (do_list_queue == 0) { + DEBUG(0,("malloc fail for size %d\n", + (int)do_list_queue_size)); + reset_do_list_queue(); + } else { + memset(do_list_queue, 0, do_list_queue_size); + } +} + +static void adjust_do_list_queue(void) +{ + /* + * If the starting point of the queue is more than half way through, + * move everything toward the beginning. + */ + if (do_list_queue && (do_list_queue_start == do_list_queue_end)) + { + DEBUG(4,("do_list_queue is empty\n")); + do_list_queue_start = do_list_queue_end = 0; + *do_list_queue = '\0'; + } + else if (do_list_queue_start > (do_list_queue_size / 2)) + { + DEBUG(4,("sliding do_list_queue backward\n")); + memmove(do_list_queue, + do_list_queue + do_list_queue_start, + do_list_queue_end - do_list_queue_start); + do_list_queue_end -= do_list_queue_start; + do_list_queue_start = 0; + } + +} + +static void add_to_do_list_queue(const char* entry) +{ + long new_end = do_list_queue_end + ((long)strlen(entry)) + 1; + while (new_end > do_list_queue_size) + { + do_list_queue_size *= 2; + DEBUG(4,("enlarging do_list_queue to %d\n", + (int)do_list_queue_size)); + do_list_queue = Realloc(do_list_queue, do_list_queue_size); + if (! do_list_queue) { + DEBUG(0,("failure enlarging do_list_queue to %d bytes\n", + (int)do_list_queue_size)); + reset_do_list_queue(); + } + else + { + memset(do_list_queue + do_list_queue_size / 2, + 0, do_list_queue_size / 2); + } + } + if (do_list_queue) + { + pstrcpy(do_list_queue + do_list_queue_end, entry); + do_list_queue_end = new_end; + DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n", + entry, (int)do_list_queue_start, (int)do_list_queue_end)); + } +} + +static char *do_list_queue_head(void) +{ + return do_list_queue + do_list_queue_start; +} + +static void remove_do_list_queue_head(void) +{ + if (do_list_queue_end > do_list_queue_start) + { + do_list_queue_start += strlen(do_list_queue_head()) + 1; + adjust_do_list_queue(); + DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n", + (int)do_list_queue_start, (int)do_list_queue_end)); + } +} + +static int do_list_queue_empty(void) +{ + return (! (do_list_queue && *do_list_queue)); +} + +/**************************************************************************** a helper for do_list ****************************************************************************/ static void do_list_helper(file_info *f, const char *mask) @@ -372,11 +488,8 @@ static void do_list_helper(file_info *f, const char *mask) if (!p) return; p[1] = 0; pstrcat(mask2, f->name); - if (do_list_fn == display_finfo) { - DEBUG(0,("\n%s\n",CNV_LANG(mask2))); - } pstrcat(mask2,"\\*"); - do_list(mask2, do_list_attr, do_list_fn, True, True); + add_to_do_list_queue(mask2); } return; } @@ -392,12 +505,68 @@ a wrapper around cli_list that adds recursion ****************************************************************************/ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),BOOL rec, BOOL dirs) { + static int in_do_list = 0; + + if (in_do_list && rec) + { + fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n"); + exit(1); + } + + in_do_list = 1; + do_list_recurse = rec; do_list_dirs = dirs; do_list_fn = fn; - do_list_attr = attribute; - cli_list(cli, mask, attribute, do_list_helper); + if (rec) + { + init_do_list_queue(); + add_to_do_list_queue(mask); + + while (! do_list_queue_empty()) + { + /* + * Need to copy head so that it doesn't become + * invalid inside the call to cli_list. This + * would happen if the list were expanded + * during the call. + * Fix from E. Jay Berkenbilt (ejb@ql.org) + */ + pstring head; + pstrcpy(head, do_list_queue_head()); + cli_list(cli, head, attribute, do_list_helper); + remove_do_list_queue_head(); + if ((! do_list_queue_empty()) && (fn == display_finfo)) + { + char* next_file = do_list_queue_head(); + char* save_ch = 0; + if ((strlen(next_file) >= 2) && + (next_file[strlen(next_file) - 1] == '*') && + (next_file[strlen(next_file) - 2] == '\\')) + { + save_ch = next_file + + strlen(next_file) - 2; + *save_ch = '\0'; + } + DEBUG(0,("\n%s\n",CNV_LANG(next_file))); + if (save_ch) + { + *save_ch = '\\'; + } + } + } + } + else + { + if (cli_list(cli, mask, attribute, do_list_helper) == -1) + { + DEBUG(0, ("%s listing %s\n", cli_errstr(cli), mask)); + } + } + + in_do_list = 0; + reset_do_list_queue(); } /**************************************************************************** @@ -476,7 +645,7 @@ static void do_get(char *rname,char *lname) BOOL newhandle = False; char *data; struct timeval tp_start; - int read_size = 65520; + int read_size = io_bufsize; uint16 attr; size_t size; off_t nread = 0; @@ -517,7 +686,11 @@ static void do_get(char *rname,char *lname) DEBUG(2,("getting file %s of size %.0f as %s ", lname, (double)size, lname)); - data = (char *)malloc(read_size); + if(!(data = (char *)malloc(read_size))) { + DEBUG(0,("malloc fail for size %d\n", read_size)); + cli_close(cli, fnum); + return; + } while (1) { int n = cli_read(cli, fnum, data, nread, read_size); @@ -531,6 +704,13 @@ static void do_get(char *rname,char *lname) nread += n; } + + if (nread < size) { + DEBUG (0, ("Short read when getting file %s. Only got %ld bytes.\n", + CNV_LANG(rname), (long)nread)); + } + + free(data); if (!cli_close(cli, fnum)) { DEBUG(0,("Error %s closing remote file\n",cli_errstr(cli))); @@ -743,7 +923,7 @@ static BOOL do_mkdir(char *name) /**************************************************************************** -make a directory of name "name" + Exit client. ****************************************************************************/ static void cmd_quit(void) { @@ -801,7 +981,7 @@ static void do_put(char *rname,char *lname) FILE *f; int nread=0; char *buf=NULL; - int maxwrite=65520; + int maxwrite=io_bufsize; struct timeval tp_start; GetTimeOfDay(&tp_start); @@ -1151,6 +1331,24 @@ static void cmd_del(void) do_list(mask, attribute,do_del,False,False); } +/**************************************************************************** +****************************************************************************/ +static void cmd_open(void) +{ + pstring mask; + fstring buf; + + pstrcpy(mask,cur_dir); + + if (!next_token(NULL,buf,NULL,sizeof(buf))) { + DEBUG(0,("del <filename>\n")); + return; + } + pstrcat(mask,buf); + + cli_open(cli, mask, O_RDWR, DENY_ALL); +} + /**************************************************************************** remove a directory @@ -1332,6 +1530,7 @@ list a share name static void browse_fn(const char *name, uint32 m, const char *comment) { fstring typestr; + *typestr=0; switch (m) @@ -1375,18 +1574,40 @@ try and browse available connections on a host ****************************************************************************/ static BOOL list_servers(char *wk_grp) { + if (!cli->server_domain) return False; + printf("\n\tServer Comment\n"); printf("\t--------- -------\n"); - cli_NetServerEnum(cli, workgroup, SV_TYPE_ALL, server_fn); + cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_ALL, server_fn); printf("\n\tWorkgroup Master\n"); printf("\t--------- -------\n"); - cli_NetServerEnum(cli, workgroup, SV_TYPE_DOMAIN_ENUM, server_fn); + cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM, server_fn); return True; } +#if defined(HAVE_LIBREADLINE) +# if defined(HAVE_READLINE_HISTORY_H) || defined(HAVE_HISTORY_H) +/**************************************************************************** +history +****************************************************************************/ +static void cmd_history(void) +{ + HIST_ENTRY **hlist; + register int i; + + hlist = history_list (); /* Get pointer to history list */ + + if (hlist) /* If list not empty */ + { + for (i = 0; hlist[i]; i++) /* then display it */ + DEBUG(0, ("%d: %s\n", i, hlist[i]->line)); + } +} +# endif +#endif /* Some constants for completing filename arguments */ @@ -1417,6 +1638,7 @@ struct {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}}, {"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}}, {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}}, + {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}}, {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}}, {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}}, {"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}}, @@ -1442,6 +1664,9 @@ struct {"setmode",cmd_setmode,"filename <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}}, {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}}, {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}}, +#ifdef HAVE_LIBREADLINE + {"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}}, +#endif {"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}}, {"",NULL,NULL,{COMPL_NONE,COMPL_NONE}} }; @@ -1499,6 +1724,7 @@ static void cmd_help(void) } } +#ifndef HAVE_LIBREADLINE /**************************************************************************** wait for keyboard activity, swallowing network packets ****************************************************************************/ @@ -1514,7 +1740,7 @@ static void wait_keyboard(void) timeout.tv_sec = 20; timeout.tv_usec = 0; - sys_select(MAX(cli->fd,fileno(stdin))+1,&fds,NULL, &timeout); + sys_select(MAX(cli->fd,fileno(stdin))+1,&fds,&timeout); if (FD_ISSET(fileno(stdin),&fds)) return; @@ -1529,6 +1755,7 @@ static void wait_keyboard(void) cli_chkpath(cli, "\\"); } } +#endif /**************************************************************************** process a -c command string @@ -1571,223 +1798,58 @@ static void process_command_string(char *cmd) } } -#ifdef HAVE_LIBREADLINE - -/**************************************************************************** -GNU readline completion functions -****************************************************************************/ - -/* Argh. This is where it gets ugly. We really need to be able to - pass back from the do_list() iterator function. */ - -static int compl_state; -static char *compl_text; -static pstring result; - -/* Iterator function for do_list() */ - -static void complete_process_file(file_info *f) -{ - /* Do we have a partial match? */ - - if ((compl_state >= 0) && (strncmp(compl_text, f->name, - strlen(compl_text)) == 0)) { - - /* Return filename if we have made enough matches */ - - if (compl_state == 0) { - pstrcpy(result, f->name); - compl_state = -1; - - return; - } - compl_state--; - } -} - -/* Complete a remote file */ - -static char *complete_remote_file(char *text, int state) -{ - int attribute = aDIR | aSYSTEM | aHIDDEN; - pstring mask; - - /* Create dir mask */ - - pstrcpy(mask, cur_dir); - pstrcat(mask, "*"); - - /* Initialise static vars for filename match */ - - compl_text = text; - compl_state = state; - result[0] = '\0'; - - /* Iterate over all files in directory */ - - do_list(mask, attribute, complete_process_file, False, True); - - /* Return matched filename */ - - if (result[0] != '\0') { - return strdup(result); /* Readline will dispose of strings */ - } else { - return NULL; - } -} - -/* Complete a smbclient command */ - -static char *complete_cmd(char *text, int state) -{ - static int cmd_index; - char *name; - - /* Initialise */ - - if (state == 0) { - cmd_index = 0; - } - - /* Return the next name which partially matches the list of commands */ - - while (strlen(name = commands[cmd_index++].name) > 0) { - if (strncmp(name, text, strlen(text)) == 0) { - return strdup(name); - } - } - - return NULL; -} - -/* Main completion function for smbclient. Work out which word we are - trying to complete and call the appropriate helper function - - complete_cmd() if we are completing smbclient commands, - comlete_remote_file() if we are completing a file on the remote end, - filename_completion_function() builtin to GNU readline for local - files. */ - -static char **completion_fn(char *text, int start, int end) -{ - int i, num_words, cmd_index; - char lastch = ' '; - - /* If we are at the start of a word, we are completing a smbclient - command. */ - - if (start == 0) { - return completion_matches(text, complete_cmd); - } - - /* Count # of words in command */ - - num_words = 0; - for (i = 0; i <= end; i++) { - if ((rl_line_buffer[i] != ' ') && (lastch == ' ')) - num_words++; - lastch = rl_line_buffer[i]; - } - - if (rl_line_buffer[end] == ' ') - num_words++; - - /* Work out which command we are completing for */ - - for (cmd_index = 0; strcmp(commands[cmd_index].name, "") != 0; - cmd_index++) { - - /* Check each command in array */ - - if (strncmp(rl_line_buffer, commands[cmd_index].name, - strlen(commands[cmd_index].name)) == 0) { - - /* Call appropriate completion function */ - - if ((num_words == 2) || (num_words == 3)) { - switch (commands[cmd_index].compl_args[num_words - 2]) { - - case COMPL_REMOTE: - return completion_matches(text, complete_remote_file); - break; - - case COMPL_LOCAL: - return completion_matches(text, filename_completion_function); - break; - - default: - /* An invalid completion type */ - break; - } - } - - /* We're either completing an argument > 3 or found an invalid - completion type. Either way do nothing about it. */ - - break; - } - } - - return NULL; -} - -/* To avoid filename completion being activated when no valid - completions are found, we assign this stub completion function - to the rl_completion_entry_function variable. */ - -static char *complete_cmd_null(char *text, int state) -{ - return NULL; -} - -#endif /* HAVE_LIBREADLINE */ - /**************************************************************************** process commands on stdin ****************************************************************************/ static void process_stdin(void) { pstring line; -#ifdef HAVE_LIBREADLINE - pstring promptline; -#endif char *ptr; +#ifdef HAVE_LIBREADLINE +/* Minimal readline support, 29Jun1999, s.xenitellis@rhbnc.ac.uk */ +#ifdef PROMPTSIZE +#undef PROMPTSIZE +#endif +#define PROMPTSIZE 2048 + char prompt_str[PROMPTSIZE]; /* This holds the buffer "smb: \dir1\> " */ + + char *temp; /* Gets the buffer from readline() */ + temp = (char *)NULL; +#endif while (!feof(stdin)) { fstring tok; int i; +#ifdef HAVE_LIBREADLINE + if ( temp != (char *)NULL ) + { + free( temp ); /* Free memory allocated every time by readline() */ + temp = (char *)NULL; + } -#ifndef HAVE_LIBREADLINE + snprintf( prompt_str, PROMPTSIZE - 1, "smb: %s> ", CNV_LANG(cur_dir) ); + + temp = readline( prompt_str ); /* We read the line here */ + if ( !temp ) + break; /* EOF occured */ + + if ( *temp ) /* If non-empty line, save to history */ + add_history (temp); + + strncpy( line, temp, 1023 ); /* Maximum size of (pstring)line. Null is guarranteed. */ +#else /* display a prompt */ DEBUG(0,("smb: %s> ", CNV_LANG(cur_dir))); dbgflush( ); - + wait_keyboard(); /* and get a response */ if (!fgets(line,1000,stdin)) break; - -#else /* !HAVE_LIBREADLINE */ - - /* Read input using GNU Readline */ - - slprintf(promptline, sizeof(promptline) - 1, "smb: %s> ", - CNV_LANG(cur_dir)); - - if (!readline(promptline)) - break; - - /* Copy read line to samba buffer */ - - pstrcpy(line, rl_line_buffer); - pstrcat(line, "\n"); - - /* Add line to history */ - - if (strlen(line) > 0) - add_history(line); #endif + /* input language code to internal one */ CNV_INPUT (line); @@ -1815,22 +1877,15 @@ static void process_stdin(void) /***************************************************** return a connection to a server *******************************************************/ -struct cli_state *do_connect(char *server, char *share, int smb_port) +struct cli_state *do_connect(char *server, char *share) { - struct cli_state *smb_cli; - struct nmb_name called, calling, stupid_smbserver_called; + struct cli_state *c; + struct nmb_name called, calling; char *server_n; struct in_addr ip; extern struct in_addr ipzero; - if ((smb_cli=cli_initialise(NULL)) == NULL) - { - DEBUG(1,("cli_initialise failed\n")); - return NULL; - } - - if (*share == '\\') - { + if (*share == '\\') { server = share+2; share = strchr(server,'\\'); if (!share) return NULL; @@ -1844,52 +1899,86 @@ struct cli_state *do_connect(char *server, char *share, int smb_port) make_nmb_name(&calling, global_myname, 0x0, ""); make_nmb_name(&called , server, name_type, ""); - make_nmb_name(&stupid_smbserver_called , "*SMBSERVER", 0x20, scope); - - fstrcpy(smb_cli->usr.user_name, username); - fstrcpy(smb_cli->usr.domain, workgroup); + again: ip = ipzero; if (have_ip) ip = dest_ip; - if (cli_set_port(smb_cli, smb_port) == 0) - { + /* have to open a new connection */ + if (!(c=cli_initialise(NULL)) || (cli_set_port(c, port) == 0) || + !cli_connect(c, server_n, &ip)) { + DEBUG(0,("Connection to %s failed\n", server_n)); return NULL; } - /* set the password cache info */ - if (got_pass) - { - if (password[0] == 0) - { - pwd_set_nullpwd(&(smb_cli->usr.pwd)); + if (!cli_session_request(c, &calling, &called)) { + char *p; + DEBUG(0,("session request to %s failed (%s)\n", + called.name, cli_errstr(c))); + cli_shutdown(c); + if ((p=strchr(called.name, '.'))) { + *p = 0; + goto again; } - else - { - /* generate 16 byte hashes */ - pwd_make_lm_nt_16(&(smb_cli->usr.pwd), password); + if (strcmp(called.name, "*SMBSERVER")) { + make_nmb_name(&called , "*SMBSERVER", 0x20, ""); + goto again; } + return NULL; } - else - { - pwd_read(&(smb_cli->usr.pwd), "Password:", True); + + DEBUG(4,(" session request ok\n")); + + if (!cli_negprot(c)) { + DEBUG(0,("protocol negotiation failed\n")); + cli_shutdown(c); + return NULL; } - /* paranoia: destroy the local copy of the password */ - bzero(password, sizeof(password)); + if (!got_pass) { + char *pass = getpass("Password: "); + if (pass) { + pstrcpy(password, pass); + } + } - smb_cli->use_ntlmv2 = lp_client_ntlmv2(); + if (!cli_session_setup(c, username, + password, strlen(password), + password, strlen(password), + workgroup)) { + /* if a password was not supplied then try again with a null username */ + if (password[0] || !username[0] || + !cli_session_setup(c, "", "", 0, "", 0, workgroup)) { + DEBUG(0,("session setup failed: %s\n", cli_errstr(c))); + return NULL; + } + DEBUG(0,("Anonymous login successful\n")); + } - if (!cli_establish_connection(smb_cli, server, &ip, &calling, &called, - share, "?????", False, True) && - !cli_establish_connection(smb_cli, server, &ip, - &calling, &stupid_smbserver_called, - share, "?????", False, True)) - { + /* + * These next two lines are needed to emulate + * old client behaviour for people who have + * scripts based on client output. + * QUESTION ? Do we want to have a 'client compatibility + * mode to turn these on/off ? JRA. + */ + + if (*c->server_domain || *c->server_os || *c->server_type) + DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n", + c->server_domain,c->server_os,c->server_type)); + + DEBUG(4,(" session setup ok\n")); + + if (!cli_send_tconX(c, share, "?????", + password, strlen(password)+1)) { + DEBUG(0,("tree connect failed: %s\n", cli_errstr(c))); + cli_shutdown(c); return NULL; } - - return smb_cli; + + DEBUG(4,(" tconx ok\n")); + + return c; } @@ -1898,7 +1987,7 @@ struct cli_state *do_connect(char *server, char *share, int smb_port) ****************************************************************************/ static BOOL process(char *base_directory) { - cli = do_connect(desthost, service, port); + cli = do_connect(desthost, service); if (!cli) { return(False); } @@ -1920,11 +2009,10 @@ usage on the program ****************************************************************************/ static void usage(char *pname) { - DEBUG(0,("Usage: %s service <password> ", pname)); + DEBUG(0,("Usage: %s service <password> [options]", pname)); DEBUG(0,("\nVersion %s\n",VERSION)); DEBUG(0,("\t-s smb.conf pathname to smb.conf file\n")); - DEBUG(0,("\t-B IP addr broadcast IP address to use\n")); DEBUG(0,("\t-O socket_options socket options to use\n")); DEBUG(0,("\t-R name resolve order use these name resolution services only\n")); DEBUG(0,("\t-M host send a winpopup message to the host\n")); @@ -1946,6 +2034,7 @@ static void usage(char *pname) DEBUG(0,("\t-T<c|x>IXFqgbNan command line tar\n")); DEBUG(0,("\t-D directory start from directory\n")); DEBUG(0,("\t-c command string execute semicolon separated commands\n")); + DEBUG(0,("\t-b xmit/send buffer changes the transmit/send buffer (default: 65520)\n")); DEBUG(0,("\n")); } @@ -2013,9 +2102,9 @@ static void get_password_file(void) /**************************************************************************** handle a -L query ****************************************************************************/ -static int do_host_query(char *query_host, int smb_port) +static int do_host_query(char *query_host) { - cli = do_connect(query_host, "IPC$", smb_port); + cli = do_connect(query_host, "IPC$"); if (!cli) return 1; @@ -2031,10 +2120,10 @@ static int do_host_query(char *query_host, int smb_port) /**************************************************************************** handle a tar operation ****************************************************************************/ -static int do_tar_op(int smb_port, char *base_directory) +static int do_tar_op(char *base_directory) { int ret; - cli = do_connect(desthost, service, smb_port); + cli = do_connect(desthost, service); if (!cli) return 1; @@ -2096,7 +2185,6 @@ static int do_message_op(void) extern int optind; pstring query_host; BOOL message = False; - BOOL explicit_user = False; extern char tar_type; static pstring servicesf = CONFIGFILE; pstring term_code; @@ -2116,15 +2204,39 @@ static int do_message_op(void) DEBUGLEVEL = 2; +#ifdef HAVE_LIBREADLINE + /* Allow conditional parsing of the ~/.inputrc file. */ + rl_readline_name = "smbclient"; +#endif setup_logging(pname,True); - TimeInit(); - charset_initialise(); + /* + * If the -E option is given, be careful not to clobber stdout + * before processing the options. 28.Feb.99, richard@hacom.nl. + * Also pre-parse the -s option to get the service file name. + */ - if(!get_myname(myhostname,NULL)) { - DEBUG(0,("Failed to get my hostname.\n")); + for (opt = 1; opt < argc; opt++) { + if (strcmp(argv[opt], "-E") == 0) + dbf = stderr; + else if(strncmp(argv[opt], "-s", 2) == 0) { + if(argv[opt][2] != '\0') + pstrcpy(servicesf, &argv[opt][2]); + else if(argv[opt+1] != NULL) { + /* + * At least one more arg left. + */ + pstrcpy(servicesf, argv[opt+1]); + } else { + usage(pname); + exit(1); + } + } } + TimeInit(); + charset_initialise(); + in_client = True; /* Make sure that we tell lp_load we are */ if (!lp_load(servicesf,True,False,False)) { @@ -2133,8 +2245,6 @@ static int do_message_op(void) codepage_initialise(lp_client_code_page()); - interpret_coding_system(term_code); - #ifdef WITH_SSL sslutil_init(0); #endif @@ -2209,14 +2319,11 @@ static int do_message_op(void) } while ((opt = - getopt(argc, argv,"s:B:O:R:M:i:Nn:d:Pp:l:hI:EU:L:t:m:W:T:D:c:")) != EOF) { + getopt(argc, argv,"s:O:R:M:i:Nn:d:Pp:l:hI:EU:L:t:m:W:T:D:c:b:")) != EOF) { switch (opt) { case 's': pstrcpy(servicesf, optarg); break; - case 'B': - iface_set_default(NULL,optarg,NULL); - break; case 'O': pstrcpy(user_socket_options,optarg); break; @@ -2270,7 +2377,6 @@ static int do_message_op(void) case 'U': { char *lp; - explicit_user = True; pstrcpy(username,optarg); if ((lp=strchr(username,'%'))) { *lp = 0; @@ -2281,9 +2387,10 @@ static int do_message_op(void) } break; case 'L': - pstrcpy(query_host,optarg); - if(!explicit_user) - *username = '\0'; + p = optarg; + while(*p == '\\' || *p == '/') + p++; + pstrcpy(query_host,p); break; case 't': pstrcpy(term_code, optarg); @@ -2307,40 +2414,32 @@ static int do_message_op(void) cmdstr = optarg; got_pass = True; break; + case 'b': + io_bufsize = MAX(1, atoi(optarg)); + break; default: usage(pname); exit(1); } } - get_myname((*global_myname)?NULL:global_myname,NULL); + get_myname((*global_myname)?NULL:global_myname); if(*new_name_resolve_order) lp_set_name_resolve_order(new_name_resolve_order); + if (*term_code) + interpret_coding_system(term_code); + if (!tar_type && !*query_host && !*service && !message) { usage(pname); exit(1); } -#ifdef HAVE_LIBREADLINE - - /* Initialise GNU Readline */ - - rl_readline_name = "smbclient"; - rl_attempted_completion_function = completion_fn; - rl_completion_entry_function = (Function *)complete_cmd_null; - - /* Initialise history list */ - - using_history(); - -#endif /* HAVE_LIBREADLINE */ - DEBUG( 3, ( "Client started (version %s).\n", VERSION ) ); if (tar_type) { - return do_tar_op(port, base_directory); + return do_tar_op(base_directory); } if ((p=strchr(query_host,'#'))) { @@ -2350,7 +2449,7 @@ static int do_message_op(void) } if (*query_host) { - return do_host_query(query_host, port); + return do_host_query(query_host); } if (message) { @@ -2358,10 +2457,8 @@ static int do_message_op(void) } if (!process(base_directory)) { - close_sockets(); return(1); } - close_sockets(); return(0); } |