Unix SMB/Netbios implementation.
Version 1.9.
Tar Extensions
- Copyright (C) Ricky Poulten 1995-1997
+ 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
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"
+static int clipfind(char **aret, int ret, char *tok);
+
+typedef struct file_info_struct file_info2;
+
+struct file_info_struct
+{
+ int size;
+ int 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;
+
+} stack;
+
+stack dir_stack = {NULL, 0}; /* Want an empty stack */
+
extern BOOL recurse;
#define SEPARATORS " \t\n\r"
#define CLIENT_TIMEOUT (30*1000)
#endif
-static char *tarbuf;
+static char *tarbuf, *buffer_p;
static int tp, ntarf, tbufsiz, ttarf;
/* Incremental mode */
BOOL tar_inc=False;
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
+/* 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=True;
+
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;
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();
+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);
+static int do_setrattr(char *fname, int attr, int setit);
/* 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
*/
+#if 0 /* Removed to get around gcc 'defined but not used' error. */
+
+/*
+ * Stack routines, push_dir, pop_dir, top_dir_name
+ */
+
+static BOOL push_dir(stack *tar_dir_stack, file_info2 *dir)
+{
+ dir -> next = tar_dir_stack -> top;
+ dir -> prev = NULL;
+ tar_dir_stack -> items++;
+ tar_dir_stack -> top = dir;
+ return(True);
+
+}
+
+static file_info2 *pop_dir(stack *tar_dir_stack)
+{
+ file_info2 *ptr;
+
+ ptr = tar_dir_stack -> top;
+ if (tar_dir_stack -> top != NULL) {
+
+ tar_dir_stack -> top = tar_dir_stack -> top -> next;
+ tar_dir_stack -> items--;
+
+ }
+
+ return ptr;
+
+}
+
+static char *top_dir_name(stack *tar_dir_stack)
+{
+
+ return(tar_dir_stack -> top != NULL?tar_dir_stack -> top -> name:NULL);
+
+}
+
+static BOOL sub_dir(char *dir1, char *dir2)
+{
+
+ return(True);
+
+}
+
+#endif /* Removed to get around gcc 'defined but not used' error. */
+
+/*******************************************************************
+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) {
+ /* 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+1, 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=%i, \n", b, strlen(b)));
+ dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1));
+ free(b);
+ }
/* use l + 1 to do the null too */
fixtarname(hb.dbuf.name, aname, (l >= NAMSIZ) ? NAMSIZ : l + 1);
/* 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++);
/****************************************************************************
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;
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));
+/* for (i = 0; i < sizeof(hb -> dummy); i++) {
+ fprintf(stdout, "%2X ", hb -> dummy[i]);
+ }
+ fprintf(stdout, "\n");
+ fprintf(stdout, "%s\n", hb -> dummy);
+ fprintf(stdout, "Tarbuf = %X, hb = %X\n", (int)tarbuf, (int)hb);*/
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;
+ }
}
}
}
/****************************************************************************
-Write a zeros to buffer / tape
+Write zeros to buffer / tape
****************************************************************************/
static void dozerobuf(int f, int n)
{
if (n+tp >= tbufsiz)
{
memset(tarbuf+tp, 0, tbufsiz-tp);
+
write(f, tarbuf, tbufsiz);
memset(tarbuf, 0, (tp+=n-tbufsiz));
}
{
/* 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 and total dumped */
tp=0; ntarf=0; ttarf=0;
****************************************************************************/
static void dotareof(int f)
{
- struct stat stbuf;
+ SMB_STRUCT_STAT stbuf;
/* Two zero blocks at end of file, write out full buffer */
(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;
* 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--;
+ int skip;
+ if((skip = skip_multibyte_char( *fp)) != 0) {
+ if (skip == 2) {
+ *tptr++ = *fp++;
+ *tptr++ = *fp++;
+ l -= 2;
+ } else if (skip == 1) {
+ *tptr++ = *fp++;
+ l--;
+ }
} else if (*fp == '\\') {
*tptr++ = '/';
fp++;
l--;
}
}
-#else
- while (l--) { *tptr=(*fp == '\\') ? '/' : *fp; tptr++; fp++; }
-#endif
}
/****************************************************************************
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 */
while (--ndgs)
{
- if (isdigit(*p))
+ if (isdigit((int)*p))
value = (value << 3) | (long) (*p - '0');
p++;
/*
* general smb utility functions
*/
+/**********************************************************************
+do_setrtime, set time on a file or dir ...
+**********************************************************************/
+
+static int do_setrtime(char *fname, int mtime, BOOL err_silent)
+{
+ char *inbuf, *outbuf, *p;
+ char *name;
+
+ DEBUG(5, ("Setting time on: %s, fnlen=%i.\n", fname, strlen(fname)));
+
+ name = (char *)malloc(strlen(fname) + 1 + 1);
+ if (name == NULL) {
+
+ DEBUG(0, ("Failed to allocate space while setting time on file: %s", fname));
+ return False;
+
+ }
+
+ if (*fname != '\\')
+ safe_strcpy(name, "\\", strlen(fname) + 1);
+ else
+ safe_strcpy(name, "", strlen(fname) + 1);
+ safe_strcat(name, fname, strlen(fname) + 1);
+
+ if (fname[strlen(name) - 1] == '\\')
+ name[strlen(name) - 1] = '\0';
+
+ inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ if (!inbuf || !outbuf) {
+
+ DEBUG(0, ("Could not allocate memory for inbuf or outbuf while changing time on: %s\n", fname));
+ free(name);
+ return False;
+
+ }
+
+ memset(outbuf, 0, smb_size);
+ set_message(outbuf, 8, 4 + strlen(name), True);
+ CVAL(outbuf, smb_com) = SMBsetatr;
+ SSVAL(outbuf, smb_tid, cnum);
+ cli_setup_pkt(outbuf);
+
+ SSVAL(outbuf, smb_vwv0, 0);
+ put_dos_date3(outbuf, smb_vwv1, mtime);
+
+ p = smb_buf(outbuf);
+ *p++ = 4;
+ safe_strcpy(p, name, strlen(name));
+ p+= (strlen(fname)+1);
+
+ *p++ = 4;
+ *p++ = 0;
+
+ send_smb(Client, outbuf);
+ client_receive_smb(Client, inbuf, CLIENT_TIMEOUT);
+
+ if (CVAL(inbuf,smb_rcls) != 0)
+ {
+ if (!err_silent) {
+ DEBUG(0,("%s setting attributes on file %s\n",
+ smb_errstr(inbuf), fname));
+ }
+ free(name);free(inbuf);free(outbuf);
+ return(False);
+ }
+
+ free(name);
+ free(inbuf);free(outbuf);
+ return(True);
+
+}
+
/****************************************************************************
Set DOS file attributes
***************************************************************************/
*/
char *inbuf,*outbuf;
char *p;
- pstring name;
+ char *name;
int fattr;
- strcpy(name,fname);
- strcpy(fname,"\\");
- strcat(fname,name);
+ name = (char *)malloc(strlen(fname) + 1 + 1);
+ if (name == NULL) {
+
+ DEBUG(0, ("Failed to allocate space in do_setrattr while setting time on file: %s", fname));
+ return False;
+
+ }
+
+ safe_strcpy(name, "\\", strlen(fname) + 1);
+ safe_strcat(name, fname, strlen(fname) + 1);
inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
if (!inbuf || !outbuf)
{
DEBUG(0,("out of memory\n"));
+ free(name);
return False;
}
set_message(outbuf,0,2 + strlen(fname),True);
CVAL(outbuf,smb_com) = SMBgetatr;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
p = smb_buf(outbuf);
*p++ = 4;
- strcpy(p,fname);
- p += (strlen(fname)+1);
+ safe_strcpy(p,name, strlen(name));
+ p += (strlen(name)+1);
*p++ = 4;
*p++ = 0;
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
if (CVAL(inbuf,smb_rcls) != 0)
DEBUG(5,("getatr: %s\n",smb_errstr(inbuf)));
/* clear out buffer and start again */
memset(outbuf,0,smb_size);
- set_message(outbuf,8,4 + strlen(fname),True);
+ set_message(outbuf,8,4 + strlen(name),True);
CVAL(outbuf,smb_com) = SMBsetatr;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
SSVAL(outbuf,smb_vwv0,attr);
-
+
p = smb_buf(outbuf);
*p++ = 4;
- strcpy(p,fname);
- p += (strlen(fname)+1);
+ safe_strcpy(p,name, strlen(name));
+ p += (strlen(name)+1);
*p++ = 4;
*p++ = 0;
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_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);
+ smb_errstr(inbuf), name));
+ free(name);free(inbuf);free(outbuf);
return(False);
}
+ free(name);
free(inbuf);free(outbuf);
return(True);
}
/****************************************************************************
Create a file on a share
***************************************************************************/
-static BOOL smbcreat(file_info finfo, int *fnum, char *inbuf, char *outbuf)
+static BOOL smbcreat(file_info2 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);
+ cli_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);
+ safe_strcpy(p,finfo.name, strlen(finfo.name));
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
if (CVAL(inbuf,smb_rcls) != 0)
{
set_message(outbuf,5,n + 3, False);
CVAL(outbuf,smb_com) = SMBwrite;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
SSVAL(outbuf,smb_vwv0,fnum);
SSVAL(outbuf,smb_vwv1,n);
SSVAL(smb_buf(outbuf),1,n);
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
if (CVAL(inbuf,smb_rcls) != 0)
{
/****************************************************************************
Close a file on a share
***************************************************************************/
-static BOOL smbshut(file_info finfo, int fnum, char *inbuf, char *outbuf)
+static BOOL smbshut(file_info2 finfo, int fnum, char *inbuf, char *outbuf)
{
/* *must* be called with buffer ready malloc'ed */
set_message(outbuf,3,0,True);
CVAL(outbuf,smb_com) = SMBclose;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
SSVAL(outbuf,smb_vwv0,fnum);
put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
- DEBUG(3,("Setting date to %s (0x%X)",
+ DEBUG(3,("Setting date to %s (0x%lX)",
asctime(LocalTime(&finfo.mtime)),
finfo.mtime));
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
if (CVAL(inbuf,smb_rcls) != 0)
{
set_message(outbuf,0,4 + strlen(fname),True);
CVAL(outbuf,smb_com) = SMBchkpth;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
p = smb_buf(outbuf);
*p++ = 4;
- strcpy(p,fname);
+ safe_strcpy(p,fname, strlen(fname));
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
DEBUG(5,("smbchkpath: %s\n",smb_errstr(inbuf)));
CVAL(outbuf,smb_com) = SMBmkdir;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
p = smb_buf(outbuf);
*p++ = 4;
- strcpy(p,fname);
+ safe_strcpy(p,fname, strlen(fname));
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
if (CVAL(inbuf,smb_rcls) != 0)
{
/* *must* be called with buffer ready malloc'ed */
/* ensures path exists */
- pstring partpath, ffname;
+ char *partpath, *ffname;
char *p=fname, *basehack;
+ DEBUG(5, ( "Ensurepath called with: %s\n", fname));
+
+ partpath = string_create_s(strlen(fname));
+ ffname = string_create_s(strlen(fname));
+
+ if ((partpath == NULL) || (ffname == NULL)){
+
+ DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
+ return(False);
+
+ }
+
*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)
while (p)
{
- strcat(partpath, p);
+ safe_strcat(partpath, p, strlen(fname) + 1);
if (!smbchkpath(partpath, inbuf, outbuf)) {
if (!smbmkdir(partpath, inbuf, outbuf))
}
- strcat(partpath, "\\");
+ safe_strcat(partpath, "\\", strlen(fname) + 1);
p = strtok(NULL,"/\\");
}
return True;
}
-int padit(char *buf, int bufsize, int padsize)
+static int padit(char *buf, int bufsize, int padsize)
{
int berr= 0;
int bytestowrite;
- DEBUG(0, ("Padding with %d zeros\n", padsize));
+ DEBUG(5, ("Padding with %d zeros\n", padsize));
memset(buf, 0, bufsize);
while( !berr && padsize > 0 ) {
bytestowrite= MIN(bufsize, padsize);
{
int fnum;
uint32 nread=0;
- char *p;
+ char *p, ftype;
char *inbuf,*outbuf;
- file_info finfo;
+ file_info2 finfo;
BOOL close_done = False;
BOOL shallitime=True;
BOOL ignore_close_error = False;
struct timeval tp_start;
GetTimeOfDay(&tp_start);
- if (finfo1)
- finfo = *finfo1;
- else
- finfo = def_finfo;
+ ftype = '0'; /* An ordinary file ... */
+
+ 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;
+ }
+
inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
CVAL(outbuf,smb_com) = SMBopenX;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
SSVAL(outbuf,smb_vwv0,0xFF);
SSVAL(outbuf,smb_vwv2,1);
SSVAL(outbuf,smb_vwv8,1);
p = smb_buf(outbuf);
- strcpy(p,rname);
+ safe_strcpy(p, rname, strlen(rname));
p = skip_string(p,1);
dos_clean_name(rname);
SSVAL(outbuf,smb_vwv1,PTR_DIFF(p,outbuf) - 4);
memset(p,0,200);
p -= smb_wct;
- SSVAL(p,smb_wct,10);
+ SCVAL(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));
}
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_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))
+ cli_reopen_connection(inbuf,outbuf))
{
do_atar(rname,lname,finfo1);
free(inbuf);free(outbuf);
return;
}
- strcpy(finfo.name,rname);
+ finfo.name = string_create_s(strlen(rname));
+ if (finfo.name == NULL) {
+
+ DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n"));
+ free(inbuf); free(outbuf);
+ return;
+
+ }
+
+ safe_strcpy(finfo.name,rname, strlen(rname));
if (!finfo1)
{
finfo.mode = SVAL(inbuf,smb_vwv3);
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)
datalen = 0;
}
- DEBUG(1,("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,
lname));
/* write a tar header, don't bother with mode - just set to 100644 */
- writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0");
+ writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0", ftype);
while (nread < finfo.size && !close_done)
{
set_message(outbuf,10,0,True);
CVAL(outbuf,smb_com) = SMBreadX;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
if (close_done)
{
}
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
if (CVAL(inbuf,smb_rcls) != 0)
{
set_message(outbuf,8,0,True);
CVAL(outbuf,smb_com) = SMBreadbraw;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
SSVAL(outbuf,smb_vwv0,fnum);
SIVAL(outbuf,smb_vwv1,nread);
SSVAL(outbuf,smb_vwv3,MIN(finfo.size-nread,readbraw_size));
set_message(outbuf,5,0,True);
CVAL(outbuf,smb_com) = SMBread;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
SSVAL(outbuf,smb_vwv0,fnum);
SSVAL(outbuf,smb_vwv1,MIN(max_xmit-200,finfo.size - nread));
SSVAL(outbuf,smb_vwv4,finfo.size - nread);
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
if (CVAL(inbuf,smb_rcls) != 0)
{
* write out in 512 byte intervals */
if (dotarbuf(tarhandle,dataptr,datalen) != datalen)
{
- DEBUG(0,("Error writing local file\n"));
+ DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
break;
}
{
DEBUG(0, ("Didn't get entire file. size=%d, nread=%d\n", finfo.size, nread));
if (padit(inbuf, BUFFER_SIZE, finfo.size - nread))
- DEBUG(0,("Error writing local file\n"));
+ DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
}
/* round tar file to nearest block */
set_message(outbuf,3,0,True);
CVAL(outbuf,smb_com) = SMBclose;
SSVAL(outbuf,smb_tid,cnum);
- setup_pkt(outbuf);
+ cli_setup_pkt(outbuf);
SSVAL(outbuf,smb_vwv0,fnum);
SIVALS(outbuf,smb_vwv1,-1);
send_smb(Client,outbuf);
- receive_smb(Client,inbuf,CLIENT_TIMEOUT);
+ client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
if (!ignore_close_error && CVAL(inbuf,smb_rcls) != 0)
{
get_total_time_ms += this_time;
get_total_size += finfo.size;
+ if (tar_noisy)
+ {
+ DEBUG(0, ("%10d (%7.1f kb/s) %s\n",
+ 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(1,("(%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))));
}
{
pstring rname;
- if (strequal(finfo->name,".") || strequal(finfo->name,".."))
+ if (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) = %i\n", strlen(cur_dir)));
+
+ safe_strcpy(exclaim, cur_dir, sizeof(pstring));
*(exclaim+strlen(exclaim)-1)='\0';
- strcat(exclaim, "\\");
- strcat(exclaim, finfo->name);
+ safe_strcat(exclaim, "\\", sizeof(pstring));
+ safe_strcat(exclaim, finfo->name, sizeof(exclaim));
- if (clipfind(cliplist, clipn, exclaim)) {
+ DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
+
+ 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, False))) {
+#endif
DEBUG(3,("Skipping file %s\n", exclaim));
return;
}
return;
}
- strcpy(saved_curdir,cur_dir);
+ safe_strcpy(saved_curdir, cur_dir, sizeof(saved_curdir));
+
+ DEBUG(5, ("Sizeof(cur_dir)=%i, strlen(cur_dir)=%i, strlen(finfo->name)=%i\nname=%s,cur_dir=%s\n", sizeof(cur_dir), strlen(cur_dir), strlen(finfo->name), finfo->name, cur_dir));
- strcat(cur_dir,finfo->name);
- strcat(cur_dir,"\\");
+ safe_strcat(cur_dir,finfo->name, sizeof(cur_dir));
+ safe_strcat(cur_dir,"\\", sizeof(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);
+ 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));
+ /* do_dir((char *)inbuf,(char *)outbuf,mtar_mask,attribute,do_tar,recurse,True); */
+ safe_strcpy(cur_dir,saved_curdir, sizeof(pstring));
free(inbuf);free(outbuf);
}
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);
}
}
/****************************************************************************
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.
+ * dos \'s in path. Kill any absolute path names. But only if first!
*/
- if (*fp == '.') fp++;
- if (*fp == '\\' || *fp == '/') fp++;
+ DEBUG(5, ("firstb=%lX, secondb=%lX, len=%i\n", (long)tptr, (long)fp, l));
-#ifdef KANJI
- while (l > 0) {
- if (is_shift_jis (*fp)) {
- *tptr++ = *fp++;
- *tptr++ = *fp++;
- l -= 2;
- } else if (is_kana (*fp)) {
- *tptr++ = *fp++;
+ if (first) {
+ if (*fp == '.') {
+ fp++;
l--;
+ }
+ if (*fp == '\\' || *fp == '/') {
+ fp++;
+ l--;
+ }
+ }
+
+ while (l > 0) {
+ int skip;
+ if(( skip = skip_multibyte_char( *fp )) != 0) {
+ if (skip == 2) {
+ *tptr++ = *fp++;
+ *tptr++ = *fp++;
+ l -= 2;
+ } else if (skip == 1) {
+ *tptr++ = *fp++;
+ l--;
+ }
} else if (*fp == '/') {
*tptr++ = '\\';
fp++;
l--;
}
}
-#else
- while (l--) { *tptr=(*fp == '/') ? '\\' : *fp; tptr++; fp++; }
-#endif
}
-static void do_tarput()
+#ifndef OLD_DOTARPUT
+
+/****************************************************************************
+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)
{
- file_info finfo;
- int nread=0, bufread;
- char *inbuf,*outbuf;
- int fsize=0;
- int fnum;
- struct timeval tp_start;
- BOOL tskip=False; /* We'll take each file as it comes */
+ int bufread, total = 0;
- 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;
- }
-
- /*
- * Must read in tbufsiz dollops
- */
+ DEBUG(5, ("Advancing to next block: %0X\n", *bufferp));
+ *bufferp += TBLOCK;
+ total = TBLOCK;
- /* These should be the only reads in clitar.c */
- while ((bufread=read(tarhandle, tarbuf, tbufsiz))>0) {
- char *bufferp, *endofbuffer;
- int chunk;
+ if (*bufferp >= (ltarbuf + bufsiz)) {
- /* Code to handle a short read.
- * We always need a TBLOCK full of stuff
- */
- if (bufread % TBLOCK) {
- int lchunk=TBLOCK-(bufread % TBLOCK);
- int lread;
+ DEBUG(5, ("Reading more data into ltarbuf ...\n"));
- /* It's a shorty - a short read that is */
- DEBUG(3, ("Short read, read %d so far (need %d)\n", bufread, lchunk));
+ total = 0;
- while ((lread=read(tarhandle, tarbuf+bufread, lchunk))>0) {
- bufread+=lread;
- if (!(lchunk-=lread)) break;
+ for (bufread = read(tarhandle, ltarbuf, bufsiz); total < bufsiz; total += bufread) {
+
+ if (bufread <= 0) { /* An error, return false */
+ return (total > 0 ? -2 : bufread);
}
- /* If we've reached EOF then that must be a short file */
- if (lread<=0) break;
}
- bufferp=tarbuf;
- endofbuffer=tarbuf+bufread;
+ DEBUG(5, ("Total bytes read ... %i\n", total));
- if (tskip) {
- if (fsize<bufread) {
- tskip=False;
- bufferp+=fsize;
- fsize=0;
- } else {
- if (fsize==bufread) tskip=False;
- fsize-=bufread;
- continue;
- }
- }
+ *bufferp = ltarbuf;
- 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;
- }
- }
+ return(total);
- if (finfo.mode & aDIR)
- {
- if (!smbchkpath(finfo.name, inbuf, outbuf)
- && !smbmkdir(finfo.name, inbuf, outbuf))
+}
+
+/* Skip a file, even if it includes a long file name? */
+static int skip_file(int skipsize)
+{
+ 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);
+}
+
+/* We get a file from the tar file and store it */
+static int get_file(file_info2 finfo, char * inbuf, char * outbuf)
+{
+ int fsize = finfo.size;
+ int fnum, pos = 0, dsize = 0, wsize = 0, rsize = 0;
+
+ DEBUG(5, ("get_file: file: %s, size %i\n", finfo.name, fsize));
+
+ if (ensurepath(finfo.name, inbuf, outbuf) &&
+ !smbcreat(finfo, &fnum, inbuf, outbuf))
+ {
+ DEBUG(0, ("abandoning restore\n"));
+ return(False);
+ }
+
+ DEBUG(0, ("restore tar file %s of size %d bytes\n",
+ finfo.name, finfo.size));
+
+ /* read the blocks from the tar file and write to the remote file */
+
+ rsize = fsize;
+
+ while (rsize > 0) {
+
+ dsize = MIN(tbufsiz - (buffer_p - tarbuf), rsize); /* Calculate the size to write */
+
+ DEBUG(5, ("writing %i bytes ...\n", dsize));
+
+ if (!smbwrite(fnum, dsize, pos, 0, fsize - pos, buffer_p, inbuf, outbuf)) {
+
+ DEBUG(0, ("Error writing remote file\n"));
+ return 0;
+
+ }
+
+ rsize -= dsize;
+
+ /* Now figure out how much to move in the buffer */
+
+ /* 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;
+
+ }
+
+ }
+
+ /* Now close the file ... */
+
+ if (!smbshut(finfo, fnum, inbuf, outbuf)) {
+
+ 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 (!do_setrtime(finfo.name, finfo.mtime, True)) {
+
+ DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
+ /*return(False); */ /* Ignore, as Win95 does not allow changes */
+
+ }
+
+ ntarf++;
+ 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, char * inbuf, char * outbuf)
+{
+
+ DEBUG(5, ("Creating directory: %s\n", finfo.name));
+
+ if (!ensurepath(finfo.name, inbuf, outbuf)) {
+
+ DEBUG(0, ("Problems creating directory\n"));
+ return(False);
+
+ }
+ 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);
+ char *xxx;
+ int offset = 0, left = finfo.size;
+ BOOL first = True;
+
+ DEBUG(5, ("Restoring a long file name: %s\n", finfo.name));
+ DEBUG(5, ("Len = %i\n", finfo.size));
+ fflush(stderr);
+
+ if (longname == NULL) {
+
+ DEBUG(0, ("could not allocate buffer of size %d for longname\n",
+ 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, *finfo2;
+ struct timeval tp_start;
+ char *inbuf, *outbuf, *longfilename = NULL;
+ int skip = False;
+
+ GetTimeOfDay(&tp_start);
+
+ DEBUG(5, ("RJS do_tarput called ...\n"));
+
+ buffer_p = tarbuf + tbufsiz; /* init this to force first read */
+
+#if 0 /* Fix later ... */
+ if (push_dir(&dir_stack, &finfo)) {
+
+ finfo2 = pop_dir(&dir_stack);
+ inbuf = top_dir_name(&dir_stack); /* FIXME */
+ if (sub_dir(inbuf, finfo2 -> name)){
+
+ DEBUG(0, (""));
+
+ }
+ }
+#endif
+
+ inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+ outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
+
+ if (!inbuf || !outbuf) {
+
+ DEBUG(0, ("Out of memory during allocate of inbuf and outbuf!\n"));
+ return;
+
+ }
+
+ /* 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;
+
+ }
+
+ DEBUG(5, ("Reading the next header ...\n"));
+ fflush(stdout);
+ 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)) {
+
+ DEBUG(0, ("Short file, bailing out...\n"));
+ free(inbuf); free(outbuf);
+ continue;
+
+ }
+
+ break;
+
+ case -1:
+ DEBUG(0, ("abandoning restore, -1 from read tar header\n"));
+ free(inbuf); free(outbuf);
+ return;
+
+ case 0: /* chksum is zero - looks like an EOF */
+ DEBUG(0, ("total of %d tar files restored to share\n", ntarf));
+ free(inbuf); free(outbuf);
+ return; /* Hmmm, bad here ... */
+
+ default:
+ break;
+
+ }
+
+ /* Now, do we have a long file name? */
+
+ if (longfilename != NULL) {
+
+ free(finfo.name); /* Free the space already allocated */
+ finfo.name = longfilename;
+ longfilename = NULL;
+
+ }
+
+ /* Well, now we have a header, process the file ... */
+
+ /* 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, False)));
+#endif
+
+ DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, cliplist[0], finfo.name));
+
+ if (skip) {
+
+ skip_file(finfo.size);
+ continue;
+
+ }
+
+ /* We only get this far if we should process the file */
+
+ switch (((union hblock *)buffer_p) -> dbuf.linkflag) {
+
+ case '0': /* Should use symbolic names--FIXME */
+ if (!get_file(finfo, inbuf, outbuf)) {
+
+ free(inbuf); free(outbuf);
+ DEBUG(0, ("Abandoning restore\n"));
+ return;
+
+ }
+ break;
+
+ case '5':
+ if (!get_dir(finfo, inbuf, outbuf)) {
+ free(inbuf); free(outbuf);
+ DEBUG(0, ("Abandoning restore \n"));
+ return;
+ }
+ break;
+
+ case 'L':
+ longfilename = get_longfilename(finfo);
+ if (!longfilename) {
+ free(inbuf); free(outbuf);
+ 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;
+
+ }
+
+ }
+
+
+}
+
+#else
+
+static void do_tarput()
+{
+ file_info2 finfo;
+ int nread=0, bufread;
+ char *inbuf,*outbuf, *longname = NULL;
+ int fsize=0;
+ int fnum;
+ struct timeval tp_start;
+ BOOL tskip=False; /* We'll take each file as it comes */
+
+ finfo.name = NULL; /* No name in here ... */
+
+ 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;
+ }
+
+ /*
+ * Must read in tbufsiz dollops
+ */
+
+ /* These should be the only reads in clitar.c */
+ while ((bufread=read(tarhandle, tarbuf, tbufsiz))>0) {
+ char *endofbuffer;
+ int chunk;
+
+ /* Code to handle a short read.
+ * We always need a TBLOCK full of stuff
+ */
+ if (bufread % TBLOCK) {
+ int lchunk=TBLOCK-(bufread % TBLOCK);
+ int lread;
+
+ /* It's a shorty - a short read that is */
+ DEBUG(3, ("Short read, read %d so far (need %d)\n", bufread, lchunk));
+
+ 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;
+ }
+
+ buffer_p=tarbuf;
+ endofbuffer=tarbuf+bufread;
+
+ if (tskip) {
+ if (fsize<bufread) {
+ tskip=False;
+ buffer_p+=fsize;
+ fsize=0;
+ } else {
+ if (fsize==bufread) tskip=False;
+ fsize-=bufread;
+ continue;
+ }
+ }
+
+ do {
+ if (!fsize)
+ {
+ int next_header = 1; /* Want at least one header */
+ while (next_header)
+ {
+ if (buffer_p >= endofbuffer) {
+
+ bufread = read(tarhandle, tarbuf, tbufsiz);
+ buffer_p = tarbuf;
+
+ }
+ next_header = 0; /* Don't want the next one ... */
+
+ if (finfo.name != NULL) { /* Free the space */
+
+ free(finfo.name);
+ finfo.name = NULL;
+
+ }
+ DEBUG(5, ("Tarbuf=%X, buffer=%X, endofbuf=%X\n",
+ (int)tarbuf, (int)buffer_p, (int)endofbuffer));
+ switch (readtarheader((union hblock *) buffer_p, &finfo, cur_dir))
+ {
+ case -2: /* something dodgy but not fatal about this */
+ DEBUG(0, ("skipping %s...\n", finfo.name));
+ buffer_p+=TBLOCK; /* header - like a link */
+ continue;
+ case -1:
+ DEBUG(0, ("abandoning restore, -1 from readtarheader\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;
+ }
+
+ /* If we have a longname left from the last time through,
+ copy it into finfo.name and free it.
+
+ The size of a pstring is the limiting factor on filenames
+ and directory names now. The total pathname length must be
+ less than sizeof(pstring) - 1, which is currently 1023. */
+
+ if (longname != NULL) {
+
+ free(finfo.name); /* Free the name in the finfo */
+ finfo.name = string_create_s(strlen(longname) + 2);
+ strncpy(finfo.name, longname, strlen(longname) + 1);
+ DEBUG(5, ("Long name = \"%s\", filename=\"%s\"\n", longname, finfo.name));
+ free(longname);
+ longname = NULL;
+
+ }
+
+ /* Check if a long-link. We do this before the clip checking
+ because clip-checking should clip on real name - RJS */
+
+ if (((union hblock *)buffer_p) -> dbuf.linkflag == 'L') {
+ int file_len, first = 0; char *cp;
+
+ /* Skip this header, but pick up length, get the name and
+ fix the name and skip the name. Hmmm, what about end of
+ buffer??? */
+
+ longname = malloc(finfo.size + strlen(cur_dir) + 1);
+ if (longname == NULL) {
+
+ DEBUG(0, ("could not allocate buffer of size %d for longname\n",
+ finfo.size + strlen(cur_dir) + 1)
+ );
+ free(inbuf); free(outbuf);
+ return;
+ }
+
+
+ bzero(longname, finfo.size + strlen(cur_dir) +1);
+
+ buffer_p += TBLOCK; /* Skip that longlink header */
+
+ /* This needs restructuring ... */
+
+ safe_strcpy(longname, cur_dir, strlen(cur_dir) + 1);
+ cp = longname + strlen(cur_dir);
+ file_len = finfo.size;
+
+ DEBUG(5, ("longname=%0X, cp=%0X, file_len=%i\n",
+ (int)longname, (int)cp, file_len));
+
+ while (file_len > 0) {
+
+ if (buffer_p >= endofbuffer) {
+
+ bufread = read(tarhandle, tarbuf, tbufsiz);
+
+ buffer_p = tarbuf;
+
+ }
+
+ unfixtarname(cp, buffer_p, file_len >= TBLOCK?TBLOCK:file_len, first == 0);
+
+ first++; /* Not the first anymore */
+ cp = cp + strlen(cp); /* Move to end of string */
+ buffer_p += TBLOCK;
+ file_len -= TBLOCK;
+ DEBUG(5, ("cp=%0X, file_len=%i\n", (int)cp, file_len));
+ next_header = 1; /* Force read of next header */
+
+ }
+ }
+ }
+ tskip=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, False)));
+#endif
+ if (tskip) {
+ buffer_p+=TBLOCK;
+ if (finfo.mode & aDIR)
+ continue;
+ else if ((fsize=finfo.size) % TBLOCK) {
+ fsize+=TBLOCK-(fsize%TBLOCK);
+ }
+ if (fsize<endofbuffer-buffer_p) {
+ buffer_p+=fsize;
+ fsize=0;
+ continue;
+ } else {
+ fsize-=endofbuffer-buffer_p;
+ break;
+ }
+ }
+
+ DEBUG(5, ("do_tarput: File is: %s\n", finfo.name));
+
+ if (finfo.mode & aDIR)
+ {
+
+ DEBUG(5, ("Creating directory: %s\n", finfo.name));
+ DEBUG(0, ("restore tar dir %s of size %d bytes\n",
+ finfo.name, finfo.size));
+
+ if (!ensurepath(finfo.name, inbuf, outbuf))
{
- DEBUG(0, ("abandoning restore\n"));
+ DEBUG(0, ("abandoning restore, problems ensuring path\n"));
free(inbuf); free(outbuf);
return;
}
else
{
- bufferp+=TBLOCK;
+ /* Now we update the creation date ... */
+
+ DEBUG(5, ("Updating creation date on %s\n", finfo.name));
+
+ if (!do_setrtime(finfo.name, finfo.mtime, True)) {
+
+ if (tar_real_noisy) {
+ DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
+ }
+ /*return; - Win 95 does not like setting time on dirs */
+
+ }
+
+ ntarf++;
+ buffer_p+=TBLOCK;
continue;
}
}
return;
}
- DEBUG(0,("restore tar file %s of size %d bytes\n",
- finfo.name,finfo.size));
+ DEBUG(0 ,("restore tar file %s of size %d bytes\n",
+ finfo.name, finfo.size));
+
+ /* if (!finfo.size) {
+ if (!smbshut(finfo, fnum, inbuf, outbuf)){
+ DEBUG(0, ("Error closing remote file of length 0: %s\n", finfo.name));
+ free(inbuf);free(outbuf);
+ return;
+ }
+ } */
nread=0;
- if ((bufferp+=TBLOCK) >= endofbuffer) break;
+ if ((buffer_p+=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;
+ chunk=(fsize-nread < endofbuffer - buffer_p)
+ ? fsize - nread : endofbuffer - buffer_p;
while (chunk > 0) {
int minichunk=MIN(chunk, max_xmit-200);
nread, /* offset low */
0, /* offset high - not implemented */
fsize-nread, /* left - only hint to server */
- bufferp,
+ buffer_p,
inbuf,
outbuf))
{
}
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;
+ buffer_p+=minichunk; nread+=minichunk;
chunk-=minichunk;
}
-
+
if (nread>=fsize)
{
if (!smbshut(finfo, fnum, inbuf, outbuf))
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)));
+ if (fsize % TBLOCK) buffer_p+=TBLOCK - (fsize % TBLOCK);
+ DEBUG(5, ("buffer_p is now %d (psn=%d)\n",
+ (int) buffer_p, (int)(buffer_p - tarbuf)));
ntarf++;
fsize=0;
+
}
- } while (bufferp < endofbuffer);
+ } while (buffer_p < endofbuffer);
}
DEBUG(0, ("premature eof on tar file ?\n"));
free(inbuf); free(outbuf);
}
+#endif
/*
* samba interactive commands
/****************************************************************************
Blocksize command
***************************************************************************/
-void cmd_block(void)
+void cmd_block(char *dum_in, char *dum_out)
{
fstring buf;
int block;
- if (!next_token(NULL,buf,NULL))
+ if (!next_token(NULL,buf,NULL,sizeof(buf)))
{
DEBUG(0, ("blocksize <n>\n"));
return;
}
blocksize=block;
- DEBUG(1,("blocksize is now %d\n", blocksize));
+ DEBUG(2,("blocksize is now %d\n", blocksize));
}
/****************************************************************************
command to set incremental / reset mode
***************************************************************************/
-void cmd_tarmode(void)
+void cmd_tarmode(char *dum_in, char *dum_out)
{
fstring buf;
- while (next_token(NULL,buf,NULL)) {
+ while (next_token(NULL,buf,NULL,sizeof(buf))) {
if (strequal(buf, "full"))
tar_inc=False;
else if (strequal(buf, "inc"))
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"));
+
}
/****************************************************************************
Feeble attrib command
***************************************************************************/
-void cmd_setmode(void)
+void cmd_setmode(char *dum_in, char *dum_out)
{
char *q;
fstring buf;
attra[0] = attra[1] = 0;
- if (!next_token(NULL,buf,NULL))
+ if (!next_token(NULL,buf,NULL,sizeof(buf)))
{
DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
return;
}
- 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(NULL,buf,NULL,sizeof(buf))) {
q=buf;
while(*q)
return;
}
- DEBUG(1, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
+ 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);
}
char **argl;
int argcl;
- if (!next_token(NULL,buf,NULL))
+ if (!next_token(NULL,buf,NULL,sizeof(buf)))
{
DEBUG(0,("tar <c|x>[IXbga] <filename>\n"));
return;
initarbuf();
switch(tar_type) {
case 'x':
+
+#if 0
+ do_tarput2();
+#else
do_tarput();
+#endif
free(tarbuf);
close(tarhandle);
break;
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], '\\')) {
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);
+ safe_strcpy(cur_dir, tarmac, sizeof(pstring));
*(strrchr(cur_dir, '\\')+1)='\0';
- do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse);
- strcpy(cur_dir,saved_dir);
+ do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse, 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));
+ do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse, 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));
+ safe_strcat(mask,"\\*", sizeof(pstring));
+ do_dir((char *)inbuf,(char *)outbuf,mask,attribute,do_tar,recurse, True);
}
if (ntarf) dotareof(tarhandle);
break;
}
+ if (must_free_cliplist) {
+ int i;
+ for (i = 0; i < clipn; ++i) {
+ free(cliplist[i]);
+ }
+ 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;
return 0;
}
+/****************************************************************************
+Read list of files to include from the file and initialize cliplist
+accordingly.
+***************************************************************************/
+static int read_inclusion_file(char *filename)
+{
+ FILE *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 = fopen(filename, "r")) == 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) && (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) {
+ inclusion_buffer_size *= 2;
+ inclusion_buffer = Realloc(inclusion_buffer,inclusion_buffer_size);
+ if (! inclusion_buffer) {
+ DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n",
+ inclusion_buffer_size));
+ error = 1;
+ break;
+ }
+ }
+
+ safe_strcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar);
+ inclusion_buffer_sofar += strlen(buf) + 1;
+ clipn++;
+ }
+ 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(p, '\000')) == NULL) {
+ DEBUG(0,("INTERNAL ERROR: inclusion_buffer is of unexpected contents.\n"));
+ abort();
+ }
+ }
+ ++p;
+ }
+ must_free_cliplist = True;
+ }
+ }
+
+ if (inclusion_buffer) {
+ free(inclusion_buffer);
+ }
+ if (error) {
+ if (cliplist) {
+ char **pp;
+ /* We know cliplist is always null-terminated */
+ for (pp = cliplist; *pp; ++pp) {
+ free(*pp);
+ }
+ 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.
***************************************************************************/
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) {
+ if (dos_stat(argv[Optind], &stbuf) == 0) {
newer_than = stbuf.st_mtime;
DEBUG(1,("Getting files newer than %s",
asctime(LocalTime(&newer_than))));
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;
default:
DEBUG(0,("Unknown tar option\n"));
return 0;
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 (Optind+1<argc) {
+
+ 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');
if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY)) == -1)
|| (tar_type=='c' && (tarhandle=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);
}
}