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 opt_ignore_existing;
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);
131 * Perhaps we want to just send an empty checksum set for this file,
132 * which will force the whole thing to be literally transferred.
134 * When do we do this? If the user's explicitly said they
135 * want the whole thing, or if { they haven't explicitly
136 * requested a delta, and it's local but not batch mode.}
139 static BOOL disable_deltas_p(void)
141 extern int whole_file, no_whole_file;
142 extern int local_server;
143 extern int write_batch;
145 assert(whole_file == 0 || whole_file == 1);
147 /* whole_file and no_whole_file are never both on at the same time */
151 else if (no_whole_file)
153 else if (write_batch)
161 * Generate a stream of signatures/checksums that describe a buffer.
163 * Generate approximately one checksum every @p n bytes.
165 * @return Newly-allocated sum_struct
167 static struct sum_struct *generate_sums(struct map_struct *buf, OFF_T len,
171 struct sum_struct *s;
174 int remainder = (len % block_len);
177 count = (len + (block_len - 1)) / block_len;
179 s = (struct sum_struct *) malloc(sizeof(*s));
181 out_of_memory("generate_sums");
184 s->remainder = remainder;
194 rprintf(FINFO, "count=%ld rem=%ld n=%ld flength=%.0f\n",
195 (long) s->count, (long) s->remainder,
196 (long) s->n, (double) s->flength);
199 s->sums = (struct sum_buf *) malloc(sizeof(s->sums[0]) * s->count);
201 out_of_memory("generate_sums");
203 for (i = 0; i < count; i++) {
204 int n1 = MIN(len, n);
205 char *map = map_ptr(buf, offset, n1);
207 s->sums[i].sum1 = get_checksum1(map, n1);
208 get_checksum2(map, n1, s->sums[i].sum2);
210 s->sums[i].offset = offset;
216 "chunk[%d] offset=%.0f len=%d sum1=%08x\n",
217 i, (double) s->sums[i].offset,
218 s->sums[i].len, s->sums[i].sum1);
230 * Acts on file number @p i from @p flist, whose name is @p fname.
232 * First fixes up permissions, then generates checksums for the file.
234 * @note This comment was added later by mbp who was trying to work it
235 * out. It might be wrong.
237 void recv_generator(char *fname, struct file_list *flist, int i, int f_out)
241 struct map_struct *buf;
242 struct sum_struct *s;
244 struct file_struct *file = flist->files[i];
246 char fnamecmpbuf[MAXPATHLEN];
247 extern char *compare_dest;
248 extern int list_only;
249 extern int preserve_perms;
250 extern int only_existing;
251 extern int orig_umask;
253 if (list_only) return;
256 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
258 statret = link_stat(fname,&st);
260 if (only_existing && statret == -1 && errno == ENOENT) {
261 /* we only want to update existing files */
262 if (verbose > 1) rprintf(FINFO, "not creating new file \"%s\"\n",fname);
268 (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
269 /* if the file exists already and we aren't perserving
270 presmissions then act as though the remote end sent
271 us the file permissions we already have */
272 file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
275 if (S_ISDIR(file->mode)) {
276 /* The file to be received is a directory, so we need
277 * to prepare appropriately. If there is already a
278 * file of that name and it is *not* a directory, then
279 * we need to delete it. If it doesn't exist, then
280 * recursively create it. */
282 if (dry_run) return; /* XXXX -- might cause inaccuracies?? -- mbp */
283 if (statret == 0 && !S_ISDIR(st.st_mode)) {
284 if (robust_unlink(fname) != 0) {
285 rprintf(FERROR, RSYNC_NAME
286 ": recv_generator: unlink \"%s\" to make room for directory: %s\n",
287 fname,strerror(errno));
292 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
293 if (!(relative_paths && errno==ENOENT &&
294 create_directory_path(fname, orig_umask)==0 &&
295 do_mkdir(fname,file->mode)==0)) {
296 rprintf(FERROR, RSYNC_NAME ": recv_generator: mkdir \"%s\": %s (2)\n",
297 fname,strerror(errno));
300 /* f_out is set to -1 when doing final directory
301 permission and modification time repair */
302 if (set_perms(fname,file,NULL,0) && verbose && (f_out != -1))
303 rprintf(FINFO,"%s/\n",fname);
307 if (preserve_links && S_ISLNK(file->mode)) {
309 char lnk[MAXPATHLEN];
311 extern int safe_symlinks;
313 if (safe_symlinks && unsafe_symlink(file->link, fname)) {
315 rprintf(FINFO,"ignoring unsafe symlink \"%s\" -> \"%s\"\n",
321 l = readlink(fname,lnk,MAXPATHLEN-1);
324 /* A link already pointing to the
325 * right place -- no further action
327 if (strcmp(lnk,file->link) == 0) {
328 set_perms(fname,file,&st,1);
332 /* Not a symlink, so delete whatever's
333 * already there and put a new symlink
337 if (do_symlink(file->link,fname) != 0) {
338 rprintf(FERROR,RSYNC_NAME": symlink \"%s\" -> \"%s\": %s\n",
339 fname,file->link,strerror(errno));
341 set_perms(fname,file,NULL,0);
343 rprintf(FINFO,"%s -> %s\n", fname,file->link);
351 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
353 st.st_mode != file->mode ||
354 st.st_rdev != file->rdev) {
357 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
358 fname,(int)file->mode,(int)file->rdev);
359 if (do_mknod(fname,file->mode,file->rdev) != 0) {
360 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
362 set_perms(fname,file,NULL,0);
364 rprintf(FINFO,"%s\n",fname);
367 set_perms(fname,file,&st,1);
373 if (preserve_hard_links && check_hard_link(file)) {
375 rprintf(FINFO, "recv_generator: \"%s\" is a hard link\n",f_name(file));
379 if (!S_ISREG(file->mode)) {
380 rprintf(FINFO, "skipping non-regular file \"%s\"\n",fname);
386 if ((statret == -1) && (compare_dest != NULL)) {
387 /* try the file at compare_dest instead */
388 int saveerrno = errno;
389 snprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
390 statret = link_stat(fnamecmpbuf,&st);
391 if (!S_ISREG(st.st_mode))
396 fnamecmp = fnamecmpbuf;
400 if (errno == ENOENT) {
402 if (!dry_run) send_sums(NULL,f_out);
405 rprintf(FERROR, RSYNC_NAME
406 ": recv_generator failed to open \"%s\": %s\n",
407 fname, strerror(errno));
412 if (!S_ISREG(st.st_mode)) {
413 if (delete_file(fname) != 0) {
417 /* now pretend the file didn't exist */
419 if (!dry_run) send_sums(NULL,f_out);
423 if (opt_ignore_existing && fnamecmp == fname) {
425 rprintf(FINFO,"%s exists\n",fname);
429 if (update_only && cmp_modtime(st.st_mtime,file->modtime)>0 && fnamecmp == fname) {
431 rprintf(FINFO,"%s is newer\n",fname);
435 if (skip_file(fname, file, &st)) {
436 if (fnamecmp == fname)
437 set_perms(fname,file,&st,1);
446 if (disable_deltas_p()) {
448 send_sums(NULL,f_out);
453 fd = do_open(fnamecmp, O_RDONLY, 0);
456 rprintf(FERROR,RSYNC_NAME": failed to open \"%s\", continuing : %s\n",fnamecmp,strerror(errno));
457 /* pretend the file didn't exist */
459 send_sums(NULL,f_out);
463 if (st.st_size > 0) {
464 buf = map_file(fd,st.st_size);
470 rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
472 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
475 rprintf(FINFO,"sending sums for %d\n",i);
481 if (buf) unmap_file(buf);
488 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
494 rprintf(FINFO,"generator starting pid=%d count=%d\n",
495 (int)getpid(),flist->count);
500 ? "delta-transmission disabled for local transfer or --whole-file\n"
501 : "delta transmission enabled\n");
504 /* we expect to just sit around now, so don't exit on a
505 timeout. If we really get a timeout then the other process should
509 for (i = 0; i < flist->count; i++) {
510 struct file_struct *file = flist->files[i];
511 mode_t saved_mode = file->mode;
512 if (!file->basename) continue;
514 /* we need to ensure that any directories we create have writeable
515 permissions initially so that we can create the files within
516 them. This is then fixed after the files are transferred */
517 if (!am_root && S_ISDIR(file->mode)) {
518 file->mode |= S_IWUSR; /* user write */
519 /* XXX: Could this be causing a problem on SCO? Perhaps their
520 * handling of permissions is strange? */
523 recv_generator(local_name?local_name:f_name(file),
526 file->mode = saved_mode;
530 csum_length = SUM_LENGTH;
534 rprintf(FINFO,"generate_files phase=%d\n",phase);
538 if (remote_version >= 13) {
539 /* in newer versions of the protocol the files can cycle through
540 the system more than once to catch initial checksum errors */
541 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
542 struct file_struct *file = flist->files[i];
543 recv_generator(local_name?local_name:f_name(file),
549 rprintf(FINFO,"generate_files phase=%d\n",phase);