1 /* -*- c-file-style: "linux" -*-
3 rsync -- fast file replication program
5 Copyright (C) 1996-2000 by Andrew Tridgell
6 Copyright (C) Paul Mackerras 1996
7 Copyright (C) 2002 by Martin Pool <mbp@samba.org>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 extern int relative_paths;
29 extern int preserve_links;
31 extern int preserve_devices;
32 extern int preserve_hard_links;
33 extern int update_only;
34 extern int whole_file;
35 extern int block_size;
36 extern int csum_length;
37 extern int ignore_times;
39 extern int io_timeout;
40 extern int remote_version;
41 extern int always_checksum;
42 extern int modify_window;
43 extern char *compare_dest;
46 /* choose whether to skip a particular file */
47 static int skip_file(char *fname,
48 struct file_struct *file, STRUCT_STAT *st)
50 if (st->st_size != file->length) {
54 /* if always checksum is set then we use the checksum instead
55 of the file time to determine whether to sync */
56 if (always_checksum && S_ISREG(st->st_mode)) {
57 char sum[MD4_SUM_LENGTH];
58 char fnamecmpdest[MAXPATHLEN];
60 if (compare_dest != NULL) {
61 if (access(fname, 0) != 0) {
62 snprintf(fnamecmpdest,MAXPATHLEN,"%s/%s",
67 file_checksum(fname,sum,st->st_size);
68 if (remote_version < 21) {
69 return (memcmp(sum,file->sum,2) == 0);
71 return (memcmp(sum,file->sum,MD4_SUM_LENGTH) == 0);
83 return (cmp_modtime(st->st_mtime,file->modtime) == 0);
87 /* use a larger block size for really big files */
88 static int adapt_block_size(struct file_struct *file, int bsize)
92 if (bsize != BLOCK_SIZE) return bsize;
94 ret = file->length / (10000); /* rough heuristic */
95 ret = ret & ~15; /* multiple of 16 */
96 if (ret < bsize) ret = bsize;
97 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
103 send a sums struct down a fd
105 static void send_sums(struct sum_struct *s, int f_out)
110 /* tell the other guy how many we are going to be
111 doing and how many bytes there are in the last
113 write_int(f_out, s->count);
114 write_int(f_out, s->n);
115 write_int(f_out, s->remainder);
117 for (i = 0; i < s->count; i++) {
118 write_int(f_out, s->sums[i].sum1);
119 write_buf(f_out, s->sums[i].sum2, csum_length);
122 /* we don't have checksums */
124 write_int(f_out, block_size);
130 generate a stream of signatures/checksums that describe a buffer
132 generate approximately one checksum every n bytes
134 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
137 struct sum_struct *s;
140 int remainder = (len%block_len);
143 count = (len+(block_len-1))/block_len;
145 s = (struct sum_struct *)malloc(sizeof(*s));
146 if (!s) out_of_memory("generate_sums");
149 s->remainder = remainder;
159 rprintf(FINFO,"count=%d rem=%d n=%d flength=%.0f\n",
160 s->count,s->remainder,s->n,(double)s->flength);
162 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
163 if (!s->sums) out_of_memory("generate_sums");
165 for (i=0;i<count;i++) {
167 char *map = map_ptr(buf,offset,n1);
169 s->sums[i].sum1 = get_checksum1(map,n1);
170 get_checksum2(map,n1,s->sums[i].sum2);
172 s->sums[i].offset = offset;
177 rprintf(FINFO,"chunk[%d] offset=%.0f len=%d sum1=%08x\n",
178 i,(double)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
190 * Acts on file number I from FLIST, whose name is fname.
192 * First fixes up permissions, then generates checksums for the file.
194 * (This comment was added later by mbp who was trying to work it out;
195 * it might be wrong.)
197 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
201 struct map_struct *buf;
202 struct sum_struct *s;
204 struct file_struct *file = flist->files[i];
206 char fnamecmpbuf[MAXPATHLEN];
207 extern char *compare_dest;
208 extern int list_only;
209 extern int preserve_perms;
210 extern int only_existing;
212 if (list_only) return;
215 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
217 statret = link_stat(fname,&st);
219 if (only_existing && statret == -1 && errno == ENOENT) {
220 /* we only want to update existing files */
221 if (verbose > 1) rprintf(FINFO, RSYNC_NAME
222 ": not creating new file \"%s\"\n",fname);
228 (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
229 /* if the file exists already and we aren't perserving
230 presmissions then act as though the remote end sent
231 us the file permissions we already have */
232 file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
235 if (S_ISDIR(file->mode)) {
236 /* The file to be received is a directory, so we need
237 * to prepare appropriately. If there is already a
238 * file of that name and it is *not* a directory, then
239 * we need to delete it. If it doesn't exist, then
240 * recursively create it. */
242 if (dry_run) return; /* XXXX -- might cause inaccuracies?? -- mbp */
243 if (statret == 0 && !S_ISDIR(st.st_mode)) {
244 if (robust_unlink(fname) != 0) {
245 rprintf(FERROR, RSYNC_NAME
246 ": recv_generator: unlink \"%s\" to make room for directory: %s\n",
247 fname,strerror(errno));
252 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
253 if (!(relative_paths && errno==ENOENT &&
254 create_directory_path(fname)==0 &&
255 do_mkdir(fname,file->mode)==0)) {
256 rprintf(FERROR, RSYNC_NAME ": recv_generator: mkdir \"%s\": %s (2)\n",
257 fname,strerror(errno));
260 /* f_out is set to -1 when doing final directory
261 permission and modification time repair */
262 if (set_perms(fname,file,NULL,0) && verbose && (f_out != -1))
263 rprintf(FINFO,"%s/\n",fname);
267 if (preserve_links && S_ISLNK(file->mode)) {
269 char lnk[MAXPATHLEN];
271 extern int safe_symlinks;
273 if (safe_symlinks && unsafe_symlink(file->link, fname)) {
275 rprintf(FINFO,RSYNC_NAME ": ignoring unsafe symlink \"%s\" -> \"%s\"\n",
281 l = readlink(fname,lnk,MAXPATHLEN-1);
284 /* A link already pointing to the
285 * right place -- no further action
287 if (strcmp(lnk,file->link) == 0) {
288 set_perms(fname,file,&st,1);
292 /* Not a symlink, so delete whatever's
293 * already there and put a new symlink
297 if (do_symlink(file->link,fname) != 0) {
298 rprintf(FERROR,RSYNC_NAME": symlink \"%s\" -> \"%s\": %s\n",
299 fname,file->link,strerror(errno));
301 set_perms(fname,file,NULL,0);
303 rprintf(FINFO,RSYNC_NAME": %s -> %s\n",
312 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
314 st.st_mode != file->mode ||
315 st.st_rdev != file->rdev) {
318 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
319 fname,(int)file->mode,(int)file->rdev);
320 if (do_mknod(fname,file->mode,file->rdev) != 0) {
321 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
323 set_perms(fname,file,NULL,0);
325 rprintf(FINFO,"%s\n",fname);
328 set_perms(fname,file,&st,1);
334 if (preserve_hard_links && check_hard_link(file)) {
336 rprintf(FINFO, RSYNC_NAME
337 ": \"%s\" is a hard link\n",f_name(file));
341 if (!S_ISREG(file->mode)) {
342 rprintf(FINFO, RSYNC_NAME
343 ": skipping non-regular file \"%s\"\n",fname);
349 if ((statret == -1) && (compare_dest != NULL)) {
350 /* try the file at compare_dest instead */
351 int saveerrno = errno;
352 snprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
353 statret = link_stat(fnamecmpbuf,&st);
354 if (!S_ISREG(st.st_mode))
359 fnamecmp = fnamecmpbuf;
363 if (errno == ENOENT) {
365 if (!dry_run) send_sums(NULL,f_out);
368 rprintf(FERROR, RSYNC_NAME
369 ": recv_generator failed to open \"%s\": %s\n",
370 fname, strerror(errno));
375 if (!S_ISREG(st.st_mode)) {
376 if (delete_file(fname) != 0) {
380 /* now pretend the file didn't exist */
382 if (!dry_run) send_sums(NULL,f_out);
386 if (update_only && cmp_modtime(st.st_mtime,file->modtime)>0 && fnamecmp == fname) {
388 rprintf(FINFO,"%s is newer\n",fname);
392 if (skip_file(fname, file, &st)) {
393 if (fnamecmp == fname)
394 set_perms(fname,file,&st,1);
405 send_sums(NULL,f_out);
410 fd = do_open(fnamecmp, O_RDONLY, 0);
413 rprintf(FERROR,RSYNC_NAME": failed to open \"%s\", continuing : %s\n",fnamecmp,strerror(errno));
414 /* pretend the file didn't exist */
416 send_sums(NULL,f_out);
420 if (st.st_size > 0) {
421 buf = map_file(fd,st.st_size);
427 rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
429 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
432 rprintf(FINFO,"sending sums for %d\n",i);
438 if (buf) unmap_file(buf);
445 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
451 rprintf(FINFO,"generator starting pid=%d count=%d\n",
452 (int)getpid(),flist->count);
454 /* we expect to just sit around now, so don't exit on a
455 timeout. If we really get a timeout then the other process should
459 for (i = 0; i < flist->count; i++) {
460 struct file_struct *file = flist->files[i];
461 mode_t saved_mode = file->mode;
462 if (!file->basename) continue;
464 /* we need to ensure that any directories we create have writeable
465 permissions initially so that we can create the files within
466 them. This is then fixed after the files are transferred */
467 if (!am_root && S_ISDIR(file->mode)) {
468 file->mode |= S_IWUSR; /* user write */
469 /* XXX: Could this be causing a problem on SCO? Perhaps their
470 * handling of permissions is strange? */
473 recv_generator(local_name?local_name:f_name(file),
476 file->mode = saved_mode;
480 csum_length = SUM_LENGTH;
484 rprintf(FINFO,"generate_files phase=%d\n",phase);
488 if (remote_version >= 13) {
489 /* in newer versions of the protocol the files can cycle through
490 the system more than once to catch initial checksum errors */
491 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
492 struct file_struct *file = flist->files[i];
493 recv_generator(local_name?local_name:f_name(file),
499 rprintf(FINFO,"generate_files phase=%d\n",phase);