X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/c7c11a0d4c315a052dddf97cc6d3d63a54b4a831..fc1ae6582fa5e199cc9c50dc2297297c1893955c:/generator.c diff --git a/generator.c b/generator.c index 8b0eeab1..740ce668 100644 --- a/generator.c +++ b/generator.c @@ -1,17 +1,21 @@ -/* - Copyright (C) Andrew Tridgell 1996 +/* -*- c-file-style: "linux" -*- + + rsync -- fast file replication program + + Copyright (C) 1996-2000 by Andrew Tridgell Copyright (C) Paul Mackerras 1996 - + Copyright (C) 2002 by Martin Pool + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. @@ -27,7 +31,7 @@ extern int am_root; extern int preserve_devices; extern int preserve_hard_links; extern int update_only; -extern int whole_file; +extern int opt_ignore_existing; extern int block_size; extern int csum_length; extern int ignore_times; @@ -35,6 +39,9 @@ extern int size_only; extern int io_timeout; extern int remote_version; extern int always_checksum; +extern int modify_window; +extern char *compare_dest; +extern int link_dest; /* choose whether to skip a particular file */ @@ -44,13 +51,41 @@ static int skip_file(char *fname, if (st->st_size != file->length) { return 0; } - - /* if always checksum is set then we use the checksum instead + if (link_dest) { + extern int preserve_perms; + extern int preserve_uid; + extern int preserve_gid; + + if(preserve_perms + && (st->st_mode & ~_S_IFMT) != (file->mode & ~_S_IFMT)) + return 0; + + if (preserve_uid && st->st_uid != file->uid) + return 0; + + if (preserve_gid && st->st_gid != file->gid) + return 0; + } + + /* if always checksum is set then we use the checksum instead of the file time to determine whether to sync */ if (always_checksum && S_ISREG(st->st_mode)) { char sum[MD4_SUM_LENGTH]; + char fnamecmpdest[MAXPATHLEN]; + + if (compare_dest != NULL) { + if (access(fname, 0) != 0) { + snprintf(fnamecmpdest,MAXPATHLEN,"%s/%s", + compare_dest,fname); + fname = fnamecmpdest; + } + } file_checksum(fname,sum,st->st_size); - return (memcmp(sum,file->sum,csum_length) == 0); + if (remote_version < 21) { + return (memcmp(sum,file->sum,2) == 0); + } else { + return (memcmp(sum,file->sum,MD4_SUM_LENGTH) == 0); + } } if (size_only) { @@ -61,7 +96,7 @@ static int skip_file(char *fname, return 0; } - return (st->st_mtime == file->modtime); + return (cmp_modtime(st->st_mtime,file->modtime) == 0); } @@ -81,96 +116,119 @@ static int adapt_block_size(struct file_struct *file, int bsize) /* - send a sums struct down a fd + * NULL sum_struct means we have no checksums */ -static void send_sums(struct sum_struct *s,int f_out) + +void write_sum_head(int f, struct sum_struct *sum) { - int i; + static struct sum_struct null_sum; - /* tell the other guy how many we are going to be doing and how many - bytes there are in the last chunk */ - write_int(f_out,s?s->count:0); - write_int(f_out,s?s->n:block_size); - write_int(f_out,s?s->remainder:0); - if (s) - for (i=0;icount;i++) { - write_int(f_out,s->sums[i].sum1); - write_buf(f_out,s->sums[i].sum2,csum_length); - } + if (sum == (struct sum_struct *)NULL) + sum = &null_sum; + + write_int(f, sum->count); + write_int(f, sum->blength); + if (remote_version >= 27) + write_int(f, sum->s2length); + write_int(f, sum->remainder); } -/* - generate a stream of signatures/checksums that describe a buffer - generate approximately one checksum every n bytes - */ -static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n) +/** + * Perhaps we want to just send an empty checksum set for this file, + * which will force the whole thing to be literally transferred. + * + * When do we do this? If the user's explicitly said they + * want the whole thing, or if { they haven't explicitly + * requested a delta, and it's local but not batch mode.} + * + * Whew. */ +static BOOL disable_deltas_p(void) { - int i; - struct sum_struct *s; - int count; - int block_len = n; - int remainder = (len%block_len); - OFF_T offset = 0; - - count = (len+(block_len-1))/block_len; + extern int whole_file; + extern int local_server; + extern int write_batch; + + if (whole_file > 0) + return True; + if (whole_file == 0 || write_batch) + return False; + return local_server; +} - s = (struct sum_struct *)malloc(sizeof(*s)); - if (!s) out_of_memory("generate_sums"); - s->count = count; - s->remainder = remainder; - s->n = n; - s->flength = len; +/* + * Generate and send a stream of signatures/checksums that describe a buffer + * + * Generate approximately one checksum every block_len bytes. + */ +static void generate_and_send_sums(struct map_struct *buf, OFF_T len, + int block_len, int f_out) +{ + size_t i; + struct sum_struct sum; + OFF_T offset = 0; - if (count==0) { - s->sums = NULL; - return s; + sum.count = (len + (block_len - 1)) / block_len; + sum.remainder = (len % block_len); + sum.blength = block_len; + sum.flength = len; + sum.s2length = csum_length; + /* not needed here sum.sums = NULL; */ + + if (sum.count && verbose > 3) { + rprintf(FINFO, "count=%ld rem=%ld n=%ld flength=%.0f\n", + (long) sum.count, (long) sum.remainder, + (long) sum.blength, (double) sum.flength); } - if (verbose > 3) - rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n", - s->count,s->remainder,s->n,(int)s->flength); + write_sum_head(f_out, &sum); - s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count); - if (!s->sums) out_of_memory("generate_sums"); - - for (i=0;isums[i].sum1 = get_checksum1(map,n1); - get_checksum2(map,n1,s->sums[i].sum2); - - s->sums[i].offset = offset; - s->sums[i].len = n1; - s->sums[i].i = i; - - if (verbose > 3) - rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n", - i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1); + get_checksum2(map, n1, sum2); + if (verbose > 3) { + rprintf(FINFO, + "chunk[%d] offset=%.0f len=%d sum1=%08lx\n", + i, (double) offset, n1, (unsigned long) sum1); + } + write_int(f_out, sum1); + write_buf(f_out, sum2, sum.s2length); len -= n1; offset += n1; } - - return s; } -void recv_generator(char *fname,struct file_list *flist,int i,int f_out) -{ + +/** + * Acts on file number @p i from @p flist, whose name is @p fname. + * + * First fixes up permissions, then generates checksums for the file. + * + * @note This comment was added later by mbp who was trying to work it + * out. It might be wrong. + **/ +void recv_generator(char *fname, struct file_list *flist, int i, int f_out) +{ int fd; STRUCT_STAT st; struct map_struct *buf; - struct sum_struct *s; int statret; struct file_struct *file = flist->files[i]; char *fnamecmp; char fnamecmpbuf[MAXPATHLEN]; extern char *compare_dest; extern int list_only; + extern int preserve_perms; + extern int only_existing; + extern int orig_umask; if (list_only) return; @@ -179,24 +237,49 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) statret = link_stat(fname,&st); + if (only_existing && statret == -1 && errno == ENOENT) { + /* we only want to update existing files */ + if (verbose > 1) rprintf(FINFO, "not creating new file \"%s\"\n",fname); + return; + } + + if (statret == 0 && + !preserve_perms && + (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) { + /* if the file exists already and we aren't perserving + * permissions then act as though the remote end sent + * us the file permissions we already have */ + file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT); + } + if (S_ISDIR(file->mode)) { - if (dry_run) return; + /* The file to be received is a directory, so we need + * to prepare appropriately. If there is already a + * file of that name and it is *not* a directory, then + * we need to delete it. If it doesn't exist, then + * recursively create it. */ + + if (dry_run) return; /* XXXX -- might cause inaccuracies?? -- mbp */ if (statret == 0 && !S_ISDIR(st.st_mode)) { if (robust_unlink(fname) != 0) { - rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno)); + rprintf(FERROR, RSYNC_NAME + ": recv_generator: unlink \"%s\" to make room for directory: %s\n", + fname,strerror(errno)); return; } statret = -1; } if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) { - if (!(relative_paths && errno==ENOENT && - create_directory_path(fname)==0 && + if (!(relative_paths && errno==ENOENT && + create_directory_path(fname, orig_umask)==0 && do_mkdir(fname,file->mode)==0)) { - rprintf(FERROR,"mkdir %s : %s (2)\n", + rprintf(FERROR, RSYNC_NAME ": recv_generator: mkdir \"%s\": %s (2)\n", fname,strerror(errno)); } } - if (set_perms(fname,file,NULL,0) && verbose) + /* f_out is set to -1 when doing final directory + permission and modification time repair */ + if (set_perms(fname,file,NULL,0) && verbose && (f_out != -1)) rprintf(FINFO,"%s/\n",fname); return; } @@ -209,7 +292,7 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) if (safe_symlinks && unsafe_symlink(file->link, fname)) { if (verbose) { - rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n", + rprintf(FINFO,"ignoring unsafe symlink \"%s\" -> \"%s\"\n", fname,file->link); } return; @@ -218,21 +301,26 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) l = readlink(fname,lnk,MAXPATHLEN-1); if (l > 0) { lnk[l] = 0; + /* A link already pointing to the + * right place -- no further action + * required. */ if (strcmp(lnk,file->link) == 0) { set_perms(fname,file,&st,1); return; } } + /* Not a symlink, so delete whatever's + * already there and put a new symlink + * in place. */ + delete_file(fname); } - delete_file(fname); if (do_symlink(file->link,fname) != 0) { - rprintf(FERROR,"link %s -> %s : %s\n", + rprintf(FERROR,RSYNC_NAME": symlink \"%s\" -> \"%s\": %s\n", fname,file->link,strerror(errno)); } else { set_perms(fname,file,NULL,0); if (verbose) { - rprintf(FINFO,"%s -> %s\n", - fname,file->link); + rprintf(FINFO,"%s -> %s\n", fname,file->link); } } #endif @@ -241,9 +329,9 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) #ifdef HAVE_MKNOD if (am_root && preserve_devices && IS_DEVICE(file->mode)) { - if (statret != 0 || + if (statret != 0 || st.st_mode != file->mode || - st.st_rdev != file->rdev) { + st.st_rdev != file->rdev) { delete_file(fname); if (verbose > 2) rprintf(FINFO,"mknod(%s,0%o,0x%x)\n", @@ -264,12 +352,12 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) if (preserve_hard_links && check_hard_link(file)) { if (verbose > 1) - rprintf(FINFO,"%s is a hard link\n",f_name(file)); + rprintf(FINFO, "recv_generator: \"%s\" is a hard link\n",f_name(file)); return; } if (!S_ISREG(file->mode)) { - rprintf(FINFO,"skipping non-regular file %s\n",fname); + rprintf(FINFO, "skipping non-regular file \"%s\"\n",fname); return; } @@ -278,12 +366,24 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) if ((statret == -1) && (compare_dest != NULL)) { /* try the file at compare_dest instead */ int saveerrno = errno; - slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname); + snprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname); statret = link_stat(fnamecmpbuf,&st); if (!S_ISREG(st.st_mode)) statret = -1; if (statret == -1) errno = saveerrno; +#if HAVE_LINK + else if (link_dest && !dry_run) { + if (do_link(fnamecmpbuf, fname) != 0) { + if (verbose > 0) + rprintf(FINFO,"link %s => %s : %s\n", + fnamecmpbuf, + fname, + strerror(errno)); + } + fnamecmp = fnamecmpbuf; + } +#endif else fnamecmp = fnamecmpbuf; } @@ -291,10 +391,12 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) if (statret == -1) { if (errno == ENOENT) { write_int(f_out,i); - if (!dry_run) send_sums(NULL,f_out); + if (!dry_run) write_sum_head(f_out, NULL); } else { if (verbose > 1) - rprintf(FERROR,"recv_generator failed to open %s\n",fname); + rprintf(FERROR, RSYNC_NAME + ": recv_generator failed to open \"%s\": %s\n", + fname, strerror(errno)); } return; } @@ -306,18 +408,25 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) /* now pretend the file didn't exist */ write_int(f_out,i); - if (!dry_run) send_sums(NULL,f_out); + if (!dry_run) write_sum_head(f_out, NULL); return; } - if (update_only && st.st_mtime > file->modtime && fnamecmp == fname) { + if (opt_ignore_existing && fnamecmp == fname) { + if (verbose > 1) + rprintf(FINFO,"%s exists\n",fname); + return; + } + + if (update_only && cmp_modtime(st.st_mtime,file->modtime)>0 && fnamecmp == fname) { if (verbose > 1) rprintf(FINFO,"%s is newer\n",fname); return; } if (skip_file(fname, file, &st)) { - set_perms(fname,file,&st,1); + if (fnamecmp == fname) + set_perms(fname,file,&st,1); return; } @@ -326,18 +435,20 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) return; } - if (whole_file) { + if (disable_deltas_p()) { write_int(f_out,i); - send_sums(NULL,f_out); + write_sum_head(f_out, NULL); return; } - /* open the file */ - fd = open(fnamecmp,O_RDONLY); + /* open the file */ + fd = do_open(fnamecmp, O_RDONLY, 0); if (fd == -1) { - rprintf(FERROR,"failed to open %s : %s\n",fnamecmp,strerror(errno)); - rprintf(FERROR,"skipping %s\n",fname); + rprintf(FERROR,RSYNC_NAME": failed to open \"%s\", continuing : %s\n",fnamecmp,strerror(errno)); + /* pretend the file didn't exist */ + write_int(f_out,i); + write_sum_head(f_out, NULL); return; } @@ -348,20 +459,17 @@ void recv_generator(char *fname,struct file_list *flist,int i,int f_out) } if (verbose > 3) - rprintf(FINFO,"gen mapped %s of size %d\n",fnamecmp,(int)st.st_size); - - s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size)); + rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size); if (verbose > 2) - rprintf(FINFO,"sending sums for %d\n",i); + rprintf(FINFO, "generating and sending sums for %d\n", i); write_int(f_out,i); - send_sums(s,f_out); + generate_and_send_sums(buf, st.st_size, + adapt_block_size(file, block_size), f_out); close(fd); if (buf) unmap_file(buf); - - free_sums(s); } @@ -375,6 +483,18 @@ void generate_files(int f,struct file_list *flist,char *local_name,int f_recv) rprintf(FINFO,"generator starting pid=%d count=%d\n", (int)getpid(),flist->count); + if (verbose >= 2) { + rprintf(FINFO, + disable_deltas_p() + ? "delta-transmission disabled for local transfer or --whole-file\n" + : "delta transmission enabled\n"); + } + + /* we expect to just sit around now, so don't exit on a + timeout. If we really get a timeout then the other process should + exit */ + io_timeout = 0; + for (i = 0; i < flist->count; i++) { struct file_struct *file = flist->files[i]; mode_t saved_mode = file->mode; @@ -385,10 +505,11 @@ void generate_files(int f,struct file_list *flist,char *local_name,int f_recv) them. This is then fixed after the files are transferred */ if (!am_root && S_ISDIR(file->mode)) { file->mode |= S_IWUSR; /* user write */ + /* XXX: Could this be causing a problem on SCO? Perhaps their + * handling of permissions is strange? */ } - recv_generator(local_name?local_name:f_name(file), - flist,i,f); + recv_generator(local_name?local_name:f_name(file), flist,i,f); file->mode = saved_mode; } @@ -402,24 +523,16 @@ void generate_files(int f,struct file_list *flist,char *local_name,int f_recv) write_int(f,-1); - /* we expect to just sit around now, so don't exit on a - timeout. If we really get a timeout then the other process should - exit */ - io_timeout = 0; - - if (remote_version >= 13) { - /* in newer versions of the protocol the files can cycle through - the system more than once to catch initial checksum errors */ - for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) { - struct file_struct *file = flist->files[i]; - recv_generator(local_name?local_name:f_name(file), - flist,i,f); - } + /* files can cycle through the system more than once + * to catch initial checksum errors */ + for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) { + struct file_struct *file = flist->files[i]; + recv_generator(local_name?local_name:f_name(file), flist,i,f); + } - phase++; - if (verbose > 2) - rprintf(FINFO,"generate_files phase=%d\n",phase); + phase++; + if (verbose > 2) + rprintf(FINFO,"generate_files phase=%d\n",phase); - write_int(f,-1); - } + write_int(f,-1); }