X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/f7632fc60d69c8dabed600ede87f0b91319a3b7f..740819ef7b3b96451e16b2fa3891d46cfc73ec64:/flist.c

diff --git a/flist.c b/flist.c
index 664f26e4..d9b0da7a 100644
--- a/flist.c
+++ b/flist.c
@@ -1,6 +1,7 @@
 /* 
    Copyright (C) Andrew Tridgell 1996
    Copyright (C) Paul Mackerras 1996
+   Copyright (C) 2001 by Martin Pool <mbp@samba.org>
    
    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
@@ -23,8 +24,6 @@
 
 extern struct stats stats;
 
-extern int csum_length;
-
 extern int verbose;
 extern int am_server;
 extern int always_checksum;
@@ -44,30 +43,83 @@ extern int preserve_gid;
 extern int preserve_times;
 extern int relative_paths;
 extern int copy_links;
+extern int copy_unsafe_links;
 extern int remote_version;
 extern int io_error;
+extern int sanitize_paths;
+
+extern int read_batch;
+extern int write_batch;
+
+static char topsrcname[MAXPATHLEN];
 
 static struct exclude_struct **local_exclude_list;
 
+static struct file_struct null_file;
+
 static void clean_flist(struct file_list *flist, int strip_root);
 
+static struct string_area *string_area_new(int size)
+{
+	struct string_area *a;
 
-static void list_file_entry(struct file_struct *f)
+	if (size <= 0) size = ARENA_SIZE;
+	a = malloc(sizeof(*a));
+	if (!a) out_of_memory("string_area_new");
+	a->current = a->base = malloc(size);
+	if (!a->current) out_of_memory("string_area_new buffer");
+	a->end = a->base + size;
+	a->next = NULL;
+
+	return a;
+}
+
+static void string_area_free(struct string_area *a)
 {
-	char perms[11] = "----------";
-	char *perm_map = "rwxrwxrwx";
-	int i;
+	struct string_area *next;
 
-	for (i=0;i<9;i++) {
-		if (f->mode & (1<<i)) perms[9-i] = perm_map[8-i];
+	for ( ; a ; a = next) {
+		next = a->next;
+		free(a->base);
 	}
-	if (S_ISLNK(f->mode)) perms[0] = 'l';
-	if (S_ISDIR(f->mode)) perms[0] = 'd';
-	if (S_ISBLK(f->mode)) perms[0] = 'b';
-	if (S_ISCHR(f->mode)) perms[0] = 'c';
-	if (S_ISSOCK(f->mode)) perms[0] = 's';
-	if (S_ISFIFO(f->mode)) perms[0] = 'p';
-	
+}
+
+static char *string_area_malloc(struct string_area **ap, int size)
+{
+	char *p;
+	struct string_area *a;
+
+	/* does the request fit into the current space? */
+	a = *ap;
+	if (a->current + size >= a->end) {
+		/* no; get space, move new string_area to front of the list */
+		a = string_area_new(size > ARENA_SIZE ? size : ARENA_SIZE);
+		a->next = *ap;
+		*ap = a;
+	}
+
+	/* have space; do the "allocation." */
+	p = a->current;
+	a->current += size;
+	return p;
+}
+
+static char *string_area_strdup(struct string_area **ap, const char *src)
+{
+	char* dest = string_area_malloc(ap, strlen(src) + 1);
+	return strcpy(dest, src);
+}
+
+static void list_file_entry(struct file_struct *f)
+{
+	char perms[11];
+
+	if (!f->basename)
+		/* this can happen if duplicate names were removed */
+		return;
+
+	permstring(perms, f->mode);
+
 	if (preserve_links && S_ISLNK(f->mode)) {
 		rprintf(FINFO,"%s %11.0f %s %s -> %s\n", 
 			perms, 
@@ -81,6 +133,32 @@ static void list_file_entry(struct file_struct *f)
 }
 
 
+int readlink_stat(const char *Path, STRUCT_STAT *Buffer, char *Linkbuf) 
+{
+#if SUPPORT_LINKS
+	if (copy_links) {
+		return do_stat(Path, Buffer);
+	}
+	if (do_lstat(Path, Buffer) == -1) {
+		return -1;
+	}
+	if (S_ISLNK(Buffer->st_mode)) {
+		int l;
+		if ((l = readlink((char *) Path, Linkbuf, MAXPATHLEN-1))== -1) {
+			return -1;
+		}
+		Linkbuf[l] = 0;
+		if (copy_unsafe_links && (topsrcname[0] != '\0') &&
+				    unsafe_symlink(Linkbuf, topsrcname)) {
+			return do_stat(Path, Buffer);
+		}
+	}
+	return 0;
+#else
+	return do_stat(Path, Buffer);
+#endif
+}
+
 int link_stat(const char *Path, STRUCT_STAT *Buffer) 
 {
 #if SUPPORT_LINKS
@@ -98,14 +176,18 @@ int link_stat(const char *Path, STRUCT_STAT *Buffer)
   This function is used to check if a file should be included/excluded
   from the list of files based on its name and type etc
  */
-static int match_file_name(char *fname,STRUCT_STAT *st)
+static int check_exclude_file(int f,char *fname,STRUCT_STAT *st)
 {
-  if (check_exclude(fname,local_exclude_list,st)) {
-    if (verbose > 2)
-      rprintf(FINFO,"excluding file %s\n",fname);
-    return 0;
-  }
-  return 1;
+	extern int delete_excluded;
+
+	/* f is set to -1 when calculating deletion file list */
+	if ((f == -1) && delete_excluded) {
+		return 0;
+	}
+	if (check_exclude(fname,local_exclude_list,st)) {
+		return 1;
+	}
+	return 0;
 }
 
 /* used by the one_file_system code */
@@ -121,7 +203,7 @@ static void set_filesystem(char *fname)
 
 static int to_wire_mode(mode_t mode)
 {
-	if (S_ISLNK(mode) && (S_IFLNK != 0120000)) {
+	if (S_ISLNK(mode) && (_S_IFLNK != 0120000)) {
 		return (mode & ~(_S_IFMT)) | 0120000;
 	}
 	return (int)mode;
@@ -129,8 +211,8 @@ static int to_wire_mode(mode_t mode)
 
 static mode_t from_wire_mode(int mode)
 {
-	if ((mode & (_S_IFMT)) == 0120000 && (S_IFLNK != 0120000)) {
-		return (mode & ~(_S_IFMT)) | S_IFLNK;
+	if ((mode & (_S_IFMT)) == 0120000 && (_S_IFLNK != 0120000)) {
+		return (mode & ~(_S_IFMT)) | _S_IFLNK;
 	}
 	return (mode_t)mode;
 }
@@ -221,7 +303,11 @@ static void send_file_entry(struct file_struct *file,int f,unsigned base_flags)
 #endif
 
 	if (always_checksum) {
-		write_buf(f,file->sum,csum_length);
+		if (remote_version < 21) {
+			write_buf(f,file->sum,2);
+		} else {
+			write_buf(f,file->sum,MD4_SUM_LENGTH);
+		}
 	}       
 
 	last_mode = file->mode;
@@ -230,7 +316,7 @@ static void send_file_entry(struct file_struct *file,int f,unsigned base_flags)
 	last_gid = file->gid;
 	last_time = file->modtime;
 
-	strlcpy(lastname,fname,MAXPATHLEN-1);
+	strlcpy(lastname,fname,MAXPATHLEN);
 	lastname[MAXPATHLEN-1] = 0;
 }
 
@@ -263,17 +349,25 @@ static void receive_file_entry(struct file_struct **fptr,
 	memset((char *)file, 0, sizeof(*file));
 	(*fptr) = file;
 
-	if (l2 >= MAXPATHLEN-l1) overflow("receive_file_entry");
+	if (l2 >= MAXPATHLEN-l1) {
+		rprintf(FERROR,"overflow: flags=0x%x l1=%d l2=%d lastname=%s\n",
+			flags, l1, l2, lastname);
+		overflow("receive_file_entry");
+	}
 
-	strlcpy(thisname,lastname,l1);
+	strlcpy(thisname,lastname,l1+1);
 	read_sbuf(f,&thisname[l1],l2);
 	thisname[l1+l2] = 0;
 
-	strlcpy(lastname,thisname,MAXPATHLEN-1);
+	strlcpy(lastname,thisname,MAXPATHLEN);
 	lastname[MAXPATHLEN-1] = 0;
 
 	clean_fname(thisname);
 
+	if (sanitize_paths) {
+		sanitize_path(thisname, NULL);
+	}
+
 	if ((p = strrchr(thisname,'/'))) {
 		static char *lastdir;
 		*p = 0;
@@ -308,6 +402,9 @@ static void receive_file_entry(struct file_struct **fptr,
 		file->link = (char *)malloc(l+1);
 		if (!file->link) out_of_memory("receive_file_entry 2");
 		read_sbuf(f,file->link,l);
+		if (sanitize_paths) {
+			sanitize_path(file->link, file->dirname);
+		}
 	}
 
 #if SUPPORT_HARD_LINKS
@@ -320,7 +417,11 @@ static void receive_file_entry(struct file_struct **fptr,
 	if (always_checksum) {
 		file->sum = (char *)malloc(MD4_SUM_LENGTH);
 		if (!file->sum) out_of_memory("md4 sum");
-		read_buf(f,file->sum,csum_length);
+		if (remote_version < 21) {
+			read_buf(f,file->sum,2);
+		} else {
+			read_buf(f,file->sum,MD4_SUM_LENGTH);
+		}
 	}
   
 	last_mode = file->mode;
@@ -362,28 +463,50 @@ static int skip_filesystem(char *fname, STRUCT_STAT *st)
 	return (st2.st_dev != filesystem_dev);
 }
 
-static struct file_struct *make_file(char *fname)
+#define STRDUP(ap, p)	(ap ? string_area_strdup(ap, p) : strdup(p))
+#define MALLOC(ap, i)	(ap ? string_area_malloc(ap, i) : malloc(i))
+
+/* create a file_struct for a named file */
+struct file_struct *make_file(int f, char *fname, struct string_area **ap,
+			      int noexcludes)
 {
 	struct file_struct *file;
 	STRUCT_STAT st;
 	char sum[SUM_LENGTH];
 	char *p;
 	char cleaned_name[MAXPATHLEN];
+	char linkbuf[MAXPATHLEN];
+	extern int module_id;
 
-	strlcpy(cleaned_name, fname, MAXPATHLEN-1);
+	strlcpy(cleaned_name, fname, MAXPATHLEN);
 	cleaned_name[MAXPATHLEN-1] = 0;
 	clean_fname(cleaned_name);
+	if (sanitize_paths) {
+		sanitize_path(cleaned_name, NULL);
+	}
 	fname = cleaned_name;
 
 	memset(sum,0,SUM_LENGTH);
 
-	if (link_stat(fname,&st) != 0) {
+	if (readlink_stat(fname,&st,linkbuf) != 0) {
+		int save_errno = errno;
+		if ((errno == ENOENT) && copy_links && !noexcludes) {
+			/* symlink pointing nowhere, see if excluded */
+			memset((char *)&st, 0, sizeof(st));
+			if (check_exclude_file(f,fname,&st)) {
+				/* file is excluded anyway, ignore silently */
+				return NULL;
+			}
+		}
 		io_error = 1;
-		rprintf(FERROR,"%s: %s\n",
-			fname,strerror(errno));
+		rprintf(FERROR,"readlink %s: %s\n",
+			fname,strerror(save_errno));
 		return NULL;
 	}
 
+	/* we use noexcludes from backup.c */
+	if (noexcludes) goto skip_excludes;
+
 	if (S_ISDIR(st.st_mode) && !recurse) {
 		rprintf(FINFO,"skipping directory %s\n",fname);
 		return NULL;
@@ -394,11 +517,17 @@ static struct file_struct *make_file(char *fname)
 			return NULL;
 	}
 	
-	if (!match_file_name(fname,&st))
+	if (check_exclude_file(f,fname,&st))
 		return NULL;
-	
+
+
+	if (lp_ignore_nonreadable(module_id) && access(fname, R_OK) != 0) 
+		return NULL;
+
+ skip_excludes:
+
 	if (verbose > 2)
-		rprintf(FINFO,"make_file(%s)\n",fname);
+		rprintf(FINFO,"make_file(%d,%s)\n",f,fname);
 	
 	file = (struct file_struct *)malloc(sizeof(*file));
 	if (!file) out_of_memory("make_file");
@@ -413,11 +542,11 @@ static struct file_struct *make_file(char *fname)
 			file->dirname = strdup(fname);
 			lastdir = file->dirname;
 		}
-		file->basename = strdup(p+1);
+		file->basename = STRDUP(ap, p+1);
 		*p = '/';
 	} else {
 		file->dirname = NULL;
-		file->basename = strdup(fname);
+		file->basename = STRDUP(ap, fname);
 	}
 
 	file->modtime = st.st_mtime;
@@ -433,21 +562,12 @@ static struct file_struct *make_file(char *fname)
 
 #if SUPPORT_LINKS
 	if (S_ISLNK(st.st_mode)) {
-		int l;
-		char lnk[MAXPATHLEN];
-		if ((l=readlink(fname,lnk,MAXPATHLEN-1)) == -1) {
-			io_error=1;
-			rprintf(FERROR,"readlink %s : %s\n",
-				fname,strerror(errno));
-			return NULL;
-		}
-		lnk[l] = 0;
-		file->link = strdup(lnk);
+		file->link = STRDUP(ap, linkbuf);
 	}
 #endif
 
 	if (always_checksum) {
-		file->sum = (char *)malloc(MD4_SUM_LENGTH);
+		file->sum = (char *)MALLOC(ap, MD4_SUM_LENGTH);
 		if (!file->sum) out_of_memory("md4 sum");
 		/* drat. we have to provide a null checksum for non-regular
 		   files in order to be compatible with earlier versions
@@ -484,7 +604,7 @@ void send_file_name(int f,struct file_list *flist,char *fname,
 {
   struct file_struct *file;
 
-  file = make_file(fname);
+  file = make_file(f,fname, &flist->string_area, 0);
 
   if (!file) return;  
   
@@ -500,6 +620,9 @@ void send_file_name(int f,struct file_list *flist,char *fname,
 		  out_of_memory("send_file_name");
   }
 
+  if (write_batch) /*  dw  */
+    file->flags = FLAG_DELETE;
+
   if (strcmp(file->basename,"")) {
     flist->files[flist->count++] = file;
     send_file_entry(file,f,base_flags);
@@ -531,7 +654,7 @@ static void send_directory(int f,struct file_list *flist,char *dir)
 		return;
 	}
 
-	strlcpy(fname,dir,MAXPATHLEN-1);
+	strlcpy(fname,dir,MAXPATHLEN);
 	l = strlen(fname);
 	if (fname[l-1] != '/') {
 		if (l == MAXPATHLEN-1) {
@@ -540,7 +663,7 @@ static void send_directory(int f,struct file_list *flist,char *dir)
 			closedir(d);
 			return;
 		}
-		strlcat(fname,"/", MAXPATHLEN-1);
+		strlcat(fname,"/", MAXPATHLEN);
 		l++;
 	}
 	p = fname + strlen(fname);
@@ -562,7 +685,7 @@ static void send_directory(int f,struct file_list *flist,char *dir)
 		if (strcmp(dname,".")==0 ||
 		    strcmp(dname,"..")==0)
 			continue;
-		strlcpy(p,dname,MAXPATHLEN-(l+1));
+		strlcpy(p,dname,MAXPATHLEN-l);
 		send_file_name(f,flist,fname,recurse,0);
 	}
 
@@ -574,7 +697,6 @@ static void send_directory(int f,struct file_list *flist,char *dir)
 }
 
 
-
 struct file_list *send_file_list(int f,int argc,char *argv[])
 {
 	int i,l;
@@ -586,38 +708,43 @@ struct file_list *send_file_list(int f,int argc,char *argv[])
 
 	if (verbose && recurse && !am_server && f != -1) {
 		rprintf(FINFO,"building file list ... ");
+                if (verbose > 1)
+                        rprintf(FINFO, "\n");
 		rflush(FINFO);
 	}
 
 	start_write = stats.total_written;
 
-	flist = (struct file_list *)malloc(sizeof(flist[0]));
-	if (!flist) out_of_memory("send_file_list");
-
-	flist->count=0;
-	flist->malloced = 1000;
-	flist->files = (struct file_struct **)malloc(sizeof(flist->files[0])*
-						     flist->malloced);
-	if (!flist->files) out_of_memory("send_file_list");
+	flist = flist_new();
 
 	if (f != -1) {
 		io_start_buffering(f);
 	}
 
 	for (i=0;i<argc;i++) {
-		char fname2[MAXPATHLEN];
-		char *fname = fname2;
+		char *fname = topsrcname;
 
-		strlcpy(fname,argv[i],MAXPATHLEN-1);
+		strlcpy(fname,argv[i],MAXPATHLEN);
 
 		l = strlen(fname);
 		if (l != 1 && fname[l-1] == '/') {
-			strlcat(fname,".",MAXPATHLEN-1);
+			if ((l == 2) && (fname[0] == '.')) {
+				/*  Turn ./ into just . rather than ./.
+				    This was put in to avoid a problem with
+				      rsync -aR --delete from ./
+				    The send_file_name() below of ./ was
+				    mysteriously preventing deletes */
+				fname[1] = 0;
+			} else {
+				strlcat(fname,".",MAXPATHLEN);
+			}
 		}
 
 		if (link_stat(fname,&st) != 0) {
-			io_error=1;
-			rprintf(FERROR,"%s : %s\n",fname,strerror(errno));
+			if (f != -1) {
+				io_error=1;
+				rprintf(FERROR,"link_stat %s : %s\n",fname,strerror(errno));
+			}
 			continue;
 		}
 
@@ -644,14 +771,21 @@ struct file_list *send_file_list(int f,int argc,char *argv[])
 			   thus getting their permissions right */
 			*p = 0;
 			if (strcmp(lastpath,fname)) {
-				strlcpy(lastpath, fname, sizeof(lastpath)-1);
+				strlcpy(lastpath, fname, sizeof(lastpath));
 				*p = '/';
 				for (p=fname+1; (p=strchr(p,'/')); p++) {
 					int copy_links_saved = copy_links;
+					int recurse_saved = recurse;
 					*p = 0;
-					copy_links = 0;
+					copy_links = copy_unsafe_links;
+					/* set recurse to 1 to prevent make_file
+					   from ignoring directory, but still
+					   turn off the recursive parameter to
+					   send_file_name */
+					recurse = 1;
 					send_file_name(f, flist, fname, 0, 0);
 					copy_links = copy_links_saved;
+					recurse = recurse_saved;
 					*p = '/';
 				}
 			} else {
@@ -678,19 +812,20 @@ struct file_list *send_file_list(int f,int argc,char *argv[])
 		if (one_file_system)
 			set_filesystem(fname);
 
-		if (!recurse || !send_included_file_names(f,flist))
-			send_file_name(f,flist,fname,recurse,FLAG_DELETE);
+		send_file_name(f,flist,fname,recurse,FLAG_DELETE);
 
 		if (olddir != NULL) {
 			flist_dir = NULL;
 			if (pop_dir(olddir) != 0) {
 				rprintf(FERROR,"pop_dir %s : %s\n",
 					dir,strerror(errno));
-				exit_cleanup(1);
+				exit_cleanup(RERR_FILESELECT);
 			}
 		}
 	}
 
+	topsrcname[0] = '\0';
+
 	if (f != -1) {
 		send_file_entry(NULL,f,0);
 	}
@@ -708,13 +843,16 @@ struct file_list *send_file_list(int f,int argc,char *argv[])
 
 	/* if protocol version is >= 17 then send the io_error flag */
 	if (f != -1 && remote_version >= 17) {
-		write_int(f, io_error);
+		extern int module_id;
+		write_int(f, lp_ignore_errors(module_id)? 0 : io_error);
 	}
 
 	if (f != -1) {
 		io_end_buffering(f);
 		stats.flist_size = stats.total_written - start_write;
 		stats.num_files = flist->count;
+		if (write_batch) /*  dw  */
+		    write_batch_flist_info(flist->count, flist->files);
 	}
 
 	if (verbose > 2)
@@ -792,8 +930,14 @@ struct file_list *recv_file_list(int f)
   }
 
   /* if protocol version is >= 17 then recv the io_error flag */
-  if (f != -1 && remote_version >= 17) {
-	  io_error |= read_int(f);
+  if (f != -1 && remote_version >= 17  && !read_batch) {  /* dw-added readbatch */
+	  extern int module_id;
+	  extern int ignore_errors;
+	  if (lp_ignore_errors(module_id) || ignore_errors) {
+		  read_int(f);
+	  } else {
+		  io_error |= read_int(f);
+	  }
   }
 
   if (list_only) {
@@ -855,16 +999,38 @@ int flist_find(struct file_list *flist,struct file_struct *f)
 /*
  * free up one file
  */
-static void free_file(struct file_struct *file)
+void free_file(struct file_struct *file)
 {
 	if (!file) return;
 	if (file->basename) free(file->basename);
 	if (file->link) free(file->link);
 	if (file->sum) free(file->sum);
-	memset((char *)file, 0, sizeof(*file));
+	*file = null_file;
 }
 
 
+/*
+ * allocate a new file list
+ */
+struct file_list *flist_new()
+{
+	struct file_list *flist;
+
+	flist = (struct file_list *)malloc(sizeof(flist[0]));
+	if (!flist) out_of_memory("send_file_list");
+
+	flist->count=0;
+	flist->malloced = 1000;
+	flist->files = (struct file_struct **)malloc(sizeof(flist->files[0])*
+						     flist->malloced);
+	if (!flist->files) out_of_memory("send_file_list");
+#if ARENA_SIZE > 0
+	flist->string_area = string_area_new(0);
+#else
+	flist->string_area = NULL;
+#endif
+	return flist;
+}
 /*
  * free up all elements in a flist
  */
@@ -872,11 +1038,14 @@ void flist_free(struct file_list *flist)
 {
 	int i;
 	for (i=1;i<flist->count;i++) {
-		free_file(flist->files[i]);
+		if (!flist->string_area)
+			free_file(flist->files[i]);
 		free(flist->files[i]);
 	}	
 	memset((char *)flist->files, 0, sizeof(flist->files[0])*flist->count);
 	free(flist->files);
+	if (flist->string_area)
+		string_area_free(flist->string_area);
 	memset((char *)flist, 0, sizeof(*flist));
 	free(flist);
 }
@@ -905,7 +1074,13 @@ static void clean_flist(struct file_list *flist, int strip_root)
 			if (verbose > 1 && !am_server)
 				rprintf(FINFO,"removing duplicate name %s from file list %d\n",
 					f_name(flist->files[i-1]),i-1);
-			free_file(flist->files[i]);
+			/* it's not great that the flist knows the semantics of the
+			 * file memory usage, but i'd rather not add a flag byte
+			 * to that struct. XXX can i use a bit in the flags field? */
+			if (flist->string_area)
+				flist->files[i][0] = null_file;
+			else
+				free_file(flist->files[i]);
 		} 
 	}
 
@@ -932,12 +1107,12 @@ static void clean_flist(struct file_list *flist, int strip_root)
 	if (verbose <= 3) return;
 
 	for (i=0;i<flist->count;i++) {
-		rprintf(FINFO,"[%d] i=%d %s %s mode=0%o len=%d\n",
-			getpid(), i, 
+		rprintf(FINFO,"[%d] i=%d %s %s mode=0%o len=%.0f\n",
+			(int) getpid(), i, 
 			NS(flist->files[i]->dirname),
 			NS(flist->files[i]->basename),
-			flist->files[i]->mode,
-			(int)flist->files[i]->length);
+			(int) flist->files[i]->mode,
+			(double)flist->files[i]->length);
 	}
 }
 
@@ -956,11 +1131,11 @@ char *f_name(struct file_struct *f)
 	n = (n+1)%10;
 
 	if (f->dirname) {
-		strlcpy(p, f->dirname, MAXPATHLEN-1);
-		strlcat(p, "/", MAXPATHLEN-1);
-		strlcat(p, f->basename, MAXPATHLEN-1);
+		strlcpy(p, f->dirname, MAXPATHLEN);
+		strlcat(p, "/", MAXPATHLEN);
+		strlcat(p, f->basename, MAXPATHLEN);
 	} else {
-		strlcpy(p, f->basename, MAXPATHLEN-1);
+		strlcpy(p, f->basename, MAXPATHLEN);
 	}
 
 	return p;