|
|
@@ -0,0 +1,644 @@
|
|
|
+/* GNU dump extensions to tar.
|
|
|
+ Copyright (C) 1988, 1992 Free Software Foundation
|
|
|
+
|
|
|
+This file is part of GNU Tar.
|
|
|
+
|
|
|
+GNU Tar 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, or (at your option)
|
|
|
+any later version.
|
|
|
+
|
|
|
+GNU Tar 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 GNU Tar; see the file COPYING. If not, write to
|
|
|
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
+
|
|
|
+#include <stdio.h>
|
|
|
+#include <sys/types.h>
|
|
|
+#include <ctype.h>
|
|
|
+#include <errno.h>
|
|
|
+#ifndef STDC_HEADERS
|
|
|
+extern int errno;
|
|
|
+#endif
|
|
|
+#include <time.h>
|
|
|
+time_t time();
|
|
|
+
|
|
|
+#include "tar.h"
|
|
|
+#include "port.h"
|
|
|
+
|
|
|
+#if defined(_POSIX_VERSION) || defined(DIRENT)
|
|
|
+#include <dirent.h>
|
|
|
+#ifdef direct
|
|
|
+#undef direct
|
|
|
+#endif /* direct */
|
|
|
+#define direct dirent
|
|
|
+#define DP_NAMELEN(x) strlen((x)->d_name)
|
|
|
+#endif /* _POSIX_VERSION or DIRENT */
|
|
|
+#if !defined(_POSIX_VERSION) && !defined(DIRENT) && defined(BSD42)
|
|
|
+#include <sys/dir.h>
|
|
|
+#define DP_NAMELEN(x) (x)->d_namlen
|
|
|
+#endif /* not _POSIX_VERSION and BSD42 */
|
|
|
+#ifdef __MSDOS__
|
|
|
+#include "msd_dir.h"
|
|
|
+#define DP_NAMELEN(x) (x)->d_namlen
|
|
|
+#define direct dirent
|
|
|
+#endif
|
|
|
+#if defined(USG) && !defined(_POSIX_VERSION) && !defined(DIRENT)
|
|
|
+#include <ndir.h>
|
|
|
+#define DP_NAMELEN(x) strlen((x)->d_name)
|
|
|
+#endif /* USG and not _POSIX_VERSION and not DIRENT */
|
|
|
+
|
|
|
+#ifndef S_ISLNK
|
|
|
+#define lstat stat
|
|
|
+#endif
|
|
|
+
|
|
|
+extern time_t new_time;
|
|
|
+extern FILE *msg_file;
|
|
|
+
|
|
|
+void addname();
|
|
|
+int check_exclude();
|
|
|
+extern PTR ck_malloc();
|
|
|
+extern PTR ck_realloc();
|
|
|
+int confirm();
|
|
|
+extern PTR init_buffer();
|
|
|
+extern char *get_buffer();
|
|
|
+int is_dot_or_dotdot();
|
|
|
+extern void add_buffer();
|
|
|
+extern void flush_buffer();
|
|
|
+void name_gather();
|
|
|
+int recursively_delete();
|
|
|
+void skip_file();
|
|
|
+char *un_quote_string();
|
|
|
+
|
|
|
+extern char *new_name();
|
|
|
+
|
|
|
+static void add_dir_name();
|
|
|
+
|
|
|
+struct dirname {
|
|
|
+ struct dirname *next;
|
|
|
+ char *name;
|
|
|
+ char *dir_text;
|
|
|
+ int dev;
|
|
|
+ int ino;
|
|
|
+ int allnew;
|
|
|
+};
|
|
|
+static struct dirname *dir_list;
|
|
|
+static time_t this_time;
|
|
|
+
|
|
|
+void
|
|
|
+add_dir(name,dev,ino,text)
|
|
|
+char *name;
|
|
|
+char *text;
|
|
|
+dev_t dev;
|
|
|
+ino_t ino;
|
|
|
+{
|
|
|
+ struct dirname *dp;
|
|
|
+
|
|
|
+ dp=(struct dirname *)malloc(sizeof(struct dirname));
|
|
|
+ if(!dp)
|
|
|
+ abort();
|
|
|
+ dp->next=dir_list;
|
|
|
+ dir_list=dp;
|
|
|
+ dp->dev=dev;
|
|
|
+ dp->ino=ino;
|
|
|
+ dp->name=malloc(strlen(name)+1);
|
|
|
+ strcpy(dp->name,name);
|
|
|
+ dp->dir_text=text;
|
|
|
+ dp->allnew=0;
|
|
|
+}
|
|
|
+
|
|
|
+void
|
|
|
+read_dir_file()
|
|
|
+{
|
|
|
+ int dev;
|
|
|
+ int ino;
|
|
|
+ char *strp;
|
|
|
+ FILE *fp;
|
|
|
+ char buf[512];
|
|
|
+ static char *path = 0;
|
|
|
+
|
|
|
+ if (path == 0)
|
|
|
+ path = ck_malloc(PATH_MAX);
|
|
|
+ time(&this_time);
|
|
|
+ if(gnu_dumpfile[0]!='/') {
|
|
|
+#if defined(__MSDOS__) || defined(USG) || defined(_POSIX_VERSION)
|
|
|
+ if(!getcwd(path,PATH_MAX))
|
|
|
+ msg("Couldn't get current directory.");
|
|
|
+ exit(EX_SYSTEM);
|
|
|
+#else
|
|
|
+ char *getwd();
|
|
|
+
|
|
|
+ if(!getwd(path)) {
|
|
|
+ msg("Couldn't get current directory: %s",path);
|
|
|
+ exit(EX_SYSTEM);
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ /* If this doesn't fit, we're in serious trouble */
|
|
|
+ strcat(path,"/");
|
|
|
+ strcat(path,gnu_dumpfile);
|
|
|
+ gnu_dumpfile=path;
|
|
|
+ }
|
|
|
+ fp=fopen(gnu_dumpfile,"r");
|
|
|
+ if(fp==0 && errno!=ENOENT) {
|
|
|
+ msg_perror("Can't open %s",gnu_dumpfile);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if(!fp)
|
|
|
+ return;
|
|
|
+ fgets(buf,sizeof(buf),fp);
|
|
|
+ if(!f_new_files) {
|
|
|
+ f_new_files++;
|
|
|
+ new_time=atol(buf);
|
|
|
+ }
|
|
|
+ while(fgets(buf,sizeof(buf),fp)) {
|
|
|
+ strp= &buf[strlen(buf)];
|
|
|
+ if(strp[-1]=='\n')
|
|
|
+ strp[-1]='\0';
|
|
|
+ strp=buf;
|
|
|
+ dev=atol(strp);
|
|
|
+ while(isdigit(*strp))
|
|
|
+ strp++;
|
|
|
+ ino=atol(strp);
|
|
|
+ while(isspace(*strp))
|
|
|
+ strp++;
|
|
|
+ while(isdigit(*strp))
|
|
|
+ strp++;
|
|
|
+ strp++;
|
|
|
+ add_dir(un_quote_string(strp),dev,ino,(char *)0);
|
|
|
+ }
|
|
|
+ fclose(fp);
|
|
|
+}
|
|
|
+
|
|
|
+void
|
|
|
+write_dir_file()
|
|
|
+{
|
|
|
+ FILE *fp;
|
|
|
+ struct dirname *dp;
|
|
|
+ char *str;
|
|
|
+ extern char *quote_copy_string();
|
|
|
+
|
|
|
+ fp=fopen(gnu_dumpfile,"w");
|
|
|
+ if(fp==0) {
|
|
|
+ msg_perror("Can't write to %s",gnu_dumpfile);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ fprintf(fp,"%lu\n",this_time);
|
|
|
+ for(dp=dir_list;dp;dp=dp->next) {
|
|
|
+ if(!dp->dir_text)
|
|
|
+ continue;
|
|
|
+ str=quote_copy_string(dp->name);
|
|
|
+ if(str) {
|
|
|
+ fprintf(fp,"%u %u %s\n",dp->dev,dp->ino,str);
|
|
|
+ free(str);
|
|
|
+ } else
|
|
|
+ fprintf(fp,"%u %u %s\n",dp->dev,dp->ino,dp->name);
|
|
|
+ }
|
|
|
+ fclose(fp);
|
|
|
+}
|
|
|
+
|
|
|
+struct dirname *
|
|
|
+get_dir(name)
|
|
|
+char *name;
|
|
|
+{
|
|
|
+ struct dirname *dp;
|
|
|
+
|
|
|
+ for(dp=dir_list;dp;dp=dp->next) {
|
|
|
+ if(!strcmp(dp->name,name))
|
|
|
+ return dp;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/* Collect all the names from argv[] (or whatever), then expand them into
|
|
|
+ a directory tree, and put all the directories at the beginning. */
|
|
|
+void
|
|
|
+collect_and_sort_names()
|
|
|
+{
|
|
|
+ struct name *n,*n_next;
|
|
|
+ int num_names;
|
|
|
+ struct stat statbuf;
|
|
|
+ int name_cmp();
|
|
|
+ char *merge_sort();
|
|
|
+
|
|
|
+ name_gather();
|
|
|
+
|
|
|
+ if(gnu_dumpfile)
|
|
|
+ read_dir_file();
|
|
|
+ if(!namelist) addname(".");
|
|
|
+ for(n=namelist;n;n=n_next) {
|
|
|
+ n_next=n->next;
|
|
|
+ if(n->found || n->dir_contents)
|
|
|
+ continue;
|
|
|
+ if(n->regexp) /* FIXME just skip regexps for now */
|
|
|
+ continue;
|
|
|
+ if(n->change_dir)
|
|
|
+ if(chdir(n->change_dir)<0) {
|
|
|
+ msg_perror("can't chdir to %s",n->change_dir);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+#ifdef AIX
|
|
|
+ if (statx (n->name, &statbuf, STATSIZE, STX_HIDDEN|STX_LINK))
|
|
|
+#else
|
|
|
+ if(lstat(n->name,&statbuf)<0)
|
|
|
+#endif /* AIX */
|
|
|
+ {
|
|
|
+ msg_perror("can't stat %s",n->name);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if(S_ISDIR(statbuf.st_mode)) {
|
|
|
+ n->found++;
|
|
|
+ add_dir_name(n->name,statbuf.st_dev);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ num_names=0;
|
|
|
+ for(n=namelist;n;n=n->next)
|
|
|
+ num_names++;
|
|
|
+ namelist=(struct name *)merge_sort((PTR)namelist,num_names,(char *)(&(namelist->next))-(char *)namelist,name_cmp);
|
|
|
+
|
|
|
+ for(n=namelist;n;n=n->next) {
|
|
|
+ n->found=0;
|
|
|
+ }
|
|
|
+ if(gnu_dumpfile)
|
|
|
+ write_dir_file(gnu_dumpfile);
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+name_cmp(n1,n2)
|
|
|
+struct name *n1,*n2;
|
|
|
+{
|
|
|
+ if(n1->found) {
|
|
|
+ if(n2->found)
|
|
|
+ return strcmp(n1->name,n2->name);
|
|
|
+ else
|
|
|
+ return -1;
|
|
|
+ } else if(n2->found)
|
|
|
+ return 1;
|
|
|
+ else
|
|
|
+ return strcmp(n1->name,n2->name);
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+dirent_cmp(p1,p2)
|
|
|
+const PTR p1;
|
|
|
+const PTR p2;
|
|
|
+{
|
|
|
+ char *frst,*scnd;
|
|
|
+
|
|
|
+ frst= (*(char **)p1)+1;
|
|
|
+ scnd= (*(char **)p2)+1;
|
|
|
+
|
|
|
+ return strcmp(frst,scnd);
|
|
|
+}
|
|
|
+
|
|
|
+char *
|
|
|
+get_dir_contents(p,device)
|
|
|
+char *p;
|
|
|
+int device;
|
|
|
+{
|
|
|
+ DIR *dirp;
|
|
|
+ register struct direct *d;
|
|
|
+ char *new_buf;
|
|
|
+ char *namebuf;
|
|
|
+ int bufsiz;
|
|
|
+ int len;
|
|
|
+ PTR the_buffer;
|
|
|
+ char *buf;
|
|
|
+ size_t n_strs;
|
|
|
+/* int n_size;*/
|
|
|
+ char *p_buf;
|
|
|
+ char **vec,**p_vec;
|
|
|
+
|
|
|
+ extern int errno;
|
|
|
+
|
|
|
+ errno=0;
|
|
|
+ dirp=opendir(p);
|
|
|
+ bufsiz=strlen(p)+NAMSIZ;
|
|
|
+ namebuf=ck_malloc(bufsiz+2);
|
|
|
+ if(!dirp) {
|
|
|
+ if(errno)
|
|
|
+ msg_perror("can't open directory %s",p);
|
|
|
+ else
|
|
|
+ msg("error opening directory %s",p);
|
|
|
+ new_buf=NULL;
|
|
|
+ } else {
|
|
|
+ struct dirname *dp;
|
|
|
+ int all_children;
|
|
|
+
|
|
|
+ dp=get_dir(p);
|
|
|
+ all_children= dp ? dp->allnew : 0;
|
|
|
+ (void) strcpy(namebuf,p);
|
|
|
+ if(p[strlen(p)-1]!='/')
|
|
|
+ (void) strcat(namebuf,"/");
|
|
|
+ len=strlen(namebuf);
|
|
|
+
|
|
|
+ the_buffer=init_buffer();
|
|
|
+ while(d=readdir(dirp)) {
|
|
|
+ struct stat hs;
|
|
|
+
|
|
|
+ /* Skip . and .. */
|
|
|
+ if(is_dot_or_dotdot(d->d_name))
|
|
|
+ continue;
|
|
|
+ if(DP_NAMELEN(d) + len >=bufsiz) {
|
|
|
+ bufsiz+=NAMSIZ;
|
|
|
+ namebuf=ck_realloc(namebuf,bufsiz+2);
|
|
|
+ }
|
|
|
+ (void) strcpy(namebuf+len,d->d_name);
|
|
|
+#ifdef AIX
|
|
|
+ if (0 != f_follow_links?
|
|
|
+ statx(namebuf, &hs, STATSIZE, STX_HIDDEN):
|
|
|
+ statx(namebuf, &hs, STATSIZE, STX_HIDDEN|STX_LINK))
|
|
|
+#else
|
|
|
+ if (0 != f_follow_links? stat(namebuf, &hs): lstat(namebuf, &hs))
|
|
|
+#endif
|
|
|
+ {
|
|
|
+ msg_perror("can't stat %s",namebuf);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if( (f_local_filesys && device!=hs.st_dev)
|
|
|
+ || (f_exclude && check_exclude(namebuf)))
|
|
|
+ add_buffer(the_buffer,"N",1);
|
|
|
+#ifdef AIX
|
|
|
+ else if (S_ISHIDDEN (hs.st_mode)) {
|
|
|
+ add_buffer (the_buffer, "D", 1);
|
|
|
+ strcat (d->d_name, "A");
|
|
|
+ d->d_namlen++;
|
|
|
+ }
|
|
|
+#endif /* AIX */
|
|
|
+ else if(S_ISDIR(hs.st_mode)) {
|
|
|
+ if(dp=get_dir(namebuf)) {
|
|
|
+ if( dp->dev!=hs.st_dev
|
|
|
+ || dp->ino!=hs.st_ino) {
|
|
|
+ if(f_verbose)
|
|
|
+ msg("directory %s has been renamed.",namebuf);
|
|
|
+ dp->allnew=1;
|
|
|
+ dp->dev=hs.st_dev;
|
|
|
+ dp->ino=hs.st_ino;
|
|
|
+ }
|
|
|
+ dp->dir_text="";
|
|
|
+ } else {
|
|
|
+ if(f_verbose)
|
|
|
+ msg("Directory %s is new",namebuf);
|
|
|
+ add_dir(namebuf,hs.st_dev,hs.st_ino,"");
|
|
|
+ dp=get_dir(namebuf);
|
|
|
+ dp->allnew=1;
|
|
|
+ }
|
|
|
+ if(all_children)
|
|
|
+ dp->allnew=1;
|
|
|
+
|
|
|
+ add_buffer(the_buffer,"D",1);
|
|
|
+ } else if( !all_children
|
|
|
+ && f_new_files
|
|
|
+ && new_time>hs.st_mtime
|
|
|
+ && ( f_new_files>1
|
|
|
+ || new_time>hs.st_ctime))
|
|
|
+ add_buffer(the_buffer,"N",1);
|
|
|
+ else
|
|
|
+ add_buffer(the_buffer,"Y",1);
|
|
|
+ add_buffer(the_buffer,d->d_name,(int)(DP_NAMELEN(d)+1));
|
|
|
+ }
|
|
|
+ add_buffer(the_buffer,"\000\000",2);
|
|
|
+ closedir(dirp);
|
|
|
+
|
|
|
+ /* Well, we've read in the contents of the dir, now sort them */
|
|
|
+ buf=get_buffer(the_buffer);
|
|
|
+ if(buf[0]=='\0') {
|
|
|
+ flush_buffer(the_buffer);
|
|
|
+ new_buf=NULL;
|
|
|
+ } else {
|
|
|
+ n_strs=0;
|
|
|
+ for(p_buf=buf;*p_buf;) {
|
|
|
+ int tmp;
|
|
|
+
|
|
|
+ tmp=strlen(p_buf)+1;
|
|
|
+ n_strs++;
|
|
|
+ p_buf+=tmp;
|
|
|
+ }
|
|
|
+ vec=(char **)malloc(sizeof(char *)*(n_strs+1));
|
|
|
+ for(p_vec=vec,p_buf=buf;*p_buf;p_buf+=strlen(p_buf)+1)
|
|
|
+ *p_vec++= p_buf;
|
|
|
+ *p_vec= 0;
|
|
|
+ qsort((PTR)vec,n_strs,sizeof(char *),dirent_cmp);
|
|
|
+ new_buf=(char *)malloc(p_buf-buf+2);
|
|
|
+ for(p_vec=vec,p_buf=new_buf;*p_vec;p_vec++) {
|
|
|
+ char *p_tmp;
|
|
|
+
|
|
|
+ for(p_tmp= *p_vec;*p_buf++= *p_tmp++;)
|
|
|
+ ;
|
|
|
+ }
|
|
|
+ *p_buf++='\0';
|
|
|
+ free(vec);
|
|
|
+ flush_buffer(the_buffer);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ free(namebuf);
|
|
|
+ return new_buf;
|
|
|
+}
|
|
|
+
|
|
|
+/* p is a directory. Add all the files in P to the namelist. If any of the
|
|
|
+ files is a directory, recurse on the subdirectory. . . */
|
|
|
+static void
|
|
|
+add_dir_name(p,device)
|
|
|
+char *p;
|
|
|
+int device;
|
|
|
+{
|
|
|
+ char *new_buf;
|
|
|
+ char *p_buf;
|
|
|
+
|
|
|
+ char *namebuf;
|
|
|
+ int buflen;
|
|
|
+ register int len;
|
|
|
+ int sublen;
|
|
|
+
|
|
|
+/* PTR the_buffer;*/
|
|
|
+
|
|
|
+/* char *buf;*/
|
|
|
+/* char **vec,**p_vec;*/
|
|
|
+/* int n_strs,n_size;*/
|
|
|
+
|
|
|
+ struct name *n;
|
|
|
+
|
|
|
+ int dirent_cmp();
|
|
|
+
|
|
|
+ new_buf=get_dir_contents(p,device);
|
|
|
+
|
|
|
+ for(n=namelist;n;n=n->next) {
|
|
|
+ if(!strcmp(n->name,p)) {
|
|
|
+ n->dir_contents = new_buf;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (new_buf)
|
|
|
+ {
|
|
|
+ len=strlen(p);
|
|
|
+ buflen= NAMSIZ<=len ? len + NAMSIZ : NAMSIZ;
|
|
|
+ namebuf= ck_malloc(buflen+1);
|
|
|
+
|
|
|
+ (void)strcpy(namebuf,p);
|
|
|
+ if(namebuf[len-1]!='/') {
|
|
|
+ namebuf[len++]='/';
|
|
|
+ namebuf[len]='\0';
|
|
|
+ }
|
|
|
+ for(p_buf=new_buf;*p_buf;p_buf+=sublen+1) {
|
|
|
+ sublen=strlen(p_buf);
|
|
|
+ if(*p_buf=='D') {
|
|
|
+ if(len+sublen>=buflen) {
|
|
|
+ buflen+=NAMSIZ;
|
|
|
+ namebuf= ck_realloc(namebuf,buflen+1);
|
|
|
+ }
|
|
|
+ (void)strcpy(namebuf+len,p_buf+1);
|
|
|
+ addname(namebuf);
|
|
|
+ add_dir_name(namebuf,device);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ free(namebuf);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* Returns non-zero if p is . or .. This could be a macro for speed. */
|
|
|
+int
|
|
|
+is_dot_or_dotdot(p)
|
|
|
+char *p;
|
|
|
+{
|
|
|
+ return (p[0]=='.' && (p[1]=='\0' || (p[1]=='.' && p[2]=='\0')));
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+void
|
|
|
+gnu_restore(skipcrud)
|
|
|
+int skipcrud;
|
|
|
+{
|
|
|
+ char *current_dir;
|
|
|
+/* int current_dir_length; */
|
|
|
+
|
|
|
+ char *archive_dir;
|
|
|
+/* int archive_dir_length; */
|
|
|
+ PTR the_buffer;
|
|
|
+ char *p;
|
|
|
+ DIR *dirp;
|
|
|
+ struct direct *d;
|
|
|
+ char *cur,*arc;
|
|
|
+ extern struct stat hstat; /* Stat struct corresponding */
|
|
|
+ long size,copied;
|
|
|
+ char *from,*to;
|
|
|
+ extern union record *head;
|
|
|
+
|
|
|
+ dirp=opendir(skipcrud+head->header.name);
|
|
|
+
|
|
|
+ if(!dirp) {
|
|
|
+ /* The directory doesn't exist now. It'll be created.
|
|
|
+ In any case, we don't have to delete any files out
|
|
|
+ of it */
|
|
|
+ skip_file((long)hstat.st_size);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ the_buffer=init_buffer();
|
|
|
+ while(d=readdir(dirp)) {
|
|
|
+ if(is_dot_or_dotdot(d->d_name))
|
|
|
+ continue;
|
|
|
+
|
|
|
+ add_buffer(the_buffer,d->d_name,(int)(DP_NAMELEN(d)+1));
|
|
|
+ }
|
|
|
+ closedir(dirp);
|
|
|
+ add_buffer(the_buffer,"",1);
|
|
|
+
|
|
|
+ current_dir=get_buffer(the_buffer);
|
|
|
+ archive_dir=(char *)malloc(hstat.st_size);
|
|
|
+ if(archive_dir==0) {
|
|
|
+ msg("Can't allocate %d bytes for restore",hstat.st_size);
|
|
|
+ skip_file((long)hstat.st_size);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ to=archive_dir;
|
|
|
+ for(size=hstat.st_size;size>0;size-=copied) {
|
|
|
+ from=findrec()->charptr;
|
|
|
+ if(!from) {
|
|
|
+ msg("Unexpected EOF in archive\n");
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ copied=endofrecs()->charptr - from;
|
|
|
+ if(copied>size)
|
|
|
+ copied=size;
|
|
|
+ bcopy((PTR)from,(PTR)to,(int)copied);
|
|
|
+ to+=copied;
|
|
|
+ userec((union record *)(from+copied-1));
|
|
|
+ }
|
|
|
+
|
|
|
+ for(cur=current_dir;*cur;cur+=strlen(cur)+1) {
|
|
|
+ for(arc=archive_dir;*arc;arc+=strlen(arc)+1) {
|
|
|
+ arc++;
|
|
|
+ if(!strcmp(arc,cur))
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if(*arc=='\0') {
|
|
|
+ p=new_name(skipcrud+head->header.name,cur);
|
|
|
+ if(f_confirm && !confirm("delete",p)) {
|
|
|
+ free(p);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if(f_verbose)
|
|
|
+ fprintf(msg_file,"%s: deleting %s\n",tar,p);
|
|
|
+ if(recursively_delete(p)) {
|
|
|
+ msg("%s: Error while deleting %s\n",tar,p);
|
|
|
+ }
|
|
|
+ free(p);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ flush_buffer(the_buffer);
|
|
|
+ free(archive_dir);
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+recursively_delete(path)
|
|
|
+char *path;
|
|
|
+{
|
|
|
+ struct stat sbuf;
|
|
|
+ DIR *dirp;
|
|
|
+ struct direct *dp;
|
|
|
+ char *path_buf;
|
|
|
+ /* int path_len; */
|
|
|
+
|
|
|
+
|
|
|
+ if(lstat(path,&sbuf)<0)
|
|
|
+ return 1;
|
|
|
+ if(S_ISDIR(sbuf.st_mode)) {
|
|
|
+
|
|
|
+ /* path_len=strlen(path); */
|
|
|
+ dirp=opendir(path);
|
|
|
+ if(dirp==0)
|
|
|
+ return 1;
|
|
|
+ while(dp=readdir(dirp)) {
|
|
|
+ if(is_dot_or_dotdot(dp->d_name))
|
|
|
+ continue;
|
|
|
+ path_buf=new_name(path,dp->d_name);
|
|
|
+ if(recursively_delete(path_buf)) {
|
|
|
+ free(path_buf);
|
|
|
+ closedir(dirp);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ free(path_buf);
|
|
|
+ }
|
|
|
+ closedir(dirp);
|
|
|
+
|
|
|
+ if(rmdir(path)<0)
|
|
|
+ return 1;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(unlink(path)<0)
|
|
|
+ return 1;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
François Pinard