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;
47 /* choose whether to skip a particular file */
48 static int skip_file(char *fname,
49 struct file_struct *file, STRUCT_STAT *st)
51 if (st->st_size != file->length) {
55 if((st->st_mode & ~_S_IFMT) != (file->mode & ~_S_IFMT)) {
58 if (st->st_uid != file->uid || st->st_gid != file->gid) {
64 /* if always checksum is set then we use the checksum instead
65 of the file time to determine whether to sync */
66 if (always_checksum && S_ISREG(st->st_mode)) {
67 char sum[MD4_SUM_LENGTH];
68 char fnamecmpdest[MAXPATHLEN];
70 if (compare_dest != NULL) {
71 if (access(fname, 0) != 0) {
72 snprintf(fnamecmpdest,MAXPATHLEN,"%s/%s",
77 file_checksum(fname,sum,st->st_size);
78 if (remote_version < 21) {
79 return (memcmp(sum,file->sum,2) == 0);
81 return (memcmp(sum,file->sum,MD4_SUM_LENGTH) == 0);
93 return (cmp_modtime(st->st_mtime,file->modtime) == 0);
97 /* use a larger block size for really big files */
98 static int adapt_block_size(struct file_struct *file, int bsize)
102 if (bsize != BLOCK_SIZE) return bsize;
104 ret = file->length / (10000); /* rough heuristic */
105 ret = ret & ~15; /* multiple of 16 */
106 if (ret < bsize) ret = bsize;
107 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
113 send a header that says "we have no checksums" down the f_out fd
115 static void send_null_sums(int f_out)
118 write_int(f_out, block_size);
125 * Perhaps we want to just send an empty checksum set for this file,
126 * which will force the whole thing to be literally transferred.
128 * When do we do this? If the user's explicitly said they
129 * want the whole thing, or if { they haven't explicitly
130 * requested a delta, and it's local but not batch mode.}
133 static BOOL disable_deltas_p(void)
135 extern int whole_file, no_whole_file;
136 extern int local_server;
137 extern int write_batch;
139 assert(whole_file == 0 || whole_file == 1);
141 /* whole_file and no_whole_file are never both on at the same time */
145 else if (no_whole_file)
147 else if (write_batch)
155 * Generate and send a stream of signatures/checksums that describe a buffer
157 * Generate approximately one checksum every block_len bytes.
159 static void generate_and_send_sums(struct map_struct *buf, OFF_T len,
160 int block_len, int f_out)
163 struct sum_struct sum;
166 sum.count = (len + (block_len - 1)) / block_len;
167 sum.remainder = (len % block_len);
170 /* not needed here sum.sums = NULL; */
172 if (sum.count && verbose > 3) {
173 rprintf(FINFO, "count=%ld rem=%ld n=%ld flength=%.0f\n",
174 (long) sum.count, (long) sum.remainder,
175 (long) sum.n, (double) sum.flength);
178 write_int(f_out, sum.count);
179 write_int(f_out, sum.n);
180 write_int(f_out, sum.remainder);
182 for (i = 0; i < sum.count; i++) {
183 int n1 = MIN(len, block_len);
184 char *map = map_ptr(buf, offset, n1);
185 uint32 sum1 = get_checksum1(map, n1);
186 char sum2[SUM_LENGTH];
188 get_checksum2(map, n1, sum2);
192 "chunk[%d] offset=%.0f len=%d sum1=%08lx\n",
193 i, (double) offset, n1, (unsigned long) sum1);
195 write_int(f_out, sum1);
196 write_buf(f_out, sum2, csum_length);
205 * Acts on file number @p i from @p flist, whose name is @p fname.
207 * First fixes up permissions, then generates checksums for the file.
209 * @note This comment was added later by mbp who was trying to work it
210 * out. It might be wrong.
212 void recv_generator(char *fname, struct file_list *flist, int i, int f_out)
216 struct map_struct *buf;
218 struct file_struct *file = flist->files[i];
220 char fnamecmpbuf[MAXPATHLEN];
221 extern char *compare_dest;
222 extern int list_only;
223 extern int preserve_perms;
224 extern int only_existing;
225 extern int orig_umask;
227 if (list_only) return;
230 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
232 statret = link_stat(fname,&st);
234 if (only_existing && statret == -1 && errno == ENOENT) {
235 /* we only want to update existing files */
236 if (verbose > 1) rprintf(FINFO, "not creating new file \"%s\"\n",fname);
242 (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
243 /* if the file exists already and we aren't perserving
244 presmissions then act as though the remote end sent
245 us the file permissions we already have */
246 file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
249 if (S_ISDIR(file->mode)) {
250 /* The file to be received is a directory, so we need
251 * to prepare appropriately. If there is already a
252 * file of that name and it is *not* a directory, then
253 * we need to delete it. If it doesn't exist, then
254 * recursively create it. */
256 if (dry_run) return; /* XXXX -- might cause inaccuracies?? -- mbp */
257 if (statret == 0 && !S_ISDIR(st.st_mode)) {
258 if (robust_unlink(fname) != 0) {
259 rprintf(FERROR, RSYNC_NAME
260 ": recv_generator: unlink \"%s\" to make room for directory: %s\n",
261 fname,strerror(errno));
266 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
267 if (!(relative_paths && errno==ENOENT &&
268 create_directory_path(fname, orig_umask)==0 &&
269 do_mkdir(fname,file->mode)==0)) {
270 rprintf(FERROR, RSYNC_NAME ": recv_generator: mkdir \"%s\": %s (2)\n",
271 fname,strerror(errno));
274 /* f_out is set to -1 when doing final directory
275 permission and modification time repair */
276 if (set_perms(fname,file,NULL,0) && verbose && (f_out != -1))
277 rprintf(FINFO,"%s/\n",fname);
281 if (preserve_links && S_ISLNK(file->mode)) {
283 char lnk[MAXPATHLEN];
285 extern int safe_symlinks;
287 if (safe_symlinks && unsafe_symlink(file->link, fname)) {
289 rprintf(FINFO,"ignoring unsafe symlink \"%s\" -> \"%s\"\n",
295 l = readlink(fname,lnk,MAXPATHLEN-1);
298 /* A link already pointing to the
299 * right place -- no further action
301 if (strcmp(lnk,file->link) == 0) {
302 set_perms(fname,file,&st,1);
306 /* Not a symlink, so delete whatever's
307 * already there and put a new symlink
311 if (do_symlink(file->link,fname) != 0) {
312 rprintf(FERROR,RSYNC_NAME": symlink \"%s\" -> \"%s\": %s\n",
313 fname,file->link,strerror(errno));
315 set_perms(fname,file,NULL,0);
317 rprintf(FINFO,"%s -> %s\n", fname,file->link);
325 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
327 st.st_mode != file->mode ||
328 st.st_rdev != file->rdev) {
331 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
332 fname,(int)file->mode,(int)file->rdev);
333 if (do_mknod(fname,file->mode,file->rdev) != 0) {
334 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
336 set_perms(fname,file,NULL,0);
338 rprintf(FINFO,"%s\n",fname);
341 set_perms(fname,file,&st,1);
347 if (preserve_hard_links && check_hard_link(file)) {
349 rprintf(FINFO, "recv_generator: \"%s\" is a hard link\n",f_name(file));
353 if (!S_ISREG(file->mode)) {
354 rprintf(FINFO, "skipping non-regular file \"%s\"\n",fname);
360 if ((statret == -1) && (compare_dest != NULL)) {
361 /* try the file at compare_dest instead */
362 int saveerrno = errno;
363 snprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
364 statret = link_stat(fnamecmpbuf,&st);
365 if (!S_ISREG(st.st_mode))
370 else if (link_dest && !dry_run) {
371 if (do_link(fnamecmpbuf, fname) != 0) {
373 rprintf(FINFO,"link %s => %s : %s\n",
378 fnamecmp = fnamecmpbuf;
382 fnamecmp = fnamecmpbuf;
386 if (errno == ENOENT) {
388 if (!dry_run) send_null_sums(f_out);
391 rprintf(FERROR, RSYNC_NAME
392 ": recv_generator failed to open \"%s\": %s\n",
393 fname, strerror(errno));
398 if (!S_ISREG(st.st_mode)) {
399 if (delete_file(fname) != 0) {
403 /* now pretend the file didn't exist */
405 if (!dry_run) send_null_sums(f_out);
409 if (opt_ignore_existing && fnamecmp == fname) {
411 rprintf(FINFO,"%s exists\n",fname);
415 if (update_only && cmp_modtime(st.st_mtime,file->modtime)>0 && fnamecmp == fname) {
417 rprintf(FINFO,"%s is newer\n",fname);
421 if (skip_file(fname, file, &st)) {
422 if (fnamecmp == fname)
423 set_perms(fname,file,&st,1);
432 if (disable_deltas_p()) {
434 send_null_sums(f_out);
439 fd = do_open(fnamecmp, O_RDONLY, 0);
442 rprintf(FERROR,RSYNC_NAME": failed to open \"%s\", continuing : %s\n",fnamecmp,strerror(errno));
443 /* pretend the file didn't exist */
445 send_null_sums(f_out);
449 if (st.st_size > 0) {
450 buf = map_file(fd,st.st_size);
456 rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
459 rprintf(FINFO, "generating and sending sums for %d\n", i);
462 generate_and_send_sums(buf, st.st_size,
463 adapt_block_size(file, block_size), f_out);
466 if (buf) unmap_file(buf);
471 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
477 rprintf(FINFO,"generator starting pid=%d count=%d\n",
478 (int)getpid(),flist->count);
483 ? "delta-transmission disabled for local transfer or --whole-file\n"
484 : "delta transmission enabled\n");
487 /* we expect to just sit around now, so don't exit on a
488 timeout. If we really get a timeout then the other process should
492 for (i = 0; i < flist->count; i++) {
493 struct file_struct *file = flist->files[i];
494 mode_t saved_mode = file->mode;
495 if (!file->basename) continue;
497 /* we need to ensure that any directories we create have writeable
498 permissions initially so that we can create the files within
499 them. This is then fixed after the files are transferred */
500 if (!am_root && S_ISDIR(file->mode)) {
501 file->mode |= S_IWUSR; /* user write */
502 /* XXX: Could this be causing a problem on SCO? Perhaps their
503 * handling of permissions is strange? */
506 recv_generator(local_name?local_name:f_name(file),
509 file->mode = saved_mode;
513 csum_length = SUM_LENGTH;
517 rprintf(FINFO,"generate_files phase=%d\n",phase);
521 if (remote_version >= 13) {
522 /* in newer versions of the protocol the files can cycle through
523 the system more than once to catch initial checksum errors */
524 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
525 struct file_struct *file = flist->files[i];
526 recv_generator(local_name?local_name:f_name(file),
532 rprintf(FINFO,"generate_files phase=%d\n",phase);