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)
361 if (bsize != BLOCK_SIZE) return bsize;
363 ret = file->length / (10000); /* rough heuristic */
364 ret = ret & ~15; /* multiple of 16 */
365 if (ret < bsize) ret = bsize;
366 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
370 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
374 struct map_struct *buf;
375 struct sum_struct *s;
377 struct file_struct *file = flist->files[i];
380 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
382 statret = link_stat(fname,&st);
384 if (S_ISDIR(file->mode)) {
386 if (statret == 0 && !S_ISDIR(st.st_mode)) {
387 if (do_unlink(fname) != 0) {
388 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
393 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
394 if (!(relative_paths && errno==ENOENT &&
395 create_directory_path(fname)==0 &&
396 do_mkdir(fname,file->mode)==0)) {
397 rprintf(FERROR,"mkdir %s : %s (2)\n",
398 fname,strerror(errno));
401 if (set_perms(fname,file,NULL,0) && verbose)
402 rprintf(FINFO,"%s/\n",fname);
406 if (preserve_links && S_ISLNK(file->mode)) {
408 char lnk[MAXPATHLEN];
411 l = readlink(fname,lnk,MAXPATHLEN-1);
414 if (strcmp(lnk,file->link) == 0) {
415 set_perms(fname,file,&st,1);
421 if (do_symlink(file->link,fname) != 0) {
422 rprintf(FERROR,"link %s -> %s : %s\n",
423 fname,file->link,strerror(errno));
425 set_perms(fname,file,NULL,0);
427 rprintf(FINFO,"%s -> %s\n",
435 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
437 st.st_mode != file->mode ||
438 st.st_rdev != file->rdev) {
441 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
442 fname,(int)file->mode,(int)file->rdev);
443 if (do_mknod(fname,file->mode,file->rdev) != 0) {
444 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
446 set_perms(fname,file,NULL,0);
448 rprintf(FINFO,"%s\n",fname);
451 set_perms(fname,file,&st,1);
457 if (preserve_hard_links && check_hard_link(file)) {
459 rprintf(FINFO,"%s is a hard link\n",f_name(file));
463 if (!S_ISREG(file->mode)) {
464 rprintf(FINFO,"skipping non-regular file %s\n",fname);
469 if (errno == ENOENT) {
471 if (!dry_run) send_sums(NULL,f_out);
474 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
479 if (!S_ISREG(st.st_mode)) {
480 if (delete_file(fname) != 0) {
484 /* now pretend the file didn't exist */
486 if (!dry_run) send_sums(NULL,f_out);
490 if (update_only && st.st_mtime > file->modtime) {
492 rprintf(FINFO,"%s is newer\n",fname);
496 if (skip_file(fname, file, &st)) {
497 set_perms(fname,file,&st,1);
508 send_sums(NULL,f_out);
513 fd = open(fname,O_RDONLY);
516 rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
517 rprintf(FERROR,"skipping %s\n",fname);
521 if (st.st_size > 0) {
522 buf = map_file(fd,st.st_size);
528 rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
530 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
533 rprintf(FINFO,"sending sums for %d\n",i);
539 if (buf) unmap_file(buf);
546 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
548 int i,n,remainder,len,count;
552 static char file_sum1[MD4_SUM_LENGTH];
553 static char file_sum2[MD4_SUM_LENGTH];
556 count = read_int(f_in);
558 remainder = read_int(f_in);
562 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
565 rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
567 stats.literal_data += i;
570 if (fd != -1 && write_file(fd,data,i) != i) {
571 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
579 if (i == count-1 && remainder != 0)
582 stats.matched_data += len;
585 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
586 i,len,(int)offset2,(int)offset);
588 map = map_ptr(buf,offset2,len);
593 if (fd != -1 && write_file(fd,map,len) != len) {
594 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
601 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
602 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
608 if (remote_version >= 14) {
609 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
611 rprintf(FINFO,"got file_sum\n");
612 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
619 static void delete_one(struct file_struct *f)
621 if (!S_ISDIR(f->mode)) {
622 if (do_unlink(f_name(f)) != 0) {
623 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
624 } else if (verbose) {
625 rprintf(FINFO,"deleting %s\n",f_name(f));
628 if (do_rmdir(f_name(f)) != 0) {
629 if (errno != ENOTEMPTY && errno != EEXIST)
630 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
631 } else if (verbose) {
632 rprintf(FINFO,"deleting directory %s\n",f_name(f));
639 static struct delete_list {
643 static int dlist_len, dlist_alloc_len;
645 static void add_delete_entry(struct file_struct *file)
647 if (dlist_len == dlist_alloc_len) {
648 dlist_alloc_len += 1024;
649 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
650 if (!delete_list) out_of_memory("add_delete_entry");
653 delete_list[dlist_len].dev = file->dev;
654 delete_list[dlist_len].inode = file->inode;
658 rprintf(FINFO,"added %s to delete list\n", f_name(file));
661 /* yuck! This function wouldn't have been necessary if I had the sorting
662 algorithm right. Unfortunately fixing the sorting algorithm would introduce
663 a backward incompatibility as file list indexes are sent over the link.
665 static int delete_already_done(struct file_list *flist,int j)
670 if (link_stat(f_name(flist->files[j]), &st)) return 1;
672 for (i=0;i<dlist_len;i++) {
673 if (st.st_ino == delete_list[i].inode &&
674 st.st_dev == delete_list[i].dev)
682 /* this deletes any files on the receiving side that are not present
683 on the sending side. For version 1.6.4 I have changed the behaviour
684 to match more closely what most people seem to expect of this option */
685 static void delete_files(struct file_list *flist)
687 struct file_list *local_file_list;
695 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
699 for (j=0;j<flist->count;j++) {
700 if (!S_ISDIR(flist->files[j]->mode) ||
701 !(flist->files[j]->flags & FLAG_DELETE)) continue;
703 if (remote_version < 19 &&
704 delete_already_done(flist, j)) continue;
706 name = strdup(f_name(flist->files[j]));
708 if (!(local_file_list = send_file_list(-1,1,&name))) {
714 rprintf(FINFO,"deleting in %s\n", name);
716 for (i=local_file_list->count-1;i>=0;i--) {
717 if (!local_file_list->files[i]->basename) continue;
718 if (remote_version < 19 &&
719 S_ISDIR(local_file_list->files[i]->mode))
720 add_delete_entry(local_file_list->files[i]);
721 if (-1 == flist_find(flist,local_file_list->files[i])) {
722 delete_one(local_file_list->files[i]);
725 flist_free(local_file_list);
730 static char *cleanup_fname;
732 void exit_cleanup(int code)
736 do_unlink(cleanup_fname);
737 signal(SIGUSR1, SIG_IGN);
752 static int get_tmpname(char *fnametmp, char *fname)
758 f = strrchr(fname,'/');
763 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
764 rprintf(FERROR,"filename too long\n");
767 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
771 f = strrchr(fname,'/');
773 if (strlen(fname)+9 > MAXPATHLEN) {
774 rprintf(FERROR,"filename too long\n");
780 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
784 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
790 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
795 char fnametmp[MAXPATHLEN];
796 struct map_struct *buf;
798 struct file_struct *file;
803 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
806 if (recurse && delete_mode && !local_name && flist->count>0) {
813 if (phase==0 && remote_version >= 13) {
815 csum_length = SUM_LENGTH;
817 rprintf(FINFO,"recv_files phase=%d\n",phase);
824 if (i < 0 || i >= flist->count) {
825 rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
830 file = flist->files[i];
831 fname = f_name(file);
833 stats.num_transferred_files++;
834 stats.total_transferred_size += file->length;
840 if (!am_server && verbose)
841 printf("%s\n",fname);
846 rprintf(FINFO,"recv_files(%s)\n",fname);
849 fd1 = open(fname,O_RDONLY);
851 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
852 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
853 receive_data(f_in,NULL,-1,NULL);
858 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
859 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
860 receive_data(f_in,NULL,-1,NULL);
865 if (fd1 != -1 && st.st_size > 0) {
866 buf = map_file(fd1,st.st_size);
868 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
873 if (!get_tmpname(fnametmp,fname)) {
874 if (buf) unmap_file(buf);
879 if (NULL == do_mktemp(fnametmp)) {
880 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
881 receive_data(f_in,buf,-1,NULL);
882 if (buf) unmap_file(buf);
887 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
888 if (fd2 == -1 && relative_paths && errno == ENOENT &&
889 create_directory_path(fnametmp) == 0) {
890 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
893 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
894 receive_data(f_in,buf,-1,NULL);
895 if (buf) unmap_file(buf);
900 cleanup_fname = fnametmp;
902 if (!am_server && verbose)
903 printf("%s\n",fname);
906 recv_ok = receive_data(f_in,buf,fd2,fname);
908 if (buf) unmap_file(buf);
915 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
918 char fnamebak[MAXPATHLEN];
919 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
920 rprintf(FERROR,"backup filename too long\n");
923 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
924 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
925 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
930 /* move tmp file over real file */
931 if (do_rename(fnametmp,fname) != 0) {
932 if (errno == EXDEV) {
933 /* rename failed on cross-filesystem link.
934 Copy the file instead. */
935 if (copy_file(fnametmp,fname, file->mode)) {
936 rprintf(FERROR,"copy %s -> %s : %s\n",
937 fnametmp,fname,strerror(errno));
939 set_perms(fname,file,NULL,0);
943 rprintf(FERROR,"rename %s -> %s : %s\n",
944 fnametmp,fname,strerror(errno));
948 set_perms(fname,file,NULL,0);
951 cleanup_fname = NULL;
955 if (csum_length == SUM_LENGTH) {
956 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
960 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
966 if (preserve_hard_links)
967 do_hard_links(flist);
969 /* now we need to fix any directory permissions that were
970 modified during the transfer */
971 for (i = 0; i < flist->count; i++) {
972 file = flist->files[i];
973 if (!file->basename || !S_ISDIR(file->mode)) continue;
974 recv_generator(f_name(file),flist,i,-1);
978 rprintf(FINFO,"recv_files finished\n");
985 void send_files(struct file_list *flist,int f_out,int f_in)
988 struct sum_struct *s;
989 struct map_struct *buf;
991 char fname[MAXPATHLEN];
993 struct file_struct *file;
997 rprintf(FINFO,"send_files starting\n");
999 setup_readbuffer(f_in);
1006 if (phase==0 && remote_version >= 13) {
1008 csum_length = SUM_LENGTH;
1009 write_int(f_out,-1);
1011 rprintf(FINFO,"send_files phase=%d\n",phase);
1017 if (i < 0 || i >= flist->count) {
1018 rprintf(FERROR,"Invalid file index %d (count=%d)\n",
1023 file = flist->files[i];
1025 stats.num_transferred_files++;
1026 stats.total_transferred_size += file->length;
1029 if (file->basedir) {
1030 strlcpy(fname,file->basedir,MAXPATHLEN-1);
1031 if (strlen(fname) == MAXPATHLEN-1) {
1033 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1037 strlcat(fname,"/",MAXPATHLEN-1);
1038 offset = strlen(file->basedir)+1;
1040 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1043 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1046 if (!am_server && verbose)
1047 printf("%s\n",fname);
1052 s = receive_sums(f_in);
1055 rprintf(FERROR,"receive_sums failed\n");
1059 fd = open(fname,O_RDONLY);
1062 rprintf(FERROR,"send_files failed to open %s: %s\n",
1063 fname,strerror(errno));
1068 /* map the local file */
1069 if (do_fstat(fd,&st) != 0) {
1071 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1077 if (st.st_size > 0) {
1078 buf = map_file(fd,st.st_size);
1084 rprintf(FINFO,"send_files mapped %s of size %d\n",
1085 fname,(int)st.st_size);
1089 write_int(f_out,s->count);
1090 write_int(f_out,s->n);
1091 write_int(f_out,s->remainder);
1094 rprintf(FINFO,"calling match_sums %s\n",fname);
1096 if (!am_server && verbose)
1097 printf("%s\n",fname+offset);
1099 match_sums(f_out,s,buf,st.st_size);
1101 if (buf) unmap_file(buf);
1107 rprintf(FINFO,"sender finished %s\n",fname);
1111 rprintf(FINFO,"send files finished\n");
1115 write_int(f_out,-1);
1120 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1126 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1127 (int)getpid(),flist->count);
1129 for (i = 0; i < flist->count; i++) {
1130 struct file_struct *file = flist->files[i];
1131 mode_t saved_mode = file->mode;
1132 if (!file->basename) continue;
1134 /* we need to ensure that any directories we create have writeable
1135 permissions initially so that we can create the files within
1136 them. This is then fixed after the files are transferred */
1137 if (!am_root && S_ISDIR(file->mode)) {
1138 file->mode |= S_IWUSR; /* user write */
1141 recv_generator(local_name?local_name:f_name(file),
1144 file->mode = saved_mode;
1148 csum_length = SUM_LENGTH;
1152 rprintf(FINFO,"generate_files phase=%d\n",phase);
1156 /* we expect to just sit around now, so don't exit on a timeout. If we
1157 really get a timeout then the other process should exit */
1160 if (remote_version >= 13) {
1161 /* in newer versions of the protocol the files can cycle through
1162 the system more than once to catch initial checksum errors */
1163 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1164 struct file_struct *file = flist->files[i];
1165 recv_generator(local_name?local_name:f_name(file),
1171 rprintf(FINFO,"generate_files phase=%d\n",phase);