Version 1.9.
Tar Extensions
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
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* The following changes developed by Richard Sharpe for Canon Information
- Systems Research Australia (CISRA) are Copyright (C) 1998 by CISRA and are
- made available under the terms of the GPL as listed above:
+ 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
#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
#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;
regex_t *preg;
#endif
/* Dump files with System attribute */
-BOOL tar_system=False;
+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;
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);
+static void unfixtarname(char *tptr, char *fp, int l, BOOL first);
/*
* tar specific utitlities
#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)
+/*******************************************************************
+Create a string of size size+1 (for the null)
+*******************************************************************/
+static char *string_create_s(int size)
{
char *tmp;
}
writetarheader(f, "/./@LongLink", l+1, 0, " 0 \0", 'L');
memset(b, 0, l+TBLOCK+100);
- fixtarname(b, aname, l+1);
+ 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));
/* write out a "standard" tar format header */
hb.dbuf.name[NAMSIZ-1]='\0';
- fstrcpy(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);
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;
}
}
- pstrcpy(finfo->name, prefix);
+ 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 some links at present */
if ((hb->dbuf.linkflag != '0') && (hb -> dbuf.linkflag != '5')) {
****************************************************************************/
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;
while (--ndgs)
{
- if (isdigit(*p))
+ if (isdigit((int)*p))
value = (value << 3) | (long) (*p - '0');
p++;
do_setrtime, set time on a file or dir ...
**********************************************************************/
-static int do_setrtime(char *fname, int mtime)
+static int do_setrtime(char *fname, int mtime, BOOL err_silent)
{
char *inbuf, *outbuf, *p;
char *name;
}
- pstrcpy(name, fname);
- pstrcpy(fname, "\\");
- pstrcat(fname, name);
+ 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(fname), True);
+ set_message(outbuf, 8, 4 + strlen(name), True);
CVAL(outbuf, smb_com) = SMBsetatr;
SSVAL(outbuf, smb_tid, cnum);
cli_setup_pkt(outbuf);
p = smb_buf(outbuf);
*p++ = 4;
- pstrcpy(p, fname);
+ safe_strcpy(p, name, strlen(name));
p+= (strlen(fname)+1);
*p++ = 4;
if (CVAL(inbuf,smb_rcls) != 0)
{
- DEBUG(0,("%s setting attributes on file %s\n",
- smb_errstr(inbuf), fname));
- free(inbuf);free(outbuf);
+ 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);
*/
char *inbuf,*outbuf;
char *p;
- pstring name;
+ char *name;
int fattr;
- pstrcpy(name,fname);
- pstrcpy(fname,"\\");
- pstrcat(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;
}
p = smb_buf(outbuf);
*p++ = 4;
- pstrcpy(p,fname);
- p += (strlen(fname)+1);
+ safe_strcpy(p,name, strlen(name));
+ p += (strlen(name)+1);
*p++ = 4;
*p++ = 0;
/* 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);
cli_setup_pkt(outbuf);
p = smb_buf(outbuf);
*p++ = 4;
- pstrcpy(p,fname);
- p += (strlen(fname)+1);
+ safe_strcpy(p,name, strlen(name));
+ p += (strlen(name)+1);
*p++ = 4;
*p++ = 0;
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);
}
p = smb_buf(outbuf);
*p++ = 4;
- pstrcpy(p,finfo.name);
+ safe_strcpy(p,finfo.name, strlen(finfo.name));
send_smb(Client,outbuf);
client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
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));
p = smb_buf(outbuf);
*p++ = 4;
- pstrcpy(p,fname);
+ safe_strcpy(p,fname, strlen(fname));
send_smb(Client,outbuf);
client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
p = smb_buf(outbuf);
*p++ = 4;
- pstrcpy(p,fname);
+ safe_strcpy(p,fname, strlen(fname));
send_smb(Client,outbuf);
client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
/* fname copied to ffname so can strtok */
- pstrcpy(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)
{
- pstrcat(partpath, p);
+ safe_strcat(partpath, p, strlen(fname) + 1);
if (!smbchkpath(partpath, inbuf, outbuf)) {
if (!smbmkdir(partpath, inbuf, outbuf))
}
- pstrcat(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;
uint32 nread=0;
char *p, ftype;
char *inbuf,*outbuf;
- file_info finfo;
+ file_info2 finfo;
BOOL close_done = False;
BOOL shallitime=True;
BOOL ignore_close_error = False;
ftype = '0'; /* An ordinary file ... */
- if (finfo1)
- finfo = *finfo1;
- else
- finfo = def_finfo;
+ 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);
SSVAL(outbuf,smb_vwv8,1);
p = smb_buf(outbuf);
- pstrcpy(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));
return;
}
- pstrcpy(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);
get_total_time_ms += this_time;
get_total_size += finfo.size;
- /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
- 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))));
if (tar_noisy)
{
- printf("%10d (%7.1f kb/s) %s\n",
+ DEBUG(0, ("%10d (%7.1f kb/s) %s\n",
finfo.size, finfo.size / MAX(0.001, (1.024*this_time)),
- finfo.name);
+ finfo.name));
}
+ /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
+ 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);
if (!tar_excl && clipn) {
pstring exclaim;
- pstrcpy(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';
- pstrcat(exclaim, "\\");
- pstrcat(exclaim, finfo->name);
+ safe_strcat(exclaim, "\\", sizeof(pstring));
+ safe_strcat(exclaim, finfo->name, sizeof(exclaim));
DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
return;
}
- pstrcpy(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));
- pstrcat(cur_dir,finfo->name);
- pstrcat(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", '5');
+ if (tar_noisy) {
+
+ DEBUG(0, (" directory %s\n", cur_dir));
+
+ }
ntarf++; /* Make sure we have a file on there */
- pstrcpy(mtar_mask,cur_dir);
- pstrcat(mtar_mask,"*");
+ 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); */
- pstrcpy(cur_dir,saved_curdir);
+ safe_strcpy(cur_dir,saved_curdir, sizeof(pstring));
free(inbuf);free(outbuf);
}
else
{
- pstrcpy(rname,cur_dir);
- pstrcat(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));
+
+ if (first) {
+ if (*fp == '.') {
+ fp++;
+ l--;
+ }
+ if (*fp == '\\' || *fp == '/') {
+ fp++;
+ l--;
+ }
+ }
while (l > 0) {
int skip;
}
}
-#if 0 /* Removed to get around gcc 'defined but not used' error. */
+#ifndef OLD_DOTARPUT
/****************************************************************************
Move to the next block in the buffer, which may mean read in another set of
-blocks.
+blocks. FIXME, we should allow more than one block to be skipped.
****************************************************************************/
-static int next_block(char *ltarbuf, char *bufferp, int bufsiz)
+static int next_block(char *ltarbuf, char **bufferp, int bufsiz)
{
int bufread, total = 0;
- if (bufferp >= (ltarbuf + bufsiz)) {
-
+ DEBUG(5, ("Advancing to next block: %0X\n", *bufferp));
+ *bufferp += TBLOCK;
+ total = TBLOCK;
+
+ if (*bufferp >= (ltarbuf + bufsiz)) {
+
+ DEBUG(5, ("Reading more data into ltarbuf ...\n"));
+
+ total = 0;
+
for (bufread = read(tarhandle, ltarbuf, bufsiz); total < bufsiz; total += bufread) {
if (bufread <= 0) { /* An error, return false */
}
- bufferp = ltarbuf;
+ DEBUG(5, ("Total bytes read ... %i\n", total));
- }
- else {
-
- bufferp += TBLOCK;
+ *bufferp = ltarbuf;
}
- return(0);
+ return(total);
}
-static int skip_file(int skip)
+/* Skip a file, even if it includes a long file name? */
+static int skip_file(int skipsize)
{
+ int dsize = skipsize;
- return(0);
+ 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);
}
-static int get_file(file_info2 finfo)
+/* 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;
- return(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);
}
-static int get_dir(file_info2 finfo)
+/* 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)
{
- return(0);
+ 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;
- return(NULL);
+ 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) {
-static char * bufferp;
+ if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
-static void do_tarput2(void)
+ 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;
GetTimeOfDay(&tp_start);
- bufferp = tarbuf + tbufsiz; /* init this to force first read */
+ 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);
}
}
+#endif
inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
}
- if (next_block(tarbuf, bufferp, tbufsiz) <= 0) {
+ /* Now read through those files ... */
+
+ while (True) {
- DEBUG(0, ("Empty file or short tar file: %s\n", strerror(errno)));
+ /* Get us to the next block, or the first block first time around */
- }
+ if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
- /* Now read through those files ... */
+ DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
- while (True) {
+ return;
+
+ }
- switch (readtarheader((union hblock *) bufferp, &finfo, cur_dir)) {
+ 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, bufferp, tbufsiz) <= 0) &&
+ if ((next_block(tarbuf, &buffer_p, tbufsiz) <= 0) &&
!skip_file(finfo.size)) {
DEBUG(0, ("Short file, bailing out...\n"));
/* Now, do we have a long file name? */
if (longfilename != NULL) {
- if (strlen(longfilename) < sizeof(finfo.name)) { /* if we have space */
- strncpy(finfo.name, longfilename, sizeof(finfo.name) - 1);
- free(longfilename);
- longfilename = NULL;
+ free(finfo.name); /* Free the space already allocated */
+ finfo.name = longfilename;
+ longfilename = NULL;
- }
- else {
+ }
- DEBUG(0, ("filename: %s too long, skipping\n", strlen(longfilename)));
- skip = True;
+ /* Well, now we have a header, process the file ... */
- }
- }
+ /* Should we skip the file? We have the long name as well here */
- /* Well, now we have a header, process the file ... */
+ 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
- /* Should we skip the file? */
+ DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, cliplist[0], finfo.name));
- if (skip) {
+ if (skip) {
- skip_file(finfo.size);
- continue;
+ skip_file(finfo.size);
+ continue;
- }
+ }
/* We only get this far if we should process the file */
- switch (((union hblock *)bufferp) -> dbuf.linkflag) {
+ switch (((union hblock *)buffer_p) -> dbuf.linkflag) {
case '0': /* Should use symbolic names--FIXME */
- get_file(finfo);
+ if (!get_file(finfo, inbuf, outbuf)) {
+
+ free(inbuf); free(outbuf);
+ DEBUG(0, ("Abandoning restore\n"));
+ return;
+
+ }
break;
case '5':
- get_dir(finfo);
+ 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:
}
-#endif /* Removed to get around gcc 'defined but not used' error. */
+
+#else
static void do_tarput()
{
/* These should be the only reads in clitar.c */
while ((bufread=read(tarhandle, tarbuf, tbufsiz))>0) {
- char *buffer_p, *endofbuffer;
+ char *endofbuffer;
int chunk;
/* Code to handle a short read.
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 */
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??? */
- DEBUG(5, ("Buffer size = %i\n", finfo.size + strlen(cur_dir) +1));
longname = malloc(finfo.size + strlen(cur_dir) + 1);
if (longname == NULL) {
return;
}
+
+ bzero(longname, finfo.size + strlen(cur_dir) +1);
+
buffer_p += TBLOCK; /* Skip that longlink header */
/* This needs restructuring ... */
- if (buffer_p >= endofbuffer) {
+ safe_strcpy(longname, cur_dir, strlen(cur_dir) + 1);
+ cp = longname + strlen(cur_dir);
+ file_len = finfo.size;
- bufread = read(tarhandle, tarbuf, tbufsiz);
+ DEBUG(5, ("longname=%0X, cp=%0X, file_len=%i\n",
+ (int)longname, (int)cp, file_len));
- buffer_p = tarbuf;
+ while (file_len > 0) {
- }
+ if (buffer_p >= endofbuffer) {
- strncpy(longname, cur_dir, strlen(cur_dir) + 1);
- unfixtarname(longname+strlen(cur_dir), buffer_p, finfo.size);
- DEBUG(5, ("UnfixedName: %s, buffer: %s\n", longname, buffer_p));
+ bufread = read(tarhandle, tarbuf, tbufsiz);
- /* Next rounds up to next TBLOCK and takes care of us being right
- on a TBLOCK boundary */
+ buffer_p = tarbuf;
- buffer_p += (((finfo.size - 1)/TBLOCK)+1)*TBLOCK;
- next_header = 1; /* Force read of next header */
+ }
+
+ 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
{
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))
{
{
/* Now we update the creation date ... */
- DEBUG(0, ("Updating creation date on %s\n", finfo.name));
+ DEBUG(5, ("Updating creation date on %s\n", finfo.name));
- if (!do_setrtime(finfo.name, finfo.mtime)) {
+ if (!do_setrtime(finfo.name, finfo.mtime, True)) {
- DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
- return;
+ 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 */
}
}
DEBUG(0 ,("restore tar file %s of size %d bytes\n",
- finfo.name,finfo.size));
+ finfo.name, finfo.size));
/* if (!finfo.size) {
if (!smbshut(finfo, fnum, inbuf, outbuf)){
}
if (fsize % TBLOCK) buffer_p+=TBLOCK - (fsize % TBLOCK);
DEBUG(5, ("buffer_p is now %d (psn=%d)\n",
- (long) buffer_p, (long)(buffer_p - tarbuf)));
+ (int) buffer_p, (int)(buffer_p - tarbuf)));
ntarf++;
fsize=0;
free(inbuf); free(outbuf);
}
+#endif
/*
* samba interactive commands
fstring buf;
int block;
- if (!next_token(NULL,buf,NULL))
+ if (!next_token(NULL,buf,NULL,sizeof(buf)))
{
DEBUG(0, ("blocksize <n>\n"));
return;
{
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"))
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;
}
- pstrcpy(fname, cur_dir);
- pstrcat(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)
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;
if (strrchr(cliplist[i], '\\')) {
pstring saved_dir;
- pstrcpy(saved_dir, cur_dir);
+ safe_strcpy(saved_dir, cur_dir, sizeof(pstring));
if (*cliplist[i]=='\\') {
- pstrcpy(tarmac, cliplist[i]);
+ safe_strcpy(tarmac, cliplist[i], sizeof(pstring));
} else {
- pstrcpy(tarmac, cur_dir);
- pstrcat(tarmac, cliplist[i]);
+ safe_strcpy(tarmac, cur_dir, sizeof(pstring));
+ safe_strcat(tarmac, cliplist[i], sizeof(pstring));
}
- pstrcpy(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, True);
- pstrcpy(cur_dir,saved_dir);
+ safe_strcpy(cur_dir,saved_dir, sizeof(pstring));
} else {
- pstrcpy(tarmac, cur_dir);
- pstrcat(tarmac, cliplist[i]);
+ 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;
- pstrcpy(mask,cur_dir);
- pstrcat(mask,"\\*");
+ safe_strcpy(mask,cur_dir, sizeof(pstring));
+ safe_strcat(mask,"\\*", sizeof(pstring));
do_dir((char *)inbuf,(char *)outbuf,mask,attribute,do_tar,recurse, True);
}
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;
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 && !tar_re_search) { /* For backwards compatibility */
+ 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;
);
return 0;
}
- unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1);
+ 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 */
git.samba.org / samba.git / blobdiff