+/*
+ Unix SMB/Netbios implementation.
+ Version 1.9.
+ SMB client
+ Copyright (C) Andrew Tridgell 1994-1995
+
+ 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
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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.
+*/
+
+#ifdef SYSLOG
+#undef SYSLOG
+#endif
+
+#include "includes.h"
+#include "nameserv.h"
+
+#ifndef REGISTER
+#define REGISTER 0
+#endif
+
+pstring cur_dir = "\\";
+pstring cd_path = "";
+pstring service="";
+pstring desthost="";
+pstring myname = "";
+pstring password = "";
+pstring username="";
+pstring workgroup=WORKGROUP;
+BOOL got_pass = False;
+BOOL connect_as_printer = False;
+BOOL connect_as_ipc = False;
+extern struct in_addr bcast_ip;
+static BOOL got_bcast=False;
+
+char cryptkey[8];
+BOOL doencrypt=False;
+
+extern pstring user_socket_options;
+
+/* 30 second timeout on most commands */
+#define CLIENT_TIMEOUT (30*1000)
+#define SHORT_TIMEOUT (5*1000)
+
+/* value for unused fid field in trans2 secondary request */
+#define FID_UNUSED (0xFFFF)
+
+int name_type = 0x20;
+
+int max_protocol = PROTOCOL_NT1;
+
+
+time_t newer_than = 0;
+int archive_level = 0;
+
+extern struct in_addr myip;
+
+extern pstring debugf;
+extern int DEBUGLEVEL;
+
+BOOL translation = False;
+
+/* clitar bits insert */
+extern void cmd_tar();
+extern void cmd_block();
+extern void cmd_tarmode();
+extern void cmd_setmode();
+extern int blocksize;
+extern BOOL tar_inc;
+extern BOOL tar_reset;
+extern int process_tar();
+extern int tar_parseargs();
+/* clitar bits end */
+
+
+int cnum = 0;
+int pid = 0;
+int gid = 0;
+int uid = 0;
+int mid = 0;
+int myumask = 0755;
+
+int max_xmit = BUFFER_SIZE;
+
+extern pstring scope;
+
+BOOL prompt = True;
+
+int printmode = 1;
+
+BOOL recurse = False;
+BOOL lowercase = False;
+
+BOOL have_ip = False;
+
+struct in_addr dest_ip;
+
+#define SEPARATORS " \t\n\r"
+
+BOOL abort_mget = True;
+
+extern int Protocol;
+
+BOOL readbraw_supported = False;
+BOOL writebraw_supported = False;
+
+pstring fileselection = "";
+
+extern file_info def_finfo;
+
+/* timing globals */
+int get_total_size = 0;
+int get_total_time_ms = 0;
+int put_total_size = 0;
+int put_total_time_ms = 0;
+
+
+extern int Client;
+
+#define USENMB
+
+#ifdef KANJI
+extern int coding_system;
+#define CNV_LANG(s) (coding_system == DOSV_CODE?s:dos_to_unix(s, False))
+#define CNV_INPUT(s) (coding_system == DOSV_CODE?s:unix_to_dos(s, True))
+static BOOL
+setup_term_code (char *code)
+{
+ int new;
+ new = interpret_coding_system (code, UNKNOWN_CODE);
+ if (new != UNKNOWN_CODE) {
+ coding_system = new;
+ return True;
+ }
+ return False;
+}
+#else
+#define CNV_LANG(s) dos2unix_format(s,False)
+#define CNV_INPUT(s) unix2dos_format(s,True)
+#endif
+
+static void send_logout(void );
+BOOL reopen_connection(char *inbuf,char *outbuf);
+static int do_long_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir);
+static int do_short_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir);
+static BOOL call_api(int prcnt,int drcnt,int mprcnt,int mdrcnt,
+ int *rprcnt,int *rdrcnt,char *param,char *data,
+ char **rparam,char **rdata);
+static BOOL send_trans_request(char *outbuf,int trans,
+ char *name,int fid,int flags,
+ char *data,char *param,uint16 *setup,
+ int ldata,int lparam,int lsetup,
+ int mdata,int mparam,int msetup);
+
+
+/****************************************************************************
+setup basics in a outgoing packet
+****************************************************************************/
+void setup_pkt(char *outbuf)
+{
+ SSVAL(outbuf,smb_pid,pid);
+ SSVAL(outbuf,smb_uid,uid);
+ SSVAL(outbuf,smb_mid,mid);
+ if (Protocol > PROTOCOL_CORE)
+ {
+ SCVAL(outbuf,smb_flg,0x8);
+ SSVAL(outbuf,smb_flg2,0x1);
+ }
+}
+
+/****************************************************************************
+write to a local file with CR/LF->LF translation if appropriate. return the
+number taken from the buffer. This may not equal the number written.
+****************************************************************************/
+static int writefile(int f, char *b, int n)
+{
+ int i;
+
+ if (!translation)
+ return(write(f,b,n));
+
+ i = 0;
+ while (i < n)
+ {
+ if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n')
+ {
+ b++;i++;
+ }
+ if (write(f, b, 1) != 1)
+ {
+ break;
+ }
+ b++;
+ i++;
+ }
+
+ return(i);
+}
+
+/****************************************************************************
+ read from a file with LF->CR/LF translation if appropriate. return the
+ number read. read approx n bytes.
+****************************************************************************/
+static int readfile(char *b, int size, int n, FILE *f)
+{
+ int i;
+ int c;
+
+ if (!translation || (size != 1))
+ return(fread(b,size,n,f));
+
+ i = 0;
+ while (i < n)
+ {
+ if ((c = getc(f)) == EOF)
+ {
+ break;
+ }
+
+ if (c == '\n') /* change all LFs to CR/LF */
+ {
+ b[i++] = '\r';
+ n++;
+ }
+
+ b[i++] = c;
+ }
+
+ return(i);
+}
+
+
+/****************************************************************************
+read from a file with print translation. return the number read. read approx n
+bytes.
+****************************************************************************/
+static int printread(FILE *f,char *b,int n)
+{
+ int i;
+
+ i = readfile(b,1, n-1,f);
+#if FORMFEED
+ if (feof(f) && i>0)
+ b[i++] = '\014';
+#endif
+
+ return(i);
+}
+
+/****************************************************************************
+check for existance of a dir
+****************************************************************************/
+static BOOL chkpath(char *path,BOOL report)
+{
+ fstring path2;
+ pstring inbuf,outbuf;
+ char *p;
+
+ strcpy(path2,path);
+ trim_string(path2,NULL,"\\");
+ if (!*path2) *path2 = '\\';
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,0,4 + strlen(path2),True);
+ SCVAL(outbuf,smb_com,SMBchkpth);
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,path2);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (report && CVAL(inbuf,smb_rcls) != 0)
+ DEBUG(2,("chkpath: %s\n",smb_errstr(inbuf)));
+
+ return(CVAL(inbuf,smb_rcls) == 0);
+}
+
+
+/****************************************************************************
+send a message
+****************************************************************************/
+static void send_message(char *inbuf,char *outbuf)
+{
+ int total_len = 0;
+
+ char *p;
+ int grp_id;
+
+ /* send a SMBsendstrt command */
+ bzero(outbuf,smb_size);
+ set_message(outbuf,0,0,True);
+ CVAL(outbuf,smb_com) = SMBsendstrt;
+ SSVAL(outbuf,smb_tid,cnum);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,username);
+ p = skip_string(p,1);
+ *p++ = 4;
+ strcpy(p,desthost);
+ p = skip_string(p,1);
+
+ set_message(outbuf,0,PTR_DIFF(p,smb_buf(outbuf)),False);
+
+ send_smb(Client,outbuf);
+
+
+ if (!receive_smb(Client,inbuf,SHORT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0)
+ {
+ printf("SMBsendstrt failed. (%s)\n",smb_errstr(inbuf));
+ return;
+ }
+
+ grp_id = SVAL(inbuf,smb_vwv0);
+
+ printf("Connected. Type your message, ending it with a Control-D\n");
+
+ while (!feof(stdin) && total_len < 1600)
+ {
+ int maxlen = MIN(1600 - total_len,127);
+ pstring msg;
+ int l=0;
+ int c;
+
+ bzero(msg,smb_size);
+
+ for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++)
+ {
+ if (c == '\n')
+ msg[l++] = '\r';
+ msg[l] = c;
+ }
+
+ CVAL(outbuf,smb_com) = SMBsendtxt;
+
+ set_message(outbuf,1,l+3,True);
+
+ SSVAL(outbuf,smb_vwv0,grp_id);
+
+ p = smb_buf(outbuf);
+ *p = 1;
+ SSVAL(p,1,l);
+ memcpy(p+3,msg,l);
+
+ send_smb(Client,outbuf);
+
+
+ if (!receive_smb(Client,inbuf,SHORT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0)
+ {
+ printf("SMBsendtxt failed (%s)\n",smb_errstr(inbuf));
+ return;
+ }
+
+ total_len += l;
+ }
+
+ if (total_len >= 1600)
+ printf("the message was truncated to 1600 bytes ");
+ else
+ printf("sent %d bytes ",total_len);
+
+ printf("(status was %d-%d)\n",CVAL(inbuf,smb_rcls),SVAL(inbuf,smb_err));
+
+ CVAL(outbuf,smb_com) = SMBsendend;
+ set_message(outbuf,1,0,False);
+ SSVAL(outbuf,smb_vwv0,grp_id);
+
+ send_smb(Client,outbuf);
+
+
+ if (!receive_smb(Client,inbuf,SHORT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0)
+ {
+ printf("SMBsendend failed (%s)\n",smb_errstr(inbuf));
+ return;
+ }
+}
+
+
+
+/****************************************************************************
+check the space on a device
+****************************************************************************/
+static void do_dskattr(void)
+{
+ pstring inbuf,outbuf;
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,0,0,True);
+ CVAL(outbuf,smb_com) = SMBdskattr;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ DEBUG(0,("Error in dskattr: %s\n",smb_errstr(inbuf)));
+
+ DEBUG(0,("\n\t\t%d blocks of size %d. %d blocks available\n",
+ SVAL(inbuf,smb_vwv0),
+ SVAL(inbuf,smb_vwv1)*SVAL(inbuf,smb_vwv2),
+ SVAL(inbuf,smb_vwv3)));
+}
+
+/****************************************************************************
+show cd/pwd
+****************************************************************************/
+static void cmd_pwd(void)
+{
+ DEBUG(0,("Current directory is %s",CNV_LANG(service)));
+ DEBUG(0,("%s\n",CNV_LANG(cur_dir)));
+}
+
+
+/****************************************************************************
+change directory - inner section
+****************************************************************************/
+static void do_cd(char *newdir)
+{
+ char *p = newdir;
+ pstring saved_dir;
+ pstring dname;
+
+ /* Save the current directory in case the
+ new directory is invalid */
+ strcpy(saved_dir, cur_dir);
+ if (*p == '\\')
+ strcpy(cur_dir,p);
+ else
+ strcat(cur_dir,p);
+ if (*(cur_dir+strlen(cur_dir)-1) != '\\') {
+ strcat(cur_dir, "\\");
+ }
+ dos_clean_name(cur_dir);
+ strcpy(dname,cur_dir);
+ strcat(cur_dir,"\\");
+ dos_clean_name(cur_dir);
+
+ if (!strequal(cur_dir,"\\"))
+ if (!chkpath(dname,True))
+ strcpy(cur_dir,saved_dir);
+
+ strcpy(cd_path,cur_dir);
+}
+
+/****************************************************************************
+change directory
+****************************************************************************/
+static void cmd_cd(char *inbuf,char *outbuf)
+{
+ fstring buf;
+
+ if (next_token(NULL,buf,NULL))
+ do_cd(buf);
+ else
+ DEBUG(0,("Current directory is %s\n",CNV_LANG(cur_dir)));
+}
+
+
+/****************************************************************************
+ display info about a file
+ ****************************************************************************/
+static void display_finfo(file_info *finfo)
+{
+ time_t t = finfo->mtime; /* the time is assumed to be passed as GMT */
+ DEBUG(0,(" %-30s%7.7s%10d %s",
+ CNV_LANG(finfo->name),
+ attrib_string(finfo->mode),
+ finfo->size,
+ asctime(LocalTime(&t,GMT_TO_LOCAL))));
+}
+
+/****************************************************************************
+ do a directory listing, calling fn on each file found
+ ****************************************************************************/
+void do_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir)
+{
+ DEBUG(5,("do_dir(%s,%x,%s)\n",Mask,attribute,BOOLSTR(recurse_dir)));
+ if (Protocol >= PROTOCOL_LANMAN2)
+ {
+ if (do_long_dir(inbuf,outbuf,Mask,attribute,fn,recurse_dir) > 0)
+ return;
+ }
+
+ expand_mask(Mask,False);
+ do_short_dir(inbuf,outbuf,Mask,attribute,fn,recurse_dir);
+ return;
+}
+
+/*******************************************************************
+ decide if a file should be operated on
+ ********************************************************************/
+static BOOL do_this_one(file_info *finfo)
+{
+ if (finfo->mode & aDIR) return(True);
+
+ if (newer_than && finfo->mtime < newer_than)
+ return(False);
+
+ if ((archive_level==1 || archive_level==2) && !(finfo->mode & aARCH))
+ return(False);
+
+ return(True);
+}
+
+/****************************************************************************
+interpret a short filename structure
+The length of the structure is returned
+****************************************************************************/
+static int interpret_short_filename(char *p,file_info *finfo)
+{
+ finfo->mode = CVAL(p,21);
+
+ /* this date is converted to GMT by make_unix_date */
+ finfo->ctime = make_unix_date(p+22);
+ finfo->mtime = finfo->atime = finfo->ctime;
+ finfo->size = IVAL(p,26);
+ strcpy(finfo->name,p+30);
+
+ return(DIR_STRUCT_SIZE);
+}
+
+/****************************************************************************
+interpret a long filename structure - this is mostly guesses at the moment
+The length of the structure is returned
+The structure of a long filename depends on the info level. 260 is used
+by NT and 2 is used by OS/2
+****************************************************************************/
+static int interpret_long_filename(int level,char *p,file_info *finfo)
+{
+ if (finfo)
+ memcpy(finfo,&def_finfo,sizeof(*finfo));
+
+ switch (level)
+ {
+ case 1: /* OS/2 understands this */
+ if (finfo)
+ {
+ /* these dates are converted to GMT by make_unix_date */
+ finfo->ctime = make_unix_date2(p+4);
+ finfo->atime = make_unix_date2(p+8);
+ finfo->mtime = make_unix_date2(p+12);
+ finfo->size = IVAL(p,16);
+ finfo->mode = CVAL(p,24);
+ strcpy(finfo->name,p+27);
+ }
+ return(28 + CVAL(p,26));
+
+ case 2: /* this is what OS/2 uses mostly */
+ if (finfo)
+ {
+ /* these dates are converted to GMT by make_unix_date */
+ finfo->ctime = make_unix_date2(p+4);
+ finfo->atime = make_unix_date2(p+8);
+ finfo->mtime = make_unix_date2(p+12);
+ finfo->size = IVAL(p,16);
+ finfo->mode = CVAL(p,24);
+ strcpy(finfo->name,p+31);
+ }
+ return(32 + CVAL(p,30));
+
+ /* levels 3 and 4 are untested */
+ case 3:
+ if (finfo)
+ {
+ /* these dates are probably like the other ones */
+ finfo->ctime = make_unix_date2(p+8);
+ finfo->atime = make_unix_date2(p+12);
+ finfo->mtime = make_unix_date2(p+16);
+ finfo->size = IVAL(p,20);
+ finfo->mode = CVAL(p,28);
+ strcpy(finfo->name,p+33);
+ }
+ return(SVAL(p,4)+4);
+
+ case 4:
+ if (finfo)
+ {
+ /* these dates are probably like the other ones */
+ finfo->ctime = make_unix_date2(p+8);
+ finfo->atime = make_unix_date2(p+12);
+ finfo->mtime = make_unix_date2(p+16);
+ finfo->size = IVAL(p,20);
+ finfo->mode = CVAL(p,28);
+ strcpy(finfo->name,p+37);
+ }
+ return(SVAL(p,4)+4);
+
+ case 260: /* NT uses this, but also accepts 2 */
+ if (finfo)
+ {
+ int ret = SVAL(p,0);
+ int namelen;
+ p += 4; /* next entry offset */
+ p += 4; /* fileindex */
+
+ /* these dates appear to arrive in a weird way. It seems to
+ be localtime plus the serverzone given in the initial
+ connect. This is GMT when DST is not in effect and one
+ hour from GMT otherwise. Can this really be right??
+
+ I suppose this could be called kludge-GMT. Is is the GMT
+ you get by using the current DST setting on a different
+ localtime. It will be cheap to calculate, I suppose, as
+ no DST tables will be needed */
+
+ finfo->ctime = interpret_long_date(p); p += 8;
+ finfo->atime = interpret_long_date(p); p += 8;
+ finfo->mtime = interpret_long_date(p); p += 8; p += 8;
+ finfo->size = IVAL(p,0); p += 8;
+ p += 8; /* alloc size */
+ finfo->mode = CVAL(p,0); p += 4;
+ namelen = IVAL(p,0); p += 4;
+ p += 4; /* EA size */
+ p += 2; /* short name len? */
+ p += 24; /* short name? */
+ StrnCpy(finfo->name,p,namelen);
+ return(ret);
+ }
+ return(SVAL(p,0));
+ }
+
+ DEBUG(1,("Unknown long filename format %d\n",level));
+ return(SVAL(p,0));
+}
+
+
+
+
+/****************************************************************************
+ act on the files in a dir listing
+ ****************************************************************************/
+static void dir_action(char *inbuf,char *outbuf,int attribute,file_info *finfo,BOOL recurse_dir,void (*fn)(),BOOL longdir)
+{
+
+ if (!((finfo->mode & aDIR) == 0 && *fileselection &&
+ !mask_match(finfo->name,fileselection,False,False)) &&
+ !(recurse_dir && (strequal(finfo->name,".") ||
+ strequal(finfo->name,".."))))
+ {
+ if (recurse_dir && (finfo->mode & aDIR))
+ {
+ pstring mask2;
+ pstring sav_dir;
+ strcpy(sav_dir,cur_dir);
+ strcat(cur_dir,finfo->name);
+ strcat(cur_dir,"\\");
+ strcpy(mask2,cur_dir);
+
+ if (!fn)
+ DEBUG(0,("\n%s\n",CNV_LANG(cur_dir)));
+
+ strcat(mask2,"*");
+
+ if (longdir)
+ do_long_dir(inbuf,outbuf,mask2,attribute,fn,True);
+ else
+ do_dir(inbuf,outbuf,mask2,attribute,fn,True);
+
+ strcpy(cur_dir,sav_dir);
+ }
+ else
+ {
+ if (fn && do_this_one(finfo))
+ fn(finfo);
+ }
+ }
+}
+
+
+/****************************************************************************
+ do a directory listing, calling fn on each file found
+ ****************************************************************************/
+static int do_short_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir)
+{
+ char *p;
+ int received = 0;
+ BOOL first = True;
+ char status[21];
+ int num_asked = (max_xmit - 100)/DIR_STRUCT_SIZE;
+ int num_received = 0;
+ int i;
+ char *dirlist = NULL;
+ pstring mask;
+ file_info finfo;
+
+ finfo = def_finfo;
+
+ bzero(status,21);
+
+ strcpy(mask,Mask);
+
+ while (1)
+ {
+ bzero(outbuf,smb_size);
+ if (first)
+ set_message(outbuf,2,5 + strlen(mask),True);
+ else
+ set_message(outbuf,2,5 + 21,True);
+
+#if FFIRST
+ if (Protocol >= PROTOCOL_LANMAN1)
+ CVAL(outbuf,smb_com) = SMBffirst;
+ else
+#endif
+ CVAL(outbuf,smb_com) = SMBsearch;
+
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,num_asked);
+ SSVAL(outbuf,smb_vwv1,attribute);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+
+ if (first)
+ strcpy(p,mask);
+ else
+ strcpy(p,"");
+ p += strlen(p) + 1;
+
+ *p++ = 5;
+ if (first)
+ SSVAL(p,0,0);
+ else
+ {
+ SSVAL(p,0,21);
+ p += 2;
+ memcpy(p,status,21);
+ }
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ received = SVAL(inbuf,smb_vwv0);
+
+ DEBUG(5,("dir received %d\n",received));
+
+ DEBUG(6,("errstr=%s\n",smb_errstr(inbuf)));
+
+ if (received <= 0) break;
+
+ first = False;
+
+ dirlist = Realloc(dirlist,(num_received + received)*DIR_STRUCT_SIZE);
+
+ if (!dirlist)
+ return 0;
+
+ p = smb_buf(inbuf) + 3;
+
+ memcpy(dirlist+num_received*DIR_STRUCT_SIZE,
+ p,received*DIR_STRUCT_SIZE);
+
+ memcpy(status,p + ((received-1)*DIR_STRUCT_SIZE),21);
+
+ num_received += received;
+
+ if (CVAL(inbuf,smb_rcls) != 0) break;
+ }
+
+#if FFIRST
+ if (!first && Protocol >= PROTOCOL_LANMAN1)
+ {
+ bzero(outbuf,smb_size);
+ CVAL(outbuf,smb_com) = SMBfclose;
+
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+
+ strcpy(p,"");
+ p += strlen(p) + 1;
+
+ *p++ = 5;
+ SSVAL(p,0,21);
+ p += 2;
+ memcpy(p,status,21);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT,False);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ DEBUG(0,("Error closing search: %s\n",smb_errstr(inbuf)));
+ }
+#endif
+
+ if (!fn)
+ for (p=dirlist,i=0;i<num_received;i++)
+ {
+ p += interpret_short_filename(p,&finfo);
+ display_finfo(&finfo);
+ }
+
+ for (p=dirlist,i=0;i<num_received;i++)
+ {
+ p += interpret_short_filename(p,&finfo);
+ dir_action(inbuf,outbuf,attribute,&finfo,recurse_dir,fn,False);
+ }
+
+ if (dirlist) free(dirlist);
+ return(num_received);
+}
+
+/****************************************************************************
+ receive a SMB trans or trans2 response allocating the necessary memory
+ ****************************************************************************/
+static BOOL receive_trans_response(char *inbuf,int trans,
+ int *data_len,int *param_len,
+ char **data,char **param)
+{
+ int total_data=0;
+ int total_param=0;
+ int this_data,this_param;
+
+ *data_len = *param_len = 0;
+
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ show_msg(inbuf);
+
+ /* sanity check */
+ if (CVAL(inbuf,smb_com) != trans)
+ {
+ DEBUG(0,("Expected %s response, got command 0x%02x\n",
+ trans==SMBtrans?"SMBtrans":"SMBtrans2", CVAL(inbuf,smb_com)));
+ return(False);
+ }
+ if (CVAL(inbuf,smb_rcls) != 0)
+ return(False);
+
+ /* parse out the lengths */
+ total_data = SVAL(inbuf,smb_tdrcnt);
+ total_param = SVAL(inbuf,smb_tprcnt);
+
+ /* allocate it */
+ *data = Realloc(*data,total_data);
+ *param = Realloc(*param,total_param);
+
+ while (1)
+ {
+ this_data = SVAL(inbuf,smb_drcnt);
+ this_param = SVAL(inbuf,smb_prcnt);
+ if (this_data)
+ memcpy(*data + SVAL(inbuf,smb_drdisp),
+ smb_base(inbuf) + SVAL(inbuf,smb_droff),
+ this_data);
+ if (this_param)
+ memcpy(*param + SVAL(inbuf,smb_prdisp),
+ smb_base(inbuf) + SVAL(inbuf,smb_proff),
+ this_param);
+ *data_len += this_data;
+ *param_len += this_param;
+
+ /* parse out the total lengths again - they can shrink! */
+ total_data = SVAL(inbuf,smb_tdrcnt);
+ total_param = SVAL(inbuf,smb_tprcnt);
+
+ if (total_data <= *data_len && total_param <= *param_len)
+ break;
+
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ show_msg(inbuf);
+
+ /* sanity check */
+ if (CVAL(inbuf,smb_com) != trans)
+ {
+ DEBUG(0,("Expected %s response, got command 0x%02x\n",
+ trans==SMBtrans?"SMBtrans":"SMBtrans2", CVAL(inbuf,smb_com)));
+ return(False);
+ }
+ if (CVAL(inbuf,smb_rcls) != 0)
+ return(False);
+ }
+
+ return(True);
+}
+
+/****************************************************************************
+ do a directory listing, calling fn on each file found. Use the TRANSACT2
+ call for long filenames
+ ****************************************************************************/
+static int do_long_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir)
+{
+ int max_matches = 512;
+ int info_level = Protocol<PROTOCOL_NT1?1:260; /* NT uses 260, OS/2 uses 2. Both accept 1. */
+ char *p;
+ pstring mask;
+ file_info finfo;
+ int i;
+ char *dirlist = NULL;
+ int dirlist_len = 0;
+ int total_received = 0;
+ BOOL First = True;
+ char *resp_data=NULL;
+ char *resp_param=NULL;
+ int resp_data_len = 0;
+ int resp_param_len=0;
+
+ int ff_resume_key = 0;
+ int ff_searchcount=0;
+ int ff_eos=0;
+ int ff_lastname=0;
+ int ff_dir_handle=0;
+ int loop_count = 0;
+
+ uint16 setup;
+ pstring param;
+
+ strcpy(mask,Mask);
+
+ while (ff_eos == 0)
+ {
+ loop_count++;
+ if (loop_count > 200)
+ {
+ DEBUG(0,("ERROR: Looping in FIND_NEXT??\n"));
+ break;
+ }
+
+ if (First)
+ {
+ setup = TRANSACT2_FINDFIRST;
+ SSVAL(param,0,attribute); /* attribute */
+ SSVAL(param,2,max_matches); /* max count */
+ SSVAL(param,4,8+4+2); /* resume required + close on end + continue */
+ SSVAL(param,6,info_level);
+ SIVAL(param,8,0);
+ strcpy(param+12,mask);
+ }
+ else
+ {
+ setup = TRANSACT2_FINDNEXT;
+ SSVAL(param,0,ff_dir_handle);
+ SSVAL(param,2,max_matches); /* max count */
+ SSVAL(param,4,info_level);
+ SIVAL(param,6,ff_resume_key); /* ff_resume_key */
+ SSVAL(param,10,8+4+2); /* resume required + close on end + continue */
+ strcpy(param+12,mask);
+
+ DEBUG(5,("hand=0x%X resume=%d ff_lastname=%d mask=%s\n",
+ ff_dir_handle,ff_resume_key,ff_lastname,mask));
+ }
+ /* ??? original code added 1 pad byte after param */
+
+ send_trans_request(outbuf,SMBtrans2,NULL,FID_UNUSED,0,
+ NULL,param,&setup,
+ 0,12+strlen(mask)+1,1,
+ BUFFER_SIZE,10,0);
+
+ if (!receive_trans_response(inbuf,SMBtrans2,
+ &resp_data_len,&resp_param_len,
+ &resp_data,&resp_param))
+ {
+ DEBUG(3,("FIND%s gave %s\n",First?"FIRST":"NEXT",smb_errstr(inbuf)));
+ break;
+ }
+
+ /* parse out some important return info */
+ p = resp_param;
+ if (First)
+ {
+ ff_dir_handle = SVAL(p,0);
+ ff_searchcount = SVAL(p,2);
+ ff_eos = SVAL(p,4);
+ ff_lastname = SVAL(p,8);
+ }
+ else
+ {
+ ff_searchcount = SVAL(p,0);
+ ff_eos = SVAL(p,2);
+ ff_lastname = SVAL(p,6);
+ }
+
+ if (ff_searchcount == 0)
+ break;
+
+ /* point to the data bytes */
+ p = resp_data;
+
+ /* we might need the lastname for continuations */
+ if (ff_lastname > 0)
+ {
+ switch(info_level)
+ {
+ case 260:
+ ff_resume_key =0;
+ StrnCpy(mask,p+ff_lastname,resp_data_len-ff_lastname);
+ /* strcpy(mask,p+ff_lastname+94); */
+ break;
+ case 1:
+ strcpy(mask,p + ff_lastname + 1);
+ ff_resume_key = 0;
+ break;
+ }
+ }
+ else
+ strcpy(mask,"");
+
+ /* and add them to the dirlist pool */
+ dirlist = Realloc(dirlist,dirlist_len + resp_data_len);
+
+ if (!dirlist)
+ {
+ DEBUG(0,("Failed to expand dirlist\n"));
+ break;
+ }
+
+ /* put in a length for the last entry, to ensure we can chain entries
+ into the next packet */
+ {
+ char *p2;
+ for (p2=p,i=0;i<(ff_searchcount-1);i++)
+ p2 += interpret_long_filename(info_level,p2,NULL);
+ SSVAL(p2,0,resp_data_len - PTR_DIFF(p2,p));
+ }
+
+ /* grab the data for later use */
+ memcpy(dirlist+dirlist_len,p,resp_data_len);
+ dirlist_len += resp_data_len;
+
+ total_received += ff_searchcount;
+
+ if (resp_data) free(resp_data); resp_data = NULL;
+ if (resp_param) free(resp_param); resp_param = NULL;
+
+ DEBUG(3,("received %d entries (eos=%d resume=%d)\n",
+ ff_searchcount,ff_eos,ff_resume_key));
+
+ First = False;
+ }
+
+ if (!fn)
+ for (p=dirlist,i=0;i<total_received;i++)
+ {
+ p += interpret_long_filename(info_level,p,&finfo);
+ display_finfo(&finfo);
+ }
+
+ for (p=dirlist,i=0;i<total_received;i++)
+ {
+ p += interpret_long_filename(info_level,p,&finfo);
+ dir_action(inbuf,outbuf,attribute,&finfo,recurse_dir,fn,True);
+ }
+
+ /* free up the dirlist buffer */
+ if (dirlist) free(dirlist);
+ return(total_received);
+}
+
+
+/****************************************************************************
+ get a directory listing
+ ****************************************************************************/
+static void cmd_dir(char *inbuf,char *outbuf)
+{
+ int attribute = aDIR | aSYSTEM | aHIDDEN;
+ pstring mask;
+ fstring buf;
+ char *p=buf;
+
+ strcpy(mask,cur_dir);
+ if(mask[strlen(mask)-1]!='\\')
+ strcat(mask,"\\");
+
+ if (next_token(NULL,buf,NULL))
+ {
+ if (*p == '\\')
+ strcpy(mask,p);
+ else
+ strcat(mask,p);
+ }
+ else {
+ strcat(mask,"*");
+ }
+
+ do_dir(inbuf,outbuf,mask,attribute,NULL,recurse);
+
+ do_dskattr();
+}
+
+
+
+/****************************************************************************
+ get a file from rname to lname
+ ****************************************************************************/
+static void do_get(char *rname,char *lname,file_info *finfo1)
+{
+ int handle=0,fnum;
+ uint32 nread=0;
+ char *p;
+ BOOL newhandle = False;
+ char *inbuf,*outbuf;
+ file_info finfo;
+ BOOL close_done = False;
+ BOOL ignore_close_error = False;
+ char *dataptr=NULL;
+ int datalen=0;
+
+ struct timeval tp_start;
+ GetTimeOfDay(&tp_start);
+
+ if (finfo1)
+ finfo = *finfo1;
+ else
+ finfo = def_finfo;
+
+ if (lowercase)
+ strlower(lname);
+
+
+ inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ if (!inbuf || !outbuf)
+ {
+ DEBUG(0,("out of memory\n"));
+ return;
+ }
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,15,1 + strlen(rname),True);
+
+ CVAL(outbuf,smb_com) = SMBopenX;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,0xFF);
+ SSVAL(outbuf,smb_vwv2,1);
+ SSVAL(outbuf,smb_vwv3,(DENY_NONE<<4));
+ SSVAL(outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
+ SSVAL(outbuf,smb_vwv5,aSYSTEM | aHIDDEN);
+ SSVAL(outbuf,smb_vwv8,1);
+
+ p = smb_buf(outbuf);
+ strcpy(p,rname);
+ p = skip_string(p,1);
+
+ /* do a chained openX with a readX? */
+#if 1
+ if (finfo.size > 0)
+ {
+ DEBUG(3,("Chaining readX wth openX\n"));
+ SSVAL(outbuf,smb_vwv0,SMBreadX);
+ SSVAL(outbuf,smb_vwv1,smb_offset(p,outbuf));
+ bzero(p,200);
+ p -= smb_wct;
+ SSVAL(p,smb_wct,10);
+ SSVAL(p,smb_vwv0,0xFF);
+ SSVAL(p,smb_vwv5,MIN(max_xmit-500,finfo.size));
+ SSVAL(p,smb_vwv9,MIN(BUFFER_SIZE,finfo.size));
+ smb_setlen(outbuf,smb_len(outbuf)+11*2+1);
+ }
+#endif
+
+ if(!strcmp(lname,"-"))
+ handle = fileno(stdout);
+ else
+ {
+ handle = creat(lname,0644);
+ newhandle = True;
+ }
+ if (handle < 0)
+ {
+ DEBUG(0,("Error opening local file %s\n",lname));
+ free(inbuf);free(outbuf);
+ return;
+ }
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ if (CVAL(inbuf,smb_rcls) == ERRSRV &&
+ SVAL(inbuf,smb_err) == ERRnoresource &&
+ reopen_connection(inbuf,outbuf))
+ {
+ do_get(rname,lname,finfo1);
+ return;
+ }
+ DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),CNV_LANG(rname)));
+ if(newhandle)
+ close(handle);
+ free(inbuf);free(outbuf);
+ return;
+ }
+
+ strcpy(finfo.name,rname);
+
+ if (!finfo1)
+ {
+ finfo.mode = SVAL(inbuf,smb_vwv3);
+ /* these times arrive as LOCAL time, using the DST offset
+ corresponding to that time, we convert them to GMT */
+ finfo.mtime = make_unix_date3(inbuf+smb_vwv4);
+ finfo.atime = finfo.ctime = finfo.mtime;
+ finfo.size = IVAL(inbuf,smb_vwv6);
+ }
+
+ DEBUG(3,("file %s attrib 0x%X\n",CNV_LANG(finfo.name),finfo.mode));
+
+ fnum = SVAL(inbuf,smb_vwv2);
+
+ /* we might have got some data from a chained readX */
+ if (SVAL(inbuf,smb_vwv0) == SMBreadX)
+ {
+ p = (smb_base(inbuf)+SVAL(inbuf,smb_vwv1)) - smb_wct;
+ datalen = SVAL(p,smb_vwv5);
+ dataptr = smb_base(inbuf) + SVAL(p,smb_vwv6);
+ }
+ else
+ {
+ dataptr = NULL;
+ datalen = 0;
+ }
+
+
+ DEBUG(2,("getting file %s of size %d bytes as %s ",
+ CNV_LANG(finfo.name),
+ finfo.size,
+ lname));
+
+ while (nread < finfo.size && !close_done)
+ {
+ int method = -1;
+ static BOOL can_chain_close = True;
+
+ p=NULL;
+
+ DEBUG(3,("nread=%d max_xmit=%d fsize=%d\n",nread,max_xmit,finfo.size));
+
+ /* 3 possible read types. readbraw if a large block is required.
+ readX + close if not much left and read if neither is supported */
+
+ /* we might have already read some data from a chained readX */
+ if (dataptr && datalen>0)
+ method=3;
+
+ /* if we can finish now then readX+close */
+ if (method<0 && can_chain_close && (Protocol >= PROTOCOL_LANMAN1) &&
+ ((finfo.size - nread) <
+ (max_xmit - (2*smb_size + 13*SIZEOFWORD + 300))))
+ method = 0;
+
+ /* if we support readraw then use that */
+ if (method<0 && readbraw_supported)
+ method = 1;
+
+ /* if we can then use readX */
+ if (method<0 && (Protocol >= PROTOCOL_LANMAN1))
+ method = 2;
+
+ switch (method)
+ {
+ /* use readX */
+ case 0:
+ case 2:
+ if (method == 0)
+ close_done = True;
+
+ /* use readX + close */
+ bzero(outbuf,smb_size);
+ set_message(outbuf,10,0,True);
+ CVAL(outbuf,smb_com) = SMBreadX;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ if (close_done)
+ {
+ CVAL(outbuf,smb_vwv0) = SMBclose;
+ SSVAL(outbuf,smb_vwv1,smb_offset(smb_buf(outbuf),outbuf));
+ }
+ else
+ CVAL(outbuf,smb_vwv0) = 0xFF;
+
+ SSVAL(outbuf,smb_vwv2,fnum);
+ SIVAL(outbuf,smb_vwv3,nread);
+ SSVAL(outbuf,smb_vwv5,MIN(max_xmit-200,finfo.size - nread));
+ SSVAL(outbuf,smb_vwv6,0);
+ SIVAL(outbuf,smb_vwv7,0);
+ SSVAL(outbuf,smb_vwv9,MIN(BUFFER_SIZE,finfo.size-nread));
+
+ if (close_done)
+ {
+ p = smb_buf(outbuf);
+ bzero(p,9);
+
+ CVAL(p,0) = 3;
+ SSVAL(p,1,fnum);
+ SIVALS(p,3,-1);
+
+ /* now set the total packet length */
+ smb_setlen(outbuf,smb_len(outbuf)+9);
+ }
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
+ break;
+ }
+
+ if (close_done &&
+ SVAL(inbuf,smb_vwv0) != SMBclose)
+ {
+ /* NOTE: WfWg sometimes just ignores the chained
+ command! This seems to break the spec? */
+ DEBUG(3,("Rejected chained close?\n"));
+ close_done = False;
+ can_chain_close = False;
+ ignore_close_error = True;
+ }
+
+ datalen = SVAL(inbuf,smb_vwv5);
+ dataptr = smb_base(inbuf) + SVAL(inbuf,smb_vwv6);
+ break;
+
+ /* use readbraw */
+ case 1:
+ {
+ static int readbraw_size = BUFFER_SIZE;
+
+ extern int Client;
+ bzero(outbuf,smb_size);
+ set_message(outbuf,8,0,True);
+ CVAL(outbuf,smb_com) = SMBreadbraw;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+ SSVAL(outbuf,smb_vwv0,fnum);
+ SIVAL(outbuf,smb_vwv1,nread);
+ SSVAL(outbuf,smb_vwv3,MIN(finfo.size-nread,readbraw_size));
+ SSVAL(outbuf,smb_vwv4,0);
+ SIVALS(outbuf,smb_vwv5,-1);
+ send_smb(Client,outbuf);
+
+ /* Now read the raw data into the buffer and write it */
+ if(read_smb_length(Client,inbuf,0) == -1) {
+ DEBUG(0,("Failed to read length in readbraw\n"));
+ exit(1);
+ }
+
+ /* Even though this is not an smb message, smb_len
+ returns the generic length of an smb message */
+ datalen = smb_len(inbuf);
+
+ if (datalen == 0)
+ {
+ /* we got a readbraw error */
+ DEBUG(4,("readbraw error - reducing size\n"));
+ readbraw_size = (readbraw_size * 9) / 10;
+
+ if (readbraw_size < max_xmit)
+ {
+ DEBUG(0,("disabling readbraw\n"));
+ readbraw_supported = False;
+ }
+
+ dataptr=NULL;
+ continue;
+ }
+
+ if(read_data(Client,inbuf,datalen) != datalen) {
+ DEBUG(0,("Failed to read data in readbraw\n"));
+ exit(1);
+ }
+ dataptr = inbuf;
+ }
+ break;
+
+ case 3:
+ /* we've already read some data with a chained readX */
+ break;
+
+ default:
+ /* use plain read */
+ bzero(outbuf,smb_size);
+ set_message(outbuf,5,0,True);
+ CVAL(outbuf,smb_com) = SMBread;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,fnum);
+ SSVAL(outbuf,smb_vwv1,MIN(max_xmit-200,finfo.size - nread));
+ SIVAL(outbuf,smb_vwv2,nread);
+ SSVAL(outbuf,smb_vwv4,finfo.size - nread);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
+ break;
+ }
+
+ datalen = SVAL(inbuf,smb_vwv0);
+ dataptr = smb_buf(inbuf) + 3;
+ break;
+ }
+
+ if (writefile(handle,dataptr,datalen) != datalen)
+ {
+ DEBUG(0,("Error writing local file\n"));
+ break;
+ }
+
+ nread += datalen;
+ if (datalen == 0)
+ {
+ DEBUG(0,("Error reading file %s. Got %d bytes\n",CNV_LANG(rname),nread));
+ break;
+ }
+
+ dataptr=NULL;
+ datalen=0;
+ }
+
+
+
+ if (!close_done)
+ {
+ bzero(outbuf,smb_size);
+ set_message(outbuf,3,0,True);
+ CVAL(outbuf,smb_com) = SMBclose;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,fnum);
+ SIVALS(outbuf,smb_vwv1,-1);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (!ignore_close_error && CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("Error %s closing remote file\n",smb_errstr(inbuf)));
+ if(newhandle)
+ close(handle);
+ free(inbuf);free(outbuf);
+ return;
+ }
+ }
+
+ if(newhandle)
+ close(handle);
+
+ if (archive_level >= 2 && (finfo.mode & aARCH)) {
+ bzero(outbuf,smb_size);
+ set_message(outbuf,8,strlen(rname)+4,True);
+ CVAL(outbuf,smb_com) = SMBsetatr;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+ SSVAL(outbuf,smb_vwv0,finfo.mode & ~(aARCH));
+ SIVALS(outbuf,smb_vwv1,0);
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,rname);
+ p += strlen(p)+1;
+ *p++ = 4;
+ *p = 0;
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ }
+
+ {
+ struct timeval tp_end;
+ int this_time;
+
+ GetTimeOfDay(&tp_end);
+ this_time =
+ (tp_end.tv_sec - tp_start.tv_sec)*1000 +
+ (tp_end.tv_usec - tp_start.tv_usec)/1000;
+ get_total_time_ms += this_time;
+ get_total_size += finfo.size;
+
+ DEBUG(2,("(%g kb/s) (average %g kb/s)\n",
+ finfo.size / (1.024*this_time + 1.0e-4),
+ get_total_size / (1.024*get_total_time_ms)));
+ }
+
+ free(inbuf);free(outbuf);
+}
+
+
+/****************************************************************************
+ get a file
+ ****************************************************************************/
+static void cmd_get(void)
+{
+ pstring lname;
+ pstring rname;
+ char *p;
+
+ strcpy(rname,cur_dir);
+ strcat(rname,"\\");
+
+ p = rname + strlen(rname);
+
+ if (!next_token(NULL,p,NULL)) {
+ DEBUG(0,("get <filename>\n"));
+ return;
+ }
+ strcpy(lname,p);
+ dos_clean_name(rname);
+
+ next_token(NULL,lname,NULL);
+
+ do_get(rname,lname,NULL);
+}
+
+
+/****************************************************************************
+ do a mget operation on one file
+ ****************************************************************************/
+static void do_mget(file_info *finfo)
+{
+ pstring rname;
+ pstring quest;
+
+ if (strequal(finfo->name,".") || strequal(finfo->name,".."))
+ return;
+
+ if (abort_mget)
+ {
+ DEBUG(0,("mget aborted\n"));
+ return;
+ }
+
+ if (finfo->mode & aDIR)
+ sprintf(quest,"Get directory %s? ",CNV_LANG(finfo->name));
+ else
+ sprintf(quest,"Get file %s? ",CNV_LANG(finfo->name));
+
+ if (prompt && !yesno(quest)) return;
+
+ if (finfo->mode & aDIR)
+ {
+ pstring saved_curdir;
+ pstring mget_mask;
+ char *inbuf,*outbuf;
+
+ inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ if (!inbuf || !outbuf)
+ {
+ DEBUG(0,("out of memory\n"));
+ return;
+ }
+
+ strcpy(saved_curdir,cur_dir);
+
+ strcat(cur_dir,finfo->name);
+ strcat(cur_dir,"\\");
+
+ unix_format(finfo->name);
+ {
+ if (lowercase)
+ strlower(finfo->name);
+
+ if (!directory_exist(finfo->name,NULL) &&
+ sys_mkdir(finfo->name,0777) != 0)
+ {
+ DEBUG(0,("failed to create directory %s\n",CNV_LANG(finfo->name)));
+ strcpy(cur_dir,saved_curdir);
+ free(inbuf);free(outbuf);
+ return;
+ }
+
+ if (sys_chdir(finfo->name) != 0)
+ {
+ DEBUG(0,("failed to chdir to directory %s\n",CNV_LANG(finfo->name)));
+ strcpy(cur_dir,saved_curdir);
+ free(inbuf);free(outbuf);
+ return;
+ }
+ }
+
+ strcpy(mget_mask,cur_dir);
+ strcat(mget_mask,"*");
+
+ do_dir((char *)inbuf,(char *)outbuf,
+ mget_mask,aSYSTEM | aHIDDEN | aDIR,do_mget,False);
+ chdir("..");
+ strcpy(cur_dir,saved_curdir);
+ free(inbuf);free(outbuf);
+ }
+ else
+ {
+ strcpy(rname,cur_dir);
+ strcat(rname,finfo->name);
+ do_get(rname,finfo->name,finfo);
+ }
+}
+
+/****************************************************************************
+view the file using the pager
+****************************************************************************/
+static void cmd_more(void)
+{
+ fstring rname,lname,tmpname,pager_cmd;
+ char *pager;
+
+ strcpy(rname,cur_dir);
+ strcat(rname,"\\");
+ sprintf(tmpname,"/tmp/smbmore.%d",getpid());
+ strcpy(lname,tmpname);
+
+ if (!next_token(NULL,rname+strlen(rname),NULL)) {
+ DEBUG(0,("more <filename>\n"));
+ return;
+ }
+ dos_clean_name(rname);
+
+ do_get(rname,lname,NULL);
+
+ pager=getenv("PAGER");
+ sprintf(pager_cmd,"%s %s",(pager? pager:PAGER), tmpname);
+ system(pager_cmd);
+ unlink(tmpname);
+}
+
+
+
+/****************************************************************************
+do a mget command
+****************************************************************************/
+static void cmd_mget(char *inbuf,char *outbuf)
+{
+ int attribute = aSYSTEM | aHIDDEN;
+ pstring mget_mask;
+ fstring buf;
+ char *p=buf;
+
+ *mget_mask = 0;
+
+ if (recurse)
+ attribute |= aDIR;
+
+ abort_mget = False;
+
+ while (next_token(NULL,p,NULL))
+ {
+ strcpy(mget_mask,cur_dir);
+ if(mget_mask[strlen(mget_mask)-1]!='\\')
+ strcat(mget_mask,"\\");
+
+ if (*p == '\\')
+ strcpy(mget_mask,p);
+ else
+ strcat(mget_mask,p);
+ do_dir((char *)inbuf,(char *)outbuf,mget_mask,attribute,do_mget,False);
+ }
+
+ if (! *mget_mask)
+ {
+ strcpy(mget_mask,cur_dir);
+ if(mget_mask[strlen(mget_mask)-1]!='\\')
+ strcat(mget_mask,"\\");
+ strcat(mget_mask,"*");
+ do_dir((char *)inbuf,(char *)outbuf,mget_mask,attribute,do_mget,False);
+ }
+}
+
+/****************************************************************************
+make a directory of name "name"
+****************************************************************************/
+static BOOL do_mkdir(char *name)
+{
+ char *p;
+ char *inbuf,*outbuf;
+
+ inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ if (!inbuf || !outbuf)
+ {
+ DEBUG(0,("out of memory\n"));
+ return False;
+ }
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,0,2 + strlen(name),True);
+
+ CVAL(outbuf,smb_com) = SMBmkdir;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,name);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s making remote directory %s\n",
+ smb_errstr(inbuf),CNV_LANG(name)));
+
+ free(inbuf);free(outbuf);
+ return(False);
+ }
+
+ free(inbuf);free(outbuf);
+ return(True);
+}
+
+
+/****************************************************************************
+ make a directory
+ ****************************************************************************/
+static void cmd_mkdir(char *inbuf,char *outbuf)
+{
+ pstring mask;
+ fstring buf;
+ char *p=buf;
+
+ strcpy(mask,cur_dir);
+
+ if (!next_token(NULL,p,NULL))
+ {
+ if (!recurse)
+ DEBUG(0,("mkdir <dirname>\n"));
+ return;
+ }
+ strcat(mask,p);
+
+ if (recurse)
+ {
+ pstring ddir;
+ pstring ddir2;
+ *ddir2 = 0;
+
+ strcpy(ddir,mask);
+ trim_string(ddir,".",NULL);
+ p = strtok(ddir,"/\\");
+ while (p)
+ {
+ strcat(ddir2,p);
+ if (!chkpath(ddir2,False))
+ {
+ do_mkdir(ddir2);
+ }
+ strcat(ddir2,"\\");
+ p = strtok(NULL,"/\\");
+ }
+ }
+ else
+ do_mkdir(mask);
+}
+
+
+/*******************************************************************
+ write to a file using writebraw
+ ********************************************************************/
+static int smb_writeraw(char *outbuf,int fnum,int pos,char *buf,int n)
+{
+ extern int Client;
+ pstring inbuf;
+
+ bzero(outbuf,smb_size);
+ bzero(inbuf,smb_size);
+ set_message(outbuf,Protocol>PROTOCOL_COREPLUS?12:10,0,True);
+
+ CVAL(outbuf,smb_com) = SMBwritebraw;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,fnum);
+ SSVAL(outbuf,smb_vwv1,n);
+ SIVAL(outbuf,smb_vwv3,pos);
+ SSVAL(outbuf,smb_vwv7,1);
+
+ send_smb(Client,outbuf);
+
+ if (!receive_smb(Client,inbuf,CLIENT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0)
+ return(0);
+
+ _smb_setlen(buf-4,n); /* HACK! XXXX */
+
+ if (write_socket(Client,buf-4,n+4) != n+4)
+ return(0);
+
+ if (!receive_smb(Client,inbuf,CLIENT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0) {
+ DEBUG(0,("Error writing remote file (2)\n"));
+ return(0);
+ }
+ return(SVAL(inbuf,smb_vwv0));
+}
+
+
+
+/*******************************************************************
+ write to a file
+ ********************************************************************/
+static int smb_writefile(char *outbuf,int fnum,int pos,char *buf,int n)
+{
+ pstring inbuf;
+
+ if (writebraw_supported && n > (max_xmit-200))
+ return(smb_writeraw(outbuf,fnum,pos,buf,n));
+
+ bzero(outbuf,smb_size);
+ bzero(inbuf,smb_size);
+ set_message(outbuf,5,n + 3,True);
+
+ CVAL(outbuf,smb_com) = SMBwrite;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,fnum);
+ SSVAL(outbuf,smb_vwv1,n);
+ SIVAL(outbuf,smb_vwv2,pos);
+ SSVAL(outbuf,smb_vwv4,0);
+ CVAL(smb_buf(outbuf),0) = 1;
+ SSVAL(smb_buf(outbuf),1,n);
+
+ memcpy(smb_buf(outbuf)+3,buf,n);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0) {
+ DEBUG(0,("%s writing remote file\n",smb_errstr(inbuf)));
+ return(0);
+ }
+ return(SVAL(inbuf,smb_vwv0));
+}
+
+
+
+/****************************************************************************
+ put a single file
+ ****************************************************************************/
+static void do_put(char *rname,char *lname,file_info *finfo)
+{
+ int fnum;
+ FILE *f;
+ int nread=0;
+ char *p;
+ char *inbuf,*outbuf;
+ time_t close_time = finfo->mtime;
+ char *buf=NULL;
+ static int maxwrite=0;
+
+ struct timeval tp_start;
+ GetTimeOfDay(&tp_start);
+
+ inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ if (!inbuf || !outbuf)
+ {
+ DEBUG(0,("out of memory\n"));
+ return;
+ }
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,3,2 + strlen(rname),True);
+
+ if (finfo->mtime == 0 || finfo->mtime == -1)
+ finfo->mtime = finfo->atime = finfo->ctime = time(NULL);
+
+ CVAL(outbuf,smb_com) = SMBcreate;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,finfo->mode);
+ put_dos_date3(outbuf,smb_vwv1,finfo->mtime);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,rname);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),CNV_LANG(rname)));
+
+ free(inbuf);free(outbuf);if (buf) free(buf);
+ return;
+ }
+
+ f = fopen(lname,"r");
+
+ if (!f)
+ {
+ DEBUG(0,("Error opening local file %s\n",lname));
+ free(inbuf);free(outbuf);
+ return;
+ }
+
+
+ fnum = SVAL(inbuf,smb_vwv0);
+ if (finfo->size < 0)
+ finfo->size = file_size(lname);
+
+ DEBUG(1,("putting file %s of size %d bytes as %s ",lname,finfo->size,CNV_LANG(rname)));
+
+ if (!maxwrite)
+ maxwrite = writebraw_supported?MAX(max_xmit,BUFFER_SIZE):(max_xmit-200);
+
+ while (nread < finfo->size)
+ {
+ int n = maxwrite;
+ int ret;
+
+ n = MIN(n,finfo->size - nread);
+
+ buf = (char *)Realloc(buf,n+4);
+
+ fseek(f,nread,SEEK_SET);
+ if ((n = readfile(buf+4,1,n,f)) < 1)
+ {
+ DEBUG(0,("Error reading local file\n"));
+ break;
+ }
+
+ ret = smb_writefile(outbuf,fnum,nread,buf+4,n);
+
+ if (n != ret) {
+ if (!maxwrite) {
+ DEBUG(0,("Error writing file\n"));
+ break;
+ } else {
+ maxwrite /= 2;
+ continue;
+ }
+ }
+
+ nread += n;
+ }
+
+
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,3,0,True);
+ CVAL(outbuf,smb_com) = SMBclose;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,fnum);
+ put_dos_date3(outbuf,smb_vwv1,close_time);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s closing remote file %s\n",smb_errstr(inbuf),CNV_LANG(rname)));
+ fclose(f);
+ free(inbuf);free(outbuf);
+ if (buf) free(buf);
+ return;
+ }
+
+
+ fclose(f);
+ free(inbuf);free(outbuf);
+ if (buf) free(buf);
+
+ {
+ struct timeval tp_end;
+ int this_time;
+
+ GetTimeOfDay(&tp_end);
+ this_time =
+ (tp_end.tv_sec - tp_start.tv_sec)*1000 +
+ (tp_end.tv_usec - tp_start.tv_usec)/1000;
+ put_total_time_ms += this_time;
+ put_total_size += finfo->size;
+
+ DEBUG(2,("(%g kb/s) (average %g kb/s)\n",
+ finfo->size / (1.024*this_time + 1.0e-4),
+ put_total_size / (1.024*put_total_time_ms)));
+ }
+}
+
+
+
+/****************************************************************************
+ put a file
+ ****************************************************************************/
+static void cmd_put(void)
+{
+ pstring lname;
+ pstring rname;
+ fstring buf;
+ char *p=buf;
+ file_info finfo;
+ finfo = def_finfo;
+
+ strcpy(rname,cur_dir);
+ strcat(rname,"\\");
+
+
+ if (!next_token(NULL,p,NULL))
+ {
+ DEBUG(0,("put <filename>\n"));
+ return;
+ }
+ strcpy(lname,p);
+
+ if (next_token(NULL,p,NULL))
+ strcat(rname,p);
+ else
+ strcat(rname,lname);
+
+ dos_clean_name(rname);
+
+ {
+ struct stat st;
+ if (!file_exist(lname,&st)) {
+ DEBUG(0,("%s does not exist\n",lname));
+ return;
+ }
+ finfo.mtime = st.st_mtime;
+ }
+
+ do_put(rname,lname,&finfo);
+}
+
+/****************************************************************************
+ seek in a directory/file list until you get something that doesn't start with
+ the specified name
+ ****************************************************************************/
+static BOOL seek_list(FILE *f,char *name)
+{
+ pstring s;
+ while (!feof(f))
+ {
+ if (fscanf(f,"%s",s) != 1) return(False);
+ trim_string(s,"./",NULL);
+ if (strncmp(s,name,strlen(name)) != 0)
+ {
+ strcpy(name,s);
+ return(True);
+ }
+ }
+
+ return(False);
+}
+
+
+/****************************************************************************
+ set the file selection mask
+ ****************************************************************************/
+static void cmd_select(void)
+{
+ strcpy(fileselection,"");
+ next_token(NULL,fileselection,NULL);
+}
+
+
+/****************************************************************************
+ mput some files
+ ****************************************************************************/
+static void cmd_mput(void)
+{
+ pstring lname;
+ pstring rname;
+ file_info finfo;
+ fstring buf;
+ char *p=buf;
+
+ finfo = def_finfo;
+
+
+ while (next_token(NULL,p,NULL))
+ {
+ struct stat st;
+ pstring cmd;
+ pstring tmpname;
+ FILE *f;
+
+ sprintf(tmpname,"/tmp/ls.smb.%d",(int)getpid());
+ if (recurse)
+ sprintf(cmd,"find . -name \"%s\" -print > %s",p,tmpname);
+ else
+ sprintf(cmd,"/bin/ls %s > %s",p,tmpname);
+ system(cmd);
+
+ f = fopen(tmpname,"r");
+ if (!f) continue;
+
+ while (!feof(f))
+ {
+ pstring quest;
+
+ if (fscanf(f,"%s",lname) != 1) break;
+ trim_string(lname,"./",NULL);
+
+ again1:
+
+ /* check if it's a directory */
+ if (directory_exist(lname,&st))
+ {
+ if (!recurse) continue;
+ sprintf(quest,"Put directory %s? ",lname);
+ if (prompt && !yesno(quest))
+ {
+ strcat(lname,"/");
+ if (!seek_list(f,lname))
+ break;
+ goto again1;
+ }
+
+ strcpy(rname,cur_dir);
+ strcat(rname,lname);
+ if (!do_mkdir(rname))
+ {
+ strcat(lname,"/");
+ if (!seek_list(f,lname))
+ break;
+ goto again1;
+ }
+
+ continue;
+ }
+ else
+ {
+ sprintf(quest,"Put file %s? ",lname);
+ if (prompt && !yesno(quest)) continue;
+
+ strcpy(rname,cur_dir);
+ strcat(rname,lname);
+ }
+ dos_format(rname);
+
+ /* null size so do_put knows to ignore it */
+ finfo.size = -1;
+
+ /* set the date on the file */
+ finfo.mtime = st.st_mtime;
+
+ do_put(rname,lname,&finfo);
+ }
+ fclose(f);
+ unlink(tmpname);
+ }
+}
+
+/****************************************************************************
+ cancel a print job
+ ****************************************************************************/
+static void do_cancel(int job)
+{
+ char *rparam = NULL;
+ char *rdata = NULL;
+ char *p;
+ int rdrcnt,rprcnt;
+ pstring param;
+
+ bzero(param,sizeof(param));
+
+ p = param;
+ SSVAL(p,0,81); /* api number */
+ p += 2;
+ strcpy(p,"W");
+ p = skip_string(p,1);
+ strcpy(p,"");
+ p = skip_string(p,1);
+ SSVAL(p,0,job);
+ p += 2;
+
+ if (call_api(PTR_DIFF(p,param),0,
+ 6,1000,
+ &rprcnt,&rdrcnt,
+ param,NULL,
+ &rparam,&rdata))
+ {
+ int res = SVAL(rparam,0);
+
+ if (!res)
+ printf("Job %d cancelled\n",job);
+ else
+ printf("Error %d calcelling job %d\n",res,job);
+ return;
+ }
+ else
+ printf("Server refused cancel request\n");
+
+ if (rparam) free(rparam);
+ if (rdata) free(rdata);
+
+ return;
+}
+
+
+/****************************************************************************
+ cancel a print job
+ ****************************************************************************/
+static void cmd_cancel(char *inbuf,char *outbuf )
+{
+ fstring buf;
+ int job;
+
+ if (!connect_as_printer)
+ {
+ DEBUG(0,("WARNING: You didn't use the -P option to smbclient.\n"));
+ DEBUG(0,("Trying to cancel print jobs without -P may fail\n"));
+ }
+
+ if (!next_token(NULL,buf,NULL)) {
+ printf("cancel <jobid> ...\n");
+ return;
+ }
+ do {
+ job = atoi(buf);
+ do_cancel(job);
+ } while (next_token(NULL,buf,NULL));
+}
+
+
+/****************************************************************************
+ get info on a file
+ ****************************************************************************/
+static void cmd_stat(char *inbuf,char *outbuf)
+{
+ fstring buf;
+ pstring param;
+ char *resp_data=NULL;
+ char *resp_param=NULL;
+ int resp_data_len = 0;
+ int resp_param_len=0;
+ char *p;
+ uint16 setup = TRANSACT2_QPATHINFO;
+
+ if (!next_token(NULL,buf,NULL)) {
+ printf("stat <file>\n");
+ return;
+ }
+
+ bzero(param,6);
+ SSVAL(param,0,4); /* level */
+ p = param+6;
+ strcpy(p,cur_dir);
+ strcat(p,buf);
+
+ send_trans_request(outbuf,SMBtrans2,NULL,FID_UNUSED,0,
+ NULL,param,&setup,
+ 0,6 + strlen(p)+1,1,
+ BUFFER_SIZE,2,0);
+
+ receive_trans_response(inbuf,SMBtrans2,
+ &resp_data_len,&resp_param_len,
+ &resp_data,&resp_param);
+
+ if (resp_data) free(resp_data); resp_data = NULL;
+ if (resp_param) free(resp_param); resp_param = NULL;
+}
+
+
+/****************************************************************************
+ print a file
+ ****************************************************************************/
+static void cmd_print(char *inbuf,char *outbuf )
+{
+ int fnum;
+ FILE *f = NULL;
+ uint32 nread=0;
+ pstring lname;
+ pstring rname;
+ char *p;
+
+ if (!connect_as_printer)
+ {
+ DEBUG(0,("WARNING: You didn't use the -P option to smbclient.\n"));
+ DEBUG(0,("Trying to print without -P may fail\n"));
+ }
+
+ if (!next_token(NULL,lname,NULL))
+ {
+ DEBUG(0,("print <filename>\n"));
+ return;
+ }
+
+ strcpy(rname,lname);
+ p = strrchr(rname,'/');
+ if (p)
+ {
+ pstring tname;
+ strcpy(tname,p+1);
+ strcpy(rname,tname);
+ }
+
+ if ((int)strlen(rname) > 14)
+ rname[14] = 0;
+
+ if (strequal(lname,"-"))
+ {
+ f = stdin;
+ strcpy(rname,"stdin");
+ }
+
+ dos_clean_name(rname);
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,2,2 + strlen(rname),True);
+
+ CVAL(outbuf,smb_com) = SMBsplopen;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,0);
+ SSVAL(outbuf,smb_vwv1,printmode);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,rname);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s opening printer for %s\n",smb_errstr(inbuf),CNV_LANG(rname)));
+ return;
+ }
+
+ if (!f)
+ f = fopen(lname,"r");
+ if (!f)
+ {
+ DEBUG(0,("Error opening local file %s\n",lname));
+ return;
+ }
+
+
+ fnum = SVAL(inbuf,smb_vwv0);
+
+ DEBUG(1,("printing file %s as %s\n",lname,CNV_LANG(rname)));
+
+ while (!feof(f))
+ {
+ int n;
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,1,3,True);
+
+ /* for some strange reason the OS/2 print server can't handle large
+ packets when printing. weird */
+ n = MIN(1024,max_xmit-(smb_len(outbuf)+4));
+
+ if (translation)
+ n = printread(f,smb_buf(outbuf)+3,(int)(0.95*n));
+ else
+ n = readfile(smb_buf(outbuf)+3,1,n,f);
+ if (n <= 0)
+ {
+ DEBUG(0,("read gave %d\n",n));
+ break;
+ }
+
+ smb_setlen(outbuf,smb_len(outbuf) + n);
+
+ CVAL(outbuf,smb_com) = SMBsplwr;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,fnum);
+ SSVAL(outbuf,smb_vwv1,n+3);
+ CVAL(smb_buf(outbuf),0) = 1;
+ SSVAL(smb_buf(outbuf),1,n);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s printing remote file\n",smb_errstr(inbuf)));
+ break;
+ }
+
+ nread += n;
+ }
+
+ DEBUG(2,("%d bytes printed\n",nread));
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,1,0,True);
+ CVAL(outbuf,smb_com) = SMBsplclose;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,fnum);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s closing print file\n",smb_errstr(inbuf)));
+ if (f != stdin)
+ fclose(f);
+ return;
+ }
+
+ if (f != stdin)
+ fclose(f);
+}
+
+/****************************************************************************
+print a file
+****************************************************************************/
+static void cmd_queue(char *inbuf,char *outbuf )
+{
+ int count;
+ char *p;
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,2,0,True);
+
+ CVAL(outbuf,smb_com) = SMBsplretq;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,32); /* a max of 20 entries is to be shown */
+ SSVAL(outbuf,smb_vwv1,0); /* the index into the queue */
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s obtaining print queue\n",smb_errstr(inbuf)));
+ return;
+ }
+
+ count = SVAL(inbuf,smb_vwv0);
+ p = smb_buf(inbuf) + 3;
+ if (count <= 0)
+ {
+ DEBUG(0,("No entries in the print queue\n"));
+ return;
+ }
+
+ {
+ char status[20];
+
+ DEBUG(0,("Job Name Size Status\n"));
+
+ while (count--)
+ {
+ switch (CVAL(p,4))
+ {
+ case 0x01: sprintf(status,"held or stopped"); break;
+ case 0x02: sprintf(status,"printing"); break;
+ case 0x03: sprintf(status,"awaiting print"); break;
+ case 0x04: sprintf(status,"in intercept"); break;
+ case 0x05: sprintf(status,"file had error"); break;
+ case 0x06: sprintf(status,"printer error"); break;
+ default: sprintf(status,"unknown"); break;
+ }
+
+ DEBUG(0,("%-6d %-16.16s %-9d %s\n",
+ SVAL(p,5),p+12,IVAL(p,7),status));
+ p += 28;
+ }
+ }
+
+}
+
+
+/****************************************************************************
+delete some files
+****************************************************************************/
+static void do_del(file_info *finfo)
+{
+ char *p;
+ char *inbuf,*outbuf;
+ pstring mask;
+
+ strcpy(mask,cur_dir);
+ strcat(mask,finfo->name);
+
+ if (finfo->mode & aDIR)
+ return;
+
+ inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ if (!inbuf || !outbuf)
+ {
+ DEBUG(0,("out of memory\n"));
+ return;
+ }
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,1,2 + strlen(mask),True);
+
+ CVAL(outbuf,smb_com) = SMBunlink;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,0);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,mask);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ DEBUG(0,("%s deleting remote file %s\n",smb_errstr(inbuf),CNV_LANG(mask)));
+
+ free(inbuf);free(outbuf);
+
+}
+
+/****************************************************************************
+delete some files
+****************************************************************************/
+static void cmd_del(char *inbuf,char *outbuf )
+{
+ pstring mask;
+ fstring buf;
+ int attribute = aSYSTEM | aHIDDEN;
+
+ if (recurse)
+ attribute |= aDIR;
+
+ strcpy(mask,cur_dir);
+
+ if (!next_token(NULL,buf,NULL))
+ {
+ DEBUG(0,("del <filename>\n"));
+ return;
+ }
+ strcat(mask,buf);
+
+ do_dir((char *)inbuf,(char *)outbuf,mask,attribute,do_del,False);
+}
+
+
+/****************************************************************************
+remove a directory
+****************************************************************************/
+static void cmd_rmdir(char *inbuf,char *outbuf )
+{
+ pstring mask;
+ fstring buf;
+ char *p;
+
+ strcpy(mask,cur_dir);
+
+ if (!next_token(NULL,buf,NULL))
+ {
+ DEBUG(0,("rmdir <dirname>\n"));
+ return;
+ }
+ strcat(mask,buf);
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,0,2 + strlen(mask),True);
+
+ CVAL(outbuf,smb_com) = SMBrmdir;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,mask);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s removing remote directory file %s\n",smb_errstr(inbuf),CNV_LANG(mask)));
+ return;
+ }
+
+}
+
+/****************************************************************************
+rename some files
+****************************************************************************/
+static void cmd_rename(char *inbuf,char *outbuf )
+{
+ pstring src,dest;
+ fstring buf,buf2;
+ char *p;
+
+ strcpy(src,cur_dir);
+ strcpy(dest,cur_dir);
+
+ if (!next_token(NULL,buf,NULL) || !next_token(NULL,buf2,NULL))
+ {
+ DEBUG(0,("rename <src> <dest>\n"));
+ return;
+ }
+ strcat(src,buf);
+ strcat(dest,buf2);
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,1,4 + strlen(src) + strlen(dest),True);
+
+ CVAL(outbuf,smb_com) = SMBmv;
+ SSVAL(outbuf,smb_tid,cnum);
+ SSVAL(outbuf,smb_vwv0,aHIDDEN | aDIR | aSYSTEM);
+ setup_pkt(outbuf);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ strcpy(p,src);
+ p = skip_string(p,1);
+ *p++ = 4;
+ strcpy(p,dest);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s renaming files\n",smb_errstr(inbuf)));
+ return;
+ }
+
+}
+
+
+/****************************************************************************
+toggle the prompt flag
+****************************************************************************/
+static void cmd_prompt(void)
+{
+ prompt = !prompt;
+ DEBUG(2,("prompting is now %s\n",prompt?"on":"off"));
+}
+
+
+/****************************************************************************
+set the newer than time
+****************************************************************************/
+static void cmd_newer(void)
+{
+ fstring buf;
+ BOOL ok;
+ struct stat sbuf;
+
+ ok = next_token(NULL,buf,NULL);
+ if (ok && (sys_stat(buf,&sbuf) == 0))
+ {
+ newer_than = sbuf.st_mtime;
+ DEBUG(1,("Getting files newer than %s",
+ asctime(LocalTime(&newer_than,GMT_TO_LOCAL))));
+ }
+ else
+ newer_than = 0;
+
+ if (ok && newer_than == 0)
+ DEBUG(0,("Error setting newer-than time\n"));
+}
+
+/****************************************************************************
+set the archive level
+****************************************************************************/
+static void cmd_archive(void)
+{
+ fstring buf;
+
+ if (next_token(NULL,buf,NULL)) {
+ archive_level = atoi(buf);
+ } else
+ DEBUG(0,("Archive level is %d\n",archive_level));
+}
+
+/****************************************************************************
+toggle the lowercaseflag
+****************************************************************************/
+static void cmd_lowercase(void)
+{
+ lowercase = !lowercase;
+ DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off"));
+}
+
+
+
+
+/****************************************************************************
+toggle the recurse flag
+****************************************************************************/
+static void cmd_recurse(void)
+{
+ recurse = !recurse;
+ DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off"));
+}
+
+/****************************************************************************
+toggle the translate flag
+****************************************************************************/
+static void cmd_translate(void)
+{
+ translation = !translation;
+ DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
+ translation?"on":"off"));
+}
+
+
+/****************************************************************************
+do a printmode command
+****************************************************************************/
+static void cmd_printmode(void)
+{
+ fstring buf;
+ fstring mode;
+
+ if (next_token(NULL,buf,NULL))
+ {
+ if (strequal(buf,"text"))
+ printmode = 0;
+ else
+ {
+ if (strequal(buf,"graphics"))
+ printmode = 1;
+ else
+ printmode = atoi(buf);
+ }
+ }
+
+ switch(printmode)
+ {
+ case 0:
+ strcpy(mode,"text");
+ break;
+ case 1:
+ strcpy(mode,"graphics");
+ break;
+ default:
+ sprintf(mode,"%d",printmode);
+ break;
+ }
+
+ DEBUG(2,("the printmode is now %s\n",mode));
+}
+
+/****************************************************************************
+do the lcd command
+****************************************************************************/
+static void cmd_lcd(void)
+{
+ fstring buf;
+ pstring d;
+
+ if (next_token(NULL,buf,NULL))
+ sys_chdir(buf);
+ DEBUG(2,("the local directory is now %s\n",GetWd(d)));
+}
+
+
+/****************************************************************************
+send a session request
+****************************************************************************/
+static BOOL send_session_request(char *inbuf,char *outbuf)
+{
+ fstring dest;
+ char *p;
+ int len = 4;
+ /* send a session request (RFC 8002) */
+
+ strcpy(dest,desthost);
+ p = strchr(dest,'.');
+ if (p) *p = 0;
+
+ /* put in the destination name */
+ p = outbuf+len;
+ name_mangle(dest,p,name_type);
+ len += name_len(p);
+
+ /* and my name */
+ p = outbuf+len;
+ name_mangle(myname,p,0);
+ len += name_len(p);
+
+ /* setup the packet length */
+ _smb_setlen(outbuf,len);
+ CVAL(outbuf,0) = 0x81;
+
+ send_smb(Client,outbuf);
+ DEBUG(5,("Sent session request\n"));
+
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,0) == 0x84) /* C. Hoch 9/14/95 Start */
+ {
+ /* For information, here is the response structure.
+ * We do the byte-twiddling to for portability.
+ struct RetargetResponse{
+ unsigned char type;
+ unsigned char flags;
+ int16 length;
+ int32 ip_addr;
+ int16 port;
+ };
+ */
+ extern int Client;
+ int port = (CVAL(inbuf,8)<<8)+CVAL(inbuf,9);
+ /* SESSION RETARGET */
+ putip((char *)&dest_ip,inbuf+4);
+
+ close_sockets();
+ Client = open_socket_out(SOCK_STREAM, &dest_ip, port);
+ if (Client == -1)
+ return False;
+
+ DEBUG(3,("Retargeted\n"));
+
+ set_socket_options(Client,user_socket_options);
+
+ /* Try again */
+ return send_session_request(inbuf,outbuf);
+ } /* C. Hoch 9/14/95 End */
+
+
+ if (CVAL(inbuf,0) != 0x82)
+ {
+ int ecode = CVAL(inbuf,4);
+ DEBUG(0,("Session request failed (%d,%d) with myname=%s destname=%s\n",
+ CVAL(inbuf,0),ecode,myname,desthost));
+ switch (ecode)
+ {
+ case 0x80:
+ DEBUG(0,("Not listening on called name\n"));
+ DEBUG(0,("Try to connect to another name (instead of %s)\n",desthost));
+ DEBUG(0,("You may find the -I option useful for this\n"));
+ break;
+ case 0x81:
+ DEBUG(0,("Not listening for calling name\n"));
+ DEBUG(0,("Try to connect as another name (instead of %s)\n",myname));
+ DEBUG(0,("You may find the -n option useful for this\n"));
+ break;
+ case 0x82:
+ DEBUG(0,("Called name not present\n"));
+ DEBUG(0,("Try to connect to another name (instead of %s)\n",desthost));
+ DEBUG(0,("You may find the -I option useful for this\n"));
+ break;
+ case 0x83:
+ DEBUG(0,("Called name present, but insufficient resources\n"));
+ DEBUG(0,("Perhaps you should try again later?\n"));
+ break;
+ default:
+ DEBUG(0,("Unspecified error 0x%X\n",ecode));
+ DEBUG(0,("Your server software is being unfriendly\n"));
+ break;
+ }
+ return(False);
+ }
+ return(True);
+}
+
+
+/****************************************************************************
+send a login command
+****************************************************************************/
+static BOOL send_login(char *inbuf,char *outbuf,BOOL start_session,BOOL use_setup)
+{
+ BOOL was_null = (!inbuf && !outbuf);
+ int sesskey=0;
+ time_t servertime = 0;
+ extern int serverzone;
+ int sec_mode=0;
+ int crypt_len;
+ int max_vcs=0;
+ struct {
+ int prot;
+ char *name;
+ }
+ prots[] =
+ {
+ {PROTOCOL_CORE,"PC NETWORK PROGRAM 1.0"},
+ {PROTOCOL_COREPLUS,"MICROSOFT NETWORKS 1.03"},
+ {PROTOCOL_LANMAN1,"MICROSOFT NETWORKS 3.0"},
+ {PROTOCOL_LANMAN1,"LANMAN1.0"},
+ {PROTOCOL_LANMAN2,"LM1.2X002"},
+ {PROTOCOL_LANMAN2,"Samba"},
+ {PROTOCOL_NT1,"NT LM 0.12"},
+ {PROTOCOL_NT1,"NT LANMAN 1.0"},
+ {-1,NULL}
+ };
+ char *pass = NULL;
+ pstring dev;
+ char *p;
+ int numprots;
+
+ if (was_null)
+ {
+ inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ }
+
+#if AJT
+ if (strstr(service,"IPC$")) connect_as_ipc = True;
+#endif
+
+ strcpy(dev,"A:");
+ if (connect_as_printer)
+ strcpy(dev,"LPT1:");
+ if (connect_as_ipc)
+ strcpy(dev,"IPC");
+
+
+ if (start_session && !send_session_request(inbuf,outbuf))
+ {
+ if (was_null)
+ {
+ free(inbuf);
+ free(outbuf);
+ }
+ return(False);
+ }
+
+ bzero(outbuf,smb_size);
+
+ /* setup the protocol strings */
+ {
+ int plength;
+
+ for (plength=0,numprots=0;
+ prots[numprots].name && prots[numprots].prot<=max_protocol;
+ numprots++)
+ plength += strlen(prots[numprots].name)+2;
+
+ set_message(outbuf,0,plength,True);
+
+ p = smb_buf(outbuf);
+ for (numprots=0;
+ prots[numprots].name && prots[numprots].prot<=max_protocol;
+ numprots++)
+ {
+ *p++ = 2;
+ strcpy(p,prots[numprots].name);
+ p += strlen(p) + 1;
+ }
+ }
+
+ CVAL(outbuf,smb_com) = SMBnegprot;
+ setup_pkt(outbuf);
+
+ CVAL(smb_buf(outbuf),0) = 2;
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ show_msg(inbuf);
+
+ if (CVAL(inbuf,smb_rcls) != 0 || ((int)SVAL(inbuf,smb_vwv0) >= numprots))
+ {
+ DEBUG(0,("SMBnegprot failed. myname=%s destname=%s - %s \n",
+ myname,desthost,smb_errstr(inbuf)));
+ if (was_null)
+ {
+ free(inbuf);
+ free(outbuf);
+ }
+ return(False);
+ }
+
+ Protocol = prots[SVAL(inbuf,smb_vwv0)].prot;
+
+
+ if (Protocol < PROTOCOL_NT1) {
+ sec_mode = SVAL(inbuf,smb_vwv1);
+ max_xmit = SVAL(inbuf,smb_vwv2);
+ sesskey = IVAL(inbuf,smb_vwv6);
+ serverzone = SVALS(inbuf,smb_vwv10)*60;
+ /* this time is converted to GMT by make_unix_date */
+ servertime = make_unix_date(inbuf+smb_vwv8);
+ if (Protocol >= PROTOCOL_COREPLUS) {
+ readbraw_supported = ((SVAL(inbuf,smb_vwv5) & 0x1) != 0);
+ writebraw_supported = ((SVAL(inbuf,smb_vwv5) & 0x2) != 0);
+ }
+ crypt_len = smb_buflen(inbuf);
+ memcpy(cryptkey,smb_buf(inbuf),8);
+ DEBUG(3,("max mux %d\n",SVAL(inbuf,smb_vwv3)));
+ max_vcs = SVAL(inbuf,smb_vwv4);
+ DEBUG(3,("max vcs %d\n",max_vcs));
+ DEBUG(3,("max blk %d\n",SVAL(inbuf,smb_vwv5)));
+ } else {
+ /* NT protocol */
+ sec_mode = CVAL(inbuf,smb_vwv1);
+ max_xmit = IVAL(inbuf,smb_vwv3+1);
+ sesskey = IVAL(inbuf,smb_vwv7+1);
+ serverzone = SVALS(inbuf,smb_vwv15+1)*60;
+ /* this time arrives in real GMT */
+ servertime = interpret_long_date(inbuf+smb_vwv11+1);
+ crypt_len = CVAL(inbuf,smb_vwv16+1);
+ memcpy(cryptkey,smb_buf(inbuf),8);
+ if (IVAL(inbuf,smb_vwv9+1) & 1)
+ readbraw_supported = writebraw_supported = True;
+ DEBUG(3,("max mux %d\n",SVAL(inbuf,smb_vwv1+1)));
+ max_vcs = SVAL(inbuf,smb_vwv2+1);
+ DEBUG(3,("max vcs %d\n",max_vcs));
+ DEBUG(3,("max raw %d\n",IVAL(inbuf,smb_vwv5+1)));
+ DEBUG(3,("capabilities 0x%x\n",IVAL(inbuf,smb_vwv9+1)));
+ }
+
+ DEBUG(3,("Sec mode %d\n",SVAL(inbuf,smb_vwv1)));
+ DEBUG(3,("max xmt %d\n",max_xmit));
+ DEBUG(3,("Got %d byte crypt key\n",crypt_len));
+ DEBUG(3,("Chose protocol [%s]\n",prots[SVAL(inbuf,smb_vwv0)].name));
+
+ doencrypt = ((sec_mode & 2) != 0);
+
+ if (servertime) {
+ static BOOL done_time = False;
+ if (!done_time) {
+ DEBUG(1,("Server time is %sTimezone is UTC%+02.1f\n",
+ asctime(LocalTime(&servertime,GMT_TO_LOCAL)),
+ -(double)(serverzone/3600.0)));
+ done_time = True;
+ }
+ }
+
+ get_pass:
+
+ if (got_pass)
+ pass = password;
+ else
+ pass = (char *)getpass("Password: ");
+
+ if (Protocol >= PROTOCOL_LANMAN1 && use_setup)
+ {
+ fstring pword;
+ int passlen = strlen(pass)+1;
+ strcpy(pword,pass);
+
+#ifdef SMB_PASSWD
+ if (doencrypt && *pass) {
+ DEBUG(3,("Using encrypted passwords\n"));
+ passlen = 24;
+ SMBencrypt(pass,cryptkey,pword);
+ }
+#else
+ doencrypt = False;
+#endif
+
+ /* if in share level security then don't send a password now */
+ if (!(sec_mode & 1)) {strcpy(pword, "");passlen=1;}
+
+ /* send a session setup command */
+ bzero(outbuf,smb_size);
+
+ if (Protocol < PROTOCOL_NT1) {
+ set_message(outbuf,10,1 + strlen(username) + passlen,True);
+ CVAL(outbuf,smb_com) = SMBsesssetupX;
+ setup_pkt(outbuf);
+
+ CVAL(outbuf,smb_vwv0) = 0xFF;
+ SSVAL(outbuf,smb_vwv2,max_xmit);
+ SSVAL(outbuf,smb_vwv3,2);
+ SSVAL(outbuf,smb_vwv4,max_vcs-1);
+ SIVAL(outbuf,smb_vwv5,sesskey);
+ SSVAL(outbuf,smb_vwv7,passlen);
+ p = smb_buf(outbuf);
+ memcpy(p,pword,passlen);
+ p += passlen;
+ strcpy(p,username);
+ } else {
+ if (!doencrypt) passlen--;
+ /* for Win95 */
+ set_message(outbuf,13,0,True);
+ CVAL(outbuf,smb_com) = SMBsesssetupX;
+ setup_pkt(outbuf);
+
+ CVAL(outbuf,smb_vwv0) = 0xFF;
+ SSVAL(outbuf,smb_vwv2,BUFFER_SIZE);
+ SSVAL(outbuf,smb_vwv3,2);
+ SSVAL(outbuf,smb_vwv4,getpid());
+ SIVAL(outbuf,smb_vwv5,sesskey);
+ SSVAL(outbuf,smb_vwv7,passlen);
+ SSVAL(outbuf,smb_vwv8,0);
+ p = smb_buf(outbuf);
+ memcpy(p,pword,passlen); p += SVAL(outbuf,smb_vwv7);
+ strcpy(p,username);p = skip_string(p,1);
+ strcpy(p,workgroup);p = skip_string(p,1);
+ strcpy(p,"Unix");p = skip_string(p,1);
+ strcpy(p,"Samba");p = skip_string(p,1);
+ set_message(outbuf,13,PTR_DIFF(p,smb_buf(outbuf)),False);
+ }
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ show_msg(inbuf);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ if (! *pass &&
+ ((CVAL(inbuf,smb_rcls) == ERRDOS &&
+ SVAL(inbuf,smb_err) == ERRnoaccess) ||
+ (CVAL(inbuf,smb_rcls) == ERRSRV &&
+ SVAL(inbuf,smb_err) == ERRbadpw)))
+ {
+ got_pass = False;
+ DEBUG(3,("resending login\n"));
+ goto get_pass;
+ }
+
+ DEBUG(0,("Session setup failed for username=%s myname=%s destname=%s %s\n",
+ username,myname,desthost,smb_errstr(inbuf)));
+ DEBUG(0,("You might find the -U, -W or -n options useful\n"));
+ DEBUG(0,("Sometimes you have to use `-n USERNAME' (particularly with OS/2)\n"));
+ DEBUG(0,("Some servers also insist on uppercase-only passwords\n"));
+ if (was_null)
+ {
+ free(inbuf);
+ free(outbuf);
+ }
+ return(False);
+ }
+
+ if (Protocol >= PROTOCOL_NT1) {
+ char *domain,*os,*lanman;
+ p = smb_buf(inbuf);
+ os = p;
+ lanman = skip_string(os,1);
+ domain = skip_string(lanman,1);
+ if (*domain || *os || *lanman)
+ DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n",domain,os,lanman));
+ }
+
+ /* use the returned uid from now on */
+ if (SVAL(inbuf,smb_uid) != uid)
+ DEBUG(3,("Server gave us a UID of %d. We gave %d\n",
+ SVAL(inbuf,smb_uid),uid));
+ uid = SVAL(inbuf,smb_uid);
+ }
+
+ /* now we've got a connection - send a tcon message */
+ bzero(outbuf,smb_size);
+
+ if (strncmp(service,"\\\\",2) != 0)
+ {
+ DEBUG(0,("\nWarning: Your service name doesn't start with \\\\. This is probably incorrect.\n"));
+ DEBUG(0,("Perhaps try replacing each \\ with \\\\ on the command line?\n\n"));
+ }
+
+
+ again2:
+
+ {
+ int passlen = strlen(pass)+1;
+ fstring pword;
+ strcpy(pword,pass);
+
+#ifdef SMB_PASSWD
+ if (doencrypt && *pass) {
+ passlen=24;
+ SMBencrypt(pass,cryptkey,pword);
+ }
+#endif
+
+ /* if in user level security then don't send a password now */
+ if ((sec_mode & 1)) {
+ strcpy(pword, ""); passlen=1;
+ }
+
+ set_message(outbuf,4,2 + strlen(service) + passlen + strlen(dev),True);
+ CVAL(outbuf,smb_com) = SMBtconX;
+ setup_pkt(outbuf);
+
+ SSVAL(outbuf,smb_vwv0,0xFF);
+ SSVAL(outbuf,smb_vwv3,passlen);
+
+ p = smb_buf(outbuf);
+ memcpy(p,pword,passlen);
+ p += passlen;
+ strcpy(p,service);
+ p = skip_string(p,1);
+ strcpy(p,dev);
+ }
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+
+ /* trying again with a blank password */
+ if (CVAL(inbuf,smb_rcls) != 0 &&
+ (int)strlen(pass) > 0 &&
+ !doencrypt &&
+ Protocol >= PROTOCOL_LANMAN1)
+ {
+ DEBUG(2,("first SMBtconX failed, trying again. %s\n",smb_errstr(inbuf)));
+ strcpy(pass,"");
+ goto again2;
+ }
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("SMBtconX failed. %s\n",smb_errstr(inbuf)));
+ DEBUG(0,("Perhaps you are using the wrong sharename, username or password?\n"));
+ DEBUG(0,("Some servers insist that these be in uppercase\n"));
+ if (was_null)
+ {
+ free(inbuf);
+ free(outbuf);
+ }
+ return(False);
+ }
+
+
+ max_xmit = MIN(max_xmit,BUFFER_SIZE-4);
+ if (max_xmit <= 0)
+ max_xmit = BUFFER_SIZE - 4;
+
+ cnum = SVAL(inbuf,smb_tid);
+
+ DEBUG(3,("Connected with cnum=%d max_xmit=%d\n",cnum,max_xmit));
+
+ if (was_null)
+ {
+ free(inbuf);
+ free(outbuf);
+ }
+ return True;
+}
+
+
+/****************************************************************************
+send a logout command
+****************************************************************************/
+static void send_logout(void )
+{
+ pstring inbuf,outbuf;
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,0,0,True);
+ CVAL(outbuf,smb_com) = SMBtdis;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,SHORT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("SMBtdis failed %s\n",smb_errstr(inbuf)));
+ }
+
+
+#ifdef STATS
+ stats_report();
+#endif
+ exit(0);
+}
+
+
+
+/****************************************************************************
+call a remote api
+****************************************************************************/
+static BOOL call_api(int prcnt,int drcnt,
+ int mprcnt,int mdrcnt,
+ int *rprcnt,int *rdrcnt,
+ char *param,char *data,
+ char **rparam,char **rdata)
+{
+ static char *inbuf=NULL;
+ static char *outbuf=NULL;
+
+ if (!inbuf) inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ if (!outbuf) outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ send_trans_request(outbuf,SMBtrans,"\\PIPE\\LANMAN",0,0,
+ data,param,NULL,
+ drcnt,prcnt,0,
+ mdrcnt,mprcnt,0);
+
+ return (receive_trans_response(inbuf,SMBtrans,
+ rdrcnt,rprcnt,
+ rdata,rparam));
+}
+
+/****************************************************************************
+ send a SMB trans or trans2 request
+ ****************************************************************************/
+static BOOL send_trans_request(char *outbuf,int trans,
+ char *name,int fid,int flags,
+ char *data,char *param,uint16 *setup,
+ int ldata,int lparam,int lsetup,
+ int mdata,int mparam,int msetup)
+{
+ int i;
+ int this_ldata,this_lparam;
+ int tot_data=0,tot_param=0;
+ char *outdata,*outparam;
+ pstring inbuf;
+ char *p;
+
+ this_lparam = MIN(lparam,max_xmit - (500+lsetup*SIZEOFWORD)); /* hack */
+ this_ldata = MIN(ldata,max_xmit - (500+lsetup*SIZEOFWORD+this_lparam));
+
+ bzero(outbuf,smb_size);
+ set_message(outbuf,14+lsetup,0,True);
+ CVAL(outbuf,smb_com) = trans;
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ outparam = smb_buf(outbuf)+(trans==SMBtrans ? strlen(name)+1 : 3);
+ outdata = outparam+this_lparam;
+
+ /* primary request */
+ SSVAL(outbuf,smb_tpscnt,lparam); /* tpscnt */
+ SSVAL(outbuf,smb_tdscnt,ldata); /* tdscnt */
+ SSVAL(outbuf,smb_mprcnt,mparam); /* mprcnt */
+ SSVAL(outbuf,smb_mdrcnt,mdata); /* mdrcnt */
+ SCVAL(outbuf,smb_msrcnt,msetup); /* msrcnt */
+ SSVAL(outbuf,smb_flags,flags); /* flags */
+ SIVAL(outbuf,smb_timeout,0); /* timeout */
+ SSVAL(outbuf,smb_pscnt,this_lparam); /* pscnt */
+ SSVAL(outbuf,smb_psoff,smb_offset(outparam,outbuf)); /* psoff */
+ SSVAL(outbuf,smb_dscnt,this_ldata); /* dscnt */
+ SSVAL(outbuf,smb_dsoff,smb_offset(outdata,outbuf)); /* dsoff */
+ SCVAL(outbuf,smb_suwcnt,lsetup); /* suwcnt */
+ for (i=0;i<lsetup;i++) /* setup[] */
+ SSVAL(outbuf,smb_setup+i*SIZEOFWORD,setup[i]);
+ p = smb_buf(outbuf);
+ if (trans==SMBtrans)
+ strcpy(p,name); /* name[] */
+ else
+ {
+ *p++ = 0; /* put in a null smb_name */
+ *p++ = 'D'; *p++ = ' '; /* this was added because OS/2 does it */
+ }
+ if (this_lparam) /* param[] */
+ memcpy(outparam,param,this_lparam);
+ if (this_ldata) /* data[] */
+ memcpy(outdata,data,this_ldata);
+ set_message(outbuf,14+lsetup, /* wcnt, bcc */
+ PTR_DIFF(outdata+this_ldata,smb_buf(outbuf)),False);
+
+ show_msg(outbuf);
+ send_smb(Client,outbuf);
+
+ if (this_ldata < ldata || this_lparam < lparam)
+ {
+ /* receive interim response */
+ if (!receive_smb(Client,inbuf,SHORT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0)
+ {
+ DEBUG(0,("%s request failed (%s)\n",
+ trans==SMBtrans?"SMBtrans":"SMBtrans2", smb_errstr(inbuf)));
+ return(False);
+ }
+
+ tot_data = this_ldata;
+ tot_param = this_lparam;
+
+ while (tot_data < ldata || tot_param < lparam)
+ {
+ this_lparam = MIN(lparam-tot_param,max_xmit - 500); /* hack */
+ this_ldata = MIN(ldata-tot_data,max_xmit - (500+this_lparam));
+
+ set_message(outbuf,trans==SMBtrans?8:9,0,True);
+ CVAL(outbuf,smb_com) = trans==SMBtrans ? SMBtranss : SMBtranss2;
+
+ outparam = smb_buf(outbuf);
+ outdata = outparam+this_lparam;
+
+ /* secondary request */
+ SSVAL(outbuf,smb_tpscnt,lparam); /* tpscnt */
+ SSVAL(outbuf,smb_tdscnt,ldata); /* tdscnt */
+ SSVAL(outbuf,smb_spscnt,this_lparam); /* pscnt */
+ SSVAL(outbuf,smb_spsoff,smb_offset(outparam,outbuf)); /* psoff */
+ SSVAL(outbuf,smb_spsdisp,tot_param); /* psdisp */
+ SSVAL(outbuf,smb_sdscnt,this_ldata); /* dscnt */
+ SSVAL(outbuf,smb_sdsoff,smb_offset(outdata,outbuf)); /* dsoff */
+ SSVAL(outbuf,smb_sdsdisp,tot_data); /* dsdisp */
+ if (trans==SMBtrans2)
+ SSVAL(outbuf,smb_sfid,fid); /* fid */
+ if (this_lparam) /* param[] */
+ memcpy(outparam,param,this_lparam);
+ if (this_ldata) /* data[] */
+ memcpy(outdata,data,this_ldata);
+ set_message(outbuf,trans==SMBtrans?8:9, /* wcnt, bcc */
+ PTR_DIFF(outdata+this_ldata,smb_buf(outbuf)),False);
+
+ show_msg(outbuf);
+ send_smb(Client,outbuf);
+
+ tot_data += this_ldata;
+ tot_param += this_lparam;
+ }
+ }
+
+ return(True);
+}
+
+/****************************************************************************
+try and browse available connections on a host
+****************************************************************************/
+static BOOL browse_host(BOOL sort)
+{
+#ifdef NOSTRCASECMP
+#define strcasecmp StrCaseCmp
+#endif
+ extern int strcasecmp();
+
+ char *rparam = NULL;
+ char *rdata = NULL;
+ char *p;
+ int rdrcnt,rprcnt;
+ pstring param;
+ int count = -1;
+
+ /* now send a SMBtrans command with api RNetShareEnum */
+ p = param;
+ SSVAL(p,0,0); /* api number */
+ p += 2;
+ strcpy(p,"WrLeh");
+ p = skip_string(p,1);
+ strcpy(p,"B13BWz");
+ p = skip_string(p,1);
+ SSVAL(p,0,1);
+ SSVAL(p,2,BUFFER_SIZE);
+ p += 4;
+
+ if (call_api(PTR_DIFF(p,param),0,
+ 1024,BUFFER_SIZE,
+ &rprcnt,&rdrcnt,
+ param,NULL,
+ &rparam,&rdata))
+ {
+ int res = SVAL(rparam,0);
+ int converter=SVAL(rparam,2);
+ int i;
+ BOOL long_share_name=False;
+
+ if (res == 0)
+ {
+ count=SVAL(rparam,4);
+ p = rdata;
+
+ if (count > 0)
+ {
+ printf("\n\tSharename Type Comment\n");
+ printf("\t--------- ---- -------\n");
+ }
+
+ if (sort)
+ qsort(p,count,20,QSORT_CAST strcasecmp);
+
+ for (i=0;i<count;i++)
+ {
+ char *sname = p;
+ int type = SVAL(p,14);
+ int comment_offset = IVAL(p,16) & 0xFFFF;
+ fstring typestr;
+ *typestr=0;
+
+ switch (type)
+ {
+ case STYPE_DISKTREE:
+ strcpy(typestr,"Disk"); break;
+ case STYPE_PRINTQ:
+ strcpy(typestr,"Printer"); break;
+ case STYPE_DEVICE:
+ strcpy(typestr,"Device"); break;
+ case STYPE_IPC:
+ strcpy(typestr,"IPC"); break;
+ }
+
+ printf("\t%-15.15s%-10.10s%s\n",
+ sname,
+ typestr,
+ comment_offset?rdata+comment_offset-converter:"");
+
+ if (strlen(sname)>8) long_share_name=True;
+
+ p += 20;
+ }
+
+ if (long_share_name) {
+ printf("\nNOTE: There were share names longer than 8 chars.\nOn older clients these may not be accessible or may give browsing errors\n");
+ }
+ }
+ }
+
+ if (rparam) free(rparam);
+ if (rdata) free(rdata);
+
+ return(count>0);
+}
+
+
+/****************************************************************************
+get some server info
+****************************************************************************/
+static void server_info()
+{
+ char *rparam = NULL;
+ char *rdata = NULL;
+ char *p;
+ int rdrcnt,rprcnt;
+ pstring param;
+
+ bzero(param,sizeof(param));
+
+ p = param;
+ SSVAL(p,0,63); /* api number */
+ p += 2;
+ strcpy(p,"WrLh");
+ p = skip_string(p,1);
+ strcpy(p,"zzzBBzz");
+ p = skip_string(p,1);
+ SSVAL(p,0,10); /* level 10 */
+ SSVAL(p,2,1000);
+ p += 6;
+
+ if (call_api(PTR_DIFF(p,param),0,
+ 6,1000,
+ &rprcnt,&rdrcnt,
+ param,NULL,
+ &rparam,&rdata))
+ {
+ int res = SVAL(rparam,0);
+ int converter=SVAL(rparam,2);
+
+ if (res == 0)
+ {
+ p = rdata;
+
+ printf("\nServer=[%s] User=[%s] Workgroup=[%s] Domain=[%s]\n",
+ rdata+SVAL(p,0)-converter,
+ rdata+SVAL(p,4)-converter,
+ rdata+SVAL(p,8)-converter,
+ rdata+SVAL(p,14)-converter);
+ }
+ }
+
+ if (rparam) free(rparam);
+ if (rdata) free(rdata);
+
+ return;
+}
+
+
+/****************************************************************************
+try and browse available connections on a host
+****************************************************************************/
+static BOOL list_servers()
+{
+ char *rparam = NULL;
+ char *rdata = NULL;
+ int rdrcnt,rprcnt;
+ char *p;
+ pstring param;
+ int uLevel = 1;
+ int count = 0;
+
+ /* now send a SMBtrans command with api ServerEnum? */
+ p = param;
+ SSVAL(p,0,0x68); /* api number */
+ p += 2;
+ strcpy(p,"WrLehDO");
+ p = skip_string(p,1);
+
+ strcpy(p,"B16BBDz");
+#if 0
+ strcpy(p,getenv("XX_STR2"));
+#endif
+
+ p = skip_string(p,1);
+ SSVAL(p,0,uLevel);
+ SSVAL(p,2,0x2000); /* buf length */
+ p += 4;
+
+ SIVAL(p,0,SV_TYPE_ALL);
+
+ if (call_api(PTR_DIFF(p+4,param),0,
+ 8,10000,
+ &rprcnt,&rdrcnt,
+ param,NULL,
+ &rparam,&rdata))
+ {
+ int res = SVAL(rparam,0);
+ int converter=SVAL(rparam,2);
+ int i;
+
+ if (res == 0) {
+ char *p2 = rdata;
+ count=SVAL(rparam,4);
+
+ if (count > 0) {
+ printf("\n\nThis machine has a browse list:\n");
+ printf("\n\tServer Comment\n");
+ printf("\t--------- -------\n");
+ }
+
+ for (i=0;i<count;i++) {
+ char *sname = p2;
+ int comment_offset = IVAL(p2,22) & 0xFFFF;
+ printf("\t%-16.16s %s\n",
+ sname,
+ comment_offset?rdata+comment_offset-converter:"");
+
+ p2 += 26;
+ }
+ }
+ }
+
+ if (rparam) {free(rparam); rparam = NULL;}
+ if (rdata) {free(rdata); rdata = NULL;}
+
+ SIVAL(p,0,SV_TYPE_DOMAIN_ENUM);
+
+ if (call_api(PTR_DIFF(p+4,param),0,
+ 8,10000,
+ &rprcnt,&rdrcnt,
+ param,NULL,
+ &rparam,&rdata))
+ {
+ int res = SVAL(rparam,0);
+ int converter=SVAL(rparam,2);
+ int i;
+
+ if (res == 0) {
+ char *p2 = rdata;
+ count=SVAL(rparam,4);
+
+ if (count > 0) {
+ printf("\n\nThis machine has a workgroup list:\n");
+ printf("\n\tWorkgroup Master\n");
+ printf("\t--------- -------\n");
+ }
+
+ for (i=0;i<count;i++) {
+ char *sname = p2;
+ int comment_offset = IVAL(p2,22) & 0xFFFF;
+ printf("\t%-16.16s %s\n",
+ sname,
+ comment_offset?rdata+comment_offset-converter:"");
+
+ p2 += 26;
+ }
+ }
+ }
+
+ if (rparam) free(rparam);
+ if (rdata) free(rdata);
+
+ return(count>0);
+}
+
+
+
+
+void cmd_help();
+
+/* This defines the commands supported by this client */
+struct
+{
+ char *name;
+ void (*fn)();
+ char *description;
+} commands[] =
+{
+ {"ls",cmd_dir,"<mask> list the contents of the current directory"},
+ {"dir",cmd_dir,"<mask> list the contents of the current directory"},
+ {"lcd",cmd_lcd,"[directory] change/report the local current working directory"},
+ {"cd",cmd_cd,"[directory] change/report the remote directory"},
+ {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)"},
+ {"get",cmd_get,"<remote name> [local name] get a file"},
+ {"mget",cmd_mget,"<mask> get all the matching files"},
+ {"put",cmd_put,"<local name> [remote name] put a file"},
+ {"mput",cmd_mput,"<mask> put all matching files"},
+ {"rename",cmd_rename,"<src> <dest> rename some files"},
+ {"more",cmd_more,"<remote name> view a remote file with your pager"},
+ {"mask",cmd_select,"<mask> mask all filenames against this"},
+ {"del",cmd_del,"<mask> delete all matching files"},
+ {"rm",cmd_del,"<mask> delete all matching files"},
+ {"mkdir",cmd_mkdir,"<directory> make a directory"},
+ {"md",cmd_mkdir,"<directory> make a directory"},
+ {"rmdir",cmd_rmdir,"<directory> remove a directory"},
+ {"rd",cmd_rmdir,"<directory> remove a directory"},
+ {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput"},
+ {"recurse",cmd_recurse,"toggle directory recursion for mget and mput"},
+ {"translate",cmd_translate,"toggle text translation for printing"},
+ {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get"},
+ {"print",cmd_print,"<file name> print a file"},
+ {"printmode",cmd_printmode,"<graphics or text> set the print mode"},
+ {"queue",cmd_queue,"show the print queue"},
+ {"cancel",cmd_cancel,"<jobid> cancel a print queue entry"},
+ {"stat",cmd_stat,"<file> get info on a file (experimental!)"},
+ {"quit",send_logout,"logoff the server"},
+ {"q",send_logout,"logoff the server"},
+ {"exit",send_logout,"logoff the server"},
+ {"newer",cmd_newer,"<file> only mget files newer than the specified local file"},
+ {"archive",cmd_archive,"<level>\n0=ignore archive bit\n1=only get archive files\n2=only get archive files and reset archive bit\n3=get all files and reset archive bit"},
+ {"tar",cmd_tar,"tar <c|x>[IXbgNa] current directory to/from <file name>" },
+ {"blocksize",cmd_block,"blocksize <number> (default 20)" },
+ {"tarmode",cmd_tarmode,
+ "<full|inc|reset|noreset> tar's behaviour towards archive bits" },
+ {"setmode",cmd_setmode,"filename <setmode string> change modes of file"},
+ {"help",cmd_help,"[command] give help on a command"},
+ {"?",cmd_help,"[command] give help on a command"},
+ {"!",NULL,"run a shell command on the local system"},
+ {"",NULL,NULL}
+};
+
+
+/*******************************************************************
+ lookup a command string in the list of commands, including
+ abbreviations
+ ******************************************************************/
+static int process_tok(fstring tok)
+{
+ int i = 0, matches = 0;
+ int cmd=0;
+ int tok_len = strlen(tok);
+
+ while (commands[i].fn != NULL)
+ {
+ if (strequal(commands[i].name,tok))
+ {
+ matches = 1;
+ cmd = i;
+ break;
+ }
+ else if (strnequal(commands[i].name, tok, tok_len+1))
+ {
+ matches++;
+ cmd = i;
+ }
+ i++;
+ }
+
+ if (matches == 0)
+ return(-1);
+ else if (matches == 1)
+ return(cmd);
+ else
+ return(-2);
+}
+
+/****************************************************************************
+help
+****************************************************************************/
+void cmd_help(void)
+{
+ int i=0,j;
+ fstring buf;
+
+ if (next_token(NULL,buf,NULL))
+ {
+ if ((i = process_tok(buf)) >= 0)
+ DEBUG(0,("HELP %s:\n\t%s\n\n",commands[i].name,commands[i].description));
+ }
+ else
+ while (commands[i].description)
+ {
+ for (j=0; commands[i].description && (j<5); j++) {
+ DEBUG(0,("%-15s",commands[i].name));
+ i++;
+ }
+ DEBUG(0,("\n"));
+ }
+}
+
+/****************************************************************************
+open the client sockets
+****************************************************************************/
+static BOOL open_sockets(int port )
+{
+ static int last_port;
+ char *host;
+ pstring service2;
+ extern int Client;
+#ifdef USENMB
+ BOOL failed = True;
+#endif
+
+ if (port == 0) port=last_port;
+ last_port=port;
+
+ strupper(service);
+
+ if (*desthost)
+ {
+ host = desthost;
+ }
+ else
+ {
+ strcpy(service2,service);
+ host = strtok(service2,"\\/");
+ if (!host) {
+ DEBUG(0,("Badly formed host name\n"));
+ return(False);
+ }
+ strcpy(desthost,host);
+ }
+
+ DEBUG(3,("Opening sockets\n"));
+
+ if (*myname == 0)
+ {
+ get_myname(myname,NULL);
+ strupper(myname);
+ }
+
+ if (!have_ip)
+ {
+ struct hostent *hp;
+
+ if ((hp = Get_Hostbyname(host))) {
+ putip((char *)&dest_ip,(char *)hp->h_addr);
+ failed = False;
+ } else {
+#ifdef USENMB
+ /* Try and resolve the name with the netbios server */
+ int bcast;
+ pstring hs;
+ struct in_addr ip1, ip2;
+
+ if ((bcast = open_socket_in(SOCK_DGRAM, 0, 3)) != -1) {
+ set_socket_options (bcast, "SO_BROADCAST");
+
+ if (!got_bcast && get_myname(hs, &ip1)) {
+ get_broadcast(&ip1, &bcast_ip, &ip2);
+ }
+
+ if (name_query(bcast, host, 0x20, True, True, bcast_ip, &dest_ip,0)){
+ failed = False;
+ }
+ close (bcast);
+ }
+#endif
+ if (failed) {
+ DEBUG(0,("Get_Hostbyname: Unknown host %s.\n",host));
+ return False;
+ }
+ }
+ }
+
+ Client = open_socket_out(SOCK_STREAM, &dest_ip, port);
+ if (Client == -1)
+ return False;
+
+ DEBUG(3,("Connected\n"));
+
+ set_socket_options(Client,user_socket_options);
+
+ return True;
+}
+
+/****************************************************************************
+wait for keyboard activity, swallowing network packets
+****************************************************************************/
+#ifdef CLIX
+static char wait_keyboard(char *buffer)
+#else
+static void wait_keyboard(char *buffer)
+#endif
+{
+ fd_set fds;
+ int selrtn;
+ struct timeval timeout;
+
+#ifdef CLIX
+ int delay = 0;
+#endif
+
+ while (1)
+ {
+ extern int Client;
+ FD_ZERO(&fds);
+ FD_SET(Client,&fds);
+#ifndef CLIX
+ FD_SET(fileno(stdin),&fds);
+#endif
+
+ timeout.tv_sec = 20;
+ timeout.tv_usec = 0;
+#ifdef CLIX
+ timeout.tv_sec = 0;
+#endif
+ selrtn = sys_select(&fds,&timeout);
+
+#ifndef CLIX
+ if (FD_ISSET(fileno(stdin),&fds))
+ return;
+#else
+ {
+ char ch;
+ int f_flags;
+ int readret;
+
+ f_flags = fcntl(fileno(stdin), F_GETFL, 0);
+ fcntl( fileno(stdin), F_SETFL, f_flags | O_NONBLOCK);
+ readret = read_data( fileno(stdin), &ch, 1);
+ fcntl(fileno(stdin), F_SETFL, f_flags);
+ if (readret == -1)
+ {
+ if (errno != EAGAIN)
+ {
+ /* should crash here */
+ DEBUG(1,("readchar stdin failed\n"));
+ }
+ }
+ else if (readret != 0)
+ {
+ return ch;
+ }
+ }
+#endif
+ if (FD_ISSET(Client,&fds))
+ receive_smb(Client,buffer,0);
+
+#ifdef CLIX
+ delay++;
+ if (delay > 100000)
+ {
+ delay = 0;
+ chkpath("\\",False);
+ }
+#else
+ chkpath("\\",False);
+#endif
+ }
+}
+
+
+/****************************************************************************
+close and open the connection again
+****************************************************************************/
+BOOL reopen_connection(char *inbuf,char *outbuf)
+{
+ static int open_count=0;
+
+ open_count++;
+
+ if (open_count>5) return(False);
+
+ DEBUG(1,("Trying to re-open connection\n"));
+
+ set_message(outbuf,0,0,True);
+ SCVAL(outbuf,smb_com,SMBtdis);
+ SSVAL(outbuf,smb_tid,cnum);
+ setup_pkt(outbuf);
+
+ send_smb(Client,outbuf);
+ receive_smb(Client,inbuf,SHORT_TIMEOUT);
+
+ close_sockets();
+ if (!open_sockets(0)) return(False);
+
+ return(send_login(inbuf,outbuf,True,True));
+}
+
+/****************************************************************************
+ process commands from the client
+****************************************************************************/
+BOOL process(char *base_directory)
+{
+ extern FILE *dbf;
+ pstring line;
+
+ char *InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ char *OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ if ((InBuffer == NULL) || (OutBuffer == NULL))
+ return(False);
+
+ bzero(OutBuffer,smb_size);
+
+ if (!send_login(InBuffer,OutBuffer,True,True))
+ return(False);
+
+ if (*base_directory) do_cd(base_directory);
+
+ while (!feof(stdin))
+ {
+ fstring tok;
+ int i;
+
+ bzero(OutBuffer,smb_size);
+
+ /* display a prompt */
+ DEBUG(1,("smb: %s> ", CNV_LANG(cur_dir)));
+ fflush(dbf);
+
+#ifdef CLIX
+ line[0] = wait_keyboard(InBuffer);
+ /* this might not be such a good idea... */
+ if ( line[0] == EOF)
+ break;
+#else
+ wait_keyboard(InBuffer);
+#endif
+
+ /* and get a response */
+#ifdef CLIX
+ fgets( &line[1],999, stdin);
+#else
+ if (!fgets(line,1000,stdin))
+ break;
+#endif
+
+ /* input language code to internal one */
+ CNV_INPUT (line);
+
+ /* special case - first char is ! */
+ if (*line == '!')
+ {
+ system(line + 1);
+ continue;
+ }
+
+ /* and get the first part of the command */
+ {
+ char *ptr = line;
+ if (!next_token(&ptr,tok,NULL)) continue;
+ }
+
+ if ((i = process_tok(tok)) >= 0)
+ commands[i].fn(InBuffer,OutBuffer);
+ else if (i == -2)
+ DEBUG(0,("%s: command abbreviation ambiguous\n",CNV_LANG(tok)));
+ else
+ DEBUG(0,("%s: command not found\n",CNV_LANG(tok)));
+ }
+
+ send_logout();
+ return(True);
+}
+
+
+/****************************************************************************
+usage on the program
+****************************************************************************/
+void usage(char *pname)
+{
+ DEBUG(0,("Usage: %s service <password> [-p port] [-d debuglevel] [-l log] ",
+ pname));
+
+#ifdef KANJI
+ DEBUG(0,("[-t termcode] "));
+#endif /* KANJI */
+
+ DEBUG(0,("\nVersion %s\n",VERSION));
+ DEBUG(0,("\t-p port listen on the specified port\n"));
+ DEBUG(0,("\t-d debuglevel set the debuglevel\n"));
+ DEBUG(0,("\t-l log basename. Basename for log/debug files\n"));
+ DEBUG(0,("\t-n netbios name. Use this name as my netbios name\n"));
+ DEBUG(0,("\t-N don't ask for a password\n"));
+ DEBUG(0,("\t-P connect to service as a printer\n"));
+ DEBUG(0,("\t-M host send a winpopup message to the host\n"));
+ DEBUG(0,("\t-m max protocol set the max protocol level\n"));
+ DEBUG(0,("\t-L host get a list of shares available on a host\n"));
+ DEBUG(0,("\t-I dest IP use this IP to connect to\n"));
+ DEBUG(0,("\t-E write messages to stderr instead of stdout\n"));
+ DEBUG(0,("\t-U username set the network username\n"));
+ DEBUG(0,("\t-W workgroup set the workgroup name\n"));
+#ifdef KANJI
+ DEBUG(0,("\t-t terminal code terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n"));
+#endif /* KANJI */
+ DEBUG(0,("\t-T<c|x>IXgbNa command line tar\n"));
+ DEBUG(0,("\t-D directory start from directory\n"));
+ DEBUG(0,("\n"));
+}
+
+
+
+/****************************************************************************
+ main program
+****************************************************************************/
+int main(int argc,char *argv[])
+{
+ fstring base_directory;
+ char *pname = argv[0];
+ int port = 139;
+ int opt;
+ extern FILE *dbf;
+ extern char *optarg;
+ extern int optind;
+ pstring query_host;
+ BOOL message = False;
+ extern char tar_type;
+
+ *query_host = 0;
+ *base_directory = 0;
+
+ DEBUGLEVEL = 2;
+
+ setup_logging(pname,True);
+
+ TimeInit();
+ charset_initialise();
+
+ pid = getpid();
+ uid = getuid();
+ gid = getgid();
+ mid = pid + 100;
+ myumask = umask(0);
+ umask(myumask);
+
+ if (getenv("USER"))
+ {
+ strcpy(username,getenv("USER"));
+ strupper(username);
+ }
+
+ if (*username == 0 && getenv("LOGNAME"))
+ {
+ strcpy(username,getenv("LOGNAME"));
+ strupper(username);
+ }
+
+ if (argc < 2)
+ {
+ usage(pname);
+ exit(1);
+ }
+
+ if (*argv[1] != '-')
+ {
+
+ strcpy(service,argv[1]);
+ argc--;
+ argv++;
+
+ if (count_chars(service,'\\') < 3)
+ {
+ usage(pname);
+ printf("\n%s: Not enough '\\' characters in service\n",service);
+ exit(1);
+ }
+
+/*
+ if (count_chars(service,'\\') > 3)
+ {
+ usage(pname);
+ printf("\n%s: Too many '\\' characters in service\n",service);
+ exit(1);
+ }
+ */
+
+ if (argc > 1 && (*argv[1] != '-'))
+ {
+ got_pass = True;
+ strcpy(password,argv[1]);
+ memset(argv[1],'X',strlen(argv[1]));
+ argc--;
+ argv++;
+ }
+ }
+
+#ifdef KANJI
+ setup_term_code (KANJI);
+ while ((opt = getopt (argc, argv, "B:O:M:i:Nn:d:Pp:l:hI:EB:U:L:t:m:W:T:D:")) != EOF)
+#else
+ while ((opt = getopt (argc, argv, "B:O:M:i:Nn:d:Pp:l:hI:EB:U:L:m:W:T:D:")) != EOF)
+#endif /* KANJI */
+ switch (opt)
+ {
+ case 'm':
+ max_protocol = interpret_protocol(optarg,max_protocol);
+ break;
+ case 'O':
+ strcpy(user_socket_options,optarg);
+ break;
+ case 'M':
+ name_type = 3;
+ strcpy(desthost,optarg);
+ strupper(desthost);
+ message = True;
+ break;
+ case 'B':
+ bcast_ip = *interpret_addr2(optarg);
+ got_bcast = True;
+ break;
+ case 'D':
+ strcpy(base_directory,optarg);
+ break;
+ case 'T':
+ if (!tar_parseargs(argc, argv, optarg, optind)) {
+ usage(pname);
+ exit(1);
+ }
+ break;
+ case 'i':
+ strcpy(scope,optarg);
+ break;
+ case 'L':
+ got_pass = True;
+ strcpy(query_host,optarg);
+ break;
+ case 'U':
+ {
+ char *p;
+ strcpy(username,optarg);
+ if ((p=strchr(username,'%')))
+ {
+ *p = 0;
+ strcpy(password,p+1);
+ got_pass = True;
+ memset(strchr(optarg,'%')+1,'X',strlen(password));
+ }
+ }
+
+ break;
+ case 'W':
+ strcpy(workgroup,optarg);
+ break;
+ case 'E':
+ dbf = stderr;
+ break;
+ case 'I':
+ {
+ dest_ip = *interpret_addr2(optarg);
+ if (zero_ip(dest_ip)) exit(1);
+ have_ip = True;
+ }
+ break;
+ case 'n':
+ strcpy(myname,optarg);
+ break;
+ case 'N':
+ got_pass = True;
+ break;
+ case 'P':
+ connect_as_printer = True;
+ break;
+ case 'd':
+ if (*optarg == 'A')
+ DEBUGLEVEL = 10000;
+ else
+ DEBUGLEVEL = atoi(optarg);
+ break;
+ case 'l':
+ sprintf(debugf,"%s.client",optarg);
+ break;
+ case 'p':
+ port = atoi(optarg);
+ break;
+ case 'h':
+ usage(pname);
+ exit(0);
+ break;
+#ifdef KANJI
+ case 't':
+ if (!setup_term_code (optarg)) {
+ DEBUG(0, ("%s: unknown terminal code name\n", optarg));
+ usage (pname);
+ exit (1);
+ }
+ break;
+#endif /* KANJI */
+ default:
+ usage(pname);
+ exit(1);
+ }
+
+ if (!tar_type && !*query_host && !*service && !message)
+ {
+ usage(pname);
+ exit(1);
+ }
+
+
+ DEBUG(3,("%s client started (version %s)\n",timestring(),VERSION));
+
+ get_myname(*myname?NULL:myname,&myip);
+ strupper(myname);
+
+ if (tar_type) {
+ recurse=True;
+
+ if (open_sockets(port)) {
+ char *InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ char *OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ int ret;
+
+ if ((InBuffer == NULL) || (OutBuffer == NULL))
+ return(1);
+
+ bzero(OutBuffer,smb_size);
+ if (!send_login(InBuffer,OutBuffer,True,True))
+ return(False);
+
+ if (*base_directory) do_cd(base_directory);
+
+ ret=process_tar(InBuffer, OutBuffer);
+
+ send_logout();
+ close_sockets();
+ return(ret);
+ } else
+ return(1);
+ }
+
+ if (*query_host)
+ {
+ int ret = 0;
+ sprintf(service,"\\\\%s\\IPC$",query_host);
+ strupper(service);
+ connect_as_ipc = True;
+ if (open_sockets(port))
+ {
+#if 0
+ *username = 0;
+#endif
+ if (!send_login(NULL,NULL,True,True))
+ return(1);
+
+ server_info();
+ if (!browse_host(True)) {
+ sleep(1);
+ browse_host(True);
+ }
+ if (!list_servers()) {
+ sleep(1);
+ list_servers();
+ }
+
+ send_logout();
+ close_sockets();
+ }
+
+ return(ret);
+ }
+
+ if (message)
+ {
+ int ret = 0;
+ if (open_sockets(port))
+ {
+ pstring inbuf,outbuf;
+ bzero(outbuf,smb_size);
+ if (!send_session_request(inbuf,outbuf))
+ return(1);
+
+ send_message(inbuf,outbuf);
+
+ close_sockets();
+ }
+
+ return(ret);
+ }
+
+ if (open_sockets(port))
+ {
+ if (!process(base_directory))
+ {
+ close_sockets();
+ return(1);
+ }
+ close_sockets();
+ }
+ else
+ return(1);
+
+ return(0);
+}
+
+
+/* error code stuff - put together by Merik Karman
+ merik@blackadder.dsh.oz.au */
+
+typedef struct
+{
+ char *name;
+ int code;
+ char *message;
+} err_code_struct;
+
+/* Dos Error Messages */
+err_code_struct dos_msgs[] = {
+ {"ERRbadfunc",1,"Invalid function."},
+ {"ERRbadfile",2,"File not found."},
+ {"ERRbadpath",3,"Directory invalid."},
+ {"ERRnofids",4,"No file descriptors available"},
+ {"ERRnoaccess",5,"Access denied."},
+ {"ERRbadfid",6,"Invalid file handle."},
+ {"ERRbadmcb",7,"Memory control blocks destroyed."},
+ {"ERRnomem",8,"Insufficient server memory to perform the requested function."},
+ {"ERRbadmem",9,"Invalid memory block address."},
+ {"ERRbadenv",10,"Invalid environment."},
+ {"ERRbadformat",11,"Invalid format."},
+ {"ERRbadaccess",12,"Invalid open mode."},
+ {"ERRbaddata",13,"Invalid data."},
+ {"ERR",14,"reserved."},
+ {"ERRbaddrive",15,"Invalid drive specified."},
+ {"ERRremcd",16,"A Delete Directory request attempted to remove the server's current directory."},
+ {"ERRdiffdevice",17,"Not same device."},
+ {"ERRnofiles",18,"A File Search command can find no more files matching the specified criteria."},
+ {"ERRbadshare",32,"The sharing mode specified for an Open conflicts with existing FIDs on the file."},
+ {"ERRlock",33,"A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process."},
+ {"ERRfilexists",80,"The file named in a Create Directory, Make New File or Link request already exists."},
+ {"ERRbadpipe",230,"Pipe invalid."},
+ {"ERRpipebusy",231,"All instances of the requested pipe are busy."},
+ {"ERRpipeclosing",232,"Pipe close in progress."},
+ {"ERRnotconnected",233,"No process on other end of pipe."},
+ {"ERRmoredata",234,"There is more data to be returned."},
+ {"ERRinvgroup",2455,"Invalid workgroup (try the -W option)"},
+ {NULL,-1,NULL}};
+
+/* Server Error Messages */
+err_code_struct server_msgs[] = {
+ {"ERRerror",1,"Non-specific error code."},
+ {"ERRbadpw",2,"Bad password - name/password pair in a Tree Connect or Session Setup are invalid."},
+ {"ERRbadtype",3,"reserved."},
+ {"ERRaccess",4,"The requester does not have the necessary access rights within the specified context for the requested function. The context is defined by the TID or the UID."},
+ {"ERRinvnid",5,"The tree ID (TID) specified in a command was invalid."},
+ {"ERRinvnetname",6,"Invalid network name in tree connect."},
+ {"ERRinvdevice",7,"Invalid device - printer request made to non-printer connection or non-printer request made to printer connection."},
+ {"ERRqfull",49,"Print queue full (files) -- returned by open print file."},
+ {"ERRqtoobig",50,"Print queue full -- no space."},
+ {"ERRqeof",51,"EOF on print queue dump."},
+ {"ERRinvpfid",52,"Invalid print file FID."},
+ {"ERRsmbcmd",64,"The server did not recognize the command received."},
+ {"ERRsrverror",65,"The server encountered an internal error, e.g., system file unavailable."},
+ {"ERRfilespecs",67,"The file handle (FID) and pathname parameters contained an invalid combination of values."},
+ {"ERRreserved",68,"reserved."},
+ {"ERRbadpermits",69,"The access permissions specified for a file or directory are not a valid combination. The server cannot set the requested attribute."},
+ {"ERRreserved",70,"reserved."},
+ {"ERRsetattrmode",71,"The attribute mode in the Set File Attribute request is invalid."},
+ {"ERRpaused",81,"Server is paused."},
+ {"ERRmsgoff",82,"Not receiving messages."},
+ {"ERRnoroom",83,"No room to buffer message."},
+ {"ERRrmuns",87,"Too many remote user names."},
+ {"ERRtimeout",88,"Operation timed out."},
+ {"ERRnoresource",89,"No resources currently available for request."},
+ {"ERRtoomanyuids",90,"Too many UIDs active on this session."},
+ {"ERRbaduid",91,"The UID is not known as a valid ID on this session."},
+ {"ERRusempx",250,"Temp unable to support Raw, use MPX mode."},
+ {"ERRusestd",251,"Temp unable to support Raw, use standard read/write."},
+ {"ERRcontmpx",252,"Continue in MPX mode."},
+ {"ERRreserved",253,"reserved."},
+ {"ERRreserved",254,"reserved."},
+ {"ERRnosupport",0xFFFF,"Function not supported."},
+ {NULL,-1,NULL}};
+
+/* Hard Error Messages */
+err_code_struct hard_msgs[] = {
+ {"ERRnowrite",19,"Attempt to write on write-protected diskette."},
+ {"ERRbadunit",20,"Unknown unit."},
+ {"ERRnotready",21,"Drive not ready."},
+ {"ERRbadcmd",22,"Unknown command."},
+ {"ERRdata",23,"Data error (CRC)."},
+ {"ERRbadreq",24,"Bad request structure length."},
+ {"ERRseek",25 ,"Seek error."},
+ {"ERRbadmedia",26,"Unknown media type."},
+ {"ERRbadsector",27,"Sector not found."},
+ {"ERRnopaper",28,"Printer out of paper."},
+ {"ERRwrite",29,"Write fault."},
+ {"ERRread",30,"Read fault."},
+ {"ERRgeneral",31,"General failure."},
+ {"ERRbadshare",32,"A open conflicts with an existing open."},
+ {"ERRlock",33,"A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process."},
+ {"ERRwrongdisk",34,"The wrong disk was found in a drive."},
+ {"ERRFCBUnavail",35,"No FCBs are available to process request."},
+ {"ERRsharebufexc",36,"A sharing buffer has been exceeded."},
+ {NULL,-1,NULL}};
+
+
+struct
+{
+ int code;
+ char *class;
+ err_code_struct *err_msgs;
+} err_classes[] = {
+ {0,"SUCCESS",NULL},
+ {0x01,"ERRDOS",dos_msgs},
+ {0x02,"ERRSRV",server_msgs},
+ {0x03,"ERRHRD",hard_msgs},
+ {0x04,"ERRXOS",NULL},
+ {0xE1,"ERRRMX1",NULL},
+ {0xE2,"ERRRMX2",NULL},
+ {0xE3,"ERRRMX3",NULL},
+ {0xFF,"ERRCMD",NULL},
+ {-1,NULL,NULL}};
+
+
+/****************************************************************************
+return a SMB error string from a SMB buffer
+****************************************************************************/
+char *smb_errstr(char *inbuf)
+{
+ static pstring ret;
+ int class = CVAL(inbuf,smb_rcls);
+ int num = SVAL(inbuf,smb_err);
+ int i,j;
+
+ for (i=0;err_classes[i].class;i++)
+ if (err_classes[i].code == class)
+ {
+ if (err_classes[i].err_msgs)
+ {
+ err_code_struct *err = err_classes[i].err_msgs;
+ for (j=0;err[j].name;j++)
+ if (num == err[j].code)
+ {
+ if (DEBUGLEVEL > 0)
+ sprintf(ret,"%s - %s (%s)",err_classes[i].class,
+ err[j].name,err[j].message);
+ else
+ sprintf(ret,"%s - %s",err_classes[i].class,err[j].name);
+ return ret;
+ }
+ }
+
+ sprintf(ret,"%s - %d",err_classes[i].class,num);
+ return ret;
+ }
+
+ sprintf(ret,"ERROR: Unknown error (%d,%d)",class,num);
+ return(ret);
+}
git.samba.org / samba.git / commitdiff