2 Copyright (C) Andrew Tridgell 1996
3 Copyright (C) Paul Mackerras 1996
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 extern int csum_length;
26 extern int always_checksum;
27 extern time_t starttime;
29 extern int remote_version;
31 extern char *backup_suffix;
34 extern int whole_file;
35 extern int block_size;
36 extern int update_only;
37 extern int make_backups;
38 extern int preserve_links;
39 extern int preserve_hard_links;
40 extern int preserve_perms;
41 extern int preserve_devices;
42 extern int preserve_uid;
43 extern int preserve_gid;
44 extern int preserve_times;
46 extern int ignore_times;
48 extern int delete_mode;
49 extern int cvs_exclude;
51 extern int relative_paths;
52 extern int io_timeout;
54 extern struct stats stats;
59 static void free_sums(struct sum_struct *s)
61 if (s->sums) free(s->sums);
67 * delete a file or directory. If force_delet is set then delete
70 static int delete_file(char *fname)
75 extern int force_delete;
80 if (do_unlink(fname) == 0 || errno == ENOENT) return 0;
83 ret = do_lstat(fname, &st);
85 ret = do_stat(fname, &st);
88 rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
92 if (!S_ISDIR(st.st_mode)) {
93 rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno));
97 if (do_rmdir(fname) == 0 || errno == ENOENT) return 0;
98 if (!force_delete || !recurse ||
99 (errno != ENOTEMPTY && errno != EEXIST)) {
100 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
104 /* now we do a recsursive delete on the directory ... */
107 rprintf(FERROR,"opendir(%s): %s\n",
108 fname,strerror(errno));
112 for (di=readdir(d); di; di=readdir(d)) {
113 char *dname = d_name(di);
114 if (strcmp(dname,".")==0 ||
115 strcmp(dname,"..")==0)
117 slprintf(buf, sizeof(buf)-1, "%s/%s", fname, dname);
119 rprintf(FINFO,"deleting %s\n", buf);
120 if (delete_file(buf) != 0) {
128 if (do_rmdir(fname) != 0) {
129 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
137 send a sums struct down a fd
139 static void send_sums(struct sum_struct *s,int f_out)
143 /* tell the other guy how many we are going to be doing and how many
144 bytes there are in the last chunk */
145 write_int(f_out,s?s->count:0);
146 write_int(f_out,s?s->n:block_size);
147 write_int(f_out,s?s->remainder:0);
149 for (i=0;i<s->count;i++) {
150 write_int(f_out,s->sums[i].sum1);
151 write_buf(f_out,s->sums[i].sum2,csum_length);
157 generate a stream of signatures/checksums that describe a buffer
159 generate approximately one checksum every n bytes
161 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
164 struct sum_struct *s;
167 int remainder = (len%block_len);
170 count = (len+(block_len-1))/block_len;
172 s = (struct sum_struct *)malloc(sizeof(*s));
173 if (!s) out_of_memory("generate_sums");
176 s->remainder = remainder;
186 rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
187 s->count,s->remainder,s->n,(int)s->flength);
189 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
190 if (!s->sums) out_of_memory("generate_sums");
192 for (i=0;i<count;i++) {
194 char *map = map_ptr(buf,offset,n1);
196 s->sums[i].sum1 = get_checksum1(map,n1);
197 get_checksum2(map,n1,s->sums[i].sum2);
199 s->sums[i].offset = offset;
204 rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
205 i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
216 receive the checksums for a buffer
218 static struct sum_struct *receive_sums(int f)
220 struct sum_struct *s;
224 s = (struct sum_struct *)malloc(sizeof(*s));
225 if (!s) out_of_memory("receive_sums");
227 s->count = read_int(f);
229 s->remainder = read_int(f);
233 rprintf(FINFO,"count=%d n=%d rem=%d\n",
234 s->count,s->n,s->remainder);
239 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
240 if (!s->sums) out_of_memory("receive_sums");
242 for (i=0;i<s->count;i++) {
243 s->sums[i].sum1 = read_int(f);
244 read_buf(f,s->sums[i].sum2,csum_length);
246 s->sums[i].offset = offset;
249 if (i == s->count-1 && s->remainder != 0) {
250 s->sums[i].len = s->remainder;
252 s->sums[i].len = s->n;
254 offset += s->sums[i].len;
257 rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
258 i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
267 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
272 extern int am_daemon;
274 if (dry_run) return 0;
277 if (link_stat(fname,&st2) != 0) {
278 rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
284 if (preserve_times && !S_ISLNK(st->st_mode) &&
285 st->st_mtime != file->modtime) {
287 if (set_modtime(fname,file->modtime) != 0) {
288 rprintf(FERROR,"failed to set times on %s : %s\n",
289 fname,strerror(errno));
294 if ((am_root || !am_daemon) &&
295 ((am_root && preserve_uid && st->st_uid != file->uid) ||
296 (preserve_gid && st->st_gid != file->gid))) {
298 (am_root&&preserve_uid)?file->uid:-1,
299 preserve_gid?file->gid:-1) != 0) {
300 if (preserve_uid && st->st_uid != file->uid)
302 if (verbose>1 || preserve_uid) {
303 rprintf(FERROR,"chown %s : %s\n",
304 fname,strerror(errno));
312 if (preserve_perms && !S_ISLNK(st->st_mode) &&
313 st->st_mode != file->mode) {
315 if (do_chmod(fname,file->mode) != 0) {
316 rprintf(FERROR,"failed to set permissions on %s : %s\n",
317 fname,strerror(errno));
323 if (verbose > 1 && report) {
325 rprintf(FINFO,"%s\n",fname);
327 rprintf(FINFO,"%s is uptodate\n",fname);
333 /* choose whether to skip a particular file */
334 static int skip_file(char *fname,
335 struct file_struct *file, STRUCT_STAT *st)
337 if (st->st_size != file->length) {
341 /* if always checksum is set then we use the checksum instead
342 of the file time to determine whether to sync */
343 if (always_checksum && S_ISREG(st->st_mode)) {
344 char sum[MD4_SUM_LENGTH];
345 file_checksum(fname,sum,st->st_size);
346 return (memcmp(sum,file->sum,csum_length) == 0);
353 return (st->st_mtime == file->modtime);
357 /* use a larger block size for really big files */
358 int adapt_block_size(struct file_struct *file, int bsize)
362 if (bsize != BLOCK_SIZE) return bsize;
364 ret = file->length / (10000); /* rough heuristic */
365 ret = ret & ~15; /* multiple of 16 */
366 if (ret < bsize) ret = bsize;
367 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
371 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
375 struct map_struct *buf;
376 struct sum_struct *s;
378 struct file_struct *file = flist->files[i];
381 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
383 statret = link_stat(fname,&st);
385 if (S_ISDIR(file->mode)) {
387 if (statret == 0 && !S_ISDIR(st.st_mode)) {
388 if (do_unlink(fname) != 0) {
389 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
394 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
395 if (!(relative_paths && errno==ENOENT &&
396 create_directory_path(fname)==0 &&
397 do_mkdir(fname,file->mode)==0)) {
398 rprintf(FERROR,"mkdir %s : %s (2)\n",
399 fname,strerror(errno));
402 if (set_perms(fname,file,NULL,0) && verbose)
403 rprintf(FINFO,"%s/\n",fname);
407 if (preserve_links && S_ISLNK(file->mode)) {
409 char lnk[MAXPATHLEN];
412 l = readlink(fname,lnk,MAXPATHLEN-1);
415 if (strcmp(lnk,file->link) == 0) {
416 set_perms(fname,file,&st,1);
422 if (do_symlink(file->link,fname) != 0) {
423 rprintf(FERROR,"link %s -> %s : %s\n",
424 fname,file->link,strerror(errno));
426 set_perms(fname,file,NULL,0);
428 rprintf(FINFO,"%s -> %s\n",
436 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
438 st.st_mode != file->mode ||
439 st.st_rdev != file->rdev) {
442 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
443 fname,(int)file->mode,(int)file->rdev);
444 if (do_mknod(fname,file->mode,file->rdev) != 0) {
445 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
447 set_perms(fname,file,NULL,0);
449 rprintf(FINFO,"%s\n",fname);
452 set_perms(fname,file,&st,1);
458 if (preserve_hard_links && check_hard_link(file)) {
460 rprintf(FINFO,"%s is a hard link\n",f_name(file));
464 if (!S_ISREG(file->mode)) {
465 rprintf(FINFO,"skipping non-regular file %s\n",fname);
470 if (errno == ENOENT) {
472 if (!dry_run) send_sums(NULL,f_out);
475 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
480 if (!S_ISREG(st.st_mode)) {
481 if (delete_file(fname) != 0) {
485 /* now pretend the file didn't exist */
487 if (!dry_run) send_sums(NULL,f_out);
491 if (update_only && st.st_mtime > file->modtime) {
493 rprintf(FINFO,"%s is newer\n",fname);
497 if (skip_file(fname, file, &st)) {
498 set_perms(fname,file,&st,1);
509 send_sums(NULL,f_out);
514 fd = open(fname,O_RDONLY);
517 rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
518 rprintf(FERROR,"skipping %s\n",fname);
522 if (st.st_size > 0) {
523 buf = map_file(fd,st.st_size);
529 rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
531 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
534 rprintf(FINFO,"sending sums for %d\n",i);
540 if (buf) unmap_file(buf);
547 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
549 int i,n,remainder,len,count;
553 static char file_sum1[MD4_SUM_LENGTH];
554 static char file_sum2[MD4_SUM_LENGTH];
557 count = read_int(f_in);
559 remainder = read_int(f_in);
563 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
566 rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
568 stats.literal_data += i;
571 if (fd != -1 && write_file(fd,data,i) != i) {
572 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
580 if (i == count-1 && remainder != 0)
583 stats.matched_data += len;
586 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
587 i,len,(int)offset2,(int)offset);
589 map = map_ptr(buf,offset2,len);
594 if (fd != -1 && write_file(fd,map,len) != len) {
595 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
602 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
603 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
609 if (remote_version >= 14) {
610 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
612 rprintf(FINFO,"got file_sum\n");
613 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
620 static void delete_one(struct file_struct *f)
622 if (!S_ISDIR(f->mode)) {
623 if (do_unlink(f_name(f)) != 0) {
624 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
625 } else if (verbose) {
626 rprintf(FINFO,"deleting %s\n",f_name(f));
629 if (do_rmdir(f_name(f)) != 0) {
630 if (errno != ENOTEMPTY && errno != EEXIST)
631 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
632 } else if (verbose) {
633 rprintf(FINFO,"deleting directory %s\n",f_name(f));
640 static struct delete_list {
644 static int dlist_len, dlist_alloc_len;
646 static void add_delete_entry(struct file_struct *file)
648 if (dlist_len == dlist_alloc_len) {
649 dlist_alloc_len += 1024;
650 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
651 if (!delete_list) out_of_memory("add_delete_entry");
654 delete_list[dlist_len].dev = file->dev;
655 delete_list[dlist_len].inode = file->inode;
659 rprintf(FINFO,"added %s to delete list\n", f_name(file));
662 /* yuck! This function wouldn't have been necessary if I had the sorting
663 algorithm right. Unfortunately fixing the sorting algorithm would introduce
664 a backward incompatibility as file list indexes are sent over the link.
666 static int delete_already_done(struct file_list *flist,int j)
671 if (link_stat(f_name(flist->files[j]), &st)) return 1;
673 for (i=0;i<dlist_len;i++) {
674 if (st.st_ino == delete_list[i].inode &&
675 st.st_dev == delete_list[i].dev)
683 /* this deletes any files on the receiving side that are not present
684 on the sending side. For version 1.6.4 I have changed the behaviour
685 to match more closely what most people seem to expect of this option */
686 static void delete_files(struct file_list *flist)
688 struct file_list *local_file_list;
696 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
700 for (j=0;j<flist->count;j++) {
701 if (!S_ISDIR(flist->files[j]->mode) ||
702 !(flist->files[j]->flags & FLAG_DELETE)) continue;
704 if (remote_version < 19 &&
705 delete_already_done(flist, j)) continue;
707 name = strdup(f_name(flist->files[j]));
709 if (!(local_file_list = send_file_list(-1,1,&name))) {
715 rprintf(FINFO,"deleting in %s\n", name);
717 for (i=local_file_list->count-1;i>=0;i--) {
718 if (!local_file_list->files[i]->basename) continue;
719 if (remote_version < 19 &&
720 S_ISDIR(local_file_list->files[i]->mode))
721 add_delete_entry(local_file_list->files[i]);
722 if (-1 == flist_find(flist,local_file_list->files[i])) {
723 delete_one(local_file_list->files[i]);
726 flist_free(local_file_list);
731 static char *cleanup_fname;
733 void exit_cleanup(int code)
737 do_unlink(cleanup_fname);
738 signal(SIGUSR1, SIG_IGN);
753 static int get_tmpname(char *fnametmp, char *fname)
759 f = strrchr(fname,'/');
764 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
765 rprintf(FERROR,"filename too long\n");
768 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
772 f = strrchr(fname,'/');
774 if (strlen(fname)+9 > MAXPATHLEN) {
775 rprintf(FERROR,"filename too long\n");
781 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
785 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
791 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
796 char fnametmp[MAXPATHLEN];
797 struct map_struct *buf;
799 struct file_struct *file;
804 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
807 if (recurse && delete_mode && !local_name && flist->count>0) {
814 if (phase==0 && remote_version >= 13) {
816 csum_length = SUM_LENGTH;
818 rprintf(FINFO,"recv_files phase=%d\n",phase);
825 if (i < 0 || i >= flist->count) {
826 rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
831 file = flist->files[i];
832 fname = f_name(file);
834 stats.num_transferred_files++;
835 stats.total_transferred_size += file->length;
841 if (!am_server && verbose)
842 printf("%s\n",fname);
847 rprintf(FINFO,"recv_files(%s)\n",fname);
850 fd1 = open(fname,O_RDONLY);
852 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
853 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
854 receive_data(f_in,NULL,-1,NULL);
859 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
860 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
861 receive_data(f_in,NULL,-1,NULL);
866 if (fd1 != -1 && st.st_size > 0) {
867 buf = map_file(fd1,st.st_size);
869 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
874 if (!get_tmpname(fnametmp,fname)) {
875 if (buf) unmap_file(buf);
880 if (NULL == do_mktemp(fnametmp)) {
881 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
882 receive_data(f_in,buf,-1,NULL);
883 if (buf) unmap_file(buf);
888 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
889 if (fd2 == -1 && relative_paths && errno == ENOENT &&
890 create_directory_path(fnametmp) == 0) {
891 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
894 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
895 receive_data(f_in,buf,-1,NULL);
896 if (buf) unmap_file(buf);
901 cleanup_fname = fnametmp;
903 if (!am_server && verbose)
904 printf("%s\n",fname);
907 recv_ok = receive_data(f_in,buf,fd2,fname);
909 if (buf) unmap_file(buf);
916 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
919 char fnamebak[MAXPATHLEN];
920 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
921 rprintf(FERROR,"backup filename too long\n");
924 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
925 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
926 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
931 /* move tmp file over real file */
932 if (do_rename(fnametmp,fname) != 0) {
933 if (errno == EXDEV) {
934 /* rename failed on cross-filesystem link.
935 Copy the file instead. */
936 if (copy_file(fnametmp,fname, file->mode)) {
937 rprintf(FERROR,"copy %s -> %s : %s\n",
938 fnametmp,fname,strerror(errno));
940 set_perms(fname,file,NULL,0);
944 rprintf(FERROR,"rename %s -> %s : %s\n",
945 fnametmp,fname,strerror(errno));
949 set_perms(fname,file,NULL,0);
952 cleanup_fname = NULL;
956 if (csum_length == SUM_LENGTH) {
957 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
961 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
967 if (preserve_hard_links)
968 do_hard_links(flist);
970 /* now we need to fix any directory permissions that were
971 modified during the transfer */
972 for (i = 0; i < flist->count; i++) {
973 file = flist->files[i];
974 if (!file->basename || !S_ISDIR(file->mode)) continue;
975 recv_generator(f_name(file),flist,i,-1);
979 rprintf(FINFO,"recv_files finished\n");
986 void send_files(struct file_list *flist,int f_out,int f_in)
989 struct sum_struct *s;
990 struct map_struct *buf;
992 char fname[MAXPATHLEN];
994 struct file_struct *file;
998 rprintf(FINFO,"send_files starting\n");
1000 setup_readbuffer(f_in);
1007 if (phase==0 && remote_version >= 13) {
1009 csum_length = SUM_LENGTH;
1010 write_int(f_out,-1);
1012 rprintf(FINFO,"send_files phase=%d\n",phase);
1018 if (i < 0 || i >= flist->count) {
1019 rprintf(FERROR,"Invalid file index %d (count=%d)\n",
1024 file = flist->files[i];
1026 stats.num_transferred_files++;
1027 stats.total_transferred_size += file->length;
1030 if (file->basedir) {
1031 strlcpy(fname,file->basedir,MAXPATHLEN-1);
1032 if (strlen(fname) == MAXPATHLEN-1) {
1034 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1038 strlcat(fname,"/",MAXPATHLEN-1);
1039 offset = strlen(file->basedir)+1;
1041 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1044 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1047 if (!am_server && verbose)
1048 printf("%s\n",fname);
1053 s = receive_sums(f_in);
1056 rprintf(FERROR,"receive_sums failed\n");
1060 fd = open(fname,O_RDONLY);
1063 rprintf(FERROR,"send_files failed to open %s: %s\n",
1064 fname,strerror(errno));
1069 /* map the local file */
1070 if (do_fstat(fd,&st) != 0) {
1072 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1078 if (st.st_size > 0) {
1079 buf = map_file(fd,st.st_size);
1085 rprintf(FINFO,"send_files mapped %s of size %d\n",
1086 fname,(int)st.st_size);
1090 write_int(f_out,s->count);
1091 write_int(f_out,s->n);
1092 write_int(f_out,s->remainder);
1095 rprintf(FINFO,"calling match_sums %s\n",fname);
1097 if (!am_server && verbose)
1098 printf("%s\n",fname+offset);
1100 match_sums(f_out,s,buf,st.st_size);
1102 if (buf) unmap_file(buf);
1108 rprintf(FINFO,"sender finished %s\n",fname);
1112 rprintf(FINFO,"send files finished\n");
1116 write_int(f_out,-1);
1121 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1127 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1128 (int)getpid(),flist->count);
1130 for (i = 0; i < flist->count; i++) {
1131 struct file_struct *file = flist->files[i];
1132 mode_t saved_mode = file->mode;
1133 if (!file->basename) continue;
1135 /* we need to ensure that any directories we create have writeable
1136 permissions initially so that we can create the files within
1137 them. This is then fixed after the files are transferred */
1138 if (!am_root && S_ISDIR(file->mode)) {
1139 file->mode |= S_IWUSR; /* user write */
1142 recv_generator(local_name?local_name:f_name(file),
1145 file->mode = saved_mode;
1149 csum_length = SUM_LENGTH;
1153 rprintf(FINFO,"generate_files phase=%d\n",phase);
1157 /* we expect to just sit around now, so don't exit on a timeout. If we
1158 really get a timeout then the other process should exit */
1161 if (remote_version >= 13) {
1162 /* in newer versions of the protocol the files can cycle through
1163 the system more than once to catch initial checksum errors */
1164 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1165 struct file_struct *file = flist->files[i];
1166 recv_generator(local_name?local_name:f_name(file),
1172 rprintf(FINFO,"generate_files phase=%d\n",phase);