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));
313 if (preserve_perms && !S_ISLNK(st->st_mode) &&
314 st->st_mode != file->mode) {
316 if (do_chmod(fname,file->mode) != 0) {
317 rprintf(FERROR,"failed to set permissions on %s : %s\n",
318 fname,strerror(errno));
324 if (verbose > 1 && report) {
326 rprintf(FINFO,"%s\n",fname);
328 rprintf(FINFO,"%s is uptodate\n",fname);
334 /* choose whether to skip a particular file */
335 static int skip_file(char *fname,
336 struct file_struct *file, STRUCT_STAT *st)
338 if (st->st_size != file->length) {
342 /* if always checksum is set then we use the checksum instead
343 of the file time to determine whether to sync */
344 if (always_checksum && S_ISREG(st->st_mode)) {
345 char sum[MD4_SUM_LENGTH];
346 file_checksum(fname,sum,st->st_size);
347 return (memcmp(sum,file->sum,csum_length) == 0);
354 return (st->st_mtime == file->modtime);
358 /* use a larger block size for really big files */
359 int adapt_block_size(struct file_struct *file, int bsize)
363 if (bsize != BLOCK_SIZE) return bsize;
365 ret = file->length / (10000); /* rough heuristic */
366 ret = ret & ~15; /* multiple of 16 */
367 if (ret < bsize) ret = bsize;
368 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
372 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
376 struct map_struct *buf;
377 struct sum_struct *s;
379 struct file_struct *file = flist->files[i];
382 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
384 statret = link_stat(fname,&st);
386 if (S_ISDIR(file->mode)) {
388 if (statret == 0 && !S_ISDIR(st.st_mode)) {
389 if (do_unlink(fname) != 0) {
390 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
395 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
396 if (!(relative_paths && errno==ENOENT &&
397 create_directory_path(fname)==0 &&
398 do_mkdir(fname,file->mode)==0)) {
399 rprintf(FERROR,"mkdir %s : %s (2)\n",
400 fname,strerror(errno));
403 if (set_perms(fname,file,NULL,0) && verbose)
404 rprintf(FINFO,"%s/\n",fname);
408 if (preserve_links && S_ISLNK(file->mode)) {
410 char lnk[MAXPATHLEN];
413 l = readlink(fname,lnk,MAXPATHLEN-1);
416 if (strcmp(lnk,file->link) == 0) {
417 set_perms(fname,file,&st,1);
423 if (do_symlink(file->link,fname) != 0) {
424 rprintf(FERROR,"link %s -> %s : %s\n",
425 fname,file->link,strerror(errno));
427 set_perms(fname,file,NULL,0);
429 rprintf(FINFO,"%s -> %s\n",
437 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
439 st.st_mode != file->mode ||
440 st.st_rdev != file->rdev) {
443 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
444 fname,(int)file->mode,(int)file->rdev);
445 if (do_mknod(fname,file->mode,file->rdev) != 0) {
446 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
448 set_perms(fname,file,NULL,0);
450 rprintf(FINFO,"%s\n",fname);
453 set_perms(fname,file,&st,1);
459 if (preserve_hard_links && check_hard_link(file)) {
461 rprintf(FINFO,"%s is a hard link\n",f_name(file));
465 if (!S_ISREG(file->mode)) {
466 rprintf(FINFO,"skipping non-regular file %s\n",fname);
471 if (errno == ENOENT) {
473 if (!dry_run) send_sums(NULL,f_out);
476 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
481 if (!S_ISREG(st.st_mode)) {
482 if (delete_file(fname) != 0) {
486 /* now pretend the file didn't exist */
488 if (!dry_run) send_sums(NULL,f_out);
492 if (update_only && st.st_mtime > file->modtime) {
494 rprintf(FINFO,"%s is newer\n",fname);
498 if (skip_file(fname, file, &st)) {
499 set_perms(fname,file,&st,1);
510 send_sums(NULL,f_out);
515 fd = open(fname,O_RDONLY);
518 rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
519 rprintf(FERROR,"skipping %s\n",fname);
523 if (st.st_size > 0) {
524 buf = map_file(fd,st.st_size);
530 rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
532 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
535 rprintf(FINFO,"sending sums for %d\n",i);
541 if (buf) unmap_file(buf);
548 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
550 int i,n,remainder,len,count;
554 static char file_sum1[MD4_SUM_LENGTH];
555 static char file_sum2[MD4_SUM_LENGTH];
558 count = read_int(f_in);
560 remainder = read_int(f_in);
564 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
567 rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
569 stats.literal_data += i;
572 if (fd != -1 && write_file(fd,data,i) != i) {
573 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
581 if (i == count-1 && remainder != 0)
584 stats.matched_data += len;
587 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
588 i,len,(int)offset2,(int)offset);
590 map = map_ptr(buf,offset2,len);
595 if (fd != -1 && write_file(fd,map,len) != len) {
596 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
603 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
604 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
610 if (remote_version >= 14) {
611 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
613 rprintf(FINFO,"got file_sum\n");
614 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
621 static void delete_one(struct file_struct *f)
623 if (!S_ISDIR(f->mode)) {
624 if (do_unlink(f_name(f)) != 0) {
625 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
626 } else if (verbose) {
627 rprintf(FINFO,"deleting %s\n",f_name(f));
630 if (do_rmdir(f_name(f)) != 0) {
631 if (errno != ENOTEMPTY && errno != EEXIST)
632 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
633 } else if (verbose) {
634 rprintf(FINFO,"deleting directory %s\n",f_name(f));
641 static struct delete_list {
645 static int dlist_len, dlist_alloc_len;
647 static void add_delete_entry(struct file_struct *file)
649 if (dlist_len == dlist_alloc_len) {
650 dlist_alloc_len += 1024;
651 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
652 if (!delete_list) out_of_memory("add_delete_entry");
655 delete_list[dlist_len].dev = file->dev;
656 delete_list[dlist_len].inode = file->inode;
660 rprintf(FINFO,"added %s to delete list\n", f_name(file));
663 /* yuck! This function wouldn't have been necessary if I had the sorting
664 algorithm right. Unfortunately fixing the sorting algorithm would introduce
665 a backward incompatibility as file list indexes are sent over the link.
667 static int delete_already_done(struct file_list *flist,int j)
672 if (link_stat(f_name(flist->files[j]), &st)) return 1;
674 for (i=0;i<dlist_len;i++) {
675 if (st.st_ino == delete_list[i].inode &&
676 st.st_dev == delete_list[i].dev)
684 /* this deletes any files on the receiving side that are not present
685 on the sending side. For version 1.6.4 I have changed the behaviour
686 to match more closely what most people seem to expect of this option */
687 static void delete_files(struct file_list *flist)
689 struct file_list *local_file_list;
697 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
701 for (j=0;j<flist->count;j++) {
702 if (!S_ISDIR(flist->files[j]->mode) ||
703 !(flist->files[j]->flags & FLAG_DELETE)) continue;
705 if (remote_version < 19 &&
706 delete_already_done(flist, j)) continue;
708 name = strdup(f_name(flist->files[j]));
710 if (!(local_file_list = send_file_list(-1,1,&name))) {
716 rprintf(FINFO,"deleting in %s\n", name);
718 for (i=local_file_list->count-1;i>=0;i--) {
719 if (!local_file_list->files[i]->basename) continue;
720 if (remote_version < 19 &&
721 S_ISDIR(local_file_list->files[i]->mode))
722 add_delete_entry(local_file_list->files[i]);
723 if (-1 == flist_find(flist,local_file_list->files[i])) {
724 delete_one(local_file_list->files[i]);
727 flist_free(local_file_list);
732 static char *cleanup_fname;
734 void exit_cleanup(int code)
738 do_unlink(cleanup_fname);
739 signal(SIGUSR1, SIG_IGN);
754 static int get_tmpname(char *fnametmp, char *fname)
760 f = strrchr(fname,'/');
765 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
766 rprintf(FERROR,"filename too long\n");
769 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
773 f = strrchr(fname,'/');
775 if (strlen(fname)+9 > MAXPATHLEN) {
776 rprintf(FERROR,"filename too long\n");
782 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
786 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
792 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
797 char fnametmp[MAXPATHLEN];
798 struct map_struct *buf;
800 struct file_struct *file;
805 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
808 if (recurse && delete_mode && !local_name && flist->count>0) {
815 if (phase==0 && remote_version >= 13) {
817 csum_length = SUM_LENGTH;
819 rprintf(FINFO,"recv_files phase=%d\n",phase);
826 if (i < 0 || i >= flist->count) {
827 rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
832 file = flist->files[i];
833 fname = f_name(file);
835 stats.num_transferred_files++;
836 stats.total_transferred_size += file->length;
842 if (!am_server && verbose)
843 printf("%s\n",fname);
848 rprintf(FINFO,"recv_files(%s)\n",fname);
851 fd1 = open(fname,O_RDONLY);
853 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
854 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
855 receive_data(f_in,NULL,-1,NULL);
860 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
861 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
862 receive_data(f_in,NULL,-1,NULL);
867 if (fd1 != -1 && st.st_size > 0) {
868 buf = map_file(fd1,st.st_size);
870 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
875 if (!get_tmpname(fnametmp,fname)) {
876 if (buf) unmap_file(buf);
881 if (NULL == do_mktemp(fnametmp)) {
882 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
883 receive_data(f_in,buf,-1,NULL);
884 if (buf) unmap_file(buf);
889 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
890 if (fd2 == -1 && relative_paths && errno == ENOENT &&
891 create_directory_path(fnametmp) == 0) {
892 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
895 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
896 receive_data(f_in,buf,-1,NULL);
897 if (buf) unmap_file(buf);
902 cleanup_fname = fnametmp;
904 if (!am_server && verbose)
905 printf("%s\n",fname);
908 recv_ok = receive_data(f_in,buf,fd2,fname);
910 if (buf) unmap_file(buf);
917 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
920 char fnamebak[MAXPATHLEN];
921 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
922 rprintf(FERROR,"backup filename too long\n");
925 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
926 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
927 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
932 /* move tmp file over real file */
933 if (do_rename(fnametmp,fname) != 0) {
934 if (errno == EXDEV) {
935 /* rename failed on cross-filesystem link.
936 Copy the file instead. */
937 if (copy_file(fnametmp,fname, file->mode)) {
938 rprintf(FERROR,"copy %s -> %s : %s\n",
939 fnametmp,fname,strerror(errno));
941 set_perms(fname,file,NULL,0);
945 rprintf(FERROR,"rename %s -> %s : %s\n",
946 fnametmp,fname,strerror(errno));
950 set_perms(fname,file,NULL,0);
953 cleanup_fname = NULL;
957 if (csum_length == SUM_LENGTH) {
958 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
962 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
968 if (preserve_hard_links)
969 do_hard_links(flist);
971 /* now we need to fix any directory permissions that were
972 modified during the transfer */
973 for (i = 0; i < flist->count; i++) {
974 file = flist->files[i];
975 if (!file->basename || !S_ISDIR(file->mode)) continue;
976 recv_generator(f_name(file),flist,i,-1);
980 rprintf(FINFO,"recv_files finished\n");
987 void send_files(struct file_list *flist,int f_out,int f_in)
990 struct sum_struct *s;
991 struct map_struct *buf;
993 char fname[MAXPATHLEN];
995 struct file_struct *file;
999 rprintf(FINFO,"send_files starting\n");
1001 setup_readbuffer(f_in);
1008 if (phase==0 && remote_version >= 13) {
1010 csum_length = SUM_LENGTH;
1011 write_int(f_out,-1);
1013 rprintf(FINFO,"send_files phase=%d\n",phase);
1019 if (i < 0 || i >= flist->count) {
1020 rprintf(FERROR,"Invalid file index %d (count=%d)\n",
1025 file = flist->files[i];
1027 stats.num_transferred_files++;
1028 stats.total_transferred_size += file->length;
1031 if (file->basedir) {
1032 strlcpy(fname,file->basedir,MAXPATHLEN-1);
1033 if (strlen(fname) == MAXPATHLEN-1) {
1035 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1039 strlcat(fname,"/",MAXPATHLEN-1);
1040 offset = strlen(file->basedir)+1;
1042 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1045 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1048 if (!am_server && verbose)
1049 printf("%s\n",fname);
1054 s = receive_sums(f_in);
1057 rprintf(FERROR,"receive_sums failed\n");
1061 fd = open(fname,O_RDONLY);
1064 rprintf(FERROR,"send_files failed to open %s: %s\n",
1065 fname,strerror(errno));
1070 /* map the local file */
1071 if (do_fstat(fd,&st) != 0) {
1073 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1079 if (st.st_size > 0) {
1080 buf = map_file(fd,st.st_size);
1086 rprintf(FINFO,"send_files mapped %s of size %d\n",
1087 fname,(int)st.st_size);
1091 write_int(f_out,s->count);
1092 write_int(f_out,s->n);
1093 write_int(f_out,s->remainder);
1096 rprintf(FINFO,"calling match_sums %s\n",fname);
1098 if (!am_server && verbose)
1099 printf("%s\n",fname+offset);
1101 match_sums(f_out,s,buf,st.st_size);
1103 if (buf) unmap_file(buf);
1109 rprintf(FINFO,"sender finished %s\n",fname);
1113 rprintf(FINFO,"send files finished\n");
1117 write_int(f_out,-1);
1122 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1128 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1129 (int)getpid(),flist->count);
1131 for (i = 0; i < flist->count; i++) {
1132 struct file_struct *file = flist->files[i];
1133 mode_t saved_mode = file->mode;
1134 if (!file->basename) continue;
1136 /* we need to ensure that any directories we create have writeable
1137 permissions initially so that we can create the files within
1138 them. This is then fixed after the files are transferred */
1139 if (!am_root && S_ISDIR(file->mode)) {
1140 file->mode |= S_IWUSR; /* user write */
1143 recv_generator(local_name?local_name:f_name(file),
1146 file->mode = saved_mode;
1150 csum_length = SUM_LENGTH;
1154 rprintf(FINFO,"generate_files phase=%d\n",phase);
1158 /* we expect to just sit around now, so don't exit on a timeout. If we
1159 really get a timeout then the other process should exit */
1162 if (remote_version >= 13) {
1163 /* in newer versions of the protocol the files can cycle through
1164 the system more than once to catch initial checksum errors */
1165 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1166 struct file_struct *file = flist->files[i];
1167 recv_generator(local_name?local_name:f_name(file),
1173 rprintf(FINFO,"generate_files phase=%d\n",phase);