diff options
Diffstat (limited to 'source3/client')
| -rw-r--r-- | source3/client/.cvsignore | 0 | ||||
| -rw-r--r-- | source3/client/client.c | 6105 | ||||
| -rw-r--r-- | source3/client/clitar.c | 2035 | ||||
| -rw-r--r-- | source3/client/smbmnt.c | 306 | ||||
| -rw-r--r-- | source3/client/smbmount.c | 883 | ||||
| -rw-r--r-- | source3/client/smbspool.c | 412 | ||||
| -rw-r--r-- | source3/client/smbumount.c | 185 | ||||
| -rw-r--r-- | source3/client/testsmbc.c | 455 | ||||
| -rw-r--r-- | source3/client/tree.c | 811 |
9 files changed, 6382 insertions, 4810 deletions
diff --git a/source3/client/.cvsignore b/source3/client/.cvsignore new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/source3/client/.cvsignore diff --git a/source3/client/client.c b/source3/client/client.c index 504cb5a0bb..1daba28b98 100644 --- a/source3/client/client.c +++ b/source3/client/client.c @@ -1,8 +1,8 @@ /* - Unix SMB/Netbios implementation. - Version 1.9. + Unix SMB/CIFS implementation. SMB client - Copyright (C) Andrew Tridgell 1994-1995 + Copyright (C) Andrew Tridgell 1994-1998 + Copyright (C) Simo Sorce 2001 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 @@ -19,36 +19,40 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#ifdef SYSLOG -#undef SYSLOG -#endif +#define NO_SYSLOG #include "includes.h" -#include "nameserv.h" #ifndef REGISTER #define REGISTER 0 #endif +const char prog_name[] = "smbclient"; + +struct cli_state *cli; +extern BOOL in_client; +extern BOOL AllowDebugChange; +static int port = 0; 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; - +static pstring service; +static pstring desthost; +extern pstring global_myname; +static pstring password; +static pstring username; +static pstring workgroup; +static char *cmdstr; +static BOOL got_pass; +static int io_bufsize = 64512; +static BOOL use_kerberos; + +static int name_type = 0x20; +static int max_protocol = PROTOCOL_NT1; extern pstring user_socket_options; +static int process_tok(fstring tok); +static int cmd_help(void); + /* 30 second timeout on most commands */ #define CLIENT_TIMEOUT (30*1000) #define SHORT_TIMEOUT (5*1000) @@ -56,65 +60,35 @@ extern pstring user_socket_options; /* 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; +static BOOL have_ip; + /* 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; +mode_t myumask = 0755; BOOL prompt = True; int printmode = 1; -BOOL recurse = False; +static 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; @@ -125,269 +99,114 @@ int get_total_time_ms = 0; int put_total_size = 0; int put_total_time_ms = 0; - -extern int Client; +/* totals globals */ +static double dir_total; #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; + 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 (!translation) { + return write(f,b,n); } - if (write(f, b, 1) != 1) - { - break; + + 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++; } - b++; - i++; - } - return(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) +static int readfile(char *b, int n, XFILE *f) { - int i; - int c; + int i; + int c; - if (!translation || (size != 1)) - return(fread(b,size,n,f)); + if (!translation) + return x_fread(b,1,n,f); - i = 0; - while (i < n) - { - if ((c = getc(f)) == EOF) - { - break; - } + i = 0; + while (i < (n - 1) && (i < BUFFER_SIZE)) { + if ((c = x_getc(f)) == EOF) { + break; + } - if (c == '\n') /* change all LFs to CR/LF */ - { - b[i++] = '\r'; - n++; - } + if (c == '\n') { /* change all LFs to CR/LF */ + b[i++] = '\r'; + } - b[i++] = c; - } + b[i++] = c; + } - return(i); + 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) +static void send_message(void) { - int total_len = 0; + int total_len = 0; + int grp_id; - 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 (!cli_message_start(cli, desthost, username, &grp_id)) { + d_printf("message start: %s\n", cli_errstr(cli)); + return; + } - 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); + d_printf("Connected. Type your message, ending it with a Control-D\n"); - 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; - while (!feof(stdin) && total_len < 1600) - { - int maxlen = MIN(1600 - total_len,127); - pstring msg; - int l=0; - int c; + ZERO_ARRAY(msg); - bzero(msg,smb_size); + for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) { + if (c == '\n') + msg[l++] = '\r'; + msg[l] = c; + } - for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) - { - if (c == '\n') - msg[l++] = '\r'; - msg[l] = c; + if (!cli_message_text(cli, msg, l, grp_id)) { + d_printf("SMBsendtxt failed (%s)\n",cli_errstr(cli)); + return; + } + + total_len += l; } - 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 (total_len >= 1600) + d_printf("the message was truncated to 1600 bytes\n"); + else + d_printf("sent %d bytes\n",total_len); - if (!receive_smb(Client,inbuf,SHORT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0) - { - printf("SMBsendtxt failed (%s)\n",smb_errstr(inbuf)); - return; + if (!cli_message_end(cli, grp_id)) { + d_printf("SMBsendend failed (%s)\n",cli_errstr(cli)); + 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; - } } @@ -395,1137 +214,572 @@ static void send_message(char *inbuf,char *outbuf) /**************************************************************************** check the space on a device ****************************************************************************/ -static void do_dskattr(void) +static int do_dskattr(void) { - pstring inbuf,outbuf; + int total, bsize, avail; - 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 (!cli_dskattr(cli, &bsize, &total, &avail)) { + d_printf("Error in dskattr: %s\n",cli_errstr(cli)); + return 1; + } - if (CVAL(inbuf,smb_rcls) != 0) - DEBUG(0,("Error in dskattr: %s\n",smb_errstr(inbuf))); + d_printf("\n\t\t%d blocks of size %d. %d blocks available\n", + total, bsize, avail); - 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))); + return 0; } /**************************************************************************** show cd/pwd ****************************************************************************/ -static void cmd_pwd(void) +static int cmd_pwd(void) { - DEBUG(0,("Current directory is %s",CNV_LANG(service))); - DEBUG(0,("%s\n",CNV_LANG(cur_dir))); + d_printf("Current directory is %s",service); + d_printf("%s\n",cur_dir); + return 0; } /**************************************************************************** change directory - inner section ****************************************************************************/ -static void do_cd(char *newdir) +static int do_cd(char *newdir) { - char *p = newdir; - pstring saved_dir; - pstring dname; + 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); + dos_format(newdir); + + /* Save the current directory in case the + new directory is invalid */ + pstrcpy(saved_dir, cur_dir); + if (*p == '\\') + pstrcpy(cur_dir,p); + else + pstrcat(cur_dir,p); + if (*(cur_dir+strlen(cur_dir)-1) != '\\') { + pstrcat(cur_dir, "\\"); + } + dos_clean_name(cur_dir); + pstrcpy(dname,cur_dir); + pstrcat(cur_dir,"\\"); + dos_clean_name(cur_dir); + + if (!strequal(cur_dir,"\\")) { + if (!cli_chkpath(cli, dname)) { + d_printf("cd %s: %s\n", dname, cli_errstr(cli)); + pstrcpy(cur_dir,saved_dir); + } + } + + pstrcpy(cd_path,cur_dir); + + return 0; } /**************************************************************************** change directory ****************************************************************************/ -static void cmd_cd(char *inbuf,char *outbuf) +static int cmd_cd(void) { - fstring buf; - - if (next_token(NULL,buf,NULL)) - do_cd(buf); - else - DEBUG(0,("Current directory is %s\n",CNV_LANG(cur_dir))); -} + fstring buf; + int rc = 0; + if (next_token_nr(NULL,buf,NULL,sizeof(buf))) + rc = do_cd(buf); + else + d_printf("Current directory is %s\n",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)))); + return rc; } -/**************************************************************************** - 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 (finfo->mode & aDIR) return(True); - if (newer_than && finfo->mtime < newer_than) - return(False); + if (*fileselection && + !mask_match(finfo->name,fileselection,False)) { + DEBUG(3,("match_match %s failed\n", finfo->name)); + return False; + } - if ((archive_level==1 || archive_level==2) && !(finfo->mode & aARCH)) - return(False); + if (newer_than && finfo->mtime < newer_than) { + DEBUG(3,("newer_than %s failed\n", finfo->name)); + return(False); + } - return(True); + if ((archive_level==1 || archive_level==2) && !(finfo->mode & aARCH)) { + DEBUG(3,("archive %s failed\n", finfo->name)); + 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) + display info about a file + ****************************************************************************/ +static void display_finfo(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); + if (do_this_one(finfo)) { + time_t t = finfo->mtime; /* the time is assumed to be passed as GMT */ + d_printf(" %-30s%7.7s %8.0f %s", + finfo->name, + attrib_string(finfo->mode), + (double)finfo->size, + asctime(LocalTime(&t))); + dir_total += finfo->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) + accumulate size of a file + ****************************************************************************/ +static void do_du(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); + if (do_this_one(finfo)) { + dir_total += finfo->size; } - 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)); +static BOOL do_list_recurse; +static BOOL do_list_dirs; +static char *do_list_queue = 0; +static long do_list_queue_size = 0; +static long do_list_queue_start = 0; +static long do_list_queue_end = 0; +static void (*do_list_fn)(file_info *); - /* 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); +/**************************************************************************** +functions for do_list_queue + ****************************************************************************/ + +/* + * The do_list_queue is a NUL-separated list of strings stored in a + * char*. Since this is a FIFO, we keep track of the beginning and + * ending locations of the data in the queue. When we overflow, we + * double the size of the char*. When the start of the data passes + * the midpoint, we move everything back. This is logically more + * complex than a linked list, but easier from a memory management + * angle. In any memory error condition, do_list_queue is reset. + * Functions check to ensure that do_list_queue is non-NULL before + * accessing it. + */ +static void reset_do_list_queue(void) +{ + SAFE_FREE(do_list_queue); + do_list_queue_size = 0; + do_list_queue_start = 0; + do_list_queue_end = 0; +} + +static void init_do_list_queue(void) +{ + reset_do_list_queue(); + do_list_queue_size = 1024; + do_list_queue = malloc(do_list_queue_size); + if (do_list_queue == 0) { + d_printf("malloc fail for size %d\n", + (int)do_list_queue_size); + reset_do_list_queue(); + } else { + memset(do_list_queue, 0, do_list_queue_size); } - return(SVAL(p,4)+4); +} - case 4: - if (finfo) +static void adjust_do_list_queue(void) +{ + /* + * If the starting point of the queue is more than half way through, + * move everything toward the beginning. + */ + if (do_list_queue && (do_list_queue_start == do_list_queue_end)) { - /* 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); + DEBUG(4,("do_list_queue is empty\n")); + do_list_queue_start = do_list_queue_end = 0; + *do_list_queue = '\0'; } - return(SVAL(p,4)+4); - - case 260: /* NT uses this, but also accepts 2 */ - if (finfo) + else if (do_list_queue_start > (do_list_queue_size / 2)) { - 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); + DEBUG(4,("sliding do_list_queue backward\n")); + memmove(do_list_queue, + do_list_queue + do_list_queue_start, + do_list_queue_end - do_list_queue_start); + do_list_queue_end -= do_list_queue_start; + do_list_queue_start = 0; } - 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) +static void add_to_do_list_queue(const char* entry) { - - 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)) + char *dlq; + long new_end = do_list_queue_end + ((long)strlen(entry)) + 1; + while (new_end > do_list_queue_size) { - 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); + do_list_queue_size *= 2; + DEBUG(4,("enlarging do_list_queue to %d\n", + (int)do_list_queue_size)); + dlq = Realloc(do_list_queue, do_list_queue_size); + if (! dlq) { + d_printf("failure enlarging do_list_queue to %d bytes\n", + (int)do_list_queue_size); + reset_do_list_queue(); + } + else + { + do_list_queue = dlq; + memset(do_list_queue + do_list_queue_size / 2, + 0, do_list_queue_size / 2); + } } - else + if (do_list_queue) { - if (fn && do_this_one(finfo)) - fn(finfo); + pstrcpy(do_list_queue + do_list_queue_end, entry); + do_list_queue_end = new_end; + DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n", + entry, (int)do_list_queue_start, (int)do_list_queue_end)); } - } } - -/**************************************************************************** - 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) +static char *do_list_queue_head(void) { - 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); + return do_list_queue + do_list_queue_start; +} - 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 +static void remove_do_list_queue_head(void) +{ + if (do_list_queue_end > do_list_queue_start) { - SSVAL(p,0,21); - p += 2; - memcpy(p,status,21); + do_list_queue_start += strlen(do_list_queue_head()) + 1; + adjust_do_list_queue(); + DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n", + (int)do_list_queue_start, (int)do_list_queue_end)); } +} - 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); +static int do_list_queue_empty(void) +{ + return (! (do_list_queue && *do_list_queue)); } /**************************************************************************** - receive a SMB trans or trans2 response allocating the necessary memory +a helper for do_list ****************************************************************************/ -static BOOL receive_trans_response(char *inbuf,int trans, - int *data_len,int *param_len, - char **data,char **param) +static void do_list_helper(file_info *f, const char *mask, void *state) { - 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 (f->mode & aDIR) { + if (do_list_dirs && do_this_one(f)) { + do_list_fn(f); + } + if (do_list_recurse && + !strequal(f->name,".") && + !strequal(f->name,"..")) { + pstring mask2; + char *p; + + pstrcpy(mask2, mask); + p = strrchr_m(mask2,'\\'); + if (!p) return; + p[1] = 0; + pstrcat(mask2, f->name); + pstrcat(mask2,"\\*"); + add_to_do_list_queue(mask2); + } + return; + } + + if (do_this_one(f)) { + do_list_fn(f); } - 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 +a wrapper around cli_list that adds recursion ****************************************************************************/ -static int do_long_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir) +void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),BOOL rec, BOOL dirs) { - 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; - } + static int in_do_list = 0; - 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 + if (in_do_list && rec) { - 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)); + fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n"); + exit(1); } - /* ??? 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); + in_do_list = 1; - 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; - } + do_list_recurse = rec; + do_list_dirs = dirs; + do_list_fn = fn; - /* parse out some important return info */ - p = resp_param; - if (First) + if (rec) { - ff_dir_handle = SVAL(p,0); - ff_searchcount = SVAL(p,2); - ff_eos = SVAL(p,4); - ff_lastname = SVAL(p,8); + init_do_list_queue(); + add_to_do_list_queue(mask); + + while (! do_list_queue_empty()) + { + /* + * Need to copy head so that it doesn't become + * invalid inside the call to cli_list. This + * would happen if the list were expanded + * during the call. + * Fix from E. Jay Berkenbilt (ejb@ql.org) + */ + pstring head; + pstrcpy(head, do_list_queue_head()); + cli_list(cli, head, attribute, do_list_helper, NULL); + remove_do_list_queue_head(); + if ((! do_list_queue_empty()) && (fn == display_finfo)) + { + char* next_file = do_list_queue_head(); + char* save_ch = 0; + if ((strlen(next_file) >= 2) && + (next_file[strlen(next_file) - 1] == '*') && + (next_file[strlen(next_file) - 2] == '\\')) + { + save_ch = next_file + + strlen(next_file) - 2; + *save_ch = '\0'; + } + d_printf("\n%s\n",next_file); + if (save_ch) + { + *save_ch = '\\'; + } + } + } } - else + else { - ff_searchcount = SVAL(p,0); - ff_eos = SVAL(p,2); - ff_lastname = SVAL(p,6); + if (cli_list(cli, mask, attribute, do_list_helper, NULL) == -1) + { + d_printf("%s listing %s\n", cli_errstr(cli), mask); + } } - if (ff_searchcount == 0) - break; - - /* point to the data bytes */ - p = resp_data; + in_do_list = 0; + reset_do_list_queue(); +} - /* 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; - } +/**************************************************************************** + get a directory listing + ****************************************************************************/ +static int cmd_dir(void) +{ + uint16 attribute = aDIR | aSYSTEM | aHIDDEN; + pstring mask; + fstring buf; + char *p=buf; + int rc; + + dir_total = 0; + pstrcpy(mask,cur_dir); + if(mask[strlen(mask)-1]!='\\') + pstrcat(mask,"\\"); + + if (next_token_nr(NULL,buf,NULL,sizeof(buf))) { + dos_format(p); + if (*p == '\\') + pstrcpy(mask,p); + else + pstrcat(mask,p); } - 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; + else { + pstrcat(mask,"*"); } - /* 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); + do_list(mask, attribute, display_finfo, recurse, True); + + rc = do_dskattr(); + + DEBUG(3, ("Total bytes listed: %.0f\n", dir_total)); + + return rc; } /**************************************************************************** get a directory listing ****************************************************************************/ -static void cmd_dir(char *inbuf,char *outbuf) +static int cmd_du(void) { - 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(); -} + uint16 attribute = aDIR | aSYSTEM | aHIDDEN; + pstring mask; + fstring buf; + char *p=buf; + int rc; + + dir_total = 0; + pstrcpy(mask,cur_dir); + if(mask[strlen(mask)-1]!='\\') + pstrcat(mask,"\\"); + + if (next_token_nr(NULL,buf,NULL,sizeof(buf))) { + dos_format(p); + if (*p == '\\') + pstrcpy(mask,p); + else + pstrcat(mask,p); + } else { + pstrcat(mask,"*"); + } + + do_list(mask, attribute, do_du, recurse, True); + + rc = do_dskattr(); + + d_printf("Total number of bytes: %.0f\n", dir_total); + return rc; +} /**************************************************************************** get a file from rname to lname ****************************************************************************/ -static void do_get(char *rname,char *lname,file_info *finfo1) +static int do_get(char *rname,char *lname) { - 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; + int handle=0,fnum; + BOOL newhandle = False; + char *data; + struct timeval tp_start; + int read_size = io_bufsize; + uint16 attr; + size_t size; + off_t nread = 0; + int rc = 0; + + GetTimeOfDay(&tp_start); + + if (lowercase) { + strlower(lname); } - 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 */ + fnum = cli_open(cli, rname, O_RDONLY, DENY_NONE); + + if (fnum == -1) { + d_printf("%s opening remote file %s\n",cli_errstr(cli),rname); + return 1; + } - /* we might have already read some data from a chained readX */ - if (dataptr && datalen>0) - method=3; + if(!strcmp(lname,"-")) { + handle = fileno(stdout); + } else { + handle = sys_open(lname,O_WRONLY|O_CREAT|O_TRUNC,0644); + newhandle = True; + } + if (handle < 0) { + d_printf("Error opening local file %s\n",lname); + return 1; + } - /* 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 (!cli_qfileinfo(cli, fnum, + &attr, &size, NULL, NULL, NULL, NULL, NULL) && + !cli_getattrE(cli, fnum, + &attr, &size, NULL, NULL, NULL)) { + d_printf("getattrib: %s\n",cli_errstr(cli)); + return 1; + } - /* if we can then use readX */ - if (method<0 && (Protocol >= PROTOCOL_LANMAN1)) - method = 2; + DEBUG(2,("getting file %s of size %.0f as %s ", + lname, (double)size, lname)); - 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(!(data = (char *)malloc(read_size))) { + d_printf("malloc fail for size %d\n", read_size); + cli_close(cli, fnum); + return 1; } + + while (1) { + int n = cli_read(cli, fnum, data, nread, read_size); + + if (n <= 0) break; - if (writefile(handle,dataptr,datalen) != datalen) - { - DEBUG(0,("Error writing local file\n")); - break; - } + if (writefile(handle,data, n) != n) { + d_printf("Error writing local file\n"); + rc = 1; + break; + } - nread += datalen; - if (datalen == 0) - { - DEBUG(0,("Error reading file %s. Got %d bytes\n",CNV_LANG(rname),nread)); - break; + nread += n; } - dataptr=NULL; - datalen=0; - } + if (nread < size) { + DEBUG (0, ("Short read when getting file %s. Only got %ld bytes.\n", + rname, (long)nread)); + rc = 1; + } + SAFE_FREE(data); + + if (!cli_close(cli, fnum)) { + d_printf("Error %s closing remote file\n",cli_errstr(cli)); + rc = 1; + } + + if (newhandle) { + close(handle); + } + + if (archive_level >= 2 && (attr & aARCH)) { + cli_setatr(cli, rname, attr & ~(uint16)aARCH, 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; + 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 += nread; + + DEBUG(2,("(%3.1f kb/s) (average %3.1f kb/s)\n", + nread / (1.024*this_time + 1.0e-4), + get_total_size / (1.024*get_total_time_ms))); } - } - - 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); + + return rc; } /**************************************************************************** get a file ****************************************************************************/ -static void cmd_get(void) +static int cmd_get(void) { - pstring lname; - pstring rname; - char *p; - - strcpy(rname,cur_dir); - strcat(rname,"\\"); + pstring lname; + pstring rname; + char *p; - 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); + pstrcpy(rname,cur_dir); + pstrcat(rname,"\\"); + + p = rname + strlen(rname); + + if (!next_token_nr(NULL,p,NULL,sizeof(rname)-strlen(rname))) { + d_printf("get <filename>\n"); + return 1; + } + pstrcpy(lname,p); + dos_clean_name(rname); + + next_token_nr(NULL,lname,NULL,sizeof(lname)); + + return do_get(rname, lname); } @@ -1534,110 +788,105 @@ static void cmd_get(void) ****************************************************************************/ static void do_mget(file_info *finfo) { - pstring rname; - pstring quest; + pstring rname; + pstring quest; + pstring saved_curdir; + pstring mget_mask; - if (strequal(finfo->name,".") || strequal(finfo->name,"..")) - return; + 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 (abort_mget) { + d_printf("mget aborted\n"); + return; + } - if (finfo->mode & aDIR) - { - pstring saved_curdir; - pstring mget_mask; - char *inbuf,*outbuf; + if (finfo->mode & aDIR) + slprintf(quest,sizeof(pstring)-1, + "Get directory %s? ",finfo->name); + else + slprintf(quest,sizeof(pstring)-1, + "Get file %s? ",finfo->name); - inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); - outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); + if (prompt && !yesno(quest)) return; - if (!inbuf || !outbuf) - { - DEBUG(0,("out of memory\n")); - return; + if (!(finfo->mode & aDIR)) { + pstrcpy(rname,cur_dir); + pstrcat(rname,finfo->name); + do_get(rname,finfo->name); + return; } - strcpy(saved_curdir,cur_dir); + /* handle directories */ + pstrcpy(saved_curdir,cur_dir); - strcat(cur_dir,finfo->name); - strcat(cur_dir,"\\"); + pstrcat(cur_dir,finfo->name); + pstrcat(cur_dir,"\\"); - unix_format(finfo->name); - { + unix_format(finfo->name); if (lowercase) - strlower(finfo->name); - + 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); - } + mkdir(finfo->name,0777) != 0) { + d_printf("failed to create directory %s\n",finfo->name); + pstrcpy(cur_dir,saved_curdir); + return; + } + + if (chdir(finfo->name) != 0) { + d_printf("failed to chdir to directory %s\n",finfo->name); + pstrcpy(cur_dir,saved_curdir); + return; + } + + pstrcpy(mget_mask,cur_dir); + pstrcat(mget_mask,"*"); + + do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,False, True); + chdir(".."); + pstrcpy(cur_dir,saved_curdir); } + /**************************************************************************** view the file using the pager ****************************************************************************/ -static void cmd_more(void) +static int 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); + fstring rname,lname,pager_cmd; + char *pager; + int fd; + int rc = 0; + + fstrcpy(rname,cur_dir); + fstrcat(rname,"\\"); + + slprintf(lname,sizeof(lname)-1, "%s/smbmore.XXXXXX",tmpdir()); + fd = smb_mkstemp(lname); + if (fd == -1) { + d_printf("failed to create temporary file for more\n"); + return 1; + } + close(fd); + + if (!next_token_nr(NULL,rname+strlen(rname),NULL,sizeof(rname)-strlen(rname))) { + d_printf("more <filename>\n"); + unlink(lname); + return 1; + } + dos_clean_name(rname); + + rc = do_get(rname,lname); + + pager=getenv("PAGER"); + + slprintf(pager_cmd,sizeof(pager_cmd)-1, + "%s %s",(pager? pager:PAGER), lname); + system(pager_cmd); + unlink(lname); + + return rc; } @@ -1645,2082 +894,1127 @@ static void cmd_more(void) /**************************************************************************** do a mget command ****************************************************************************/ -static void cmd_mget(char *inbuf,char *outbuf) +static int cmd_mget(void) { - 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); - } + uint16 attribute = aSYSTEM | aHIDDEN; + pstring mget_mask; + fstring buf; + char *p=buf; + + *mget_mask = 0; + + if (recurse) + attribute |= aDIR; + + abort_mget = False; + + while (next_token_nr(NULL,p,NULL,sizeof(buf))) { + pstrcpy(mget_mask,cur_dir); + if(mget_mask[strlen(mget_mask)-1]!='\\') + pstrcat(mget_mask,"\\"); + + if (*p == '\\') + pstrcpy(mget_mask,p); + else + pstrcat(mget_mask,p); + do_list(mget_mask, attribute,do_mget,False,True); + } + + if (!*mget_mask) { + pstrcpy(mget_mask,cur_dir); + if(mget_mask[strlen(mget_mask)-1]!='\\') + pstrcat(mget_mask,"\\"); + pstrcat(mget_mask,"*"); + do_list(mget_mask, attribute,do_mget,False,True); + } + + return 0; } + /**************************************************************************** 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); + if (!cli_mkdir(cli, name)) { + d_printf("%s making remote directory %s\n", + cli_errstr(cli),name); + return(False); + } - - 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))); + return(True); +} - free(inbuf);free(outbuf); - return(False); - } +/**************************************************************************** +show 8.3 name of a file +****************************************************************************/ +static BOOL do_altname(char *name) +{ + fstring altname; + if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) { + d_printf("%s getting alt name for %s\n", + cli_errstr(cli),name); + return(False); + } + d_printf("%s\n", altname); - free(inbuf);free(outbuf); - return(True); + return(True); } /**************************************************************************** - make a directory - ****************************************************************************/ -static void cmd_mkdir(char *inbuf,char *outbuf) + Exit client. +****************************************************************************/ +static int cmd_quit(void) { - 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); + cli_shutdown(cli); + exit(0); + /* NOTREACHED */ + return 0; } -/******************************************************************* - write to a file using writebraw - ********************************************************************/ -static int smb_writeraw(char *outbuf,int fnum,int pos,char *buf,int n) +/**************************************************************************** + make a directory + ****************************************************************************/ +static int cmd_mkdir(void) { - 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); + pstring mask; + fstring buf; + char *p=buf; - if (!receive_smb(Client,inbuf,CLIENT_TIMEOUT) || CVAL(inbuf,smb_rcls) != 0) - return(0); - - _smb_setlen(buf-4,n); /* HACK! XXXX */ + pstrcpy(mask,cur_dir); - if (write_socket(Client,buf-4,n+4) != n+4) - return(0); + if (!next_token_nr(NULL,p,NULL,sizeof(buf))) { + if (!recurse) + d_printf("mkdir <dirname>\n"); + return 1; + } + pstrcat(mask,p); - 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)); + if (recurse) { + pstring ddir; + pstring ddir2; + *ddir2 = 0; + + pstrcpy(ddir,mask); + trim_string(ddir,".",NULL); + p = strtok(ddir,"/\\"); + while (p) { + pstrcat(ddir2,p); + if (!cli_chkpath(cli, ddir2)) { + do_mkdir(ddir2); + } + pstrcat(ddir2,"\\"); + p = strtok(NULL,"/\\"); + } + } else { + do_mkdir(mask); + } + + return 0; } - -/******************************************************************* - write to a file - ********************************************************************/ -static int smb_writefile(char *outbuf,int fnum,int pos,char *buf,int n) +/**************************************************************************** + show alt name + ****************************************************************************/ +static int cmd_altname(void) { - 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); + pstring name; + fstring buf; + char *p=buf; + + pstrcpy(name,cur_dir); - memcpy(smb_buf(outbuf)+3,buf,n); + if (!next_token_nr(NULL,p,NULL,sizeof(buf))) { + d_printf("altname <file>\n"); + return 1; + } + pstrcat(name,p); - send_smb(Client,outbuf); - receive_smb(Client,inbuf,CLIENT_TIMEOUT); + do_altname(name); - if (CVAL(inbuf,smb_rcls) != 0) { - DEBUG(0,("%s writing remote file\n",smb_errstr(inbuf))); - return(0); - } - return(SVAL(inbuf,smb_vwv0)); + return 0; } - /**************************************************************************** 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); +static int do_put(char *rname,char *lname) +{ + int fnum; + XFILE *f; + int nread=0; + char *buf=NULL; + int maxwrite=io_bufsize; + int rc = 0; + + struct timeval tp_start; + GetTimeOfDay(&tp_start); + + fnum = cli_open(cli, rname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE); - if (CVAL(inbuf,smb_rcls) != 0) - { - DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),CNV_LANG(rname))); + if (fnum == -1) { + d_printf("%s opening remote file %s\n",cli_errstr(cli),rname); + return 1; + } - free(inbuf);free(outbuf);if (buf) free(buf); - return; - } + /* allow files to be piped into smbclient + jdblair 24.jun.98 - f = fopen(lname,"r"); + Note that in this case this function will exit(0) rather + than returning. */ + if (!strcmp(lname, "-")) { + f = x_stdin; + /* size of file is not known */ + } else { + f = x_fopen(lname,O_RDONLY, 0); + } - if (!f) - { - DEBUG(0,("Error opening local file %s\n",lname)); - free(inbuf);free(outbuf); - return; - } + if (!f) { + d_printf("Error opening local file %s\n",lname); + return 1; + } - fnum = SVAL(inbuf,smb_vwv0); - if (finfo->size < 0) - finfo->size = file_size(lname); + DEBUG(1,("putting file %s as %s ",lname, + rname)); - 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); + buf = (char *)malloc(maxwrite); + if (!buf) { + d_printf("ERROR: Not enough memory!\n"); + return 1; + } + while (!x_feof(f)) { + int n = maxwrite; + int ret; - while (nread < finfo->size) - { - int n = maxwrite; - int ret; + if ((n = readfile(buf,n,f)) < 1) { + if((n == 0) && x_feof(f)) + break; /* Empty local file. */ - n = MIN(n,finfo->size - nread); + d_printf("Error reading local file: %s\n", strerror(errno)); + rc = 1; + break; + } - 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 = cli_write(cli, fnum, 0, buf, nread, n); - ret = smb_writefile(outbuf,fnum,nread,buf+4,n); + if (n != ret) { + d_printf("Error writing file: %s\n", cli_errstr(cli)); + rc = 1; + break; + } - if (n != ret) { - if (!maxwrite) { - DEBUG(0,("Error writing file\n")); - break; - } else { - maxwrite /= 2; - continue; + nread += n; } - } - - 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); + if (!cli_close(cli, fnum)) { + d_printf("%s closing remote file %s\n",cli_errstr(cli),rname); + x_fclose(f); + SAFE_FREE(buf); + return 1; + } - SSVAL(outbuf,smb_vwv0,fnum); - put_dos_date3(outbuf,smb_vwv1,close_time); + + x_fclose(f); + SAFE_FREE(buf); - 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; - } + { + 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 += nread; + + DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n", + nread / (1.024*this_time + 1.0e-4), + put_total_size / (1.024*put_total_time_ms))); + } - - 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))); - } -} + if (f == x_stdin) { + cli_shutdown(cli); + exit(0); + } + + return rc; +} /**************************************************************************** put a file ****************************************************************************/ -static void cmd_put(void) +static int cmd_put(void) { - pstring lname; - pstring rname; - fstring buf; - char *p=buf; - file_info finfo; - finfo = def_finfo; - - strcpy(rname,cur_dir); - strcat(rname,"\\"); - + pstring lname; + pstring rname; + fstring buf; + char *p=buf; + + pstrcpy(rname,cur_dir); + pstrcat(rname,"\\"); - if (!next_token(NULL,p,NULL)) - { - DEBUG(0,("put <filename>\n")); - return; - } - strcpy(lname,p); + if (!next_token_nr(NULL,p,NULL,sizeof(buf))) { + d_printf("put <filename>\n"); + return 1; + } + pstrcpy(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); + if (next_token_nr(NULL,p,NULL,sizeof(buf))) + pstrcat(rname,p); + else + pstrcat(rname,lname); + + dos_clean_name(rname); + + { + SMB_STRUCT_STAT st; + /* allow '-' to represent stdin + jdblair, 24.jun.98 */ + if (!file_exist(lname,&st) && + (strcmp(lname,"-"))) { + d_printf("%s does not exist\n",lname); + return 1; + } + } + + return do_put(rname,lname); +} + +/************************************* + File list structure +*************************************/ + +static struct file_list { + struct file_list *prev, *next; + char *file_path; + BOOL isdir; +} *file_list; + +/**************************************************************************** + Free a file_list structure +****************************************************************************/ + +static void free_file_list (struct file_list * list) +{ + struct file_list *tmp; + + while (list) + { + tmp = list; + DLIST_REMOVE(list, list); + SAFE_FREE(tmp->file_path); + SAFE_FREE(tmp); + } } /**************************************************************************** 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) +static BOOL seek_list(struct file_list *list, 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); + while (list) { + trim_string(list->file_path,"./","\n"); + if (strncmp(list->file_path, name, strlen(name)) != 0) { + return(True); + } + list = list->next; } - } - return(False); + return(False); } - /**************************************************************************** set the file selection mask ****************************************************************************/ -static void cmd_select(void) +static int cmd_select(void) { - strcpy(fileselection,""); - next_token(NULL,fileselection,NULL); + pstrcpy(fileselection,""); + next_token_nr(NULL,fileselection,NULL,sizeof(fileselection)); + + return 0; } +/**************************************************************************** + Recursive file matching function act as find + match must be always set to True when calling this function +****************************************************************************/ +static int file_find(struct file_list **list, const char *directory, + const char *expression, BOOL match) +{ + DIR *dir; + struct file_list *entry; + struct stat statbuf; + int ret; + char *path; + BOOL isdir; + char *dname; + + dir = opendir(directory); + if (!dir) return -1; + + while ((dname = readdirname(dir))) { + if (!strcmp("..", dname)) continue; + if (!strcmp(".", dname)) continue; + + if (asprintf(&path, "%s/%s", directory, dname) <= 0) { + continue; + } + + isdir = False; + if (!match || !gen_fnmatch(expression, dname)) { + if (recurse) { + ret = stat(path, &statbuf); + if (ret == 0) { + if (S_ISDIR(statbuf.st_mode)) { + isdir = True; + ret = file_find(list, path, expression, False); + } + } else { + d_printf("file_find: cannot stat file %s\n", path); + } + + if (ret == -1) { + SAFE_FREE(path); + closedir(dir); + return -1; + } + } + entry = (struct file_list *) malloc(sizeof (struct file_list)); + if (!entry) { + d_printf("Out of memory in file_find\n"); + closedir(dir); + return -1; + } + entry->file_path = path; + entry->isdir = isdir; + DLIST_ADD(*list, entry); + } else { + SAFE_FREE(path); + } + } + + closedir(dir); + return 0; +} /**************************************************************************** mput some files ****************************************************************************/ -static void cmd_mput(void) +static int 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: + fstring buf; + char *p=buf; + + while (next_token_nr(NULL,p,NULL,sizeof(buf))) { + int ret; + struct file_list *temp_list; + char *quest, *lname, *rname; + + file_list = NULL; - /* 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; + ret = file_find(&file_list, ".", p, True); + if (ret) { + free_file_list(file_list); + continue; } - - strcpy(rname,cur_dir); - strcat(rname,lname); - if (!do_mkdir(rname)) - { - strcat(lname,"/"); - if (!seek_list(f,lname)) - break; - goto again1; + + quest = NULL; + lname = NULL; + rname = NULL; + + for (temp_list = file_list; temp_list; + temp_list = temp_list->next) { + + SAFE_FREE(lname); + if (asprintf(&lname, "%s/", temp_list->file_path) <= 0) + continue; + trim_string(lname, "./", "/"); + + /* check if it's a directory */ + if (temp_list->isdir) { + /* if (!recurse) continue; */ + + SAFE_FREE(quest); + if (asprintf(&quest, "Put directory %s? ", lname) < 0) break; + if (prompt && !yesno(quest)) { /* No */ + /* Skip the directory */ + lname[strlen(lname)-1] = '/'; + if (!seek_list(temp_list, lname)) + break; + } else { /* Yes */ + SAFE_FREE(rname); + if(asprintf(&rname, "%s%s", cur_dir, lname) < 0) break; + dos_format(rname); + if (!cli_chkpath(cli, rname) && + !do_mkdir(rname)) { + DEBUG (0, ("Unable to make dir, skipping...")); + /* Skip the directory */ + lname[strlen(lname)-1] = '/'; + if (!seek_list(temp_list, lname)) + break; + } + } + continue; + } else { + SAFE_FREE(quest); + if (asprintf(&quest,"Put file %s? ", lname) < 0) break; + if (prompt && !yesno(quest)) /* No */ + continue; + + /* Yes */ + SAFE_FREE(rname); + if (asprintf(&rname, "%s%s", cur_dir, lname) < 0) break; + } + + dos_format(rname); + + do_put(rname, lname); } - - 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); + free_file_list(file_list); + SAFE_FREE(quest); + SAFE_FREE(lname); + SAFE_FREE(rname); } - 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; + return 0; } /**************************************************************************** cancel a print job ****************************************************************************/ -static void cmd_cancel(char *inbuf,char *outbuf ) +static int do_cancel(int job) { - 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)); + if (cli_printjob_del(cli, job)) { + d_printf("Job %d cancelled\n",job); + return 0; + } else { + d_printf("Error cancelling job %d : %s\n",job,cli_errstr(cli)); + return 1; + } } /**************************************************************************** - get info on a file + cancel a print job ****************************************************************************/ -static void cmd_stat(char *inbuf,char *outbuf) +static int cmd_cancel(void) { - 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; + fstring buf; + int job; + + if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) { + d_printf("cancel <jobid> ...\n"); + return 1; + } + do { + job = atoi(buf); + do_cancel(job); + } while (next_token_nr(NULL,buf,NULL,sizeof(buf))); + + return 0; } /**************************************************************************** print a file ****************************************************************************/ -static void cmd_print(char *inbuf,char *outbuf ) +static int cmd_print(void) { - 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; - } + pstring lname; + pstring rname; + char *p; - - 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; + if (!next_token_nr(NULL,lname,NULL, sizeof(lname))) { + d_printf("print <filename>\n"); + return 1; } - 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; + pstrcpy(rname,lname); + p = strrchr_m(rname,'/'); + if (p) { + slprintf(rname, sizeof(rname)-1, "%s-%d", p+1, (int)sys_getpid()); } - nread += n; - } - - DEBUG(2,("%d bytes printed\n",nread)); + if (strequal(lname,"-")) { + slprintf(rname, sizeof(rname)-1, "stdin-%d", (int)sys_getpid()); + } - bzero(outbuf,smb_size); - set_message(outbuf,1,0,True); - CVAL(outbuf,smb_com) = SMBsplclose; - SSVAL(outbuf,smb_tid,cnum); - setup_pkt(outbuf); + return do_put(rname, lname); +} - 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); +/**************************************************************************** + show a print queue entry +****************************************************************************/ +static void queue_fn(struct print_job_info *p) +{ + d_printf("%-6d %-9d %s\n", (int)p->id, (int)p->size, p->name); } /**************************************************************************** -print a file + show a print queue ****************************************************************************/ -static void cmd_queue(char *inbuf,char *outbuf ) +static int cmd_queue(void) { - 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; - } - } - + cli_print_queue(cli, queue_fn); + + return 0; } - /**************************************************************************** delete some files ****************************************************************************/ static void do_del(file_info *finfo) { - char *p; - char *inbuf,*outbuf; - pstring mask; + pstring mask; - strcpy(mask,cur_dir); - strcat(mask,finfo->name); + pstrcpy(mask,cur_dir); + pstrcat(mask,finfo->name); - if (finfo->mode & aDIR) - return; + 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); + if (!cli_unlink(cli, mask)) { + d_printf("%s deleting remote file %s\n",cli_errstr(cli),mask); + } +} - 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))); +/**************************************************************************** +delete some files +****************************************************************************/ +static int cmd_del(void) +{ + pstring mask; + fstring buf; + uint16 attribute = aSYSTEM | aHIDDEN; - free(inbuf);free(outbuf); - + if (recurse) + attribute |= aDIR; + + pstrcpy(mask,cur_dir); + + if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) { + d_printf("del <filename>\n"); + return 1; + } + pstrcat(mask,buf); + + do_list(mask, attribute,do_del,False,False); + + return 0; } /**************************************************************************** -delete some files ****************************************************************************/ -static void cmd_del(char *inbuf,char *outbuf ) +static int cmd_open(void) { - pstring mask; - fstring buf; - int attribute = aSYSTEM | aHIDDEN; + pstring mask; + fstring buf; + + pstrcpy(mask,cur_dir); + + if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) { + d_printf("open <filename>\n"); + return 1; + } + pstrcat(mask,buf); - 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); + cli_open(cli, mask, O_RDWR, DENY_ALL); + + return 0; } /**************************************************************************** remove a directory ****************************************************************************/ -static void cmd_rmdir(char *inbuf,char *outbuf ) +static int cmd_rmdir(void) { - 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); + pstring mask; + fstring buf; - CVAL(outbuf,smb_com) = SMBrmdir; - SSVAL(outbuf,smb_tid,cnum); - setup_pkt(outbuf); + pstrcpy(mask,cur_dir); + + if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) { + d_printf("rmdir <dirname>\n"); + return 1; + } + pstrcat(mask,buf); - - 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; - } - + if (!cli_rmdir(cli, mask)) { + d_printf("%s removing remote directory file %s\n", + cli_errstr(cli),mask); + } + + return 0; } /**************************************************************************** -rename some files + UNIX hardlink. ****************************************************************************/ -static void cmd_rename(char *inbuf,char *outbuf ) + +static int cmd_link(void) { - 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); + pstring src,dest; + fstring buf,buf2; - 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; - } - -} + if (!SERVER_HAS_UNIX_CIFS(cli)) { + d_printf("Server doesn't support UNIX CIFS calls.\n"); + return 1; + } + pstrcpy(src,cur_dir); + pstrcpy(dest,cur_dir); + + if (!next_token(NULL,buf,NULL,sizeof(buf)) || + !next_token(NULL,buf2,NULL, sizeof(buf2))) { + d_printf("link <src> <dest>\n"); + return 1; + } -/**************************************************************************** -toggle the prompt flag -****************************************************************************/ -static void cmd_prompt(void) -{ - prompt = !prompt; - DEBUG(2,("prompting is now %s\n",prompt?"on":"off")); -} + pstrcat(src,buf); + pstrcat(dest,buf2); + if (!cli_unix_hardlink(cli, src, dest)) { + d_printf("%s linking files (%s -> %s)\n", cli_errstr(cli), src, dest); + return 1; + } -/**************************************************************************** -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")); + return 0; } /**************************************************************************** -set the archive level + UNIX symlink. ****************************************************************************/ -static void cmd_archive(void) + +static int cmd_symlink(void) { - fstring buf; + pstring src,dest; + fstring buf,buf2; + + if (!SERVER_HAS_UNIX_CIFS(cli)) { + d_printf("Server doesn't support UNIX CIFS calls.\n"); + return 1; + } - if (next_token(NULL,buf,NULL)) { - archive_level = atoi(buf); - } else - DEBUG(0,("Archive level is %d\n",archive_level)); + pstrcpy(src,cur_dir); + pstrcpy(dest,cur_dir); + + if (!next_token(NULL,buf,NULL,sizeof(buf)) || + !next_token(NULL,buf2,NULL, sizeof(buf2))) { + d_printf("symlink <src> <dest>\n"); + return 1; + } + + pstrcat(src,buf); + pstrcat(dest,buf2); + + if (!cli_unix_symlink(cli, src, dest)) { + d_printf("%s symlinking files (%s -> %s)\n", + cli_errstr(cli), src, dest); + return 1; + } + + return 0; } /**************************************************************************** -toggle the lowercaseflag + UNIX chmod. ****************************************************************************/ -static void cmd_lowercase(void) + +static int cmd_chmod(void) { - lowercase = !lowercase; - DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off")); -} + pstring src; + mode_t mode; + fstring buf, buf2; + + if (!SERVER_HAS_UNIX_CIFS(cli)) { + d_printf("Server doesn't support UNIX CIFS calls.\n"); + return 1; + } + pstrcpy(src,cur_dir); + + if (!next_token(NULL,buf,NULL,sizeof(buf)) || + !next_token(NULL,buf2,NULL, sizeof(buf2))) { + d_printf("chmod mode file\n"); + return 1; + } + mode = (mode_t)strtol(buf, NULL, 8); + pstrcat(src,buf2); + if (!cli_unix_chmod(cli, src, mode)) { + d_printf("%s chmod file %s 0%o\n", + cli_errstr(cli), src, (unsigned int)mode); + return 1; + } -/**************************************************************************** -toggle the recurse flag -****************************************************************************/ -static void cmd_recurse(void) -{ - recurse = !recurse; - DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off")); + return 0; } /**************************************************************************** -toggle the translate flag + UNIX chown. ****************************************************************************/ -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) +static int cmd_chown(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); + pstring src; + uid_t uid; + gid_t gid; + fstring buf, buf2, buf3; + + if (!SERVER_HAS_UNIX_CIFS(cli)) { + d_printf("Server doesn't support UNIX CIFS calls.\n"); + return 1; } - } - - 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)); + + pstrcpy(src,cur_dir); + + if (!next_token(NULL,buf,NULL,sizeof(buf)) || + !next_token(NULL,buf2,NULL, sizeof(buf2)) || + !next_token(NULL,buf3,NULL, sizeof(buf3))) { + d_printf("chown uid gid file\n"); + return 1; + } + + uid = (uid_t)atoi(buf); + gid = (gid_t)atoi(buf2); + pstrcat(src,buf3); + + if (!cli_unix_chown(cli, src, uid, gid)) { + d_printf("%s chown file %s uid=%d, gid=%d\n", + cli_errstr(cli), src, (int)uid, (int)gid); + return 1; + } + + return 0; } /**************************************************************************** -do the lcd command +rename some files ****************************************************************************/ -static void cmd_lcd(void) +static int cmd_rename(void) { - fstring buf; - pstring d; + pstring src,dest; + fstring buf,buf2; + + pstrcpy(src,cur_dir); + pstrcpy(dest,cur_dir); + + if (!next_token_nr(NULL,buf,NULL,sizeof(buf)) || + !next_token_nr(NULL,buf2,NULL, sizeof(buf2))) { + d_printf("rename <src> <dest>\n"); + return 1; + } + + pstrcat(src,buf); + pstrcat(dest,buf2); - if (next_token(NULL,buf,NULL)) - sys_chdir(buf); - DEBUG(2,("the local directory is now %s\n",GetWd(d))); + if (!cli_rename(cli, src, dest)) { + d_printf("%s renaming files\n",cli_errstr(cli)); + return 1; + } + + return 0; } /**************************************************************************** -send a session request +toggle the prompt flag ****************************************************************************/ -static BOOL send_session_request(char *inbuf,char *outbuf) +static int cmd_prompt(void) { - 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); + prompt = !prompt; + DEBUG(2,("prompting is now %s\n",prompt?"on":"off")); + + return 1; } /**************************************************************************** -send a login command +set the newer than time ****************************************************************************/ -static BOOL send_login(char *inbuf,char *outbuf,BOOL start_session,BOOL use_setup) +static int cmd_newer(void) { - 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"); + fstring buf; + BOOL ok; + SMB_STRUCT_STAT sbuf; - - 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); + ok = next_token_nr(NULL,buf,NULL,sizeof(buf)); + if (ok && (sys_stat(buf,&sbuf) == 0)) { + newer_than = sbuf.st_mtime; + DEBUG(1,("Getting files newer than %s", + asctime(LocalTime(&newer_than)))); + } else { + newer_than = 0; } - 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 (ok && newer_than == 0) { + d_printf("Error setting newer-than time\n"); + return 1; } - 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; + return 0; +} - cnum = SVAL(inbuf,smb_tid); +/**************************************************************************** +set the archive level +****************************************************************************/ +static int cmd_archive(void) +{ + fstring buf; - DEBUG(3,("Connected with cnum=%d max_xmit=%d\n",cnum,max_xmit)); + if (next_token_nr(NULL,buf,NULL,sizeof(buf))) { + archive_level = atoi(buf); + } else + d_printf("Archive level is %d\n",archive_level); - if (was_null) - { - free(inbuf); - free(outbuf); - } - return True; + return 0; } - /**************************************************************************** -send a logout command +toggle the lowercaseflag ****************************************************************************/ -static void send_logout(void ) +static int cmd_lowercase(void) { - pstring inbuf,outbuf; + lowercase = !lowercase; + DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off")); - bzero(outbuf,smb_size); - set_message(outbuf,0,0,True); - CVAL(outbuf,smb_com) = SMBtdis; - SSVAL(outbuf,smb_tid,cnum); - setup_pkt(outbuf); + return 0; +} - 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); -} +/**************************************************************************** +toggle the recurse flag +****************************************************************************/ +static int cmd_recurse(void) +{ + recurse = !recurse; + DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off")); + return 0; +} /**************************************************************************** -call a remote api +toggle the translate flag ****************************************************************************/ -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 int cmd_translate(void) { - static char *inbuf=NULL; - static char *outbuf=NULL; + translation = !translation; + DEBUG(2,("CR/LF<->LF and print text translation now %s\n", + translation?"on":"off")); - if (!inbuf) inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); - if (!outbuf) outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); + return 0; +} - 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)); +/**************************************************************************** +do a printmode command +****************************************************************************/ +static int cmd_printmode(void) +{ + fstring buf; + fstring mode; + + if (next_token_nr(NULL,buf,NULL,sizeof(buf))) { + if (strequal(buf,"text")) { + printmode = 0; + } else { + if (strequal(buf,"graphics")) + printmode = 1; + else + printmode = atoi(buf); + } + } + + switch(printmode) + { + case 0: + fstrcpy(mode,"text"); + break; + case 1: + fstrcpy(mode,"graphics"); + break; + default: + slprintf(mode,sizeof(mode)-1,"%d",printmode); + break; + } + + DEBUG(2,("the printmode is now %s\n",mode)); + + return 0; } /**************************************************************************** - 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) +do the lcd command +****************************************************************************/ +static int cmd_lcd(void) { - 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; - } - } + fstring buf; + pstring d; + + if (next_token_nr(NULL,buf,NULL,sizeof(buf))) + chdir(buf); + DEBUG(2,("the local directory is now %s\n",sys_getwd(d))); - return(True); + return 0; } /**************************************************************************** -try and browse available connections on a host +list a share name ****************************************************************************/ -static BOOL browse_host(BOOL sort) +static void browse_fn(const char *name, uint32 m, + const char *comment, void *state) { -#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; - } + fstring typestr; - 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); + *typestr=0; - return(count>0); + switch (m) + { + case STYPE_DISKTREE: + fstrcpy(typestr,"Disk"); break; + case STYPE_PRINTQ: + fstrcpy(typestr,"Printer"); break; + case STYPE_DEVICE: + fstrcpy(typestr,"Device"); break; + case STYPE_IPC: + fstrcpy(typestr,"IPC"); break; + } + /* FIXME: If the remote machine returns non-ascii characters + in any of these fields, they can corrupt the output. We + should remove them. */ + d_printf("\t%-15.15s%-10.10s%s\n", + name,typestr,comment); } /**************************************************************************** -get some server info +try and browse available connections on a host ****************************************************************************/ -static void server_info() +static BOOL browse_host(BOOL sort) { - 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; + int ret; - 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); - } - } + d_printf("\n\tSharename Type Comment\n"); + d_printf("\t--------- ---- -------\n"); - if (rparam) free(rparam); - if (rdata) free(rdata); + if((ret = cli_RNetShareEnum(cli, browse_fn, NULL)) == -1) + d_printf("Error returning browse list: %s\n", cli_errstr(cli)); - return; + return (ret != -1); } +/**************************************************************************** +list a server name +****************************************************************************/ +static void server_fn(const char *name, uint32 m, + const char *comment, void *state) +{ + d_printf("\t%-16.16s %s\n", name, comment); +} /**************************************************************************** try and browse available connections on a host ****************************************************************************/ -static BOOL list_servers() +static BOOL list_servers(char *wk_grp) { - 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"); - } + if (!cli->server_domain) return False; - 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; - } - } - } + d_printf("\n\tServer Comment\n"); + d_printf("\t--------- -------\n"); - if (rparam) free(rparam); - if (rdata) free(rdata); - - return(count>0); -} + cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_ALL, server_fn, NULL); + d_printf("\n\tWorkgroup Master\n"); + d_printf("\t--------- -------\n"); + cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM, server_fn, NULL); + return True; +} +/* Some constants for completing filename arguments */ -void cmd_help(); +#define COMPL_NONE 0 /* No completions */ +#define COMPL_REMOTE 1 /* Complete remote filename */ +#define COMPL_LOCAL 2 /* Complete local filename */ -/* This defines the commands supported by this client */ +/* This defines the commands supported by this client. + * NOTE: The "!" must be the last one in the list because it's fn pointer + * field is NULL, and NULL in that field is used in process_tok() + * (below) to indicate the end of the list. crh + */ struct { char *name; - void (*fn)(); + int (*fn)(void); char *description; + char compl_args[2]; /* Completion argument info */ } 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} + {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}}, + {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}}, + {"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",{COMPL_NONE,COMPL_NONE}}, + {"blocksize",cmd_block,"blocksize <number> (default 20)",{COMPL_NONE,COMPL_NONE}}, + {"cancel",cmd_cancel,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}}, + {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}}, + {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_REMOTE}}, + {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_REMOTE}}, + {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}}, + {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}}, + {"du",cmd_du,"<mask> computes the total size of the current directory",{COMPL_REMOTE,COMPL_NONE}}, + {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}}, + {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}}, + {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}}, + {"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}}, + {"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}}, + {"link",cmd_link,"<src> <dest> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}}, + {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}}, + {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}}, + {"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}}, + {"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}}, + {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}}, + {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}}, + {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}}, + {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}}, + {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}}, + {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}}, + {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}}, + {"printmode",cmd_printmode,"<graphics or text> set the print mode",{COMPL_NONE,COMPL_NONE}}, + {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}}, + {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}}, + {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}}, + {"q",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}}, + {"queue",cmd_queue,"show the print queue",{COMPL_NONE,COMPL_NONE}}, + {"quit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}}, + {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}}, + {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}}, + {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}}, + {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}}, + {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}}, + {"setmode",cmd_setmode,"filename <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}}, + {"symlink",cmd_symlink,"<src> <dest> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}}, + {"tar",cmd_tar,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE,COMPL_NONE}}, + {"tarmode",cmd_tarmode,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE,COMPL_NONE}}, + {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}}, + + /* Yes, this must be here, see crh's comment above. */ + {"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}}, + {"",NULL,NULL,{COMPL_NONE,COMPL_NONE}} }; @@ -3730,805 +2024,892 @@ struct ******************************************************************/ 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; + 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)) { + matches++; + cmd = i; + } + i++; } - i++; - } - if (matches == 0) - return(-1); - else if (matches == 1) - return(cmd); - else - return(-2); + if (matches == 0) + return(-1); + else if (matches == 1) + return(cmd); + else + return(-2); } /**************************************************************************** help ****************************************************************************/ -void cmd_help(void) +static int 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++; + int i=0,j; + fstring buf; + + if (next_token_nr(NULL,buf,NULL,sizeof(buf))) { + if ((i = process_tok(buf)) >= 0) + d_printf("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++) { + d_printf("%-15s",commands[i].name); + i++; + } + d_printf("\n"); + } } - DEBUG(0,("\n")); - } + return 0; } /**************************************************************************** -open the client sockets +process a -c command string ****************************************************************************/ -static BOOL open_sockets(int port ) +static int process_command_string(char *cmd) { - static int last_port; - char *host; - pstring service2; - extern int Client; -#ifdef USENMB - BOOL failed = True; -#endif + pstring line; + char *ptr; + int rc = 0; - 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; + while (cmd[0] != '\0') { + char *p; + fstring tok; + int i; + + if ((p = strchr_m(cmd, ';')) == 0) { + strncpy(line, cmd, 999); + line[1000] = '\0'; + cmd += strlen(cmd); + } else { + if (p - cmd > 999) p = cmd + 999; + strncpy(line, cmd, p - cmd); + line[p - cmd] = '\0'; + cmd = p + 1; + } + + /* and get the first part of the command */ + ptr = line; + if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue; + + if ((i = process_tok(tok)) >= 0) { + rc = commands[i].fn(); + } else if (i == -2) { + d_printf("%s: command abbreviation ambiguous\n",tok); + } else { + d_printf("%s: command not found\n",tok); + } + } - if ((bcast = open_socket_in(SOCK_DGRAM, 0, 3)) != -1) { - set_socket_options (bcast, "SO_BROADCAST"); + return rc; +} + +/**************************************************************************** +handle completion of commands for readline +****************************************************************************/ +static char **completion_fn(char *text, int start, int end) +{ +#define MAX_COMPLETIONS 100 + char **matches; + int i, count=0; + + /* for words not at the start of the line fallback to filename completion */ + if (start) return NULL; - if (!got_bcast && get_myname(hs, &ip1)) { - get_broadcast(&ip1, &bcast_ip, &ip2); - } + matches = (char **)malloc(sizeof(matches[0])*MAX_COMPLETIONS); + if (!matches) return NULL; - if (name_query(bcast, host, 0x20, True, True, bcast_ip, &dest_ip,0)){ - failed = False; - } - close (bcast); + matches[count++] = strdup(text); + if (!matches[0]) return NULL; + + for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) { + if (strncmp(text, commands[i].name, strlen(text)) == 0) { + matches[count] = strdup(commands[i].name); + if (!matches[count]) return NULL; + count++; + } } -#endif - if (failed) { - DEBUG(0,("Get_Hostbyname: Unknown host %s.\n",host)); - return False; + + if (count == 2) { + SAFE_FREE(matches[0]); + matches[0] = strdup(matches[1]); } - } - } + matches[count] = NULL; + return matches; +} - 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; +/**************************************************************************** +make sure we swallow keepalives during idle time +****************************************************************************/ +static void readline_callback(void) +{ + fd_set fds; + struct timeval timeout; + static time_t last_t; + time_t t; + + t = time(NULL); + + if (t - last_t < 5) return; + + last_t = t; + + again: + FD_ZERO(&fds); + FD_SET(cli->fd,&fds); + + timeout.tv_sec = 0; + timeout.tv_usec = 0; + sys_select_intr(cli->fd+1,&fds,NULL,NULL,&timeout); + + /* We deliberately use receive_smb instead of + client_receive_smb as we want to receive + session keepalives and then drop them here. + */ + if (FD_ISSET(cli->fd,&fds)) { + receive_smb(cli->fd,cli->inbuf,0); + goto again; + } + + cli_chkpath(cli, "\\"); } + /**************************************************************************** -wait for keyboard activity, swallowing network packets +process commands on stdin ****************************************************************************/ -#ifdef CLIX -static char wait_keyboard(char *buffer) -#else -static void wait_keyboard(char *buffer) -#endif +static void process_stdin(void) { - 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 + char *ptr; - 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); + while (1) { + fstring tok; + fstring the_prompt; + char *cline; + pstring line; + int i; + + /* display a prompt */ + slprintf(the_prompt, sizeof(the_prompt)-1, "smb: %s> ", cur_dir); + cline = smb_readline(the_prompt, readline_callback, completion_fn); + + if (!cline) break; + + pstrcpy(line, cline); + + /* special case - first char is ! */ + if (*line == '!') { + system(line + 1); + continue; + } -#ifdef CLIX - delay++; - if (delay > 100000) - { - delay = 0; - chkpath("\\",False); + /* and get the first part of the command */ + ptr = line; + if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue; + + if ((i = process_tok(tok)) >= 0) { + commands[i].fn(); + } else if (i == -2) { + d_printf("%s: command abbreviation ambiguous\n",tok); + } else { + d_printf("%s: command not found\n",tok); + } } -#else - chkpath("\\",False); -#endif - } } -/**************************************************************************** -close and open the connection again -****************************************************************************/ -BOOL reopen_connection(char *inbuf,char *outbuf) +/***************************************************** +return a connection to a server +*******************************************************/ +struct cli_state *do_connect(const char *server, const char *share) { - static int open_count=0; + struct cli_state *c; + struct nmb_name called, calling; + const char *server_n; + struct in_addr ip; + fstring servicename; + char *sharename; + + /* make a copy so we don't modify the global string 'service' */ + safe_strcpy(servicename, share, sizeof(servicename)-1); + sharename = servicename; + if (*sharename == '\\') { + server = sharename+2; + sharename = strchr_m(server,'\\'); + if (!sharename) return NULL; + *sharename = 0; + sharename++; + } - open_count++; + server_n = server; + + zero_ip(&ip); + + make_nmb_name(&calling, global_myname, 0x0); + make_nmb_name(&called , server, name_type); - if (open_count>5) return(False); + again: + zero_ip(&ip); + if (have_ip) ip = dest_ip; + + /* have to open a new connection */ + if (!(c=cli_initialise(NULL)) || (cli_set_port(c, port) != port) || + !cli_connect(c, server_n, &ip)) { + d_printf("Connection to %s failed\n", server_n); + return NULL; + } + + c->protocol = max_protocol; + c->use_kerberos = use_kerberos; + + if (!cli_session_request(c, &calling, &called)) { + char *p; + d_printf("session request to %s failed (%s)\n", + called.name, cli_errstr(c)); + cli_shutdown(c); + if ((p=strchr_m(called.name, '.'))) { + *p = 0; + goto again; + } + if (strcmp(called.name, "*SMBSERVER")) { + make_nmb_name(&called , "*SMBSERVER", 0x20); + goto again; + } + return NULL; + } - DEBUG(1,("Trying to re-open connection\n")); + DEBUG(4,(" session request ok\n")); - set_message(outbuf,0,0,True); - SCVAL(outbuf,smb_com,SMBtdis); - SSVAL(outbuf,smb_tid,cnum); - setup_pkt(outbuf); + if (!cli_negprot(c)) { + d_printf("protocol negotiation failed\n"); + cli_shutdown(c); + return NULL; + } - send_smb(Client,outbuf); - receive_smb(Client,inbuf,SHORT_TIMEOUT); + if (!got_pass) { + char *pass = getpass("Password: "); + if (pass) { + pstrcpy(password, pass); + } + } - close_sockets(); - if (!open_sockets(0)) return(False); + if (!cli_session_setup(c, username, + password, strlen(password), + password, strlen(password), + workgroup)) { + /* if a password was not supplied then try again with a null username */ + if (password[0] || !username[0] || use_kerberos || + !cli_session_setup(c, "", "", 0, "", 0, workgroup)) { + d_printf("session setup failed: %s\n", cli_errstr(c)); + cli_shutdown(c); + return NULL; + } + d_printf("Anonymous login successful\n"); + } - return(send_login(inbuf,outbuf,True,True)); + if (*c->server_domain) { + DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n", + c->server_domain,c->server_os,c->server_type)); + } else if (*c->server_os || *c->server_type){ + DEBUG(1,("OS=[%s] Server=[%s]\n", + c->server_os,c->server_type)); + } + + DEBUG(4,(" session setup ok\n")); + + if (!cli_send_tconX(c, sharename, "?????", + password, strlen(password)+1)) { + d_printf("tree connect failed: %s\n", cli_errstr(c)); + cli_shutdown(c); + return NULL; + } + + DEBUG(4,(" tconx ok\n")); + + return c; } + /**************************************************************************** process commands from the client ****************************************************************************/ -BOOL process(char *base_directory) +static int process(char *base_directory) { - extern FILE *dbf; - pstring line; + int rc = 0; - char *InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); - char *OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); + cli = do_connect(desthost, service); + if (!cli) { + return 1; + } - if ((InBuffer == NULL) || (OutBuffer == NULL)) - return(False); + if (*base_directory) do_cd(base_directory); + + if (cmdstr) { + rc = process_command_string(cmdstr); + } else { + process_stdin(); + } - bzero(OutBuffer,smb_size); - - if (!send_login(InBuffer,OutBuffer,True,True)) - return(False); + cli_shutdown(cli); + return rc; +} - if (*base_directory) do_cd(base_directory); +/**************************************************************************** +usage on the program +****************************************************************************/ +static void usage(char *pname) +{ + d_printf("Usage: %s service <password> [options]", pname); + + d_printf("\nVersion %s\n",VERSION); + d_printf("\t-s smb.conf pathname to smb.conf file\n"); + d_printf("\t-O socket_options socket options to use\n"); + d_printf("\t-R name resolve order use these name resolution services only\n"); + d_printf("\t-M host send a winpopup message to the host\n"); + d_printf("\t-i scope use this NetBIOS scope\n"); + d_printf("\t-N don't ask for a password\n"); + d_printf("\t-n netbios name. Use this name as my netbios name\n"); + d_printf("\t-d debuglevel set the debuglevel\n"); + d_printf("\t-P connect to service as a printer\n"); + d_printf("\t-p port connect to the specified port\n"); + d_printf("\t-l log basename. Basename for log/debug files\n"); + d_printf("\t-h Print this help message.\n"); + d_printf("\t-I dest IP use this IP to connect to\n"); + d_printf("\t-E write messages to stderr instead of stdout\n"); + d_printf("\t-k use kerberos (active directory) authentication\n"); + d_printf("\t-U username set the network username\n"); + d_printf("\t-L host get a list of shares available on a host\n"); + d_printf("\t-t terminal code terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n"); + d_printf("\t-m max protocol set the max protocol level\n"); + d_printf("\t-A filename get the credentials from a file\n"); + d_printf("\t-W workgroup set the workgroup name\n"); + d_printf("\t-T<c|x>IXFqgbNan command line tar\n"); + d_printf("\t-D directory start from directory\n"); + d_printf("\t-c command string execute semicolon separated commands\n"); + d_printf("\t-b xmit/send buffer changes the transmit/send buffer (default: 65520)\n"); + d_printf("\n"); +} + + +/**************************************************************************** +get a password from a a file or file descriptor +exit on failure +****************************************************************************/ +static void get_password_file(void) +{ + int fd = -1; + char *p; + BOOL close_it = False; + pstring spec; + char pass[128]; + + if ((p = getenv("PASSWD_FD")) != NULL) { + pstrcpy(spec, "descriptor "); + pstrcat(spec, p); + sscanf(p, "%d", &fd); + close_it = False; + } else if ((p = getenv("PASSWD_FILE")) != NULL) { + fd = sys_open(p, O_RDONLY, 0); + pstrcpy(spec, p); + if (fd < 0) { + fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n", + spec, strerror(errno)); + exit(1); + } + close_it = True; + } - while (!feof(stdin)) - { - fstring tok; - int i; + for(p = pass, *p = '\0'; /* ensure that pass is null-terminated */ + p && p - pass < sizeof(pass);) { + switch (read(fd, p, 1)) { + case 1: + if (*p != '\n' && *p != '\0') { + *++p = '\0'; /* advance p, and null-terminate pass */ + break; + } + case 0: + if (p - pass) { + *p = '\0'; /* null-terminate it, just in case... */ + p = NULL; /* then force the loop condition to become false */ + break; + } else { + fprintf(stderr, "Error reading password from file %s: %s\n", + spec, "empty password\n"); + exit(1); + } + + default: + fprintf(stderr, "Error reading password from file %s: %s\n", + spec, strerror(errno)); + exit(1); + } + } + pstrcpy(password, pass); + if (close_it) + close(fd); +} - 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 +/**************************************************************************** +handle a -L query +****************************************************************************/ +static int do_host_query(char *query_host) +{ + cli = do_connect(query_host, "IPC$"); + if (!cli) + return 1; - /* input language code to internal one */ - CNV_INPUT (line); + browse_host(True); + list_servers(workgroup); - /* 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); + cli_shutdown(cli); + + return(0); } /**************************************************************************** -usage on the program +handle a tar operation ****************************************************************************/ -void usage(char *pname) +static int do_tar_op(char *base_directory) { - DEBUG(0,("Usage: %s service <password> [-p port] [-d debuglevel] [-l log] ", - pname)); + int ret; + cli = do_connect(desthost, service); + if (!cli) + return 1; -#ifdef KANJI - DEBUG(0,("[-t termcode] ")); -#endif /* KANJI */ + recurse=True; - 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")); -} + if (*base_directory) do_cd(base_directory); + + ret=process_tar(); + cli_shutdown(cli); + return(ret); +} /**************************************************************************** - main program +handle a message operation ****************************************************************************/ -int main(int argc,char *argv[]) +static int do_message_op(void) { - 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] != '-') - { + struct in_addr ip; + struct nmb_name called, calling; - strcpy(service,argv[1]); - argc--; - argv++; + zero_ip(&ip); - if (count_chars(service,'\\') < 3) - { - usage(pname); - printf("\n%s: Not enough '\\' characters in service\n",service); - exit(1); - } + make_nmb_name(&calling, global_myname, 0x0); + make_nmb_name(&called , desthost, name_type); -/* - if (count_chars(service,'\\') > 3) - { - usage(pname); - printf("\n%s: Too many '\\' characters in service\n",service); - exit(1); - } - */ + zero_ip(&ip); + if (have_ip) ip = dest_ip; - if (argc > 1 && (*argv[1] != '-')) - { - got_pass = True; - strcpy(password,argv[1]); - memset(argv[1],'X',strlen(argv[1])); - argc--; - argv++; + if (!(cli=cli_initialise(NULL)) || (cli_set_port(cli, port) != port) || !cli_connect(cli, desthost, &ip)) { + d_printf("Connection to %s failed\n", desthost); + return 1; } - } -#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); + if (!cli_session_request(cli, &calling, &called)) { + d_printf("session request failed\n"); + cli_shutdown(cli); + return 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; + + send_message(); + cli_shutdown(cli); + + return 0; +} + + +/** + * Process "-L hostname" option. + * + * We don't actually do anything yet -- we just stash the name in a + * global variable and do the query when all options have been read. + **/ +static void remember_query_host(const char *arg, + pstring query_host) +{ + char *slash; + + while (*arg == '\\' || *arg == '/') + arg++; + pstrcpy(query_host, arg); + if ((slash = strchr(query_host, '/')) + || (slash = strchr(query_host, '\\'))) { + *slash = 0; } - 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; +} + + +/**************************************************************************** + main program +****************************************************************************/ + int main(int argc,char *argv[]) +{ + fstring base_directory; + char *pname = argv[0]; + int opt; + extern char *optarg; + extern int optind; + int old_debug; + pstring query_host; + BOOL message = False; + extern char tar_type; + pstring term_code; + pstring new_name_resolve_order; + pstring logfile; + char *p; + int rc = 0; + #ifdef KANJI - case 't': - if (!setup_term_code (optarg)) { - DEBUG(0, ("%s: unknown terminal code name\n", optarg)); - usage (pname); - exit (1); - } - break; + pstrcpy(term_code, KANJI); +#else /* KANJI */ + *term_code = 0; #endif /* KANJI */ - default: - usage(pname); - exit(1); - } - if (!tar_type && !*query_host && !*service && !message) - { - usage(pname); - exit(1); - } + *query_host = 0; + *base_directory = 0; + *new_name_resolve_order = 0; - DEBUG(3,("%s client started (version %s)\n",timestring(),VERSION)); + DEBUGLEVEL = 2; + AllowDebugChange = False; + + setup_logging(pname,True); + + /* + * If the -E option is given, be careful not to clobber stdout + * before processing the options. 28.Feb.99, richard@hacom.nl. + * Also pre-parse the -s option to get the service file name. + */ + + for (opt = 1; opt < argc; opt++) { + if (strcmp(argv[opt], "-E") == 0) + dbf = x_stderr; + else if(strncmp(argv[opt], "-s", 2) == 0) { + if(argv[opt][2] != '\0') + pstrcpy(dyn_CONFIGFILE, &argv[opt][2]); + else if(argv[opt+1] != NULL) { + /* + * At least one more arg left. + */ + pstrcpy(dyn_CONFIGFILE, argv[opt+1]); + } else { + usage(pname); + exit(1); + } + } + } - get_myname(*myname?NULL:myname,&myip); - strupper(myname); + in_client = True; /* Make sure that we tell lp_load we are */ - if (tar_type) { - recurse=True; + old_debug = DEBUGLEVEL; + if (!lp_load(dyn_CONFIGFILE,True,False,False)) { + fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n", + prog_name, dyn_CONFIGFILE); + } + DEBUGLEVEL = old_debug; + +#ifdef WITH_SSL + sslutil_init(0); +#endif - if (open_sockets(port)) { - char *InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); - char *OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); - int ret; + pstrcpy(workgroup,lp_workgroup()); - if ((InBuffer == NULL) || (OutBuffer == NULL)) - return(1); + load_interfaces(); + myumask = umask(0); + umask(myumask); - bzero(OutBuffer,smb_size); - if (!send_login(InBuffer,OutBuffer,True,True)) - return(False); + if (getenv("USER")) { + pstrcpy(username,getenv("USER")); - if (*base_directory) do_cd(base_directory); + /* modification to support userid%passwd syntax in the USER var + 25.Aug.97, jdblair@uab.edu */ - ret=process_tar(InBuffer, OutBuffer); + if ((p=strchr_m(username,'%'))) { + *p = 0; + pstrcpy(password,p+1); + got_pass = True; + memset(strchr_m(getenv("USER"),'%')+1,'X',strlen(password)); + } + strupper(username); + } - 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(); + /* modification to support PASSWD environmental var + 25.Aug.97, jdblair@uab.edu */ + if (getenv("PASSWD")) { + pstrcpy(password,getenv("PASSWD")); + got_pass = True; } - return(ret); - } + if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) { + get_password_file(); + got_pass = True; + } - if (message) - { - int ret = 0; - if (open_sockets(port)) - { - pstring inbuf,outbuf; - bzero(outbuf,smb_size); - if (!send_session_request(inbuf,outbuf)) - return(1); + if (*username == 0 && getenv("LOGNAME")) { + pstrcpy(username,getenv("LOGNAME")); + strupper(username); + } - send_message(inbuf,outbuf); + if (*username == 0) { + pstrcpy(username,"GUEST"); + } - close_sockets(); + if (argc < 2) { + usage(pname); + exit(1); } - return(ret); - } + /* FIXME: At the moment, if the user should happen to give the + * options ahead of the service name (in standard Unix + * fashion) then smbclient just spits out the usage message + * with no explanation of what in particular was wrong. Is + * there any reason we can't just parse out the service name + * and password after running getopt?? -- mbp */ + if (*argv[1] != '-') { + pstrcpy(service,argv[1]); + /* Convert any '/' characters in the service name to '\' characters */ + string_replace( service, '/','\\'); + argc--; + argv++; + + if (count_chars(service,'\\') < 3) { + usage(pname); + d_printf("\n%s: Not enough '\\' characters in service\n",service); + exit(1); + } - if (open_sockets(port)) - { - if (!process(base_directory)) - { - close_sockets(); - return(1); + if (argc > 1 && (*argv[1] != '-')) { + got_pass = True; + pstrcpy(password,argv[1]); + memset(argv[1],'X',strlen(argv[1])); + argc--; + argv++; + } } - close_sockets(); - } - else - return(1); - return(0); -} + while ((opt = + getopt(argc, argv,"s:O:R:M:i:Nn:d:Pp:l:hI:EU:L:t:m:W:T:D:c:b:A:k")) != EOF) { + switch (opt) { + case 's': + pstrcpy(dyn_CONFIGFILE, optarg); + break; + case 'O': + pstrcpy(user_socket_options,optarg); + break; + case 'R': + pstrcpy(new_name_resolve_order, optarg); + break; + case 'M': + name_type = 0x03; /* messages are sent to NetBIOS name type 0x3 */ + pstrcpy(desthost,optarg); + message = True; + break; + case 'i': + { + extern pstring global_scope; + pstrcpy(global_scope,optarg); + strupper(global_scope); + } + break; + case 'N': + got_pass = True; + break; + case 'n': + pstrcpy(global_myname,optarg); + break; + case 'd': + if (*optarg == 'A') + DEBUGLEVEL = 10000; + else + DEBUGLEVEL = atoi(optarg); + break; + case 'P': + /* not needed anymore */ + break; + case 'p': + port = atoi(optarg); + break; + case 'l': + slprintf(logfile,sizeof(logfile)-1, "%s.client",optarg); + lp_set_logfile(logfile); + break; + case 'h': + usage(pname); + exit(0); + break; + case 'I': + { + dest_ip = *interpret_addr2(optarg); + if (is_zero_ip(dest_ip)) + exit(1); + have_ip = True; + } + break; + case 'E': + display_set_stderr(); + dbf = x_stderr; + break; + case 'U': + { + char *lp; + pstrcpy(username,optarg); + if ((lp=strchr_m(username,'%'))) { + *lp = 0; + pstrcpy(password,lp+1); + got_pass = True; + memset(strchr_m(optarg,'%')+1,'X',strlen(password)); + } + } + break; + + case 'A': + { + XFILE *auth; + fstring buf; + uint16 len = 0; + char *ptr, *val, *param; + + if ((auth=x_fopen(optarg, O_RDONLY, 0)) == NULL) + { + /* fail if we can't open the credentials file */ + d_printf("ERROR: Unable to open credentials file!\n"); + exit (-1); + } + + while (!x_feof(auth)) + { + /* get a line from the file */ + if (!x_fgets(buf, sizeof(buf), auth)) + continue; + len = strlen(buf); + + if ((len) && (buf[len-1]=='\n')) + { + buf[len-1] = '\0'; + len--; + } + if (len == 0) + continue; + + /* break up the line into parameter & value. + will need to eat a little whitespace possibly */ + param = buf; + if (!(ptr = strchr_m (buf, '='))) + continue; + val = ptr+1; + *ptr = '\0'; + + /* eat leading white space */ + while ((*val!='\0') && ((*val==' ') || (*val=='\t'))) + val++; + + if (strwicmp("password", param) == 0) + { + pstrcpy(password, val); + got_pass = True; + } + else if (strwicmp("username", param) == 0) + pstrcpy(username, val); + else if (strwicmp("domain", param) == 0) + pstrcpy(workgroup,val); + memset(buf, 0, sizeof(buf)); + } + x_fclose(auth); + } + break; + + case 'L': + remember_query_host(optarg, query_host); + break; + case 't': + pstrcpy(term_code, optarg); + break; + case 'm': + max_protocol = interpret_protocol(optarg, max_protocol); + break; + case 'W': + pstrcpy(workgroup,optarg); + break; + case 'T': + if (!tar_parseargs(argc, argv, optarg, optind)) { + usage(pname); + exit(1); + } + break; + case 'D': + pstrcpy(base_directory,optarg); + break; + case 'c': + cmdstr = optarg; + break; + case 'b': + io_bufsize = MAX(1, atoi(optarg)); + break; + case 'k': +#ifdef HAVE_KRB5 + use_kerberos = True; + got_pass = True; +#else + d_printf("No kerberos support compiled in\n"); + exit(1); +#endif + break; + default: + usage(pname); + exit(1); + } + } + get_myname((*global_myname)?NULL:global_myname); -/* error code stuff - put together by Merik Karman - merik@blackadder.dsh.oz.au */ + if(*new_name_resolve_order) + lp_set_name_resolve_order(new_name_resolve_order); -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}}; + if (!tar_type && !*query_host && !*service && !message) { + usage(pname); + exit(1); + } + DEBUG( 3, ( "Client started (version %s).\n", VERSION ) ); -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}}; + if (tar_type) { + if (cmdstr) + process_command_string(cmdstr); + return do_tar_op(base_directory); + } + if ((p=strchr_m(query_host,'#'))) { + *p = 0; + p++; + sscanf(p, "%x", &name_type); + } + + if (*query_host) { + return do_host_query(query_host); + } -/**************************************************************************** -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; - } - } + if (message) { + return do_message_op(); + } + + if (process(base_directory)) { + return 1; + } - sprintf(ret,"%s - %d",err_classes[i].class,num); - return ret; - } - - sprintf(ret,"ERROR: Unknown error (%d,%d)",class,num); - return(ret); + return rc; } diff --git a/source3/client/clitar.c b/source3/client/clitar.c index 1433ec5941..9fa3750b0c 100644 --- a/source3/client/clitar.c +++ b/source3/client/clitar.c @@ -1,8 +1,8 @@ /* - Unix SMB/Netbios implementation. - Version 1.9. + Unix SMB/CIFS implementation. Tar Extensions - Copyright (C) Ricky Poulten 1995 + Copyright (C) Ricky Poulten 1995-1998 + Copyright (C) Richard Sharpe 1998 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 @@ -18,100 +18,181 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +/* The following changes developed by Richard Sharpe for Canon Information + Systems Research Australia (CISRA) + + 1. Restore can now restore files with long file names + 2. Save now saves directory information so that we can restore + directory creation times + 3. tar now accepts both UNIX path names and DOS path names. I prefer + those lovely /'s to those UGLY \'s :-) + 4. the files to exclude can be specified as a regular expression by adding + an r flag to the other tar flags. Eg: + + -TcrX file.tar "*.(obj|exe)" + + will skip all .obj and .exe files +*/ #include "includes.h" #include "clitar.h" -extern void setup_pkt(char *outbuf); -extern BOOL reopen_connection(char *inbuf,char *outbuf); -extern void do_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir); +static int clipfind(char **aret, int ret, char *tok); + +typedef struct file_info_struct file_info2; -int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind); +struct file_info_struct +{ + size_t size; + uint16 mode; + int uid; + int gid; + /* These times are normally kept in GMT */ + time_t mtime; + time_t atime; + time_t ctime; + char *name; /* This is dynamically allocate */ + + file_info2 *next, *prev; /* Used in the stack ... */ + +}; + +typedef struct +{ + file_info2 *top; + int items; -extern BOOL recurse; +} stack; + +stack dir_stack = {NULL, 0}; /* Want an empty stack */ #define SEPARATORS " \t\n\r" -extern int DEBUGLEVEL; -extern int Client; +extern struct cli_state *cli; /* These defines are for the do_setrattr routine, to indicate * setting and reseting of file attributes in the function call */ #define ATTRSET 1 #define ATTRRESET 0 -static int attribute = aDIR | aSYSTEM | aHIDDEN; +static uint16 attribute = aDIR | aSYSTEM | aHIDDEN; #ifndef CLIENT_TIMEOUT #define CLIENT_TIMEOUT (30*1000) #endif -static char *tarbuf; +static char *tarbuf, *buffer_p; static int tp, ntarf, tbufsiz; +static double ttarf; /* Incremental mode */ BOOL tar_inc=False; /* Reset archive bit */ BOOL tar_reset=False; /* Include / exclude mode (true=include, false=exclude) */ BOOL tar_excl=True; +/* use regular expressions for search on file names */ +BOOL tar_re_search=False; +#ifdef HAVE_REGEX_H +regex_t *preg; +#endif +/* Do not dump anything, just calculate sizes */ +BOOL dry_run=False; +/* Dump files with System attribute */ +BOOL tar_system=True; +/* Dump files with Hidden attribute */ +BOOL tar_hidden=True; +/* Be noisy - make a catalogue */ +BOOL tar_noisy=True; +BOOL tar_real_noisy=False; /* Don't want to be really noisy by default */ + char tar_type='\0'; static char **cliplist=NULL; static int clipn=0; +static BOOL must_free_cliplist = False; extern file_info def_finfo; extern BOOL lowercase; -extern int cnum; +extern uint16 cnum; extern BOOL readbraw_supported; extern int max_xmit; extern pstring cur_dir; extern int get_total_time_ms; extern int get_total_size; -extern int Protocol; int blocksize=20; int tarhandle; -static void writetarheader(); -static void do_atar(); -static void do_tar(); -static void oct_it(); -static void fixtarname(); -static int dotarbuf(); -static void dozerobuf(); -static void dotareof(); -static void initarbuf(); -static int do_setrattr(); -void cmd_tar(); -int process_tar(); -char **toktocliplist(); -int clipfind(); +static void writetarheader(int f, char *aname, int size, time_t mtime, + char *amode, unsigned char ftype); +static void do_atar(char *rname,char *lname,file_info *finfo1); +static void do_tar(file_info *finfo); +static void oct_it(long value, int ndgs, char *p); +static void fixtarname(char *tptr, char *fp, int l); +static int dotarbuf(int f, char *b, int n); +static void dozerobuf(int f, int n); +static void dotareof(int f); +static void initarbuf(void); + /* restore functions */ -static long readtarheader(); -static long unoct(); -static void do_tarput(); -static void unfixtarname(); +static long readtarheader(union hblock *hb, file_info2 *finfo, char *prefix); +static long unoct(char *p, int ndgs); +static void do_tarput(void); +static void unfixtarname(char *tptr, char *fp, int l, BOOL first); /* * tar specific utitlities */ +/******************************************************************* +Create a string of size size+1 (for the null) +*******************************************************************/ +static char *string_create_s(int size) +{ + char *tmp; + + tmp = (char *)malloc(size+1); + + if (tmp == NULL) { + + DEBUG(0, ("Out of memory in string_create_s\n")); + + } + + return(tmp); + +} + /**************************************************************************** Write a tar header to buffer ****************************************************************************/ static void writetarheader(int f, char *aname, int size, time_t mtime, - char *amode) + char *amode, unsigned char ftype) { union hblock hb; int i, chk, l; char *jp; + DEBUG(5, ("WriteTarHdr, Type = %c, Size= %i, Name = %s\n", ftype, size, aname)); + memset(hb.dummy, 0, sizeof(hb.dummy)); l=strlen(aname); - if (l >= NAMSIZ) - { - DEBUG(0, ("tar file %s name length exceeds NAMSIZ\n", aname)); - } + if (l >= NAMSIZ - 1) { + /* write a GNU tar style long header */ + char *b; + b = (char *)malloc(l+TBLOCK+100); + if (!b) { + DEBUG(0,("out of memory\n")); + exit(1); + } + writetarheader(f, "/./@LongLink", l+2, 0, " 0 \0", 'L'); + memset(b, 0, l+TBLOCK+100); + fixtarname(b, aname, l); + i = strlen(b)+1; + DEBUG(5, ("File name in tar file: %s, size=%d, \n", b, (int)strlen(b))); + dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1)); + SAFE_FREE(b); + } /* use l + 1 to do the null too */ fixtarname(hb.dbuf.name, aname, (l >= NAMSIZ) ? NAMSIZ : l + 1); @@ -122,14 +203,14 @@ static void writetarheader(int f, char *aname, int size, time_t mtime, /* write out a "standard" tar format header */ hb.dbuf.name[NAMSIZ-1]='\0'; - strcpy(hb.dbuf.mode, amode); + safe_strcpy(hb.dbuf.mode, amode, strlen(amode)); oct_it(0L, 8, hb.dbuf.uid); oct_it(0L, 8, hb.dbuf.gid); oct_it((long) size, 13, hb.dbuf.size); oct_it((long) mtime, 13, hb.dbuf.mtime); memcpy(hb.dbuf.chksum, " ", sizeof(hb.dbuf.chksum)); - hb.dbuf.linkflag='0'; memset(hb.dbuf.linkname, 0, NAMSIZ); + hb.dbuf.linkflag=ftype; for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;) chk+=(0xFF & *jp++); @@ -142,7 +223,7 @@ static void writetarheader(int f, char *aname, int size, time_t mtime, /**************************************************************************** Read a tar header into a hblock structure, and validate ***************************************************************************/ -static long readtarheader(union hblock *hb, file_info *finfo, char *prefix) +static long readtarheader(union hblock *hb, file_info2 *finfo, char *prefix) { long chk, fchk; int i; @@ -167,29 +248,44 @@ static long readtarheader(union hblock *hb, file_info *finfo, char *prefix) fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum)); - DEBUG(5, ("checksum totals chk=%d fchk=%d chksum=%s\n", + DEBUG(5, ("checksum totals chk=%ld fchk=%ld chksum=%s\n", chk, fchk, hb->dbuf.chksum)); if (fchk != chk) { - DEBUG(0, ("checksums don't match %d %d\n", fchk, chk)); + DEBUG(0, ("checksums don't match %ld %ld\n", fchk, chk)); + dump_data(5, (char *)hb - TBLOCK, TBLOCK *3); return -1; } - strcpy(finfo->name, prefix); + if ((finfo->name = string_create_s(strlen(prefix) + strlen(hb -> dbuf.name) + 3)) == NULL) { + + DEBUG(0, ("Out of space creating file_info2 for %s\n", hb -> dbuf.name)); + return(-1); + + } + + safe_strcpy(finfo->name, prefix, strlen(prefix) + strlen(hb -> dbuf.name) + 3); /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */ unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name, - strlen(hb->dbuf.name) + 1); + strlen(hb->dbuf.name) + 1, True); -/* can't handle links at present */ - if (hb->dbuf.linkflag != '0') { + /* can't handle some links at present */ + if ((hb->dbuf.linkflag != '0') && (hb -> dbuf.linkflag != '5')) { if (hb->dbuf.linkflag == 0) { DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n", finfo->name)); } else { - DEBUG(0, ("this tar file appears to contain some kind of link - ignoring\n")); - return -2; + if (hb -> dbuf.linkflag == 'L') { /* We have a longlink */ + /* Do nothing here at the moment. do_tarput will handle this + as long as the longlink gets back to it, as it has to advance + the buffer pointer, etc */ + + } else { + DEBUG(0, ("this tar file appears to contain some kind of link other than a GNUtar Longlink - ignoring\n")); + return -2; + } } } @@ -222,6 +318,9 @@ static int dotarbuf(int f, char *b, int n) { int fail=1, writ=n; + if (dry_run) { + return writ; + } /* This routine and the next one should be the only ones that do write()s */ if (tp + n >= tbufsiz) { @@ -250,7 +349,7 @@ static int dotarbuf(int f, char *b, int n) } /**************************************************************************** -Write a zeros to buffer / tape +Write zeros to buffer / tape ****************************************************************************/ static void dozerobuf(int f, int n) { @@ -258,9 +357,13 @@ static void dozerobuf(int f, int n) * used to round files to nearest block * and to do tar EOFs */ + if (dry_run) + return; + if (n+tp >= tbufsiz) { memset(tarbuf+tp, 0, tbufsiz-tp); + write(f, tarbuf, tbufsiz); memset(tarbuf, 0, (tp+=n-tbufsiz)); } @@ -274,14 +377,14 @@ static void dozerobuf(int f, int n) /**************************************************************************** Malloc tape buffer ****************************************************************************/ -static void initarbuf() +static void initarbuf(void) { /* initialize tar buffer */ tbufsiz=blocksize*TBLOCK; - tarbuf=malloc(tbufsiz); + tarbuf=malloc(tbufsiz); /* FIXME: We might not get the buffer */ - /* reset tar buffer pointer and tar file counter */ - tp=0; ntarf=0; + /* reset tar buffer pointer and tar file counter and total dumped */ + tp=0; ntarf=0; ttarf=0; } /**************************************************************************** @@ -289,13 +392,16 @@ Write two zero blocks at end of file ****************************************************************************/ static void dotareof(int f) { - struct stat stbuf; + SMB_STRUCT_STAT stbuf; /* Two zero blocks at end of file, write out full buffer */ + if (dry_run) + return; + (void) dozerobuf(f, TBLOCK); (void) dozerobuf(f, TBLOCK); - if (fstat(f, &stbuf) == -1) + if (sys_fstat(f, &stbuf) == -1) { DEBUG(0, ("Couldn't stat file handle\n")); return; @@ -311,37 +417,18 @@ static void dotareof(int f) ****************************************************************************/ static void fixtarname(char *tptr, char *fp, int l) { - /* add a '.' to start of file name, convert from ugly dos \'s in path - * to lovely unix /'s :-} */ - - *tptr++='.'; -#ifdef KANJI - while (l > 0) { - if (is_shift_jis (*fp)) { - *tptr++ = *fp++; - *tptr++ = *fp++; - l -= 2; - } else if (is_kana (*fp)) { - *tptr++ = *fp++; - l--; - } else if (*fp == '\\') { - *tptr++ = '/'; - fp++; - l--; - } else { - *tptr++ = *fp++; - l--; - } - } -#else - while (l--) { *tptr=(*fp == '\\') ? '/' : *fp; tptr++; fp++; } -#endif + /* add a '.' to start of file name, convert from ugly dos \'s in path + * to lovely unix /'s :-} */ + *tptr++='.'; + + safe_strcpy(tptr, fp, l); + string_replace(tptr, '\\', '/'); } /**************************************************************************** Convert from decimal to octal string ****************************************************************************/ -static void oct_it (register long value, register int ndgs, register char *p) +static void oct_it (long value, int ndgs, char *p) { /* Converts long to octal string, pads with leading zeros */ @@ -371,7 +458,7 @@ static long unoct(char *p, int ndgs) while (--ndgs) { - if (isdigit(*p)) + if (isdigit((int)*p)) value = (value << 3) | (long) (*p - '0'); p++; @@ -381,10 +468,14 @@ static long unoct(char *p, int ndgs) } /**************************************************************************** -Compare two strings in a slash insensitive way +Compare two strings in a slash insensitive way, allowing s1 to match s2 +if s1 is an "initial" string (up to directory marker). Thus, if s2 is +a file in any subdirectory of s1, declare a match. ***************************************************************************/ -int strslashcmp(const char *s1, const char *s2) +static int strslashcmp(char *s1, char *s2) { + char *s1_0=s1; + while(*s1 && *s2 && (*s1 == *s2 || tolower(*s1) == tolower(*s2) @@ -393,296 +484,52 @@ int strslashcmp(const char *s1, const char *s2) s1++; s2++; } - return *s1-*s2; -} - -/* - * general smb utility functions - */ -/**************************************************************************** -Set DOS file attributes -***************************************************************************/ -static int do_setrattr(char *fname, int attr, int setit) -{ - /* - * First get the existing attribs from existing file + /* if s1 has a trailing slash, it compared equal, so s1 is an "initial" + string of s2. */ - char *inbuf,*outbuf; - char *p; - pstring name; - int fattr; - - strcpy(name,fname); - strcpy(fname,"\\"); - strcat(fname,name); - - 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; - } - - /* send an smb getatr message */ - - memset(outbuf,0,smb_size); - set_message(outbuf,0,2 + strlen(fname),True); - CVAL(outbuf,smb_com) = SMBgetatr; - SSVAL(outbuf,smb_tid,cnum); - setup_pkt(outbuf); - - p = smb_buf(outbuf); - *p++ = 4; - strcpy(p,fname); - p += (strlen(fname)+1); - - *p++ = 4; - *p++ = 0; - - send_smb(Client,outbuf); - receive_smb(Client,inbuf,CLIENT_TIMEOUT); - - if (CVAL(inbuf,smb_rcls) != 0) - DEBUG(5,("getatr: %s\n",smb_errstr(inbuf))); - else - { - DEBUG(5,("\nattr 0x%X time %d size %d\n", - (int)CVAL(inbuf,smb_vwv0), - SVAL(inbuf,smb_vwv1), - SVAL(inbuf,smb_vwv3))); - } - - fattr=CVAL(inbuf,smb_vwv0); + if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\')) return 0; - /* combine found attributes with bits to be set or reset */ + /* ignore trailing slash on s1 */ + if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1)) return 0; - attr=setit ? (fattr | attr) : (fattr & ~attr); + /* check for s1 is an "initial" string of s2 */ + if (*s2 == '/' || *s2 == '\\') return 0; - /* now try and set attributes by sending smb reset message */ - - /* clear out buffer and start again */ - memset(outbuf,0,smb_size); - set_message(outbuf,8,4 + strlen(fname),True); - CVAL(outbuf,smb_com) = SMBsetatr; - SSVAL(outbuf,smb_tid,cnum); - setup_pkt(outbuf); - - SSVAL(outbuf,smb_vwv0,attr); - - p = smb_buf(outbuf); - *p++ = 4; - strcpy(p,fname); - p += (strlen(fname)+1); - - *p++ = 4; - *p++ = 0; - - send_smb(Client,outbuf); - receive_smb(Client,inbuf,CLIENT_TIMEOUT); - - if (CVAL(inbuf,smb_rcls) != 0) - { - DEBUG(0,("%s setting attributes on file %s\n", - smb_errstr(inbuf), fname)); - free(inbuf);free(outbuf); - return(False); - } - - free(inbuf);free(outbuf); - return(True); + return *s1-*s2; } -/**************************************************************************** -Create a file on a share -***************************************************************************/ -static BOOL smbcreat(file_info finfo, int *fnum, char *inbuf, char *outbuf) -{ - char *p; - /* *must* be called with buffer ready malloc'ed */ - /* open remote file */ - - memset(outbuf,0,smb_size); - set_message(outbuf,3,2 + strlen(finfo.name),True); - 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,finfo.name); - - 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), - finfo.name)); - return 0; - } - - *fnum = SVAL(inbuf,smb_vwv0); - return True; -} /**************************************************************************** -Write a file to a share -***************************************************************************/ -static BOOL smbwrite(int fnum, int n, int low, int high, int left, - char *bufferp, char *inbuf, char *outbuf) -{ - /* *must* be called with buffer ready malloc'ed */ - - memset(outbuf,0,smb_size); - set_message(outbuf,5,n + 3,True); - - memcpy(smb_buf(outbuf)+3, bufferp, n); - - set_message(outbuf,5,n + 3, False); - 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,low); - SSVAL(outbuf,smb_vwv4,left); - 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 writing remote file\n",smb_errstr(inbuf))); - return False; - } - - if (n != SVAL(inbuf,smb_vwv0)) - { - DEBUG(0,("Error: only wrote %d bytes out of %d\n", - SVAL(inbuf,smb_vwv0), n)); - return False; - } - - return True; -} - -/**************************************************************************** -Close a file on a share +Ensure a remote path exists (make if necessary) ***************************************************************************/ -static BOOL smbshut(file_info finfo, int fnum, char *inbuf, char *outbuf) +static BOOL ensurepath(char *fname) { /* *must* be called with buffer ready malloc'ed */ + /* ensures path exists */ - memset(outbuf,0,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,finfo.mtime); - - DEBUG(3,("Setting date to %s (0x%X)", - asctime(LocalTime(&finfo.mtime,GMT_TO_LOCAL)), - finfo.mtime)); - - 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), - finfo.name)); - return False; - } - - return True; -} - -/**************************************************************************** -Verify existence of path on share -***************************************************************************/ -static BOOL smbchkpath(char *fname, char *inbuf, char *outbuf) -{ - char *p; - - memset(outbuf,0,smb_size); - set_message(outbuf,0,4 + strlen(fname),True); - CVAL(outbuf,smb_com) = SMBchkpth; - SSVAL(outbuf,smb_tid,cnum); - setup_pkt(outbuf); - - p = smb_buf(outbuf); - *p++ = 4; - strcpy(p,fname); - - send_smb(Client,outbuf); - receive_smb(Client,inbuf,CLIENT_TIMEOUT); - - DEBUG(5,("smbchkpath: %s\n",smb_errstr(inbuf))); - - return(CVAL(inbuf,smb_rcls) == 0); -} + char *partpath, *ffname; + char *p=fname, *basehack; -/**************************************************************************** -Make a directory on share -***************************************************************************/ -static BOOL smbmkdir(char *fname, char *inbuf, char *outbuf) -{ - /* *must* be called with buffer ready malloc'ed */ - char *p; + DEBUG(5, ( "Ensurepath called with: %s\n", fname)); - memset(outbuf,0,smb_size); - set_message(outbuf,0,2 + strlen(fname),True); - - CVAL(outbuf,smb_com) = SMBmkdir; - SSVAL(outbuf,smb_tid,cnum); - setup_pkt(outbuf); - - p = smb_buf(outbuf); - *p++ = 4; - strcpy(p,fname); - - 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),fname)); - return(False); - } + partpath = string_create_s(strlen(fname)); + ffname = string_create_s(strlen(fname)); - return(True); -} + if ((partpath == NULL) || (ffname == NULL)){ -/**************************************************************************** -Ensure a remote path exists (make if necessary) -***************************************************************************/ -static BOOL ensurepath(char *fname, char *inbuf, char *outbuf) -{ - /* *must* be called with buffer ready malloc'ed */ - /* ensures path exists */ + DEBUG(0, ("Out of memory in ensurepath: %s\n", fname)); + return(False); - pstring partpath, ffname; - char *p=fname, *basehack; + } *partpath = 0; /* fname copied to ffname so can strtok */ - strcpy(ffname, fname); + safe_strcpy(ffname, fname, strlen(fname)); /* do a `basename' on ffname, so don't try and make file name directory */ - if ((basehack=strrchr(ffname, '\\')) == NULL) + if ((basehack=strrchr_m(ffname, '\\')) == NULL) return True; else *basehack='\0'; @@ -691,10 +538,10 @@ static BOOL ensurepath(char *fname, char *inbuf, char *outbuf) while (p) { - strcat(partpath, p); + safe_strcat(partpath, p, strlen(fname) + 1); - if (!smbchkpath(partpath, inbuf, outbuf)) { - if (!smbmkdir(partpath, inbuf, outbuf)) + if (!cli_chkpath(cli, partpath)) { + if (!cli_mkdir(cli, partpath)) { DEBUG(0, ("Error mkdirhiering\n")); return False; @@ -704,16 +551,48 @@ static BOOL ensurepath(char *fname, char *inbuf, char *outbuf) } - strcat(partpath, "\\"); + safe_strcat(partpath, "\\", strlen(fname) + 1); p = strtok(NULL,"/\\"); } return True; } -/* - * smbclient functions - */ +static int padit(char *buf, int bufsize, int padsize) +{ + int berr= 0; + int bytestowrite; + + DEBUG(5, ("Padding with %d zeros\n", padsize)); + memset(buf, 0, bufsize); + while( !berr && padsize > 0 ) { + bytestowrite= MIN(bufsize, padsize); + berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite; + padsize -= bytestowrite; + } + + return berr; +} + + +static void do_setrattr(char *name, uint16 attr, int set) +{ + uint16 oldattr; + + if (!cli_getatr(cli, name, &oldattr, NULL, NULL)) return; + + if (set == ATTRSET) { + attr |= oldattr; + } else { + attr = oldattr & ~attr; + } + + if (!cli_setatr(cli, name, attr, 0)) { + DEBUG(1,("setatr failed: %s\n", cli_errstr(cli))); + } +} + + /**************************************************************************** append one remote file to the tar file ***************************************************************************/ @@ -721,356 +600,154 @@ static void do_atar(char *rname,char *lname,file_info *finfo1) { int fnum; uint32 nread=0; - char *p; - char *inbuf,*outbuf; - file_info finfo; + char ftype; + file_info2 finfo; BOOL close_done = False; BOOL shallitime=True; - BOOL ignore_close_error = False; - char *dataptr=NULL; + char data[65520]; + int read_size = 65520; int datalen=0; struct timeval tp_start; GetTimeOfDay(&tp_start); - if (finfo1) - finfo = *finfo1; - else - finfo = def_finfo; + ftype = '0'; /* An ordinary file ... */ - inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); - outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); + if (finfo1) { + finfo.size = finfo1 -> size; + finfo.mode = finfo1 -> mode; + finfo.uid = finfo1 -> uid; + finfo.gid = finfo1 -> gid; + finfo.mtime = finfo1 -> mtime; + finfo.atime = finfo1 -> atime; + finfo.ctime = finfo1 -> ctime; + } + else { + finfo.size = def_finfo.size; + finfo.mode = def_finfo.mode; + finfo.uid = def_finfo.uid; + finfo.gid = def_finfo.gid; + finfo.mtime = def_finfo.mtime; + finfo.atime = def_finfo.atime; + finfo.ctime = def_finfo.ctime; + } - if (!inbuf || !outbuf) + if (dry_run) { - DEBUG(0,("out of memory\n")); + DEBUG(3,("skipping file %s of size %d bytes\n", + finfo.name, + (int)finfo.size)); + shallitime=0; + ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK); + ntarf++; return; } - memset(outbuf,0,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); + fnum = cli_open(cli, rname, O_RDONLY, DENY_NONE); dos_clean_name(rname); - /* do a chained openX with a readX? */ - if (finfo.size > 0) - { - SSVAL(outbuf,smb_vwv0,SMBreadX); - SSVAL(outbuf,smb_vwv1,PTR_DIFF(p,outbuf) - 4); - memset(p,0,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(0xFFFF,finfo.size)); - smb_setlen(outbuf,smb_len(outbuf)+11*2+1); - } - - 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_atar(rname,lname,finfo1); - free(inbuf);free(outbuf); + if (fnum == -1) { + DEBUG(0,("%s opening remote file %s (%s)\n", + cli_errstr(cli),rname, cur_dir)); return; - } + } - DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),rname)); - free(inbuf);free(outbuf); - return; - } + finfo.name = string_create_s(strlen(rname)); + if (finfo.name == NULL) { + DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n")); + return; + } - strcpy(finfo.name,rname); - if (!finfo1) - { - finfo.mode = SVAL(inbuf,smb_vwv3); - finfo.size = IVAL(inbuf,smb_vwv4); - finfo.mtime = make_unix_date3(inbuf+smb_vwv6); - finfo.atime = finfo.ctime = finfo.mtime; - } + safe_strcpy(finfo.name,rname, strlen(rname)); + if (!finfo1) { + if (!cli_getattrE(cli, fnum, &finfo.mode, &finfo.size, NULL, &finfo.atime, &finfo.mtime)) { + DEBUG(0, ("getattrE: %s\n", cli_errstr(cli))); + return; + } + finfo.ctime = finfo.mtime; + } DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode)); - fnum = SVAL(inbuf,smb_vwv2); - if (tar_inc && !(finfo.mode & aARCH)) { DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name)); shallitime=0; } + else if (!tar_system && (finfo.mode & aSYSTEM)) + { + DEBUG(4, ("skipping %s - system bit is set\n", finfo.name)); + shallitime=0; + } + else if (!tar_hidden && (finfo.mode & aHIDDEN)) + { + DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name)); + shallitime=0; + } else { - if (SVAL(inbuf,smb_vwv0) == SMBreadX) - { - p = (inbuf+4+SVAL(inbuf,smb_vwv1)) - smb_wct; - datalen = SVAL(p,smb_vwv5); - dataptr = inbuf + 4 + SVAL(p,smb_vwv6); - } - else - { - dataptr = NULL; - datalen = 0; - } - - DEBUG(2,("getting file %s of size %d bytes as a tar file %s", + DEBUG(3,("getting file %s of size %d bytes as a tar file %s", finfo.name, - finfo.size, + (int)finfo.size, lname)); /* write a tar header, don't bother with mode - just set to 100644 */ - writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0"); - - while (nread < finfo.size && !close_done) - { - int method = -1; - static BOOL can_chain_close=True; + writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0", ftype); - p=NULL; - - DEBUG(3,("nread=%d\n",nread)); - - /* 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; + while (nread < finfo.size && !close_done) { - /* use readX + close */ - memset(outbuf,0,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,PTR_DIFF(smb_buf(outbuf),outbuf) - 4); - } - 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(0xFFFF,finfo.size-nread)); - - if (close_done) - { - p = smb_buf(outbuf); - memset(p,0,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; - } + DEBUG(3,("nread=%d\n",nread)); - datalen = SVAL(inbuf,smb_vwv5); - dataptr = inbuf + 4 + SVAL(inbuf,smb_vwv6); - break; + datalen = cli_read(cli, fnum, data, nread, read_size); + if (datalen == -1) { + DEBUG(0,("Error reading file %s : %s\n", rname, cli_errstr(cli))); + break; + } - /* use readbraw */ - case 1: - { - static int readbraw_size = 0xFFFF; - - extern int Client; - memset(outbuf,0,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; + nread += datalen; + + /* if file size has increased since we made file size query, truncate + read so tar header for this file will be correct. + */ + + if (nread > finfo.size) { + datalen -= nread - finfo.size; + DEBUG(0,("File size change - truncating %s to %d bytes\n", finfo.name, (int)finfo.size)); } - if(read_data(Client,inbuf,datalen) != datalen) { - DEBUG(0,("Failed to read data in readbraw\n")); - exit(1); - } - dataptr = inbuf; + /* add received bits of file to buffer - dotarbuf will + * write out in 512 byte intervals */ + if (dotarbuf(tarhandle,data,datalen) != datalen) { + DEBUG(0,("Error writing to tar file - %s\n", strerror(errno))); + break; } - break; - - case 3: - /* we've already read some data with a chained readX */ - break; - - default: - /* use plain read */ - memset(outbuf,0,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; - } - - - /* add received bits of file to buffer - dotarbuf will - * write out in 512 byte intervals */ - if (dotarbuf(tarhandle,dataptr,datalen) != datalen) - { - DEBUG(0,("Error writing local file\n")); - break; - } - - nread += datalen; - if (datalen == 0) - { - DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname)); - break; - } - - dataptr=NULL; - datalen=0; - } - + if (datalen == 0) { + DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname)); + break; + } + + datalen=0; + } + + /* pad tar file with zero's if we couldn't get entire file */ + if (nread < finfo.size) { + DEBUG(0, ("Didn't get entire file. size=%d, nread=%d\n", (int)finfo.size, (int)nread)); + if (padit(data, sizeof(data), finfo.size - nread)) + DEBUG(0,("Error writing tar file - %s\n", strerror(errno))); + } + /* round tar file to nearest block */ if (finfo.size % TBLOCK) dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK)); + ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK); ntarf++; } - if (!close_done) - { - memset(outbuf,0,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))); - free(inbuf);free(outbuf); - return; - } - } + cli_close(cli, fnum); if (shallitime) { @@ -1078,7 +755,8 @@ static void do_atar(char *rname,char *lname,file_info *finfo1) int this_time; /* if shallitime is true then we didn't skip */ - if (tar_reset) (void) do_setrattr(finfo.name, aARCH, ATTRRESET); + if (tar_reset && !dry_run) + (void) do_setrattr(finfo.name, aARCH, ATTRRESET); GetTimeOfDay(&tp_end); this_time = @@ -1087,13 +765,18 @@ static void do_atar(char *rname,char *lname,file_info *finfo1) get_total_time_ms += this_time; get_total_size += finfo.size; + if (tar_noisy) + { + DEBUG(0, ("%10d (%7.1f kb/s) %s\n", + (int)finfo.size, finfo.size / MAX(0.001, (1.024*this_time)), + finfo.name)); + } + /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */ - DEBUG(2,("(%g kb/s) (average %g kb/s)\n", + DEBUG(3,("(%g kb/s) (average %g kb/s)\n", finfo.size / MAX(0.001, (1.024*this_time)), get_total_size / MAX(0.001, (1.024*get_total_time_ms)))); } - - free(inbuf);free(outbuf); } /**************************************************************************** @@ -1103,25 +786,29 @@ static void do_tar(file_info *finfo) { pstring rname; - if (strequal(finfo->name,".") || strequal(finfo->name,"..")) + if (strequal(finfo->name,"..") || strequal(finfo->name,".")) return; /* Is it on the exclude list ? */ if (!tar_excl && clipn) { pstring exclaim; - strcpy(exclaim, cur_dir); + DEBUG(5, ("Excl: strlen(cur_dir) = %d\n", (int)strlen(cur_dir))); + + safe_strcpy(exclaim, cur_dir, sizeof(pstring)); *(exclaim+strlen(exclaim)-1)='\0'; - if (clipfind(cliplist, clipn, exclaim)) { - DEBUG(3,("Skipping directory %s\n", exclaim)); - return; - } + safe_strcat(exclaim, "\\", sizeof(pstring)); + safe_strcat(exclaim, finfo->name, sizeof(exclaim)); - strcat(exclaim, "\\"); - strcat(exclaim, finfo->name); + DEBUG(5, ("...tar_re_search: %d\n", tar_re_search)); - if (clipfind(cliplist, clipn, exclaim)) { + if ((!tar_re_search && clipfind(cliplist, clipn, exclaim)) || +#ifdef HAVE_REGEX_H + (tar_re_search && !regexec(preg, exclaim, 0, NULL, 0))) { +#else + (tar_re_search && mask_match(exclaim, cliplist[0], True))) { +#endif DEBUG(3,("Skipping file %s\n", exclaim)); return; } @@ -1131,36 +818,33 @@ static void do_tar(file_info *finfo) { pstring saved_curdir; pstring mtar_mask; - char *inbuf,*outbuf; - inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); - outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN); + safe_strcpy(saved_curdir, cur_dir, sizeof(saved_curdir)); - if (!inbuf || !outbuf) - { - DEBUG(0,("out of memory\n")); - return; - } + DEBUG(5, ("Sizeof(cur_dir)=%d, strlen(cur_dir)=%d, strlen(finfo->name)=%d\nname=%s,cur_dir=%s\n", (int)sizeof(cur_dir), (int)strlen(cur_dir), (int)strlen(finfo->name), finfo->name, cur_dir)); - strcpy(saved_curdir,cur_dir); + safe_strcat(cur_dir,finfo->name, sizeof(cur_dir)); + safe_strcat(cur_dir,"\\", sizeof(cur_dir)); - strcat(cur_dir,finfo->name); - strcat(cur_dir,"\\"); + DEBUG(5, ("Writing a dir, Name = %s\n", cur_dir)); /* write a tar directory, don't bother with mode - just set it to * 40755 */ - writetarheader(tarhandle, cur_dir, 0, finfo->mtime, "040755 \0"); - strcpy(mtar_mask,cur_dir); - strcat(mtar_mask,"*"); - - do_dir((char *)inbuf,(char *)outbuf,mtar_mask,attribute,do_tar,recurse); - strcpy(cur_dir,saved_curdir); - free(inbuf);free(outbuf); + writetarheader(tarhandle, cur_dir, 0, finfo->mtime, "040755 \0", '5'); + if (tar_noisy) { + DEBUG(0,(" directory %s\n", cur_dir)); + } + ntarf++; /* Make sure we have a file on there */ + safe_strcpy(mtar_mask,cur_dir, sizeof(pstring)); + safe_strcat(mtar_mask,"*", sizeof(pstring)); + DEBUG(5, ("Doing list with mtar_mask: %s\n", mtar_mask)); + do_list(mtar_mask, attribute, do_tar, False, True); + safe_strcpy(cur_dir,saved_curdir, sizeof(pstring)); } else { - strcpy(rname,cur_dir); - strcat(rname,finfo->name); + safe_strcpy(rname,cur_dir, sizeof(pstring)); + safe_strcat(rname,finfo->name, sizeof(pstring)); do_atar(rname,finfo->name,finfo); } } @@ -1168,227 +852,423 @@ static void do_tar(file_info *finfo) /**************************************************************************** Convert from UNIX to DOS file names ***************************************************************************/ -static void unfixtarname(char *tptr, char *fp, int l) +static void unfixtarname(char *tptr, char *fp, int l, BOOL first) { - /* remove '.' from start of file name, convert from unix /'s to - * dos \'s in path. Kill any absolute path names. - */ + /* remove '.' from start of file name, convert from unix /'s to + * dos \'s in path. Kill any absolute path names. But only if first! + */ - if (*fp == '.') fp++; - if (*fp == '\\' || *fp == '/') fp++; - -#ifdef KANJI - while (l > 0) { - if (is_shift_jis (*fp)) { - *tptr++ = *fp++; - *tptr++ = *fp++; - l -= 2; - } else if (is_kana (*fp)) { - *tptr++ = *fp++; - l--; - } else if (*fp == '/') { - *tptr++ = '\\'; - fp++; - l--; - } else { - *tptr++ = *fp++; - l--; + DEBUG(5, ("firstb=%lX, secondb=%lX, len=%i\n", (long)tptr, (long)fp, l)); + + if (first) { + if (*fp == '.') { + fp++; + l--; + } + if (*fp == '\\' || *fp == '/') { + fp++; + l--; + } + } + + safe_strcpy(tptr, fp, l); + string_replace(tptr, '/', '\\'); +} + + +/**************************************************************************** +Move to the next block in the buffer, which may mean read in another set of +blocks. FIXME, we should allow more than one block to be skipped. +****************************************************************************/ +static int next_block(char *ltarbuf, char **bufferp, int bufsiz) +{ + int bufread, total = 0; + + DEBUG(5, ("Advancing to next block: %0lx\n", (unsigned long)*bufferp)); + *bufferp += TBLOCK; + total = TBLOCK; + + if (*bufferp >= (ltarbuf + bufsiz)) { + + DEBUG(5, ("Reading more data into ltarbuf ...\n")); + + /* + * Bugfix from Bob Boehmer <boehmer@worldnet.att.net> + * Fixes bug where read can return short if coming from + * a pipe. + */ + + bufread = read(tarhandle, ltarbuf, bufsiz); + total = bufread; + + while (total < bufsiz) { + if (bufread < 0) { /* An error, return false */ + return (total > 0 ? -2 : bufread); + } + if (bufread == 0) { + if (total <= 0) { + return -2; + } + break; + } + bufread = read(tarhandle, <arbuf[total], bufsiz - total); + total += bufread; } + + DEBUG(5, ("Total bytes read ... %i\n", total)); + + *bufferp = ltarbuf; + } -#else - while (l--) { *tptr=(*fp == '/') ? '\\' : *fp; tptr++; fp++; } -#endif + + return(total); + } -static void do_tarput() +/* Skip a file, even if it includes a long file name? */ +static int skip_file(int skipsize) { - file_info finfo; - int nread=0, bufread; - char *inbuf,*outbuf; - int fsize=0; - int fnum; + int dsize = skipsize; + + DEBUG(5, ("Skiping file. Size = %i\n", skipsize)); + + /* FIXME, we should skip more than one block at a time */ + + while (dsize > 0) { + + if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) { + + DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno))); + return(False); + + } + + dsize -= TBLOCK; + + } + + return(True); +} + +/************************************************************* + Get a file from the tar file and store it. + When this is called, tarbuf already contains the first + file block. This is a bit broken & needs fixing. +**************************************************************/ + +static int get_file(file_info2 finfo) +{ + int fnum = -1, pos = 0, dsize = 0, rsize = 0, bpos = 0; + + DEBUG(5, ("get_file: file: %s, size %i\n", finfo.name, (int)finfo.size)); + + if (ensurepath(finfo.name) && + (fnum=cli_open(cli, finfo.name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) == -1) { + DEBUG(0, ("abandoning restore\n")); + return(False); + } + + /* read the blocks from the tar file and write to the remote file */ + + rsize = finfo.size; /* This is how much to write */ + + while (rsize > 0) { + + /* We can only write up to the end of the buffer */ + + dsize = MIN(tbufsiz - (buffer_p - tarbuf) - bpos, 65520); /* Calculate the size to write */ + dsize = MIN(dsize, rsize); /* Should be only what is left */ + DEBUG(5, ("writing %i bytes, bpos = %i ...\n", dsize, bpos)); + + if (cli_write(cli, fnum, 0, buffer_p + bpos, pos, dsize) != dsize) { + DEBUG(0, ("Error writing remote file\n")); + return 0; + } + + rsize -= dsize; + pos += dsize; + + /* Now figure out how much to move in the buffer */ + + /* FIXME, we should skip more than one block at a time */ + + /* First, skip any initial part of the part written that is left over */ + /* from the end of the first TBLOCK */ + + if ((bpos) && ((bpos + dsize) >= TBLOCK)) { + + dsize -= (TBLOCK - bpos); /* Get rid of the end of the first block */ + bpos = 0; + + if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) { /* and skip the block */ + DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno))); + return False; + + } + + } + + /* + * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>. + * If the file being extracted is an exact multiple of + * TBLOCK bytes then we don't want to extract the next + * block from the tarfile here, as it will be done in + * the caller of get_file(). + */ + + while (((rsize != 0) && (dsize >= TBLOCK)) || + ((rsize == 0) && (dsize > TBLOCK))) { + + if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) { + DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno))); + return False; + } + + dsize -= TBLOCK; + } + + bpos = dsize; + + } + + /* Now close the file ... */ + + if (!cli_close(cli, fnum)) { + DEBUG(0, ("Error closing remote file\n")); + return(False); + } + + /* Now we update the creation date ... */ + + DEBUG(5, ("Updating creation date on %s\n", finfo.name)); + + if (!cli_setatr(cli, finfo.name, finfo.mode, finfo.mtime)) { + if (tar_real_noisy) { + DEBUG(0, ("Could not set time on file: %s\n", finfo.name)); + /*return(False); */ /* Ignore, as Win95 does not allow changes */ + } + } + + ntarf++; + + DEBUG(0, ("restore tar file %s of size %d bytes\n", finfo.name, (int)finfo.size)); + + return(True); +} + +/* Create a directory. We just ensure that the path exists and return as there + is no file associated with a directory +*/ +static int get_dir(file_info2 finfo) +{ + + DEBUG(0, ("restore directory %s\n", finfo.name)); + + if (!ensurepath(finfo.name)) { + + DEBUG(0, ("Problems creating directory\n")); + return(False); + + } + + ntarf++; + return(True); + +} +/* Get a file with a long file name ... first file has file name, next file + has the data. We only want the long file name, as the loop in do_tarput + will deal with the rest. +*/ +static char * get_longfilename(file_info2 finfo) +{ + int namesize = finfo.size + strlen(cur_dir) + 2; + char *longname = malloc(namesize); + int offset = 0, left = finfo.size; + BOOL first = True; + + DEBUG(5, ("Restoring a long file name: %s\n", finfo.name)); + DEBUG(5, ("Len = %d\n", (int)finfo.size)); + + if (longname == NULL) { + + DEBUG(0, ("could not allocate buffer of size %d for longname\n", + (int)(finfo.size + strlen(cur_dir) + 2))); + return(NULL); + } + + /* First, add cur_dir to the long file name */ + + if (strlen(cur_dir) > 0) { + strncpy(longname, cur_dir, namesize); + offset = strlen(cur_dir); + } + + /* Loop through the blocks picking up the name */ + + while (left > 0) { + + if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) { + + DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno))); + return(NULL); + + } + + unfixtarname(longname + offset, buffer_p, MIN(TBLOCK, finfo.size), first--); + DEBUG(5, ("UnfixedName: %s, buffer: %s\n", longname, buffer_p)); + + offset += TBLOCK; + left -= TBLOCK; + + } + + return(longname); + +} + +static void do_tarput(void) +{ + file_info2 finfo; struct timeval tp_start; - BOOL tskip=False; /* We'll take each file as it comes */ + char *longfilename = NULL, linkflag; + int skip = False; 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")); + + DEBUG(5, ("RJS do_tarput called ...\n")); + + buffer_p = tarbuf + tbufsiz; /* init this to force first read */ + + /* Now read through those files ... */ + + while (True) { + + /* Get us to the next block, or the first block first time around */ + + if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) { + + DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno))); + return; + } - - /* - * Must read in tbufsiz dollops - */ - /* These should be the only reads in clitar.c */ - while ((bufread=read(tarhandle, tarbuf, tbufsiz))>0) { - char *bufferp, *endofbuffer; - int chunk; + DEBUG(5, ("Reading the next header ...\n")); - /* Code to handle a short read. - * We always need a TBLOCK full of stuff - */ - if (bufread % TBLOCK) { - int lchunk=TBLOCK-(bufread % TBLOCK); - int lread; + switch (readtarheader((union hblock *) buffer_p, &finfo, cur_dir)) { + + case -2: /* Hmm, not good, but not fatal */ + DEBUG(0, ("Skipping %s...\n", finfo.name)); + if ((next_block(tarbuf, &buffer_p, tbufsiz) <= 0) && + !skip_file(finfo.size)) { - /* It's a shorty - a short read that is */ - DEBUG(3, ("Short read, read %d so far (need %d)\n", bufread, lchunk)); + DEBUG(0, ("Short file, bailing out...\n")); + return; - while ((lread=read(tarhandle, tarbuf+bufread, lchunk))>0) { - bufread+=lread; - if (!(lchunk-=lread)) break; } - /* If we've reached EOF then that must be a short file */ - if (lread<=0) break; + break; + + case -1: + DEBUG(0, ("abandoning restore, -1 from read tar header\n")); + return; + + case 0: /* chksum is zero - looks like an EOF */ + DEBUG(0, ("tar: restored %d files and directories\n", ntarf)); + return; /* Hmmm, bad here ... */ + + default: + /* No action */ + + break; + } - bufferp=tarbuf; - endofbuffer=tarbuf+bufread; + /* Now, do we have a long file name? */ + + if (longfilename != NULL) { + + SAFE_FREE(finfo.name); /* Free the space already allocated */ + finfo.name = longfilename; + longfilename = NULL; - if (tskip) { - if (fsize<bufread) { - tskip=False; - bufferp+=fsize; - fsize=0; - } else { - if (fsize==bufread) tskip=False; - fsize-=bufread; - continue; - } } - do { - if (!fsize) - { - switch (readtarheader((union hblock *) bufferp, &finfo, cur_dir)) - { - case -2: /* something dodgy but not fatal about this */ - DEBUG(0, ("skipping %s...\n", finfo.name)); - bufferp+=TBLOCK; /* header - like a link */ - continue; - case -1: - DEBUG(0, ("abandoning restore\n")); - free(inbuf); free(outbuf); - return; - case 0: /* chksum is zero - we assume that one all zero - *header block will do for eof */ - DEBUG(0, - ("total of %d tar files restored to share\n", ntarf)); - free(inbuf); free(outbuf); - return; - default: - break; - } - - tskip=clipn - && (clipfind(cliplist, clipn, finfo.name) ^ tar_excl); - if (tskip) { - bufferp+=TBLOCK; - if (finfo.mode & aDIR) - continue; - else if ((fsize=finfo.size) % TBLOCK) { - fsize+=TBLOCK-(fsize%TBLOCK); - } - if (fsize<endofbuffer-bufferp) { - bufferp+=fsize; - fsize=0; - continue; - } else { - fsize-=endofbuffer-bufferp; - break; - } - } + /* Well, now we have a header, process the file ... */ - if (finfo.mode & aDIR) - { - if (!smbchkpath(finfo.name, inbuf, outbuf) - && !smbmkdir(finfo.name, inbuf, outbuf)) - { - DEBUG(0, ("abandoning restore\n")); - free(inbuf); free(outbuf); - return; - } - else - { - bufferp+=TBLOCK; - continue; - } - } - - fsize=finfo.size; - - if (ensurepath(finfo.name, inbuf, outbuf) - && !smbcreat(finfo, &fnum, inbuf, outbuf)) - { - DEBUG(0, ("abandoning restore\n")); - free(inbuf);free(outbuf); - return; - } - - DEBUG(0,("restore tar file %s of size %d bytes\n", - finfo.name,finfo.size)); - - nread=0; - if ((bufferp+=TBLOCK) >= endofbuffer) break; - } /* if (!fsize) */ - - /* write out the file in chunk sized chunks - don't - * go past end of buffer though */ - chunk=(fsize-nread < endofbuffer - bufferp) - ? fsize - nread : endofbuffer - bufferp; - - while (chunk > 0) { - int minichunk=MIN(chunk, max_xmit-200); - - if (!smbwrite(fnum, /* file descriptor */ - minichunk, /* n */ - nread, /* offset low */ - 0, /* offset high - not implemented */ - fsize-nread, /* left - only hint to server */ - bufferp, - inbuf, - outbuf)) - { - DEBUG(0, ("Error writing remote file\n")); - free(inbuf); free(outbuf); - return; - } - DEBUG(5, ("chunk writing fname=%s fnum=%d nread=%d minichunk=%d chunk=%d size=%d\n", finfo.name, fnum, nread, minichunk, chunk, fsize)); - - bufferp+=minichunk; nread+=minichunk; - chunk-=minichunk; + /* Should we skip the file? We have the long name as well here */ + + skip = clipn && + ((!tar_re_search && clipfind(cliplist, clipn, finfo.name) ^ tar_excl) +#ifdef HAVE_REGEX_H + || (tar_re_search && !regexec(preg, finfo.name, 0, NULL, 0))); +#else + || (tar_re_search && mask_match(finfo.name, cliplist[0], True))); +#endif + + DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, (cliplist?cliplist[0]:NULL), finfo.name)); + + if (skip) { + + skip_file(finfo.size); + continue; + + } + + /* We only get this far if we should process the file */ + linkflag = ((union hblock *)buffer_p) -> dbuf.linkflag; + + switch (linkflag) { + + case '0': /* Should use symbolic names--FIXME */ + + /* + * Skip to the next block first, so we can get the file, FIXME, should + * be in get_file ... + * The 'finfo.size != 0' fix is from Bob Boehmer <boehmer@worldnet.att.net> + * Fixes bug where file size in tarfile is zero. + */ + + if ((finfo.size != 0) && next_block(tarbuf, &buffer_p, tbufsiz) <=0) { + DEBUG(0, ("Short file, bailing out...\n")); + return; } - - if (nread>=fsize) - { - if (!smbshut(finfo, fnum, inbuf, outbuf)) - { - DEBUG(0, ("Error closing remote file\n")); - free(inbuf);free(outbuf); - return; - } - if (fsize % TBLOCK) bufferp+=TBLOCK - (fsize % TBLOCK); - DEBUG(5, ("bufferp is now %d (psn=%d)\n", - (long) bufferp, (long)(bufferp - tarbuf))); - ntarf++; - fsize=0; - } - } while (bufferp < endofbuffer); + if (!get_file(finfo)) { + DEBUG(0, ("Abandoning restore\n")); + return; + + } + break; + + case '5': + if (!get_dir(finfo)) { + DEBUG(0, ("Abandoning restore \n")); + return; + } + break; + + case 'L': + longfilename = get_longfilename(finfo); + if (!longfilename) { + DEBUG(0, ("abandoning restore\n")); + return; + + } + DEBUG(5, ("Long file name: %s\n", longfilename)); + break; + + default: + skip_file(finfo.size); /* Don't handle these yet */ + break; + + } + } - DEBUG(0, ("premature eof on tar file ?\n")); - DEBUG(0,("total of %d tar files restored to share\n", ntarf)); - free(inbuf); free(outbuf); } + /* * samba interactive commands */ @@ -1396,36 +1276,38 @@ static void do_tarput() /**************************************************************************** Blocksize command ***************************************************************************/ -void cmd_block(void) +int cmd_block(void) { fstring buf; int block; - if (!next_token(NULL,buf,NULL)) + if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) { DEBUG(0, ("blocksize <n>\n")); - return; + return 1; } block=atoi(buf); if (block < 0 || block > 65535) { DEBUG(0, ("blocksize out of range")); - return; + return 1; } blocksize=block; DEBUG(2,("blocksize is now %d\n", blocksize)); + + return 0; } /**************************************************************************** command to set incremental / reset mode ***************************************************************************/ -void cmd_tarmode(void) +int cmd_tarmode(void) { fstring buf; - while (next_token(NULL,buf,NULL)) { + while (next_token_nr(NULL,buf,NULL,sizeof(buf))) { if (strequal(buf, "full")) tar_inc=False; else if (strequal(buf, "inc")) @@ -1434,37 +1316,54 @@ void cmd_tarmode(void) tar_reset=True; else if (strequal(buf, "noreset")) tar_reset=False; + else if (strequal(buf, "system")) + tar_system=True; + else if (strequal(buf, "nosystem")) + tar_system=False; + else if (strequal(buf, "hidden")) + tar_hidden=True; + else if (strequal(buf, "nohidden")) + tar_hidden=False; + else if (strequal(buf, "verbose") || strequal(buf, "noquiet")) + tar_noisy=True; + else if (strequal(buf, "quiet") || strequal(buf, "noverbose")) + tar_noisy=False; else DEBUG(0, ("tarmode: unrecognised option %s\n", buf)); } - DEBUG(0, ("tarmode is now %s, %s\n", + DEBUG(0, ("tarmode is now %s, %s, %s, %s, %s\n", tar_inc ? "incremental" : "full", - tar_reset ? "reset" : "noreset")); + tar_system ? "system" : "nosystem", + tar_hidden ? "hidden" : "nohidden", + tar_reset ? "reset" : "noreset", + tar_noisy ? "verbose" : "quiet")); + + return 0; } /**************************************************************************** Feeble attrib command ***************************************************************************/ -void cmd_setmode(void) +int cmd_setmode(void) { char *q; fstring buf; pstring fname; - int attra[2]; + uint16 attra[2]; int direct=1; attra[0] = attra[1] = 0; - if (!next_token(NULL,buf,NULL)) + if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) { - DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n")); - return; + DEBUG(0, ("setmode <filename> <[+|-]rsha>\n")); + return 1; } - strcpy(fname, cur_dir); - strcat(fname, buf); + safe_strcpy(fname, cur_dir, sizeof(pstring)); + safe_strcat(fname, buf, sizeof(pstring)); - while (next_token(NULL,buf,NULL)) { + while (next_token_nr(NULL,buf,NULL,sizeof(buf))) { q=buf; while(*q) @@ -1482,55 +1381,64 @@ void cmd_setmode(void) case 'a': attra[direct]|=aARCH; break; default: DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n")); - return; + return 1; } } if (attra[ATTRSET]==0 && attra[ATTRRESET]==0) { - DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n")); - return; + DEBUG(0, ("setmode <filename> <[+|-]rsha>\n")); + return 1; } -DEBUG(2, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET])); - (void) do_setrattr(fname, attra[ATTRSET], ATTRSET); - (void) do_setrattr(fname, attra[ATTRRESET], ATTRRESET); + DEBUG(2, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET])); + do_setrattr(fname, attra[ATTRSET], ATTRSET); + do_setrattr(fname, attra[ATTRRESET], ATTRRESET); + + return 0; } /**************************************************************************** Principal command for creating / extracting ***************************************************************************/ -void cmd_tar(char *inbuf, char *outbuf) +int cmd_tar(void) { fstring buf; char **argl; int argcl; - if (!next_token(NULL,buf,NULL)) + if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) { - DEBUG(0,("tar <c|x>[IXbga] <filename>\n")); - return; + DEBUG(0,("tar <c|x>[IXbgan] <filename>\n")); + return 1; } argl=toktocliplist(&argcl, NULL); if (!tar_parseargs(argcl, argl, buf, 0)) - return; + return 1; - process_tar(inbuf, outbuf); + process_tar(); - free(argl); + SAFE_FREE(argl); + + return 0; } /**************************************************************************** Command line (option) version ***************************************************************************/ -int process_tar(char *inbuf, char *outbuf) +int process_tar(void) { initarbuf(); switch(tar_type) { case 'x': + +#if 0 + do_tarput2(); +#else do_tarput(); - free(tarbuf); +#endif + SAFE_FREE(tarbuf); close(tarhandle); break; case 'r': @@ -1540,67 +1448,82 @@ int process_tar(char *inbuf, char *outbuf) pstring tarmac; for (i=0; i<clipn; i++) { - DEBUG(0,("arg %d = %s\n", i, cliplist[i])); + DEBUG(5,("arg %d = %s\n", i, cliplist[i])); if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') { *(cliplist[i]+strlen(cliplist[i])-1)='\0'; } - if (strrchr(cliplist[i], '\\')) { + if (strrchr_m(cliplist[i], '\\')) { pstring saved_dir; - strcpy(saved_dir, cur_dir); + safe_strcpy(saved_dir, cur_dir, sizeof(pstring)); if (*cliplist[i]=='\\') { - strcpy(tarmac, cliplist[i]); + safe_strcpy(tarmac, cliplist[i], sizeof(pstring)); } else { - strcpy(tarmac, cur_dir); - strcat(tarmac, cliplist[i]); + safe_strcpy(tarmac, cur_dir, sizeof(pstring)); + safe_strcat(tarmac, cliplist[i], sizeof(pstring)); } - strcpy(cur_dir, tarmac); - *(strrchr(cur_dir, '\\')+1)='\0'; + safe_strcpy(cur_dir, tarmac, sizeof(pstring)); + *(strrchr_m(cur_dir, '\\')+1)='\0'; - do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse); - strcpy(cur_dir,saved_dir); + DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac)); + do_list(tarmac,attribute,do_tar, False, True); + safe_strcpy(cur_dir,saved_dir, sizeof(pstring)); } else { - strcpy(tarmac, cur_dir); - strcat(tarmac, cliplist[i]); - do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse); + safe_strcpy(tarmac, cur_dir, sizeof(pstring)); + safe_strcat(tarmac, cliplist[i], sizeof(pstring)); + DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac)); + do_list(tarmac,attribute,do_tar, False, True); } } } else { pstring mask; - strcpy(mask,cur_dir); - strcat(mask,"\\*"); - do_dir((char *)inbuf,(char *)outbuf,mask,attribute,do_tar,recurse); + safe_strcpy(mask,cur_dir, sizeof(pstring)); + DEBUG(5, ("process_tar, do_list with mask: %s\n", mask)); + safe_strcat(mask,"\\*", sizeof(pstring)); + do_list(mask,attribute,do_tar,False, True); } if (ntarf) dotareof(tarhandle); close(tarhandle); - free(tarbuf); + SAFE_FREE(tarbuf); - DEBUG(0, ("tar: dumped %d tar files\n", ntarf)); + DEBUG(0, ("tar: dumped %d files and directories\n", ntarf)); + DEBUG(0, ("Total bytes written: %.0f\n", (double)ttarf)); break; } + if (must_free_cliplist) { + int i; + for (i = 0; i < clipn; ++i) { + SAFE_FREE(cliplist[i]); + } + SAFE_FREE(cliplist); + cliplist = NULL; + clipn = 0; + must_free_cliplist = False; + } + return(0); } /**************************************************************************** Find a token (filename) in a clip list ***************************************************************************/ -int clipfind(char **aret, int ret, char *tok) +static int clipfind(char **aret, int ret, char *tok) { if (aret==NULL) return 0; /* ignore leading slashes or dots in token */ - while(strchr("/\\.", *tok)) tok++; + while(strchr_m("/\\.", *tok)) tok++; while(ret--) { char *pkey=*aret++; /* ignore leading slashes or dots in list */ - while(strchr("/\\.", *pkey)) pkey++; + while(strchr_m("/\\.", *pkey)) pkey++; if (!strslashcmp(pkey, tok)) return 1; } @@ -1609,6 +1532,114 @@ int clipfind(char **aret, int ret, char *tok) } /**************************************************************************** +Read list of files to include from the file and initialize cliplist +accordingly. +***************************************************************************/ +static int read_inclusion_file(char *filename) +{ + XFILE *inclusion = NULL; + char buf[MAXPATHLEN + 1]; + char *inclusion_buffer = NULL; + int inclusion_buffer_size = 0; + int inclusion_buffer_sofar = 0; + char *p; + char *tmpstr; + int i; + int error = 0; + + clipn = 0; + buf[MAXPATHLEN] = '\0'; /* guarantee null-termination */ + if ((inclusion = x_fopen(filename, O_RDONLY, 0)) == NULL) { + /* XXX It would be better to include a reason for failure, but without + * autoconf, it's hard to use strerror, sys_errlist, etc. + */ + DEBUG(0,("Unable to open inclusion file %s\n", filename)); + return 0; + } + + while ((! error) && (x_fgets(buf, sizeof(buf)-1, inclusion))) { + if (inclusion_buffer == NULL) { + inclusion_buffer_size = 1024; + if ((inclusion_buffer = malloc(inclusion_buffer_size)) == NULL) { + DEBUG(0,("failure allocating buffer to read inclusion file\n")); + error = 1; + break; + } + } + + if (buf[strlen(buf)-1] == '\n') { + buf[strlen(buf)-1] = '\0'; + } + + if ((strlen(buf) + 1 + inclusion_buffer_sofar) >= inclusion_buffer_size) { + char *ib; + inclusion_buffer_size *= 2; + ib = Realloc(inclusion_buffer,inclusion_buffer_size); + if (! ib) { + DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n", + inclusion_buffer_size)); + error = 1; + break; + } + else inclusion_buffer = ib; + } + + safe_strcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar); + inclusion_buffer_sofar += strlen(buf) + 1; + clipn++; + } + x_fclose(inclusion); + + if (! error) { + /* Allocate an array of clipn + 1 char*'s for cliplist */ + cliplist = malloc((clipn + 1) * sizeof(char *)); + if (cliplist == NULL) { + DEBUG(0,("failure allocating memory for cliplist\n")); + error = 1; + } else { + cliplist[clipn] = NULL; + p = inclusion_buffer; + for (i = 0; (! error) && (i < clipn); i++) { + /* set current item to NULL so array will be null-terminated even if + * malloc fails below. */ + cliplist[i] = NULL; + if ((tmpstr = (char *)malloc(strlen(p)+1)) == NULL) { + DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", i)); + error = 1; + } else { + unfixtarname(tmpstr, p, strlen(p) + 1, True); + cliplist[i] = tmpstr; + if ((p = strchr_m(p, '\000')) == NULL) { + DEBUG(0,("INTERNAL ERROR: inclusion_buffer is of unexpected contents.\n")); + abort(); + } + } + ++p; + } + must_free_cliplist = True; + } + } + + SAFE_FREE(inclusion_buffer); + if (error) { + if (cliplist) { + char **pp; + /* We know cliplist is always null-terminated */ + for (pp = cliplist; *pp; ++pp) { + SAFE_FREE(*pp); + } + SAFE_FREE(cliplist); + cliplist = NULL; + must_free_cliplist = False; + } + return 0; + } + + /* cliplist and its elements are freed at the end of process_tar. */ + return 1; +} + +/**************************************************************************** Parse tar arguments. Sets tar_type, tar_excl, etc. ***************************************************************************/ int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind) @@ -1620,6 +1651,7 @@ int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind) */ tar_type='\0'; tar_excl=True; + dry_run=False; while (*Optarg) switch(*Optarg++) { @@ -1649,13 +1681,13 @@ int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind) DEBUG(0,("Option N must be followed by valid file name\n")); return 0; } else { - struct stat stbuf; + SMB_STRUCT_STAT stbuf; extern time_t newer_than; if (sys_stat(argv[Optind], &stbuf) == 0) { newer_than = stbuf.st_mtime; DEBUG(1,("Getting files newer than %s", - asctime(LocalTime(&newer_than,GMT_TO_LOCAL)))); + asctime(LocalTime(&newer_than)))); Optind++; } else { DEBUG(0,("Error setting newer-than time\n")); @@ -1666,20 +1698,43 @@ int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind) case 'a': tar_reset=True; break; + case 'q': + tar_noisy=False; + break; case 'I': if (tar_clipfl) { - DEBUG(0,("Only one of I,X must be specified\n")); + DEBUG(0,("Only one of I,X,F must be specified\n")); return 0; } tar_clipfl='I'; break; case 'X': if (tar_clipfl) { - DEBUG(0,("Only one of I,X must be specified\n")); + DEBUG(0,("Only one of I,X,F must be specified\n")); return 0; } tar_clipfl='X'; break; + case 'F': + if (tar_clipfl) { + DEBUG(0,("Only one of I,X,F must be specified\n")); + return 0; + } + tar_clipfl='F'; + break; + case 'r': + DEBUG(0, ("tar_re_search set\n")); + tar_re_search = True; + break; + case 'n': + if (tar_type == 'c') { + DEBUG(0, ("dry_run set\n")); + dry_run = True; + } else { + DEBUG(0, ("n is only meaningful when creating a tar-file\n")); + return 0; + } + break; default: DEBUG(0,("Unknown tar option\n")); return 0; @@ -1690,21 +1745,105 @@ int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind) return 0; } + /* tar_excl is true if cliplist lists files to be included. + * Both 'I' and 'F' mean include. */ + tar_excl=tar_clipfl!='X'; + + if (tar_clipfl=='F') { + if (argc-Optind-1 != 1) { + DEBUG(0,("Option F must be followed by exactly one filename.\n")); + return 0; + } + if (! read_inclusion_file(argv[Optind+1])) { + return 0; + } + } else if (Optind+1<argc && !tar_re_search) { /* For backwards compatibility */ + char *tmpstr; + char **tmplist; + int clipcount; + + cliplist=argv+Optind+1; + clipn=argc-Optind-1; + clipcount = clipn; + + if ((tmplist=malloc(clipn*sizeof(char *))) == NULL) { + DEBUG(0, ("Could not allocate space to process cliplist, count = %i\n", + clipn) + ); + return 0; + } + + for (clipcount = 0; clipcount < clipn; clipcount++) { + + DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount])); + + if ((tmpstr = (char *)malloc(strlen(cliplist[clipcount])+1)) == NULL) { + DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", + clipcount) + ); + return 0; + } + unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1, True); + tmplist[clipcount] = tmpstr; + DEBUG(5, ("Processed an item, %s\n", tmpstr)); + + DEBUG(5, ("Cliplist is: %s\n", cliplist[0])); + } + cliplist = tmplist; + must_free_cliplist = True; + } + + if (Optind+1<argc && tar_re_search) { /* Doing regular expression seaches */ +#ifdef HAVE_REGEX_H + int errcode; + + if ((preg = (regex_t *)malloc(65536)) == NULL) { + + DEBUG(0, ("Could not allocate buffer for regular expression search\n")); + return; + + } + + if (errcode = regcomp(preg, argv[Optind + 1], REG_EXTENDED)) { + char errstr[1024]; + size_t errlen; + + errlen = regerror(errcode, preg, errstr, sizeof(errstr) - 1); + + DEBUG(0, ("Could not compile pattern buffer for re search: %s\n%s\n", argv[Optind + 1], errstr)); + return; + + } +#endif + + clipn=argc-Optind-1; + cliplist=argv+Optind+1; + + } + if (Optind>=argc || !strcmp(argv[Optind], "-")) { /* Sets tar handle to either 0 or 1, as appropriate */ tarhandle=(tar_type=='c'); + /* + * Make sure that dbf points to stderr if we are using stdout for + * tar output + */ + if (tarhandle == 1) + dbf = x_stderr; } else { - tar_excl=tar_clipfl!='X'; - - if (Optind+1<argc) { - cliplist=argv+Optind+1; - clipn=argc-Optind-1; - } - - if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY)) == -1) - || (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0)) + if (tar_type=='c' && (dry_run || strcmp(argv[Optind], "/dev/null")==0)) + { + if (!dry_run) { + DEBUG(0,("Output is /dev/null, assuming dry_run")); + dry_run = True; + } + tarhandle=-1; + } else + if ((tar_type=='x' && (tarhandle = sys_open(argv[Optind], O_RDONLY, 0)) == -1) + || (tar_type=='c' && (tarhandle=sys_creat(argv[Optind], 0644)) < 0)) { - DEBUG(0,("Error opening local file %s\n",argv[Optind])); + DEBUG(0,("Error opening local file %s - %s\n", + argv[Optind], strerror(errno))); return(0); } } diff --git a/source3/client/smbmnt.c b/source3/client/smbmnt.c new file mode 100644 index 0000000000..36248987b1 --- /dev/null +++ b/source3/client/smbmnt.c @@ -0,0 +1,306 @@ +/* + * smbmnt.c + * + * Copyright (C) 1995-1998 by Paal-Kr. Engstad and Volker Lendecke + * extensively modified by Tridge + * + */ + +#include "includes.h" + +#include <mntent.h> +#include <sys/utsname.h> + +#include <asm/types.h> +#include <asm/posix_types.h> +#include <linux/smb.h> +#include <linux/smb_mount.h> +#include <asm/unistd.h> + +#ifndef MS_MGC_VAL +/* This may look strange but MS_MGC_VAL is what we are looking for and + is what we need from <linux/fs.h> under libc systems and is + provided in standard includes on glibc systems. So... We + switch on what we need... */ +#include <linux/fs.h> +#endif + +static uid_t mount_uid; +static gid_t mount_gid; +static int mount_ro; +static unsigned mount_fmask; +static unsigned mount_dmask; +static int user_mount; +static char *options; + +static void +help(void) +{ + printf("\n"); + printf("Usage: smbmnt mount-point [options]\n"); + printf("Version %s\n\n",VERSION); + printf("-s share share name on server\n" + "-r mount read-only\n" + "-u uid mount as uid\n" + "-g gid mount as gid\n" + "-f mask permission mask for files\n" + "-d mask permission mask for directories\n" + "-o options name=value, list of options\n" + "-h print this help text\n"); +} + +static int +parse_args(int argc, char *argv[], struct smb_mount_data *data, char **share) +{ + int opt; + + while ((opt = getopt (argc, argv, "s:u:g:rf:d:o:")) != EOF) + { + switch (opt) + { + case 's': + *share = optarg; + break; + case 'u': + if (!user_mount) { + mount_uid = strtol(optarg, NULL, 0); + } + break; + case 'g': + if (!user_mount) { + mount_gid = strtol(optarg, NULL, 0); + } + break; + case 'r': + mount_ro = 1; + break; + case 'f': + mount_fmask = strtol(optarg, NULL, 8); + break; + case 'd': + mount_dmask = strtol(optarg, NULL, 8); + break; + case 'o': + options = optarg; + break; + default: + return -1; + } + } + return 0; + +} + +static char * +fullpath(const char *p) +{ + char path[MAXPATHLEN]; + + if (strlen(p) > MAXPATHLEN-1) { + return NULL; + } + + if (realpath(p, path) == NULL) { + fprintf(stderr,"Failed to find real path for mount point\n"); + exit(1); + } + return strdup(path); +} + +/* Check whether user is allowed to mount on the specified mount point. If it's + OK then we change into that directory - this prevents race conditions */ +static int mount_ok(char *mount_point) +{ + SMB_STRUCT_STAT st; + + if (chdir(mount_point) != 0) { + return -1; + } + + if (sys_stat(".", &st) != 0) { + return -1; + } + + if (!S_ISDIR(st.st_mode)) { + errno = ENOTDIR; + return -1; + } + + if ((getuid() != 0) && + ((getuid() != st.st_uid) || + ((st.st_mode & S_IRWXU) != S_IRWXU))) { + errno = EPERM; + return -1; + } + + return 0; +} + +/* Tries to mount using the appropriate format. For 2.2 the struct, + for 2.4 the ascii version. */ +static int +do_mount(char *share_name, unsigned int flags, struct smb_mount_data *data) +{ + pstring opts; + struct utsname uts; + char *release, *major, *minor; + char *data1, *data2; + + uname(&uts); + release = uts.release; + major = strsep(&release, "."); + minor = strsep(&release, "."); + if (major && minor && atoi(major) == 2 && atoi(minor) < 4) { + /* < 2.4, assume struct */ + data1 = (char *) data; + data2 = opts; + } else { + /* >= 2.4, assume ascii but fall back on struct */ + data1 = opts; + data2 = (char *) data; + } + + slprintf(opts, sizeof(opts)-1, + "version=7,uid=%d,gid=%d,file_mode=0%o,dir_mode=0%o,%s", + data->uid, data->gid, data->file_mode, data->dir_mode,options); + if (mount(share_name, ".", "smbfs", flags, data1) == 0) + return 0; + return mount(share_name, ".", "smbfs", flags, data2); +} + + int main(int argc, char *argv[]) +{ + char *mount_point, *share_name = NULL; + FILE *mtab; + int fd; + unsigned int flags; + struct smb_mount_data data; + struct mntent ment; + + memset(&data, 0, sizeof(struct smb_mount_data)); + + if (argc < 2) { + help(); + exit(1); + } + + if (argv[1][0] == '-') { + help(); + exit(1); + } + + if (getuid() != 0) { + user_mount = 1; + } + + if (geteuid() != 0) { + fprintf(stderr, "smbmnt must be installed suid root for direct user mounts (%d,%d)\n", getuid(), geteuid()); + exit(1); + } + + mount_uid = getuid(); + mount_gid = getgid(); + mount_fmask = umask(0); + umask(mount_fmask); + mount_fmask = ~mount_fmask; + + mount_point = fullpath(argv[1]); + + argv += 1; + argc -= 1; + + if (mount_ok(mount_point) != 0) { + fprintf(stderr, "cannot mount on %s: %s\n", + mount_point, strerror(errno)); + exit(1); + } + + data.version = SMB_MOUNT_VERSION; + + /* getuid() gives us the real uid, who may umount the fs */ + data.mounted_uid = getuid(); + + if (parse_args(argc, argv, &data, &share_name) != 0) { + help(); + return -1; + } + + data.uid = mount_uid; + data.gid = mount_gid; + data.file_mode = (S_IRWXU|S_IRWXG|S_IRWXO) & mount_fmask; + data.dir_mode = (S_IRWXU|S_IRWXG|S_IRWXO) & mount_dmask; + + if (mount_dmask == 0) { + data.dir_mode = data.file_mode; + if ((data.dir_mode & S_IRUSR) != 0) + data.dir_mode |= S_IXUSR; + if ((data.dir_mode & S_IRGRP) != 0) + data.dir_mode |= S_IXGRP; + if ((data.dir_mode & S_IROTH) != 0) + data.dir_mode |= S_IXOTH; + } + + flags = MS_MGC_VAL; + + if (mount_ro) flags |= MS_RDONLY; + + if (do_mount(share_name, flags, &data) < 0) { + switch (errno) { + case ENODEV: + fprintf(stderr, "ERROR: smbfs filesystem not supported by the kernel\n"); + break; + default: + perror("mount error"); + } + fprintf(stderr, "Please refer to the smbmnt(8) manual page\n"); + return -1; + } + + ment.mnt_fsname = share_name ? share_name : "none"; + ment.mnt_dir = mount_point; + ment.mnt_type = "smbfs"; + ment.mnt_opts = ""; + ment.mnt_freq = 0; + ment.mnt_passno= 0; + + mount_point = ment.mnt_dir; + + if (mount_point == NULL) + { + fprintf(stderr, "Mount point too long\n"); + return -1; + } + + if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1) + { + fprintf(stderr, "Can't get "MOUNTED"~ lock file"); + return 1; + } + close(fd); + + if ((mtab = setmntent(MOUNTED, "a+")) == NULL) + { + fprintf(stderr, "Can't open " MOUNTED); + return 1; + } + + if (addmntent(mtab, &ment) == 1) + { + fprintf(stderr, "Can't write mount entry"); + return 1; + } + if (fchmod(fileno(mtab), 0644) == -1) + { + fprintf(stderr, "Can't set perms on "MOUNTED); + return 1; + } + endmntent(mtab); + + if (unlink(MOUNTED"~") == -1) + { + fprintf(stderr, "Can't remove "MOUNTED"~"); + return 1; + } + + return 0; +} diff --git a/source3/client/smbmount.c b/source3/client/smbmount.c new file mode 100644 index 0000000000..ad050063ec --- /dev/null +++ b/source3/client/smbmount.c @@ -0,0 +1,883 @@ +/* + Unix SMB/CIFS implementation. + SMBFS mount program + Copyright (C) Andrew Tridgell 1999 + + 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. +*/ + +#define NO_SYSLOG + +#include "includes.h" + +#include <mntent.h> +#include <asm/types.h> +#include <linux/smb_fs.h> + +extern BOOL in_client; +extern pstring user_socket_options; +extern BOOL append_log; +extern fstring remote_machine; + +static pstring credentials; +static pstring my_netbios_name; +static pstring password; +static pstring username; +static pstring workgroup; +static pstring mpoint; +static pstring service; +static pstring options; + +static struct in_addr dest_ip; +static BOOL have_ip; +static int smb_port = 0; +static BOOL got_pass; +static uid_t mount_uid; +static gid_t mount_gid; +static int mount_ro; +static unsigned mount_fmask; +static unsigned mount_dmask; + +static void usage(void); + +static void exit_parent(int sig) +{ + /* parent simply exits when child says go... */ + exit(0); +} + +static void daemonize(void) +{ + int j, status; + pid_t child_pid; + + signal( SIGTERM, exit_parent ); + + if ((child_pid = sys_fork()) < 0) { + DEBUG(0,("could not fork\n")); + } + + if (child_pid > 0) { + while( 1 ) { + j = waitpid( child_pid, &status, 0 ); + if( j < 0 ) { + if( EINTR == errno ) { + continue; + } + status = errno; + } + break; + } + /* If we get here - the child exited with some error status */ + exit(status); + } + + signal( SIGTERM, SIG_DFL ); + chdir("/"); +} + +static void close_our_files(int client_fd) +{ + int i; + struct rlimit limits; + + getrlimit(RLIMIT_NOFILE,&limits); + for (i = 0; i< limits.rlim_max; i++) { + if (i == client_fd) + continue; + close(i); + } +} + +static void usr1_handler(int x) +{ + return; +} + + +/***************************************************** +return a connection to a server +*******************************************************/ +static struct cli_state *do_connection(char *the_service) +{ + struct cli_state *c; + struct nmb_name called, calling; + char *server_n; + struct in_addr ip; + pstring server; + char *share; + + if (the_service[0] != '\\' || the_service[1] != '\\') { + usage(); + exit(1); + } + + pstrcpy(server, the_service+2); + share = strchr_m(server,'\\'); + if (!share) { + usage(); + exit(1); + } + *share = 0; + share++; + + server_n = server; + + make_nmb_name(&calling, my_netbios_name, 0x0); + make_nmb_name(&called , server, 0x20); + + again: + zero_ip(&ip); + if (have_ip) ip = dest_ip; + + /* have to open a new connection */ + if (!(c=cli_initialise(NULL)) || (cli_set_port(c, smb_port) != smb_port) || + !cli_connect(c, server_n, &ip)) { + DEBUG(0,("%d: Connection to %s failed\n", sys_getpid(), server_n)); + if (c) { + cli_shutdown(c); + } + return NULL; + } + + /* SPNEGO doesn't work till we get NTSTATUS error support */ + c->use_spnego = False; + + if (!cli_session_request(c, &calling, &called)) { + char *p; + DEBUG(0,("%d: session request to %s failed (%s)\n", + sys_getpid(), called.name, cli_errstr(c))); + cli_shutdown(c); + if ((p=strchr_m(called.name, '.'))) { + *p = 0; + goto again; + } + if (strcmp(called.name, "*SMBSERVER")) { + make_nmb_name(&called , "*SMBSERVER", 0x20); + goto again; + } + return NULL; + } + + DEBUG(4,("%d: session request ok\n", sys_getpid())); + + if (!cli_negprot(c)) { + DEBUG(0,("%d: protocol negotiation failed\n", sys_getpid())); + cli_shutdown(c); + return NULL; + } + + if (!got_pass) { + char *pass = getpass("Password: "); + if (pass) { + pstrcpy(password, pass); + } + } + + /* This should be right for current smbfs. Future versions will support + large files as well as unicode and oplocks. */ + c->capabilities &= ~(CAP_UNICODE | CAP_LARGE_FILES | CAP_NT_SMBS | + CAP_NT_FIND | CAP_STATUS32 | CAP_LEVEL_II_OPLOCKS); + c->force_dos_errors = True; + if (!cli_session_setup(c, username, + password, strlen(password), + password, strlen(password), + workgroup)) { + /* if a password was not supplied then try again with a + null username */ + if (password[0] || !username[0] || + !cli_session_setup(c, "", "", 0, "", 0, workgroup)) { + DEBUG(0,("%d: session setup failed: %s\n", + sys_getpid(), cli_errstr(c))); + cli_shutdown(c); + return NULL; + } + DEBUG(0,("Anonymous login successful\n")); + } + + DEBUG(4,("%d: session setup ok\n", sys_getpid())); + + if (!cli_send_tconX(c, share, "?????", + password, strlen(password)+1)) { + DEBUG(0,("%d: tree connect failed: %s\n", + sys_getpid(), cli_errstr(c))); + cli_shutdown(c); + return NULL; + } + + DEBUG(4,("%d: tconx ok\n", sys_getpid())); + + got_pass = True; + + return c; +} + + +/**************************************************************************** +unmount smbfs (this is a bailout routine to clean up if a reconnect fails) + Code blatently stolen from smbumount.c + -mhw- +****************************************************************************/ +static void smb_umount(char *mount_point) +{ + int fd; + struct mntent *mnt; + FILE* mtab; + FILE* new_mtab; + + /* Programmers Note: + This routine only gets called to the scene of a disaster + to shoot the survivors... A connection that was working + has now apparently failed. We have an active mount point + (presumably) that we need to dump. If we get errors along + the way - make some noise, but we are already turning out + the lights to exit anyways... + */ + if (umount(mount_point) != 0) { + DEBUG(0,("%d: Could not umount %s: %s\n", + sys_getpid(), mount_point, strerror(errno))); + return; + } + + if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1) { + DEBUG(0,("%d: Can't get "MOUNTED"~ lock file", sys_getpid())); + return; + } + + close(fd); + + if ((mtab = setmntent(MOUNTED, "r")) == NULL) { + DEBUG(0,("%d: Can't open " MOUNTED ": %s\n", + sys_getpid(), strerror(errno))); + return; + } + +#define MOUNTED_TMP MOUNTED".tmp" + + if ((new_mtab = setmntent(MOUNTED_TMP, "w")) == NULL) { + DEBUG(0,("%d: Can't open " MOUNTED_TMP ": %s\n", + sys_getpid(), strerror(errno))); + endmntent(mtab); + return; + } + + while ((mnt = getmntent(mtab)) != NULL) { + if (strcmp(mnt->mnt_dir, mount_point) != 0) { + addmntent(new_mtab, mnt); + } + } + + endmntent(mtab); + + if (fchmod (fileno (new_mtab), S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) < 0) { + DEBUG(0,("%d: Error changing mode of %s: %s\n", + sys_getpid(), MOUNTED_TMP, strerror(errno))); + return; + } + + endmntent(new_mtab); + + if (rename(MOUNTED_TMP, MOUNTED) < 0) { + DEBUG(0,("%d: Cannot rename %s to %s: %s\n", + sys_getpid(), MOUNTED, MOUNTED_TMP, strerror(errno))); + return; + } + + if (unlink(MOUNTED"~") == -1) { + DEBUG(0,("%d: Can't remove "MOUNTED"~", sys_getpid())); + return; + } +} + + +/* + * Call the smbfs ioctl to install a connection socket, + * then wait for a signal to reconnect. Note that we do + * not exit after open_sockets() or send_login() errors, + * as the smbfs mount would then have no way to recover. + */ +static void send_fs_socket(char *the_service, char *mount_point, struct cli_state *c) +{ + int fd, closed = 0, res = 1; + pid_t parentpid = getppid(); + struct smb_conn_opt conn_options; + + memset(&conn_options, 0, sizeof(conn_options)); + + while (1) { + if ((fd = open(mount_point, O_RDONLY)) < 0) { + DEBUG(0,("mount.smbfs[%d]: can't open %s\n", + sys_getpid(), mount_point)); + break; + } + + conn_options.fd = c->fd; + conn_options.protocol = c->protocol; + conn_options.case_handling = SMB_CASE_DEFAULT; + conn_options.max_xmit = c->max_xmit; + conn_options.server_uid = c->vuid; + conn_options.tid = c->cnum; + conn_options.secmode = c->sec_mode; + conn_options.rawmode = 0; + conn_options.sesskey = c->sesskey; + conn_options.maxraw = 0; + conn_options.capabilities = c->capabilities; + conn_options.serverzone = c->serverzone/60; + + res = ioctl(fd, SMB_IOC_NEWCONN, &conn_options); + if (res != 0) { + DEBUG(0,("mount.smbfs[%d]: ioctl failed, res=%d\n", + sys_getpid(), res)); + close(fd); + break; + } + + if (parentpid) { + /* Ok... We are going to kill the parent. Now + is the time to break the process group... */ + setsid(); + /* Send a signal to the parent to terminate */ + kill(parentpid, SIGTERM); + parentpid = 0; + } + + close(fd); + + /* This looks wierd but we are only closing the userspace + side, the connection has already been passed to smbfs and + it has increased the usage count on the socket. + + If we don't do this we will "leak" sockets and memory on + each reconnection we have to make. */ + cli_shutdown(c); + c = NULL; + + if (!closed) { + /* redirect stdout & stderr since we can't know that + the library functions we use are using DEBUG. */ + if ( (fd = open("/dev/null", O_WRONLY)) < 0) + DEBUG(2,("mount.smbfs: can't open /dev/null\n")); + close_our_files(fd); + if (fd >= 0) { + dup2(fd, STDOUT_FILENO); + dup2(fd, STDERR_FILENO); + close(fd); + } + + /* here we are no longer interactive */ + pstrcpy(remote_machine, "smbmount"); /* sneaky ... */ + setup_logging("mount.smbfs", False); + append_log = True; + reopen_logs(); + DEBUG(0, ("mount.smbfs: entering daemon mode for service %s, pid=%d\n", the_service, sys_getpid())); + + closed = 1; + } + + /* Wait for a signal from smbfs ... but don't continue + until we actually get a new connection. */ + while (!c) { + CatchSignal(SIGUSR1, &usr1_handler); + pause(); + DEBUG(2,("mount.smbfs[%d]: got signal, getting new socket\n", sys_getpid())); + c = do_connection(the_service); + } + } + + smb_umount(mount_point); + DEBUG(2,("mount.smbfs[%d]: exit\n", sys_getpid())); + exit(1); +} + + +/** + * Mount a smbfs + **/ +static void init_mount(void) +{ + char mount_point[MAXPATHLEN+1]; + pstring tmp; + pstring svc2; + struct cli_state *c; + char *args[20]; + int i, status; + + if (realpath(mpoint, mount_point) == NULL) { + fprintf(stderr, "Could not resolve mount point %s\n", mpoint); + return; + } + + + c = do_connection(service); + if (!c) { + fprintf(stderr,"SMB connection failed\n"); + exit(1); + } + + /* + Set up to return as a daemon child and wait in the parent + until the child say it's ready... + */ + daemonize(); + + pstrcpy(svc2, service); + string_replace(svc2, '\\','/'); + string_replace(svc2, ' ','_'); + + memset(args, 0, sizeof(args[0])*20); + + i=0; + args[i++] = "smbmnt"; + + args[i++] = mount_point; + args[i++] = "-s"; + args[i++] = svc2; + + if (mount_ro) { + args[i++] = "-r"; + } + if (mount_uid) { + slprintf(tmp, sizeof(tmp)-1, "%d", mount_uid); + args[i++] = "-u"; + args[i++] = smb_xstrdup(tmp); + } + if (mount_gid) { + slprintf(tmp, sizeof(tmp)-1, "%d", mount_gid); + args[i++] = "-g"; + args[i++] = smb_xstrdup(tmp); + } + if (mount_fmask) { + slprintf(tmp, sizeof(tmp)-1, "0%o", mount_fmask); + args[i++] = "-f"; + args[i++] = smb_xstrdup(tmp); + } + if (mount_dmask) { + slprintf(tmp, sizeof(tmp)-1, "0%o", mount_dmask); + args[i++] = "-d"; + args[i++] = smb_xstrdup(tmp); + } + if (options) { + args[i++] = "-o"; + args[i++] = options; + } + + if (sys_fork() == 0) { + char *smbmnt_path; + + asprintf(&smbmnt_path, "%s/smbmnt", dyn_BINDIR); + + if (file_exist(smbmnt_path, NULL)) { + execv(smbmnt_path, args); + fprintf(stderr, + "smbfs/init_mount: execv of %s failed. Error was %s.", + smbmnt_path, strerror(errno)); + } else { + execvp("smbmnt", args); + fprintf(stderr, + "smbfs/init_mount: execv of %s failed. Error was %s.", + "smbmnt", strerror(errno)); + } + free(smbmnt_path); + exit(1); + } + + if (waitpid(-1, &status, 0) == -1) { + fprintf(stderr,"waitpid failed: Error was %s", strerror(errno) ); + /* FIXME: do some proper error handling */ + exit(1); + } + + if (WIFEXITED(status) && WEXITSTATUS(status) != 0) { + fprintf(stderr,"smbmnt failed: %d\n", WEXITSTATUS(status)); + /* FIXME: do some proper error handling */ + exit(1); + } + + /* Ok... This is the rubicon for that mount point... At any point + after this, if the connections fail and can not be reconstructed + for any reason, we will have to unmount the mount point. There + is no exit from the next call... + */ + send_fs_socket(service, mount_point, c); +} + + +/**************************************************************************** +get a password from a a file or file descriptor +exit on failure (from smbclient, move to libsmb or shared .c file?) +****************************************************************************/ +static void get_password_file(void) +{ + int fd = -1; + char *p; + BOOL close_it = False; + pstring spec; + char pass[128]; + + if ((p = getenv("PASSWD_FD")) != NULL) { + pstrcpy(spec, "descriptor "); + pstrcat(spec, p); + sscanf(p, "%d", &fd); + close_it = False; + } else if ((p = getenv("PASSWD_FILE")) != NULL) { + fd = sys_open(p, O_RDONLY, 0); + pstrcpy(spec, p); + if (fd < 0) { + fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n", + spec, strerror(errno)); + exit(1); + } + close_it = True; + } + + for(p = pass, *p = '\0'; /* ensure that pass is null-terminated */ + p && p - pass < sizeof(pass);) { + switch (read(fd, p, 1)) { + case 1: + if (*p != '\n' && *p != '\0') { + *++p = '\0'; /* advance p, and null-terminate pass */ + break; + } + case 0: + if (p - pass) { + *p = '\0'; /* null-terminate it, just in case... */ + p = NULL; /* then force the loop condition to become false */ + break; + } else { + fprintf(stderr, "Error reading password from file %s: %s\n", + spec, "empty password\n"); + exit(1); + } + + default: + fprintf(stderr, "Error reading password from file %s: %s\n", + spec, strerror(errno)); + exit(1); + } + } + pstrcpy(password, pass); + if (close_it) + close(fd); +} + +/**************************************************************************** +get username and password from a credentials file +exit on failure (from smbclient, move to libsmb or shared .c file?) +****************************************************************************/ +static void read_credentials_file(char *filename) +{ + FILE *auth; + fstring buf; + uint16 len = 0; + char *ptr, *val, *param; + + if ((auth=sys_fopen(filename, "r")) == NULL) + { + /* fail if we can't open the credentials file */ + DEBUG(0,("ERROR: Unable to open credentials file!\n")); + exit (-1); + } + + while (!feof(auth)) + { + /* get a line from the file */ + if (!fgets (buf, sizeof(buf), auth)) + continue; + len = strlen(buf); + + if ((len) && (buf[len-1]=='\n')) + { + buf[len-1] = '\0'; + len--; + } + if (len == 0) + continue; + + /* break up the line into parameter & value. + will need to eat a little whitespace possibly */ + param = buf; + if (!(ptr = strchr (buf, '='))) + continue; + val = ptr+1; + *ptr = '\0'; + + /* eat leading white space */ + while ((*val!='\0') && ((*val==' ') || (*val=='\t'))) + val++; + + if (strwicmp("password", param) == 0) + { + pstrcpy(password, val); + got_pass = True; + } + else if (strwicmp("username", param) == 0) + pstrcpy(username, val); + + memset(buf, 0, sizeof(buf)); + } + fclose(auth); +} + + +/**************************************************************************** +usage on the program +****************************************************************************/ +static void usage(void) +{ + printf("Usage: mount.smbfs service mountpoint [-o options,...]\n"); + + printf("Version %s\n\n",VERSION); + + printf( +"Options:\n\ + username=<arg> SMB username\n\ + password=<arg> SMB password\n\ + credentials=<filename> file with username/password\n\ + netbiosname=<arg> source NetBIOS name\n\ + uid=<arg> mount uid or username\n\ + gid=<arg> mount gid or groupname\n\ + port=<arg> remote SMB port number\n\ + fmask=<arg> file umask\n\ + dmask=<arg> directory umask\n\ + debug=<arg> debug level\n\ + ip=<arg> destination host or IP address\n\ + workgroup=<arg> workgroup on destination\n\ + sockopt=<arg> TCP socket options\n\ + scope=<arg> NetBIOS scope\n\ + iocharset=<arg> Linux charset (iso8859-1, utf8)\n\ + codepage=<arg> server codepage (cp850)\n\ + ttl=<arg> dircache time to live\n\ + guest don't prompt for a password\n\ + ro mount read-only\n\ + rw mount read-write\n\ +\n\ +This command is designed to be run from within /bin/mount by giving\n\ +the option '-t smbfs'. For example:\n\ + mount -t smbfs -o username=tridge,password=foobar //fjall/test /data/test\n\ +"); +} + + +/**************************************************************************** + Argument parsing for mount.smbfs interface + mount will call us like this: + mount.smbfs device mountpoint -o <options> + + <options> is never empty, containing at least rw or ro + ****************************************************************************/ +static void parse_mount_smb(int argc, char **argv) +{ + int opt; + char *opts; + char *opteq; + extern char *optarg; + int val; + extern pstring global_scope; + char *p; + + if (argc < 2 || argv[1][0] == '-') { + usage(); + exit(1); + } + + pstrcpy(service, argv[1]); + pstrcpy(mpoint, argv[2]); + + /* Convert any '/' characters in the service name to + '\' characters */ + string_replace(service, '/','\\'); + argc -= 2; + argv += 2; + + opt = getopt(argc, argv, "o:"); + if(opt != 'o') { + return; + } + + options[0] = 0; + p = options; + + /* + * option parsing from nfsmount.c (util-linux-2.9u) + */ + for (opts = strtok(optarg, ","); opts; opts = strtok(NULL, ",")) { + DEBUG(3, ("opts: %s\n", opts)); + if ((opteq = strchr_m(opts, '='))) { + val = atoi(opteq + 1); + *opteq = '\0'; + + if (!strcmp(opts, "username") || + !strcmp(opts, "logon")) { + char *lp; + pstrcpy(username,opteq+1); + if ((lp=strchr_m(username,'%'))) { + *lp = 0; + pstrcpy(password,lp+1); + got_pass = True; + memset(strchr_m(opteq+1,'%')+1,'X',strlen(password)); + } + if ((lp=strchr_m(username,'/'))) { + *lp = 0; + pstrcpy(workgroup,lp+1); + } + } else if(!strcmp(opts, "passwd") || + !strcmp(opts, "password")) { + pstrcpy(password,opteq+1); + got_pass = True; + memset(opteq+1,'X',strlen(password)); + } else if(!strcmp(opts, "credentials")) { + pstrcpy(credentials,opteq+1); + } else if(!strcmp(opts, "netbiosname")) { + pstrcpy(my_netbios_name,opteq+1); + } else if(!strcmp(opts, "uid")) { + mount_uid = nametouid(opteq+1); + } else if(!strcmp(opts, "gid")) { + mount_gid = nametogid(opteq+1); + } else if(!strcmp(opts, "port")) { + smb_port = val; + } else if(!strcmp(opts, "fmask")) { + mount_fmask = strtol(opteq+1, NULL, 8); + } else if(!strcmp(opts, "dmask")) { + mount_dmask = strtol(opteq+1, NULL, 8); + } else if(!strcmp(opts, "debug")) { + DEBUGLEVEL = val; + } else if(!strcmp(opts, "ip")) { + dest_ip = *interpret_addr2(opteq+1); + if (is_zero_ip(dest_ip)) { + fprintf(stderr,"Can't resolve address %s\n", opteq+1); + exit(1); + } + have_ip = True; + } else if(!strcmp(opts, "workgroup")) { + pstrcpy(workgroup,opteq+1); + } else if(!strcmp(opts, "sockopt")) { + pstrcpy(user_socket_options,opteq+1); + } else if(!strcmp(opts, "scope")) { + pstrcpy(global_scope,opteq+1); + } else { + slprintf(p, sizeof(pstring) - (p - options) - 1, "%s=%s,", opts, opteq+1); + p += strlen(p); + } + } else { + val = 1; + if(!strcmp(opts, "nocaps")) { + fprintf(stderr, "Unhandled option: %s\n", opteq+1); + exit(1); + } else if(!strcmp(opts, "guest")) { + *password = '\0'; + got_pass = True; + } else if(!strcmp(opts, "rw")) { + mount_ro = 0; + } else if(!strcmp(opts, "ro")) { + mount_ro = 1; + } else { + strncpy(p, opts, sizeof(pstring) - (p - options) - 1); + p += strlen(opts); + *p++ = ','; + *p = 0; + } + } + } + + if (!*service) { + usage(); + exit(1); + } + + if (p != options) { + *(p-1) = 0; /* remove trailing , */ + DEBUG(3,("passthrough options '%s'\n", options)); + } +} + +/**************************************************************************** + main program +****************************************************************************/ + int main(int argc,char *argv[]) +{ + extern char *optarg; + extern int optind; + char *p; + + DEBUGLEVEL = 1; + + /* here we are interactive, even if run from autofs */ + setup_logging("mount.smbfs",True); + +#if 0 /* JRA - Urban says not needed ? */ + /* CLI_FORCE_ASCII=false makes smbmount negotiate unicode. The default + is to not announce any unicode capabilities as current smbfs does + not support it. */ + p = getenv("CLI_FORCE_ASCII"); + if (p && !strcmp(p, "false")) + unsetenv("CLI_FORCE_ASCII"); + else + setenv("CLI_FORCE_ASCII", "true", 1); +#endif + + in_client = True; /* Make sure that we tell lp_load we are */ + + if (getenv("USER")) { + pstrcpy(username,getenv("USER")); + + if ((p=strchr_m(username,'%'))) { + *p = 0; + pstrcpy(password,p+1); + got_pass = True; + memset(strchr_m(getenv("USER"),'%')+1,'X',strlen(password)); + } + strupper(username); + } + + if (getenv("PASSWD")) { + pstrcpy(password,getenv("PASSWD")); + got_pass = True; + } + + if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) { + get_password_file(); + got_pass = True; + } + + if (*username == 0 && getenv("LOGNAME")) { + pstrcpy(username,getenv("LOGNAME")); + } + + if (!lp_load(dyn_CONFIGFILE,True,False,False)) { + fprintf(stderr, "Can't load %s - run testparm to debug it\n", + dyn_CONFIGFILE); + } + + parse_mount_smb(argc, argv); + + if (*credentials != 0) { + read_credentials_file(credentials); + } + + DEBUG(3,("mount.smbfs started (version %s)\n", VERSION)); + + if (*workgroup == 0) { + pstrcpy(workgroup,lp_workgroup()); + } + + load_interfaces(); + if (!*my_netbios_name) { + pstrcpy(my_netbios_name, myhostname()); + } + strupper(my_netbios_name); + + init_mount(); + return 0; +} diff --git a/source3/client/smbspool.c b/source3/client/smbspool.c new file mode 100644 index 0000000000..2a2d5cbaf5 --- /dev/null +++ b/source3/client/smbspool.c @@ -0,0 +1,412 @@ +/* + Unix SMB/CIFS implementation. + SMB backend for the Common UNIX Printing System ("CUPS") + Copyright 1999 by Easy Software Products + Copyright Andrew Tridgell 1994-1998 + + 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. +*/ + +#define NO_SYSLOG + +#include "includes.h" + +/* + * Globals... + */ + +extern BOOL in_client; /* Boolean for client library */ + + +/* + * Local functions... + */ + +static void list_devices(void); +static struct cli_state *smb_connect(char *, char *, char *, char *, char *); +static int smb_print(struct cli_state *, char *, FILE *); + + +/* + * 'main()' - Main entry for SMB backend. + */ + + int /* O - Exit status */ + main(int argc, /* I - Number of command-line arguments */ + char *argv[]) /* I - Command-line arguments */ +{ + int i; /* Looping var */ + int copies; /* Number of copies */ + char uri[1024], /* URI */ + *sep, /* Pointer to separator */ + *username, /* Username */ + *password, /* Password */ + *workgroup, /* Workgroup */ + *server, /* Server name */ + *printer; /* Printer name */ + FILE *fp; /* File to print */ + int status=0; /* Status of LPD job */ + struct cli_state *cli; /* SMB interface */ + + /* we expect the URI in argv[0]. Detect the case where it is in argv[1] and cope */ + if (argc > 2 && strncmp(argv[0],"smb://", 6) && !strncmp(argv[1],"smb://", 6)) { + argv++; + argc--; + } + + if (argc == 1) + { + /* + * NEW! In CUPS 1.1 the backends are run with no arguments to list the + * available devices. These can be devices served by this backend + * or any other backends (i.e. you can have an SNMP backend that + * is only used to enumerate the available network printers... :) + */ + + list_devices(); + return (0); + } + + if (argc < 6 || argc > 7) + { + fprintf(stderr, "Usage: %s [DEVICE_URI] job-id user title copies options [file]\n", + argv[0]); + fputs(" The DEVICE_URI environment variable can also contain the\n", stderr); + fputs(" destination printer:\n", stderr); + fputs("\n", stderr); + fputs(" smb://[username:password@][workgroup/]server/printer\n", stderr); + return (1); + } + + /* + * If we have 7 arguments, print the file named on the command-line. + * Otherwise, print data from stdin... + */ + + if (argc == 6) + { + /* + * Print from Copy stdin to a temporary file... + */ + + fp = stdin; + copies = 1; + } + else if ((fp = fopen(argv[6], "rb")) == NULL) + { + perror("ERROR: Unable to open print file"); + return (1); + } + else + copies = atoi(argv[4]); + + /* + * Find the URI... + */ + + if (strncmp(argv[0], "smb://", 6) == 0) + strncpy(uri, argv[0], sizeof(uri) - 1); + else if (getenv("DEVICE_URI") != NULL) + strncpy(uri, getenv("DEVICE_URI"), sizeof(uri) - 1); + else + { + fputs("ERROR: No device URI found in argv[0] or DEVICE_URI environment variable!\n", stderr); + return (1); + } + + uri[sizeof(uri) - 1] = '\0'; + + /* + * Extract the destination from the URI... + */ + + if ((sep = strrchr_m(uri, '@')) != NULL) + { + username = uri + 6; + *sep++ = '\0'; + + server = sep; + + /* + * Extract password as needed... + */ + + if ((password = strchr_m(username, ':')) != NULL) + *password++ = '\0'; + else + password = ""; + } + else + { + username = ""; + password = ""; + server = uri + 6; + } + + if ((sep = strchr_m(server, '/')) == NULL) + { + fputs("ERROR: Bad URI - need printer name!\n", stderr); + return (1); + } + + *sep++ = '\0'; + printer = sep; + + if ((sep = strchr_m(printer, '/')) != NULL) + { + /* + * Convert to smb://[username:password@]workgroup/server/printer... + */ + + *sep++ = '\0'; + + workgroup = server; + server = printer; + printer = sep; + } + else + workgroup = NULL; + + /* + * Setup the SAMBA server state... + */ + + setup_logging("smbspool", True); + + in_client = True; /* Make sure that we tell lp_load we are */ + + if (!lp_load(dyn_CONFIGFILE, True, False, False)) + { + fprintf(stderr, "ERROR: Can't load %s - run testparm to debug it\n", dyn_CONFIGFILE); + return (1); + } + + if (workgroup == NULL) + workgroup = lp_workgroup(); + + load_interfaces(); + + do + { + if ((cli = smb_connect(workgroup, server, printer, username, password)) == NULL) + { + if (getenv("CLASS") == NULL) + { + perror("ERROR: Unable to connect to SAMBA host, will retry in 60 seconds..."); + sleep (60); + } + else + { + perror("ERROR: Unable to connect to SAMBA host, trying next printer..."); + return (1); + } + } + } + while (cli == NULL); + + /* + * Now that we are connected to the server, ignore SIGTERM so that we + * can finish out any page data the driver sends (e.g. to eject the + * current page... Only ignore SIGTERM if we are printing data from + * stdin (otherwise you can't cancel raw jobs...) + */ + + if (argc < 7) + CatchSignal(SIGTERM, SIG_IGN); + + /* + * Queue the job... + */ + + for (i = 0; i < copies; i ++) + if ((status = smb_print(cli, argv[3] /* title */, fp)) != 0) + break; + + cli_shutdown(cli); + + /* + * Return the queue status... + */ + + return (status); +} + + +/* + * 'list_devices()' - List the available printers seen on the network... + */ + +static void +list_devices(void) +{ + /* + * Eventually, search the local workgroup for available hosts and printers. + */ + + puts("network smb \"Unknown\" \"Windows Printer via SAMBA\""); +} + + +/* + * 'smb_connect()' - Return a connection to a server. + */ + +static struct cli_state * /* O - SMB connection */ +smb_connect(char *workgroup, /* I - Workgroup */ + char *server, /* I - Server */ + char *share, /* I - Printer */ + char *username, /* I - Username */ + char *password) /* I - Password */ +{ + struct cli_state *c; /* New connection */ + struct nmb_name called, /* NMB name of server */ + calling; /* NMB name of client */ + struct in_addr ip; /* IP address of server */ + pstring myname; /* Client name */ + + + /* + * Get the names and addresses of the client and server... + */ + + get_myname(myname); + + zero_ip(&ip); + + make_nmb_name(&calling, myname, 0x0); + make_nmb_name(&called, server, 0x20); + + /* + * Open a new connection to the SMB server... + */ + + if ((c = cli_initialise(NULL)) == NULL) + { + fputs("ERROR: cli_initialize() failed...\n", stderr); + return (NULL); + } + + if (!cli_connect(c, server, &ip)) + { + fputs("ERROR: cli_connect() failed...\n", stderr); + return (NULL); + } + + if (!cli_session_request(c, &calling, &called)) + { + fputs("ERROR: cli_session_request() failed...\n", stderr); + return (NULL); + } + + if (!cli_negprot(c)) + { + fputs("ERROR: SMB protocol negotiation failed\n", stderr); + cli_shutdown(c); + return (NULL); + } + + /* + * Do password stuff... + */ + + if (!cli_session_setup(c, username, + password, strlen(password), + password, strlen(password), + workgroup)) + { + fprintf(stderr, "ERROR: SMB session setup failed: %s\n", cli_errstr(c)); + return (NULL); + } + + if (!cli_send_tconX(c, share, "?????", + password, strlen(password)+1)) + { + fprintf(stderr, "ERROR: SMB tree connect failed: %s\n", cli_errstr(c)); + cli_shutdown(c); + return (NULL); + } + + /* + * Return the new connection... + */ + + return (c); +} + + +/* + * 'smb_print()' - Queue a job for printing using the SMB protocol. + */ + +static int /* O - 0 = success, non-0 = failure */ +smb_print(struct cli_state *cli, /* I - SMB connection */ + char *title, /* I - Title/job name */ + FILE *fp) /* I - File to print */ +{ + int fnum; /* File number */ + int nbytes, /* Number of bytes read */ + tbytes; /* Total bytes read */ + char buffer[8192], /* Buffer for copy */ + *ptr; /* Pointer into tile */ + + + /* + * Sanitize the title... + */ + + for (ptr = title; *ptr; ptr ++) + if (!isalnum((int)*ptr) && !isspace((int)*ptr)) + *ptr = '_'; + + /* + * Open the printer device... + */ + + if ((fnum = cli_open(cli, title, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE)) == -1) + { + fprintf(stderr, "ERROR: %s opening remote file %s\n", + cli_errstr(cli), title); + return (1); + } + + /* + * Copy the file to the printer... + */ + + if (fp != stdin) + rewind(fp); + + tbytes = 0; + + while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) + { + if (cli_write(cli, fnum, 0, buffer, tbytes, nbytes) != nbytes) + { + fprintf(stderr, "ERROR: Error writing file: %s\n", cli_errstr(cli)); + break; + } + + tbytes += nbytes; + } + + if (!cli_close(cli, fnum)) + { + fprintf(stderr, "ERROR: %s closing remote file %s\n", + cli_errstr(cli), title); + return (1); + } + else + return (0); +} diff --git a/source3/client/smbumount.c b/source3/client/smbumount.c new file mode 100644 index 0000000000..983ad44fa0 --- /dev/null +++ b/source3/client/smbumount.c @@ -0,0 +1,185 @@ +/* + * smbumount.c + * + * Copyright (C) 1995-1998 by Volker Lendecke + * + */ + +#include "includes.h" + +#include <mntent.h> + +#include <asm/types.h> +#include <asm/posix_types.h> +#include <linux/smb.h> +#include <linux/smb_mount.h> +#include <linux/smb_fs.h> + +/* This is a (hopefully) temporary hack due to the fact that + sizeof( uid_t ) != sizeof( __kernel_uid_t ) under glibc. + This may change in the future and smb.h may get fixed in the + future. In the mean time, it's ugly hack time - get over it. +*/ +#undef SMB_IOC_GETMOUNTUID +#define SMB_IOC_GETMOUNTUID _IOR('u', 1, __kernel_uid_t) + +#ifndef O_NOFOLLOW +#define O_NOFOLLOW 0400000 +#endif + +static void +usage(void) +{ + printf("usage: smbumount mountpoint\n"); +} + +static int +umount_ok(const char *mount_point) +{ + /* we set O_NOFOLLOW to prevent users playing games with symlinks to + umount filesystems they don't own */ + int fid = open(mount_point, O_RDONLY|O_NOFOLLOW, 0); + __kernel_uid_t mount_uid; + + if (fid == -1) { + fprintf(stderr, "Could not open %s: %s\n", + mount_point, strerror(errno)); + return -1; + } + + if (ioctl(fid, SMB_IOC_GETMOUNTUID, &mount_uid) != 0) { + fprintf(stderr, "%s probably not smb-filesystem\n", + mount_point); + return -1; + } + + if ((getuid() != 0) + && (mount_uid != getuid())) { + fprintf(stderr, "You are not allowed to umount %s\n", + mount_point); + return -1; + } + + close(fid); + return 0; +} + +/* Make a canonical pathname from PATH. Returns a freshly malloced string. + It is up the *caller* to ensure that the PATH is sensible. i.e. + canonicalize ("/dev/fd0/.") returns "/dev/fd0" even though ``/dev/fd0/.'' + is not a legal pathname for ``/dev/fd0'' Anything we cannot parse + we return unmodified. */ +static char * +canonicalize (char *path) +{ + char *canonical = malloc (PATH_MAX + 1); + + if (!canonical) { + fprintf(stderr, "Error! Not enough memory!\n"); + return NULL; + } + + if (strlen(path) > PATH_MAX) { + fprintf(stderr, "Mount point string too long\n"); + return NULL; + } + + if (path == NULL) + return NULL; + + if (realpath (path, canonical)) + return canonical; + + pstrcpy (canonical, path); + return canonical; +} + + +int +main(int argc, char *argv[]) +{ + int fd; + char* mount_point; + struct mntent *mnt; + FILE* mtab; + FILE* new_mtab; + + if (argc != 2) { + usage(); + exit(1); + } + + if (geteuid() != 0) { + fprintf(stderr, "smbumount must be installed suid root\n"); + exit(1); + } + + mount_point = canonicalize(argv[1]); + + if (mount_point == NULL) + { + exit(1); + } + + if (umount_ok(mount_point) != 0) { + exit(1); + } + + if (umount(mount_point) != 0) { + fprintf(stderr, "Could not umount %s: %s\n", + mount_point, strerror(errno)); + exit(1); + } + + if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1) + { + fprintf(stderr, "Can't get "MOUNTED"~ lock file"); + return 1; + } + close(fd); + + if ((mtab = setmntent(MOUNTED, "r")) == NULL) { + fprintf(stderr, "Can't open " MOUNTED ": %s\n", + strerror(errno)); + return 1; + } + +#define MOUNTED_TMP MOUNTED".tmp" + + if ((new_mtab = setmntent(MOUNTED_TMP, "w")) == NULL) { + fprintf(stderr, "Can't open " MOUNTED_TMP ": %s\n", + strerror(errno)); + endmntent(mtab); + return 1; + } + + while ((mnt = getmntent(mtab)) != NULL) { + if (strcmp(mnt->mnt_dir, mount_point) != 0) { + addmntent(new_mtab, mnt); + } + } + + endmntent(mtab); + + if (fchmod (fileno (new_mtab), S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) < 0) { + fprintf(stderr, "Error changing mode of %s: %s\n", + MOUNTED_TMP, strerror(errno)); + exit(1); + } + + endmntent(new_mtab); + + if (rename(MOUNTED_TMP, MOUNTED) < 0) { + fprintf(stderr, "Cannot rename %s to %s: %s\n", + MOUNTED, MOUNTED_TMP, strerror(errno)); + exit(1); + } + + if (unlink(MOUNTED"~") == -1) + { + fprintf(stderr, "Can't remove "MOUNTED"~"); + return 1; + } + + return 0; +} diff --git a/source3/client/testsmbc.c b/source3/client/testsmbc.c new file mode 100644 index 0000000000..ec98774dcf --- /dev/null +++ b/source3/client/testsmbc.c @@ -0,0 +1,455 @@ +/* + Unix SMB/CIFS implementation. + SMB client library test program + Copyright (C) Andrew Tridgell 1998 + Copyright (C) Richard Sharpe 2000 + Copyright (C) John Terpsra 2000 + + 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. +*/ + +#include <stdio.h> +#include <errno.h> +#include <sys/time.h> +#include <string.h> +#include <unistd.h> +#include <stdlib.h> +#include <libsmbclient.h> + +void auth_fn(const char *server, const char *share, + char *workgroup, int wgmaxlen, char *username, int unmaxlen, + char *password, int pwmaxlen) +{ + char temp[128]; + + fprintf(stdout, "Need password for //%s/%s\n", server, share); + + fprintf(stdout, "Enter workgroup: [%s] ", workgroup); + fgets(temp, sizeof(temp), stdin); + + if (temp[strlen(temp) - 1] == 0x0a) /* A new line? */ + temp[strlen(temp) - 1] = 0x00; + + if (temp[0]) strncpy(workgroup, temp, wgmaxlen - 1); + + fprintf(stdout, "Enter username: [%s] ", username); + fgets(temp, sizeof(temp), stdin); + + if (temp[strlen(temp) - 1] == 0x0a) /* A new line? */ + temp[strlen(temp) - 1] = 0x00; + + if (temp[0]) strncpy(username, temp, unmaxlen - 1); + + fprintf(stdout, "Enter password: [%s] ", password); + fgets(temp, sizeof(temp), stdin); + + if (temp[strlen(temp) - 1] == 0x0a) /* A new line? */ + temp[strlen(temp) - 1] = 0x00; + + if (temp[0]) strncpy(password, temp, pwmaxlen - 1); + +} + +int global_id = 0; + +void print_list_fn(struct print_job_info *pji) +{ + + fprintf(stdout, "Print job: ID: %u, Prio: %u, Size: %u, User: %s, Name: %s\n", + pji->id, pji->priority, pji->size, pji->user, pji->name); + + global_id = pji->id; + +} + +int main(int argc, char *argv[]) +{ + int err, fd, dh1, dh2, dh3, dsize, dirc; + const char *file = "smb://samba/public/testfile.txt"; + const char *file2 = "smb://samba/public/testfile2.txt"; + char buff[256]; + char dirbuf[512]; + char *dirp; + struct stat st1, st2; + + err = smbc_init(auth_fn, 10); /* Initialize things */ + + if (err < 0) { + + fprintf(stderr, "Initializing the smbclient library ...: %s\n", strerror(errno)); + + } + + if (argc > 1) { + + /* Try to list the print jobs ... */ + + if (smbc_list_print_jobs("smb://samba/pclp", print_list_fn) < 0) { + + fprintf(stderr, "Could not list print jobs: %s, %d\n", strerror(errno), errno); + exit(1); + + } + + /* Try to delete the last job listed */ + + if (global_id > 0) { + + fprintf(stdout, "Trying to delete print job %u\n", global_id); + + if (smbc_unlink_print_job("smb://samba/pclp", global_id) < 0) { + + fprintf(stderr, "Failed to unlink job id %u, %s, %u\n", global_id, + strerror(errno), errno); + + exit(1); + + } + + } + + /* Try to print a file ... */ + + if (smbc_print_file("smb://samba/public/testfile2.txt", "smb://samba/pclp") < 0) { + + fprintf(stderr, "Failed to print job: %s %u\n", strerror(errno), errno); + exit(1); + + } + + /* Try to delete argv[1] as a file ... */ + + if (smbc_unlink(argv[1]) < 0) { + + fprintf(stderr, "Could not unlink: %s, %s, %d\n", + argv[1], strerror(errno), errno); + + exit(0); + + } + + if ((dh1 = smbc_opendir("smb://"))<1) { + + fprintf(stderr, "Could not open directory: smb://: %s\n", + strerror(errno)); + + exit(1); + + } + + if ((dh2 = smbc_opendir("smb://sambanet")) < 0) { + + fprintf(stderr, "Could not open directory: smb://sambanet: %s\n", + strerror(errno)); + + exit(1); + + } + + if ((dh3 = smbc_opendir("smb://samba")) < 0) { + + fprintf(stderr, "Could not open directory: smb://samba: %s\n", + strerror(errno)); + + exit(1); + + } + + fprintf(stdout, "Directory handles: %u, %u, %u\n", dh1, dh2, dh3); + + /* Now, list those directories, but in funny ways ... */ + + dirp = (char *)dirbuf; + + if ((dirc = smbc_getdents(dh1, (struct smbc_dirent *)dirp, + sizeof(dirbuf))) < 0) { + + fprintf(stderr, "Problems getting directory entries: %s\n", + strerror(errno)); + + exit(1); + + } + + /* Now, process the list of names ... */ + + fprintf(stdout, "Directory listing, size = %u\n", dirc); + + while (dirc > 0) { + + dsize = ((struct smbc_dirent *)dirp)->dirlen; + fprintf(stdout, "Dir Ent, Type: %u, Name: %s, Comment: %s\n", + ((struct smbc_dirent *)dirp)->smbc_type, + ((struct smbc_dirent *)dirp)->name, + ((struct smbc_dirent *)dirp)->comment); + + dirp += dsize; + (char *)dirc -= dsize; + + } + + dirp = (char *)dirbuf; + + if ((dirc = smbc_getdents(dh2, (struct smbc_dirent *)dirp, + sizeof(dirbuf))) < 0) { + + fprintf(stderr, "Problems getting directory entries: %s\n", + strerror(errno)); + + exit(1); + + } + + /* Now, process the list of names ... */ + + fprintf(stdout, "\nDirectory listing, size = %u\n", dirc); + + while (dirc > 0) { + + dsize = ((struct smbc_dirent *)dirp)->dirlen; + fprintf(stdout, "Dir Ent, Type: %u, Name: %s, Comment: %s\n", + ((struct smbc_dirent *)dirp)->smbc_type, + ((struct smbc_dirent *)dirp)->name, + ((struct smbc_dirent *)dirp)->comment); + + dirp += dsize; + (char *)dirc -= dsize; + + } + + dirp = (char *)dirbuf; + + if ((dirc = smbc_getdents(dh3, (struct smbc_dirent *)dirp, + sizeof(dirbuf))) < 0) { + + fprintf(stderr, "Problems getting directory entries: %s\n", + strerror(errno)); + + exit(1); + + } + + /* Now, process the list of names ... */ + + fprintf(stdout, "Directory listing, size = %u\n", dirc); + + while (dirc > 0) { + + dsize = ((struct smbc_dirent *)dirp)->dirlen; + fprintf(stdout, "\nDir Ent, Type: %u, Name: %s, Comment: %s\n", + ((struct smbc_dirent *)dirp)->smbc_type, + ((struct smbc_dirent *)dirp)->name, + ((struct smbc_dirent *)dirp)->comment); + + (char *)dirp += dsize; + (char *)dirc -= dsize; + + } + + exit(1); + + } + + /* For now, open a file on a server that is hard coded ... later will + * read from the command line ... + */ + + fd = smbc_open(file, O_RDWR | O_CREAT | O_TRUNC, 0666); + + if (fd < 0) { + + fprintf(stderr, "Creating file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + fprintf(stdout, "Opened or created file: %s\n", file); + + /* Now, write some date to the file ... */ + + bzero(buff, sizeof(buff)); + strcpy(buff, "Some test data for the moment ..."); + + err = smbc_write(fd, buff, sizeof(buff)); + + if (err < 0) { + + fprintf(stderr, "writing file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + fprintf(stdout, "Wrote %d bytes to file: %s\n", sizeof(buff), buff); + + /* Now, seek the file back to offset 0 */ + + err = smbc_lseek(fd, SEEK_SET, 0); + + if (err < 0) { + + fprintf(stderr, "Seeking file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + fprintf(stdout, "Completed lseek on file: %s\n", file); + + /* Now, read the file contents back ... */ + + err = smbc_read(fd, buff, sizeof(buff)); + + if (err < 0) { + + fprintf(stderr, "Reading file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + fprintf(stdout, "Read file: %s\n", buff); /* Should check the contents */ + + fprintf(stdout, "Now fstat'ing file: %s\n", file); + + err = smbc_fstat(fd, &st1); + + if (err < 0) { + + fprintf(stderr, "Fstat'ing file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + + /* Now, close the file ... */ + + err = smbc_close(fd); + + if (err < 0) { + + fprintf(stderr, "Closing file: %s: %s\n", file, strerror(errno)); + + } + + /* Now, rename the file ... */ + + err = smbc_rename(file, file2); + + if (err < 0) { + + fprintf(stderr, "Renaming file: %s to %s: %s\n", file, file2, strerror(errno)); + + } + + fprintf(stdout, "Renamed file %s to %s\n", file, file2); + + /* Now, create a file and delete it ... */ + + fprintf(stdout, "Now, creating file: %s so we can delete it.\n", file); + + fd = smbc_open(file, O_RDWR | O_CREAT, 0666); + + if (fd < 0) { + + fprintf(stderr, "Creating file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + fprintf(stdout, "Opened or created file: %s\n", file); + + err = smbc_close(fd); + + if (err < 0) { + + fprintf(stderr, "Closing file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + /* Now, delete the file ... */ + + fprintf(stdout, "File %s created, now deleting ...\n", file); + + err = smbc_unlink(file); + + if (err < 0) { + + fprintf(stderr, "Deleting file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + /* Now, stat the file, file 2 ... */ + + fprintf(stdout, "Now stat'ing file: %s\n", file); + + err = smbc_stat(file2, &st2); + + if (err < 0) { + + fprintf(stderr, "Stat'ing file: %s: %s\n", file, strerror(errno)); + exit(0); + + } + + fprintf(stdout, "Stat'ed file: %s. Size = %d, mode = %04X\n", file2, + (int)st2.st_size, st2.st_mode); + fprintf(stdout, " time: %s\n", ctime(&st2.st_atime)); + fprintf(stdout, "Earlier stat: %s, Size = %d, mode = %04X\n", file, + (int)st1.st_size, st1.st_mode); + fprintf(stdout, " time: %s\n", ctime(&st1.st_atime)); + + /* Now, make a directory ... */ + + fprintf(stdout, "Making directory smb://samba/public/make-dir\n"); + + if (smbc_mkdir("smb://samba/public/make-dir", 0666) < 0) { + + fprintf(stderr, "Error making directory: smb://samba/public/make-dir: %s\n", + strerror(errno)); + + if (errno == EEXIST) { /* Try to delete the directory */ + + fprintf(stdout, "Trying to delete directory: smb://samba/public/make-dir\n"); + + if (smbc_rmdir("smb://samba/public/make-dir") < 0) { /* Error */ + + fprintf(stderr, "Error removing directory: smb://samba/public/make-dir: %s\n", strerror(errno)); + + exit(0); + + } + + fprintf(stdout, "Making directory: smb://samba/public/make-dir\n"); + + if (smbc_mkdir("smb://samba/public/make-dir", 666) < 0) { + + fprintf(stderr, "Error making directory: smb://samba/public/make-dir: %s\n", + strerror(errno)); + + fprintf(stderr, "I give up!\n"); + + exit(1); + + } + + } + + exit(0); + + } + + fprintf(stdout, "Made dir: make-dir\n"); + return 0; +} diff --git a/source3/client/tree.c b/source3/client/tree.c new file mode 100644 index 0000000000..94fd93c210 --- /dev/null +++ b/source3/client/tree.c @@ -0,0 +1,811 @@ +/* + Unix SMB/CIFS implementation. + SMB client GTK+ tree-based application + Copyright (C) Andrew Tridgell 1998 + Copyright (C) Richard Sharpe 2001 + Copyright (C) John Terpstra 2001 + + 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. +*/ + +/* example-gtk+ application, ripped off from the gtk+ tree.c sample */ + +#include <stdio.h> +#include <errno.h> +#include <gtk/gtk.h> +#include "libsmbclient.h" + +static GtkWidget *clist; + +struct tree_data { + + guint32 type; /* Type of tree item, an SMBC_TYPE */ + char name[256]; /* May need to change this later */ + +}; + +void error_message(gchar *message) { + + GtkWidget *dialog, *label, *okay_button; + + /* Create the widgets */ + + dialog = gtk_dialog_new(); + gtk_window_set_modal(GTK_WINDOW(dialog), True); + label = gtk_label_new (message); + okay_button = gtk_button_new_with_label("Okay"); + + /* Ensure that the dialog box is destroyed when the user clicks ok. */ + + gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked", + GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog); + gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area), + okay_button); + + /* Add the label, and show everything we've added to the dialog. */ + + gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), + label); + gtk_widget_show_all (dialog); +} + +/* + * We are given a widget, and we want to retrieve its URL so we + * can do a directory listing. + * + * We walk back up the tree, picking up pieces until we hit a server or + * workgroup type and return a path from there + */ + +static char path_string[1024]; + +char *get_path(GtkWidget *item) +{ + GtkWidget *p = item; + struct tree_data *pd; + char *comps[1024]; /* We keep pointers to the components here */ + int i = 0, j, level,type; + + /* Walk back up the tree, getting the private data */ + + level = GTK_TREE(item->parent)->level; + + /* Pick up this item's component info */ + + pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(item)); + + comps[i++] = pd->name; + type = pd->type; + + while (level > 0 && type != SMBC_SERVER && type != SMBC_WORKGROUP) { + + /* Find the parent and extract the data etc ... */ + + p = GTK_WIDGET(p->parent); + p = GTK_WIDGET(GTK_TREE(p)->tree_owner); + + pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(p)); + + level = GTK_TREE(item->parent)->level; + + comps[i++] = pd->name; + type = pd->type; + + } + + /* + * Got a list of comps now, should check that we did not hit a workgroup + * when we got other things as well ... Later + * + * Now, build the path + */ + + snprintf(path_string, sizeof(path_string), "smb:/"); + + for (j = i - 1; j >= 0; j--) { + + strncat(path_string, "/", sizeof(path_string) - strlen(path_string)); + strncat(path_string, comps[j], sizeof(path_string) - strlen(path_string)); + + } + + fprintf(stdout, "Path string = %s\n", path_string); + + return path_string; + +} + +struct tree_data *make_tree_data(guint32 type, const char *name) +{ + struct tree_data *p = (struct tree_data *)malloc(sizeof(struct tree_data)); + + if (p) { + + p->type = type; + strncpy(p->name, name, sizeof(p->name)); + + } + + return p; + +} + +/* Note that this is called every time the user clicks on an item, + whether it is already selected or not. */ +static void cb_select_child (GtkWidget *root_tree, GtkWidget *child, + GtkWidget *subtree) +{ + gint dh, err, dirlen; + char dirbuf[512]; + struct smbc_dirent *dirp; + struct stat st1; + char path[1024], path1[1024]; + + g_print ("select_child called for root tree %p, subtree %p, child %p\n", + root_tree, subtree, child); + + /* Now, figure out what it is, and display it in the clist ... */ + + gtk_clist_clear(GTK_CLIST(clist)); /* Clear the CLIST */ + + /* Now, get the private data for the subtree */ + + strncpy(path, get_path(child), 1024); + + if ((dh = smbc_opendir(path)) < 0) { /* Handle error */ + + g_print("cb_select_child: Could not open dir %s, %s\n", path, + strerror(errno)); + + gtk_main_quit(); + + return; + + } + + while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, + sizeof(dirbuf))) != 0) { + + if (err < 0) { + + g_print("cb_select_child: Could not read dir %s, %s\n", path, + strerror(errno)); + + gtk_main_quit(); + + return; + + } + + dirp = (struct smbc_dirent *)dirbuf; + + while (err > 0) { + gchar col1[128], col2[128], col3[128], col4[128]; + gchar *rowdata[4] = {col1, col2, col3, col4}; + + dirlen = dirp->dirlen; + + /* Format each of the items ... */ + + strncpy(col1, dirp->name, 128); + + col2[0] = col3[0] = col4[0] = (char)0; + + switch (dirp->smbc_type) { + + case SMBC_WORKGROUP: + + break; + + case SMBC_SERVER: + + strncpy(col2, (dirp->comment?dirp->comment:""), 128); + + break; + + case SMBC_FILE_SHARE: + + strncpy(col2, (dirp->comment?dirp->comment:""), 128); + + break; + + case SMBC_PRINTER_SHARE: + + strncpy(col2, (dirp->comment?dirp->comment:""), 128); + break; + + case SMBC_COMMS_SHARE: + + break; + + case SMBC_IPC_SHARE: + + break; + + case SMBC_DIR: + case SMBC_FILE: + + /* Get stats on the file/dir and see what we have */ + + if ((strcmp(dirp->name, ".") != 0) && + (strcmp(dirp->name, "..") != 0)) { + + strncpy(path1, path, sizeof(path1)); + strncat(path1, "/", sizeof(path) - strlen(path)); + strncat(path1, dirp->name, sizeof(path) - strlen(path)); + + if (smbc_stat(path1, &st1) < 0) { + + if (errno != EBUSY) { + + g_print("cb_select_child: Could not stat file %s, %s\n", path1, + strerror(errno)); + + gtk_main_quit(); + + return; + + } + else { + + strncpy(col2, "Device or resource busy", sizeof(col2)); + + } + } + else { + /* Now format each of the relevant things ... */ + + snprintf(col2, sizeof(col2), "%c%c%c%c%c%c%c%c%c(%0X)", + (st1.st_mode&S_IRUSR?'r':'-'), + (st1.st_mode&S_IWUSR?'w':'-'), + (st1.st_mode&S_IXUSR?'x':'-'), + (st1.st_mode&S_IRGRP?'r':'-'), + (st1.st_mode&S_IWGRP?'w':'-'), + (st1.st_mode&S_IXGRP?'x':'-'), + (st1.st_mode&S_IROTH?'r':'-'), + (st1.st_mode&S_IWOTH?'w':'-'), + (st1.st_mode&S_IXOTH?'x':'-'), + st1.st_mode); + snprintf(col3, sizeof(col3), "%u", st1.st_size); + snprintf(col4, sizeof(col4), "%s", ctime(&st1.st_mtime)); + } + } + + break; + + default: + + break; + } + + gtk_clist_append(GTK_CLIST(clist), rowdata); + + (char *)dirp += dirlen; + err -= dirlen; + + } + + } + +} + +/* Note that this is never called */ +static void cb_unselect_child( GtkWidget *root_tree, + GtkWidget *child, + GtkWidget *subtree ) +{ + g_print ("unselect_child called for root tree %p, subtree %p, child %p\n", + root_tree, subtree, child); +} + +/* for all the GtkItem:: and GtkTreeItem:: signals */ +static void cb_itemsignal( GtkWidget *item, + gchar *signame ) +{ + GtkWidget *real_tree, *aitem, *subtree; + gchar *name; + GtkLabel *label; + gint dh, err, dirlen, level; + char dirbuf[512]; + struct smbc_dirent *dirp; + + label = GTK_LABEL (GTK_BIN (item)->child); + /* Get the text of the label */ + gtk_label_get (label, &name); + + level = GTK_TREE(item->parent)->level; + + /* Get the level of the tree which the item is in */ + g_print ("%s called for item %s->%p, level %d\n", signame, name, + item, GTK_TREE (item->parent)->level); + + real_tree = GTK_TREE_ITEM_SUBTREE(item); /* Get the subtree */ + + if (strncmp(signame, "expand", 6) == 0) { /* Expand called */ + char server[128]; + + if ((dh = smbc_opendir(get_path(item))) < 0) { /* Handle error */ + gchar errmsg[256]; + + g_print("cb_itemsignal: Could not open dir %s, %s\n", get_path(item), + strerror(errno)); + + slprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not open dir %s, %s\n", get_path(item), strerror(errno)); + + error_message(errmsg); + + /* gtk_main_quit();*/ + + return; + + } + + while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, + sizeof(dirbuf))) != 0) { + + if (err < 0) { /* An error, report it */ + gchar errmsg[256]; + + g_print("cb_itemsignal: Could not read dir smbc://, %s\n", + strerror(errno)); + + slprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not read dir smbc://, %s\n", strerror(errno)); + + error_message(errmsg); + + /* gtk_main_quit();*/ + + return; + + } + + dirp = (struct smbc_dirent *)dirbuf; + + while (err > 0) { + struct tree_data *my_data; + + dirlen = dirp->dirlen; + + my_data = make_tree_data(dirp->smbc_type, dirp->name); + + if (!my_data) { + + g_print("Could not allocate space for tree_data: %s\n", + dirp->name); + + gtk_main_quit(); + return; + + } + + aitem = gtk_tree_item_new_with_label(dirp->name); + + /* Connect all GtkItem:: and GtkTreeItem:: signals */ + gtk_signal_connect (GTK_OBJECT(aitem), "select", + GTK_SIGNAL_FUNC(cb_itemsignal), "select"); + gtk_signal_connect (GTK_OBJECT(aitem), "deselect", + GTK_SIGNAL_FUNC(cb_itemsignal), "deselect"); + gtk_signal_connect (GTK_OBJECT(aitem), "toggle", + GTK_SIGNAL_FUNC(cb_itemsignal), "toggle"); + gtk_signal_connect (GTK_OBJECT(aitem), "expand", + GTK_SIGNAL_FUNC(cb_itemsignal), "expand"); + gtk_signal_connect (GTK_OBJECT(aitem), "collapse", + GTK_SIGNAL_FUNC(cb_itemsignal), "collapse"); + /* Add it to the parent tree */ + gtk_tree_append (GTK_TREE(real_tree), aitem); + + gtk_widget_show (aitem); + + gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data); + + fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen); + + if (dirp->smbc_type != SMBC_FILE && + dirp->smbc_type != SMBC_IPC_SHARE && + (strcmp(dirp->name, ".") != 0) && + (strcmp(dirp->name, "..") !=0)){ + + subtree = gtk_tree_new(); + gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree); + + gtk_signal_connect(GTK_OBJECT(subtree), "select_child", + GTK_SIGNAL_FUNC(cb_select_child), real_tree); + gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child", + GTK_SIGNAL_FUNC(cb_unselect_child), real_tree); + + } + + (char *)dirp += dirlen; + err -= dirlen; + + } + + } + + smbc_closedir(dh); + + } + else if (strncmp(signame, "collapse", 8) == 0) { + GtkWidget *subtree = gtk_tree_new(); + + gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children); + + gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree); + + gtk_signal_connect (GTK_OBJECT(subtree), "select_child", + GTK_SIGNAL_FUNC(cb_select_child), real_tree); + gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child", + GTK_SIGNAL_FUNC(cb_unselect_child), real_tree); + + } + +} + +static void cb_selection_changed( GtkWidget *tree ) +{ + GList *i; + + g_print ("selection_change called for tree %p\n", tree); + g_print ("selected objects are:\n"); + + i = GTK_TREE_SELECTION(tree); + while (i){ + gchar *name; + GtkLabel *label; + GtkWidget *item; + + /* Get a GtkWidget pointer from the list node */ + item = GTK_WIDGET (i->data); + label = GTK_LABEL (GTK_BIN (item)->child); + gtk_label_get (label, &name); + g_print ("\t%s on level %d\n", name, GTK_TREE + (item->parent)->level); + i = i->next; + } +} + +/* + * Expand or collapse the whole network ... + */ +static void cb_wholenet(GtkWidget *item, gchar *signame) +{ + GtkWidget *real_tree, *aitem, *subtree; + gchar *name; + GtkLabel *label; + gint dh, err, dirlen; + char dirbuf[512]; + struct smbc_dirent *dirp; + + label = GTK_LABEL (GTK_BIN (item)->child); + gtk_label_get (label, &name); + g_print ("%s called for item %s->%p, level %d\n", signame, name, + item, GTK_TREE (item->parent)->level); + + real_tree = GTK_TREE_ITEM_SUBTREE(item); /* Get the subtree */ + + if (strncmp(signame, "expand", 6) == 0) { /* Expand called */ + + if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */ + + g_print("cb_wholenet: Could not open dir smbc://, %s\n", + strerror(errno)); + + gtk_main_quit(); + + return; + + } + + while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, + sizeof(dirbuf))) != 0) { + + if (err < 0) { /* An error, report it */ + + g_print("cb_wholenet: Could not read dir smbc://, %s\n", + strerror(errno)); + + gtk_main_quit(); + + return; + + } + + dirp = (struct smbc_dirent *)dirbuf; + + while (err > 0) { + struct tree_data *my_data; + + dirlen = dirp->dirlen; + + my_data = make_tree_data(dirp->smbc_type, dirp->name); + + aitem = gtk_tree_item_new_with_label(dirp->name); + + /* Connect all GtkItem:: and GtkTreeItem:: signals */ + gtk_signal_connect (GTK_OBJECT(aitem), "select", + GTK_SIGNAL_FUNC(cb_itemsignal), "select"); + gtk_signal_connect (GTK_OBJECT(aitem), "deselect", + GTK_SIGNAL_FUNC(cb_itemsignal), "deselect"); + gtk_signal_connect (GTK_OBJECT(aitem), "toggle", + GTK_SIGNAL_FUNC(cb_itemsignal), "toggle"); + gtk_signal_connect (GTK_OBJECT(aitem), "expand", + GTK_SIGNAL_FUNC(cb_itemsignal), "expand"); + gtk_signal_connect (GTK_OBJECT(aitem), "collapse", + GTK_SIGNAL_FUNC(cb_itemsignal), "collapse"); + + gtk_tree_append (GTK_TREE(real_tree), aitem); + /* Show it - this can be done at any time */ + gtk_widget_show (aitem); + + gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data); + + fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen); + + subtree = gtk_tree_new(); + + gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree); + + gtk_signal_connect(GTK_OBJECT(subtree), "select_child", + GTK_SIGNAL_FUNC(cb_select_child), real_tree); + gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child", + GTK_SIGNAL_FUNC(cb_unselect_child), real_tree); + + (char *)dirp += dirlen; + err -= dirlen; + + } + + } + + smbc_closedir(dh); + + } + else { /* Must be collapse ... FIXME ... */ + GtkWidget *subtree = gtk_tree_new(); + + gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children); + + gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree); + + gtk_signal_connect (GTK_OBJECT(subtree), "select_child", + GTK_SIGNAL_FUNC(cb_select_child), real_tree); + gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child", + GTK_SIGNAL_FUNC(cb_unselect_child), real_tree); + + + } + +} + +/* Should put up a dialog box to ask the user for username and password */ + +static void +auth_fn(const char *server, const char *share, + char *workgroup, int wgmaxlen, char *username, int unmaxlen, + char *password, int pwmaxlen) +{ + + strncpy(username, "test", unmaxlen); + strncpy(password, "test", pwmaxlen); + +} + +static char *col_titles[] = { + "Name", "Attributes", "Size", "Modification Date", +}; + +int main( int argc, + char *argv[] ) +{ + GtkWidget *window, *scrolled_win, *scrolled_win2, *tree; + GtkWidget *subtree, *item, *main_hbox, *r_pane, *l_pane; + gint err, dh; + gint i; + char dirbuf[512]; + struct smbc_dirent *dirp; + + gtk_init (&argc, &argv); + + /* Init the smbclient library */ + + err = smbc_init(auth_fn, 10); + + /* Print an error response ... */ + + if (err < 0) { + + fprintf(stderr, "smbc_init returned %s (%i)\nDo you have a ~/.smb/smb.conf file?\n", strerror(errno), errno); + exit(1); + + } + + /* a generic toplevel window */ + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_widget_set_name(window, "main browser window"); + gtk_signal_connect (GTK_OBJECT(window), "delete_event", + GTK_SIGNAL_FUNC (gtk_main_quit), NULL); + gtk_window_set_title(GTK_WINDOW(window), "The Linux Windows Network Browser"); + gtk_widget_set_usize(GTK_WIDGET(window), 750, -1); + gtk_container_set_border_width (GTK_CONTAINER(window), 5); + + gtk_widget_show (window); + + /* A container for the two panes ... */ + + main_hbox = gtk_hbox_new(FALSE, 1); + gtk_container_border_width(GTK_CONTAINER(main_hbox), 1); + gtk_container_add(GTK_CONTAINER(window), main_hbox); + + gtk_widget_show(main_hbox); + + l_pane = gtk_hpaned_new(); + gtk_paned_gutter_size(GTK_PANED(l_pane), (GTK_PANED(l_pane))->handle_size); + r_pane = gtk_hpaned_new(); + gtk_paned_gutter_size(GTK_PANED(r_pane), (GTK_PANED(r_pane))->handle_size); + gtk_container_add(GTK_CONTAINER(main_hbox), l_pane); + gtk_widget_show(l_pane); + + /* A generic scrolled window */ + scrolled_win = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + gtk_widget_set_usize (scrolled_win, 150, 200); + gtk_container_add (GTK_CONTAINER(l_pane), scrolled_win); + gtk_widget_show (scrolled_win); + + /* Another generic scrolled window */ + scrolled_win2 = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win2), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + gtk_widget_set_usize (scrolled_win2, 150, 200); + gtk_paned_add2 (GTK_PANED(l_pane), scrolled_win2); + gtk_widget_show (scrolled_win2); + + /* Create the root tree */ + tree = gtk_tree_new(); + g_print ("root tree is %p\n", tree); + /* connect all GtkTree:: signals */ + gtk_signal_connect (GTK_OBJECT(tree), "select_child", + GTK_SIGNAL_FUNC(cb_select_child), tree); + gtk_signal_connect (GTK_OBJECT(tree), "unselect_child", + GTK_SIGNAL_FUNC(cb_unselect_child), tree); + gtk_signal_connect (GTK_OBJECT(tree), "selection_changed", + GTK_SIGNAL_FUNC(cb_selection_changed), tree); + /* Add it to the scrolled window */ + gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win), + tree); + /* Set the selection mode */ + gtk_tree_set_selection_mode (GTK_TREE(tree), + GTK_SELECTION_MULTIPLE); + /* Show it */ + gtk_widget_show (tree); + + /* Now, create a clist and attach it to the second pane */ + + clist = gtk_clist_new_with_titles(4, col_titles); + + gtk_container_add (GTK_CONTAINER(scrolled_win2), clist); + + gtk_widget_show(clist); + + /* Now, build the top level display ... */ + + if ((dh = smbc_opendir("smb:///")) < 0) { + + fprintf(stderr, "Could not list default workgroup: smb:///: %s\n", + strerror(errno)); + + exit(1); + + } + + /* Create a tree item for Whole Network */ + + item = gtk_tree_item_new_with_label ("Whole Network"); + /* Connect all GtkItem:: and GtkTreeItem:: signals */ + gtk_signal_connect (GTK_OBJECT(item), "select", + GTK_SIGNAL_FUNC(cb_itemsignal), "select"); + gtk_signal_connect (GTK_OBJECT(item), "deselect", + GTK_SIGNAL_FUNC(cb_itemsignal), "deselect"); + gtk_signal_connect (GTK_OBJECT(item), "toggle", + GTK_SIGNAL_FUNC(cb_itemsignal), "toggle"); + gtk_signal_connect (GTK_OBJECT(item), "expand", + GTK_SIGNAL_FUNC(cb_wholenet), "expand"); + gtk_signal_connect (GTK_OBJECT(item), "collapse", + GTK_SIGNAL_FUNC(cb_wholenet), "collapse"); + /* Add it to the parent tree */ + gtk_tree_append (GTK_TREE(tree), item); + /* Show it - this can be done at any time */ + gtk_widget_show (item); + + subtree = gtk_tree_new(); /* A subtree for Whole Network */ + + gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree); + + gtk_signal_connect (GTK_OBJECT(subtree), "select_child", + GTK_SIGNAL_FUNC(cb_select_child), tree); + gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child", + GTK_SIGNAL_FUNC(cb_unselect_child), tree); + + /* Now, get the items in smb:/// and add them to the tree */ + + dirp = (struct smbc_dirent *)dirbuf; + + while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, + sizeof(dirbuf))) != 0) { + + if (err < 0) { /* Handle the error */ + + fprintf(stderr, "Could not read directory for smbc:///: %s\n", + strerror(errno)); + + exit(1); + + } + + fprintf(stdout, "Dir len: %u\n", err); + + while (err > 0) { /* Extract each entry and make a sub-tree */ + struct tree_data *my_data; + int dirlen = dirp->dirlen; + + my_data = make_tree_data(dirp->smbc_type, dirp->name); + + item = gtk_tree_item_new_with_label(dirp->name); + /* Connect all GtkItem:: and GtkTreeItem:: signals */ + gtk_signal_connect (GTK_OBJECT(item), "select", + GTK_SIGNAL_FUNC(cb_itemsignal), "select"); + gtk_signal_connect (GTK_OBJECT(item), "deselect", + GTK_SIGNAL_FUNC(cb_itemsignal), "deselect"); + gtk_signal_connect (GTK_OBJECT(item), "toggle", + GTK_SIGNAL_FUNC(cb_itemsignal), "toggle"); + gtk_signal_connect (GTK_OBJECT(item), "expand", + GTK_SIGNAL_FUNC(cb_itemsignal), "expand"); + gtk_signal_connect (GTK_OBJECT(item), "collapse", + GTK_SIGNAL_FUNC(cb_itemsignal), "collapse"); + /* Add it to the parent tree */ + gtk_tree_append (GTK_TREE(tree), item); + /* Show it - this can be done at any time */ + gtk_widget_show (item); + + gtk_object_set_user_data(GTK_OBJECT(item), (gpointer)my_data); + + fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen); + + subtree = gtk_tree_new(); + + gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree); + + gtk_signal_connect (GTK_OBJECT(subtree), "select_child", + GTK_SIGNAL_FUNC(cb_select_child), tree); + gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child", + GTK_SIGNAL_FUNC(cb_unselect_child), tree); + + (char *)dirp += dirlen; + err -= dirlen; + + } + + } + + smbc_closedir(dh); /* FIXME, check for error :-) */ + + /* Show the window and loop endlessly */ + gtk_main(); + return 0; +} +/* example-end */ |