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));
295 if (preserve_perms && !S_ISLNK(st->st_mode) &&
296 st->st_mode != file->mode) {
298 if (do_chmod(fname,file->mode) != 0) {
299 rprintf(FERROR,"failed to set permissions on %s : %s\n",
300 fname,strerror(errno));
306 if ((am_root || !am_daemon) &&
307 ((am_root && preserve_uid && st->st_uid != file->uid) ||
308 (preserve_gid && st->st_gid != file->gid))) {
310 (am_root&&preserve_uid)?file->uid:-1,
311 preserve_gid?file->gid:-1) != 0) {
312 if (preserve_uid && st->st_uid != file->uid)
314 if (verbose>1 || preserve_uid)
315 rprintf(FERROR,"chown %s : %s\n",
316 fname,strerror(errno));
322 if (verbose > 1 && report) {
324 rprintf(FINFO,"%s\n",fname);
326 rprintf(FINFO,"%s is uptodate\n",fname);
332 /* choose whether to skip a particular file */
333 static int skip_file(char *fname,
334 struct file_struct *file, STRUCT_STAT *st)
336 if (st->st_size != file->length) {
340 /* if always checksum is set then we use the checksum instead
341 of the file time to determine whether to sync */
342 if (always_checksum && S_ISREG(st->st_mode)) {
343 char sum[MD4_SUM_LENGTH];
344 file_checksum(fname,sum,st->st_size);
345 return (memcmp(sum,file->sum,csum_length) == 0);
352 return (st->st_mtime == file->modtime);
356 /* use a larger block size for really big files */
357 int adapt_block_size(struct file_struct *file, int bsize)
359 int ret = file->length / (10000); /* rough heuristic */
360 ret = ret & ~15; /* multiple of 16 */
361 if (ret < bsize) ret = bsize;
362 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
366 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
370 struct map_struct *buf;
371 struct sum_struct *s;
373 struct file_struct *file = flist->files[i];
376 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
378 statret = link_stat(fname,&st);
380 if (S_ISDIR(file->mode)) {
382 if (statret == 0 && !S_ISDIR(st.st_mode)) {
383 if (do_unlink(fname) != 0) {
384 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
389 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
390 if (!(relative_paths && errno==ENOENT &&
391 create_directory_path(fname)==0 &&
392 do_mkdir(fname,file->mode)==0)) {
393 rprintf(FERROR,"mkdir %s : %s (2)\n",
394 fname,strerror(errno));
397 if (set_perms(fname,file,NULL,0) && verbose)
398 rprintf(FINFO,"%s/\n",fname);
402 if (preserve_links && S_ISLNK(file->mode)) {
404 char lnk[MAXPATHLEN];
407 l = readlink(fname,lnk,MAXPATHLEN-1);
410 if (strcmp(lnk,file->link) == 0) {
411 set_perms(fname,file,&st,1);
417 if (do_symlink(file->link,fname) != 0) {
418 rprintf(FERROR,"link %s -> %s : %s\n",
419 fname,file->link,strerror(errno));
421 set_perms(fname,file,NULL,0);
423 rprintf(FINFO,"%s -> %s\n",
431 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
433 st.st_mode != file->mode ||
434 st.st_rdev != file->rdev) {
437 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
438 fname,(int)file->mode,(int)file->rdev);
439 if (do_mknod(fname,file->mode,file->rdev) != 0) {
440 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
442 set_perms(fname,file,NULL,0);
444 rprintf(FINFO,"%s\n",fname);
447 set_perms(fname,file,&st,1);
453 if (preserve_hard_links && check_hard_link(file)) {
455 rprintf(FINFO,"%s is a hard link\n",f_name(file));
459 if (!S_ISREG(file->mode)) {
460 rprintf(FINFO,"skipping non-regular file %s\n",fname);
465 if (errno == ENOENT) {
467 if (!dry_run) send_sums(NULL,f_out);
470 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
475 if (!S_ISREG(st.st_mode)) {
476 if (delete_file(fname) != 0) {
480 /* now pretend the file didn't exist */
482 if (!dry_run) send_sums(NULL,f_out);
486 if (update_only && st.st_mtime > file->modtime) {
488 rprintf(FINFO,"%s is newer\n",fname);
492 if (skip_file(fname, file, &st)) {
493 set_perms(fname,file,&st,1);
504 send_sums(NULL,f_out);
509 fd = open(fname,O_RDONLY);
512 rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
513 rprintf(FERROR,"skipping %s\n",fname);
517 if (st.st_size > 0) {
518 buf = map_file(fd,st.st_size);
524 rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
526 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
529 rprintf(FINFO,"sending sums for %d\n",i);
535 if (buf) unmap_file(buf);
542 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
544 int i,n,remainder,len,count;
548 static char file_sum1[MD4_SUM_LENGTH];
549 static char file_sum2[MD4_SUM_LENGTH];
552 count = read_int(f_in);
554 remainder = read_int(f_in);
558 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
561 rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
563 stats.literal_data += i;
566 if (fd != -1 && write_file(fd,data,i) != i) {
567 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
575 if (i == count-1 && remainder != 0)
578 stats.matched_data += len;
581 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
582 i,len,(int)offset2,(int)offset);
584 map = map_ptr(buf,offset2,len);
589 if (fd != -1 && write_file(fd,map,len) != len) {
590 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
597 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
598 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
604 if (remote_version >= 14) {
605 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
607 rprintf(FINFO,"got file_sum\n");
608 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
615 static void delete_one(struct file_struct *f)
617 if (!S_ISDIR(f->mode)) {
618 if (do_unlink(f_name(f)) != 0) {
619 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
620 } else if (verbose) {
621 rprintf(FINFO,"deleting %s\n",f_name(f));
624 if (do_rmdir(f_name(f)) != 0) {
625 if (errno != ENOTEMPTY && errno != EEXIST)
626 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
627 } else if (verbose) {
628 rprintf(FINFO,"deleting directory %s\n",f_name(f));
635 static struct delete_list {
639 static int dlist_len, dlist_alloc_len;
641 static void add_delete_entry(struct file_struct *file)
643 if (dlist_len == dlist_alloc_len) {
644 dlist_alloc_len += 1024;
645 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
646 if (!delete_list) out_of_memory("add_delete_entry");
649 delete_list[dlist_len].dev = file->dev;
650 delete_list[dlist_len].inode = file->inode;
654 rprintf(FINFO,"added %s to delete list\n", f_name(file));
657 /* yuck! This function wouldn't have been necessary if I had the sorting
658 algorithm right. Unfortunately fixing the sorting algorithm would introduce
659 a backward incompatibility as file list indexes are sent over the link.
661 static int delete_already_done(struct file_list *flist,int j)
666 if (link_stat(f_name(flist->files[j]), &st)) return 1;
668 for (i=0;i<dlist_len;i++) {
669 if (st.st_ino == delete_list[i].inode &&
670 st.st_dev == delete_list[i].dev)
678 /* this deletes any files on the receiving side that are not present
679 on the sending side. For version 1.6.4 I have changed the behaviour
680 to match more closely what most people seem to expect of this option */
681 static void delete_files(struct file_list *flist)
683 struct file_list *local_file_list;
691 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
695 for (j=0;j<flist->count;j++) {
696 if (!S_ISDIR(flist->files[j]->mode) ||
697 !(flist->files[j]->flags & FLAG_DELETE)) continue;
699 if (remote_version < 19 &&
700 delete_already_done(flist, j)) continue;
702 name = strdup(f_name(flist->files[j]));
704 if (!(local_file_list = send_file_list(-1,1,&name))) {
710 rprintf(FINFO,"deleting in %s\n", name);
712 for (i=local_file_list->count-1;i>=0;i--) {
713 if (!local_file_list->files[i]->basename) continue;
714 if (remote_version < 19 &&
715 S_ISDIR(local_file_list->files[i]->mode))
716 add_delete_entry(local_file_list->files[i]);
717 if (-1 == flist_find(flist,local_file_list->files[i])) {
718 delete_one(local_file_list->files[i]);
721 flist_free(local_file_list);
726 static char *cleanup_fname;
728 void exit_cleanup(int code)
732 do_unlink(cleanup_fname);
733 signal(SIGUSR1, SIG_IGN);
748 static int get_tmpname(char *fnametmp, char *fname)
754 f = strrchr(fname,'/');
759 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
760 rprintf(FERROR,"filename too long\n");
763 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
767 f = strrchr(fname,'/');
769 if (strlen(fname)+9 > MAXPATHLEN) {
770 rprintf(FERROR,"filename too long\n");
776 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
780 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
786 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
791 char fnametmp[MAXPATHLEN];
792 struct map_struct *buf;
794 struct file_struct *file;
799 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
802 if (recurse && delete_mode && !local_name && flist->count>0) {
809 if (phase==0 && remote_version >= 13) {
811 csum_length = SUM_LENGTH;
813 rprintf(FINFO,"recv_files phase=%d\n",phase);
820 if (i < 0 || i >= flist->count) {
821 rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
826 file = flist->files[i];
827 fname = f_name(file);
829 stats.num_transferred_files++;
830 stats.total_transferred_size += file->length;
836 if (!am_server && verbose)
837 printf("%s\n",fname);
842 rprintf(FINFO,"recv_files(%s)\n",fname);
845 fd1 = open(fname,O_RDONLY);
847 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
848 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
849 receive_data(f_in,NULL,-1,NULL);
854 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
855 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
856 receive_data(f_in,NULL,-1,NULL);
861 if (fd1 != -1 && st.st_size > 0) {
862 buf = map_file(fd1,st.st_size);
864 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
869 if (!get_tmpname(fnametmp,fname)) {
870 if (buf) unmap_file(buf);
875 if (NULL == do_mktemp(fnametmp)) {
876 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
877 receive_data(f_in,buf,-1,NULL);
878 if (buf) unmap_file(buf);
883 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
884 if (fd2 == -1 && relative_paths && errno == ENOENT &&
885 create_directory_path(fnametmp) == 0) {
886 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
889 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
890 receive_data(f_in,buf,-1,NULL);
891 if (buf) unmap_file(buf);
896 cleanup_fname = fnametmp;
898 if (!am_server && verbose)
899 printf("%s\n",fname);
902 recv_ok = receive_data(f_in,buf,fd2,fname);
904 if (buf) unmap_file(buf);
911 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
914 char fnamebak[MAXPATHLEN];
915 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
916 rprintf(FERROR,"backup filename too long\n");
919 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
920 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
921 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
926 /* move tmp file over real file */
927 if (do_rename(fnametmp,fname) != 0) {
928 if (errno == EXDEV) {
929 /* rename failed on cross-filesystem link.
930 Copy the file instead. */
931 if (copy_file(fnametmp,fname, file->mode)) {
932 rprintf(FERROR,"copy %s -> %s : %s\n",
933 fnametmp,fname,strerror(errno));
935 set_perms(fname,file,NULL,0);
939 rprintf(FERROR,"rename %s -> %s : %s\n",
940 fnametmp,fname,strerror(errno));
944 set_perms(fname,file,NULL,0);
947 cleanup_fname = NULL;
951 if (csum_length == SUM_LENGTH) {
952 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
956 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
962 if (preserve_hard_links)
963 do_hard_links(flist);
965 /* now we need to fix any directory permissions that were
966 modified during the transfer */
967 for (i = 0; i < flist->count; i++) {
968 file = flist->files[i];
969 if (!file->basename || !S_ISDIR(file->mode)) continue;
970 recv_generator(f_name(file),flist,i,-1);
974 rprintf(FINFO,"recv_files finished\n");
981 void send_files(struct file_list *flist,int f_out,int f_in)
984 struct sum_struct *s;
985 struct map_struct *buf;
987 char fname[MAXPATHLEN];
989 struct file_struct *file;
993 rprintf(FINFO,"send_files starting\n");
995 setup_readbuffer(f_in);
1002 if (phase==0 && remote_version >= 13) {
1004 csum_length = SUM_LENGTH;
1005 write_int(f_out,-1);
1007 rprintf(FINFO,"send_files phase=%d\n",phase);
1013 if (i < 0 || i >= flist->count) {
1014 rprintf(FERROR,"Invalid file index %d (count=%d)\n",
1019 file = flist->files[i];
1021 stats.num_transferred_files++;
1022 stats.total_transferred_size += file->length;
1025 if (file->basedir) {
1026 strlcpy(fname,file->basedir,MAXPATHLEN-1);
1027 if (strlen(fname) == MAXPATHLEN-1) {
1029 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1033 strlcat(fname,"/",MAXPATHLEN-1);
1034 offset = strlen(file->basedir)+1;
1036 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1039 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1042 if (!am_server && verbose)
1043 printf("%s\n",fname);
1048 s = receive_sums(f_in);
1051 rprintf(FERROR,"receive_sums failed\n");
1055 fd = open(fname,O_RDONLY);
1058 rprintf(FERROR,"send_files failed to open %s: %s\n",
1059 fname,strerror(errno));
1064 /* map the local file */
1065 if (do_fstat(fd,&st) != 0) {
1067 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1073 if (st.st_size > 0) {
1074 buf = map_file(fd,st.st_size);
1080 rprintf(FINFO,"send_files mapped %s of size %d\n",
1081 fname,(int)st.st_size);
1085 write_int(f_out,s->count);
1086 write_int(f_out,s->n);
1087 write_int(f_out,s->remainder);
1090 rprintf(FINFO,"calling match_sums %s\n",fname);
1092 if (!am_server && verbose)
1093 printf("%s\n",fname+offset);
1095 match_sums(f_out,s,buf,st.st_size);
1097 if (buf) unmap_file(buf);
1103 rprintf(FINFO,"sender finished %s\n",fname);
1107 rprintf(FINFO,"send files finished\n");
1111 write_int(f_out,-1);
1116 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1122 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1123 (int)getpid(),flist->count);
1125 for (i = 0; i < flist->count; i++) {
1126 struct file_struct *file = flist->files[i];
1127 mode_t saved_mode = file->mode;
1128 if (!file->basename) continue;
1130 /* we need to ensure that any directories we create have writeable
1131 permissions initially so that we can create the files within
1132 them. This is then fixed after the files are transferred */
1133 if (!am_root && S_ISDIR(file->mode)) {
1134 file->mode |= S_IWUSR; /* user write */
1137 recv_generator(local_name?local_name:f_name(file),
1140 file->mode = saved_mode;
1144 csum_length = SUM_LENGTH;
1148 rprintf(FINFO,"generate_files phase=%d\n",phase);
1152 /* we expect to just sit around now, so don't exit on a timeout. If we
1153 really get a timeout then the other process should exit */
1156 if (remote_version >= 13) {
1157 /* in newer versions of the protocol the files can cycle through
1158 the system more than once to catch initial checksum errors */
1159 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1160 struct file_struct *file = flist->files[i];
1161 recv_generator(local_name?local_name:f_name(file),
1167 rprintf(FINFO,"generate_files phase=%d\n",phase);