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;
57 /* handling the cleanup when a transfer is interrupted is tricky when
58 --partial is selected. We need to ensure that the partial file is
59 kept if any real data has been transferred */
60 static int cleanup_got_literal;
61 static char *cleanup_fname;
62 static char *cleanup_new_fname;
63 static struct file_struct *cleanup_file;
64 static void finish_transfer(char *fname, char *fnametmp, struct file_struct *file);
66 void exit_cleanup(int code)
68 extern int keep_partial;
70 signal(SIGUSR1, SIG_IGN);
72 if (cleanup_got_literal && cleanup_fname && keep_partial) {
73 char *fname = cleanup_fname;
75 finish_transfer(cleanup_new_fname, fname, cleanup_file);
79 do_unlink(cleanup_fname);
90 static void free_sums(struct sum_struct *s)
92 if (s->sums) free(s->sums);
98 * delete a file or directory. If force_delet is set then delete
101 static int delete_file(char *fname)
105 char buf[MAXPATHLEN];
106 extern int force_delete;
111 if (do_unlink(fname) == 0 || errno == ENOENT) return 0;
114 ret = do_lstat(fname, &st);
116 ret = do_stat(fname, &st);
119 rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
123 if (!S_ISDIR(st.st_mode)) {
124 rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno));
128 if (do_rmdir(fname) == 0 || errno == ENOENT) return 0;
129 if (!force_delete || !recurse ||
130 (errno != ENOTEMPTY && errno != EEXIST)) {
131 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
135 /* now we do a recsursive delete on the directory ... */
138 rprintf(FERROR,"opendir(%s): %s\n",
139 fname,strerror(errno));
143 for (di=readdir(d); di; di=readdir(d)) {
144 char *dname = d_name(di);
145 if (strcmp(dname,".")==0 ||
146 strcmp(dname,"..")==0)
148 slprintf(buf, sizeof(buf)-1, "%s/%s", fname, dname);
150 rprintf(FINFO,"deleting %s\n", buf);
151 if (delete_file(buf) != 0) {
159 if (do_rmdir(fname) != 0) {
160 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
168 send a sums struct down a fd
170 static void send_sums(struct sum_struct *s,int f_out)
174 /* tell the other guy how many we are going to be doing and how many
175 bytes there are in the last chunk */
176 write_int(f_out,s?s->count:0);
177 write_int(f_out,s?s->n:block_size);
178 write_int(f_out,s?s->remainder:0);
180 for (i=0;i<s->count;i++) {
181 write_int(f_out,s->sums[i].sum1);
182 write_buf(f_out,s->sums[i].sum2,csum_length);
188 generate a stream of signatures/checksums that describe a buffer
190 generate approximately one checksum every n bytes
192 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
195 struct sum_struct *s;
198 int remainder = (len%block_len);
201 count = (len+(block_len-1))/block_len;
203 s = (struct sum_struct *)malloc(sizeof(*s));
204 if (!s) out_of_memory("generate_sums");
207 s->remainder = remainder;
217 rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
218 s->count,s->remainder,s->n,(int)s->flength);
220 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
221 if (!s->sums) out_of_memory("generate_sums");
223 for (i=0;i<count;i++) {
225 char *map = map_ptr(buf,offset,n1);
227 s->sums[i].sum1 = get_checksum1(map,n1);
228 get_checksum2(map,n1,s->sums[i].sum2);
230 s->sums[i].offset = offset;
235 rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
236 i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
247 receive the checksums for a buffer
249 static struct sum_struct *receive_sums(int f)
251 struct sum_struct *s;
255 s = (struct sum_struct *)malloc(sizeof(*s));
256 if (!s) out_of_memory("receive_sums");
258 s->count = read_int(f);
260 s->remainder = read_int(f);
264 rprintf(FINFO,"count=%d n=%d rem=%d\n",
265 s->count,s->n,s->remainder);
270 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
271 if (!s->sums) out_of_memory("receive_sums");
273 for (i=0;i<s->count;i++) {
274 s->sums[i].sum1 = read_int(f);
275 read_buf(f,s->sums[i].sum2,csum_length);
277 s->sums[i].offset = offset;
280 if (i == s->count-1 && s->remainder != 0) {
281 s->sums[i].len = s->remainder;
283 s->sums[i].len = s->n;
285 offset += s->sums[i].len;
288 rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
289 i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
298 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
303 extern int am_daemon;
305 if (dry_run) return 0;
308 if (link_stat(fname,&st2) != 0) {
309 rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
315 if (preserve_times && !S_ISLNK(st->st_mode) &&
316 st->st_mtime != file->modtime) {
318 if (set_modtime(fname,file->modtime) != 0) {
319 rprintf(FERROR,"failed to set times on %s : %s\n",
320 fname,strerror(errno));
325 if ((am_root || !am_daemon) &&
326 ((am_root && preserve_uid && st->st_uid != file->uid) ||
327 (preserve_gid && st->st_gid != file->gid))) {
329 (am_root&&preserve_uid)?file->uid:-1,
330 preserve_gid?file->gid:-1) != 0) {
331 if (preserve_uid && st->st_uid != file->uid)
333 if (verbose>1 || preserve_uid) {
334 rprintf(FERROR,"chown %s : %s\n",
335 fname,strerror(errno));
344 if (preserve_perms && !S_ISLNK(st->st_mode) &&
345 (st->st_mode != file->mode ||
346 (updated && (file->mode & ~ACCESSPERMS)))) {
348 if (do_chmod(fname,file->mode) != 0) {
349 rprintf(FERROR,"failed to set permissions on %s : %s\n",
350 fname,strerror(errno));
356 if (verbose > 1 && report) {
358 rprintf(FINFO,"%s\n",fname);
360 rprintf(FINFO,"%s is uptodate\n",fname);
366 /* choose whether to skip a particular file */
367 static int skip_file(char *fname,
368 struct file_struct *file, STRUCT_STAT *st)
370 if (st->st_size != file->length) {
374 /* if always checksum is set then we use the checksum instead
375 of the file time to determine whether to sync */
376 if (always_checksum && S_ISREG(st->st_mode)) {
377 char sum[MD4_SUM_LENGTH];
378 file_checksum(fname,sum,st->st_size);
379 return (memcmp(sum,file->sum,csum_length) == 0);
386 return (st->st_mtime == file->modtime);
390 /* use a larger block size for really big files */
391 int adapt_block_size(struct file_struct *file, int bsize)
395 if (bsize != BLOCK_SIZE) return bsize;
397 ret = file->length / (10000); /* rough heuristic */
398 ret = ret & ~15; /* multiple of 16 */
399 if (ret < bsize) ret = bsize;
400 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
404 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
408 struct map_struct *buf;
409 struct sum_struct *s;
411 struct file_struct *file = flist->files[i];
414 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
416 statret = link_stat(fname,&st);
418 if (S_ISDIR(file->mode)) {
420 if (statret == 0 && !S_ISDIR(st.st_mode)) {
421 if (do_unlink(fname) != 0) {
422 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
427 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
428 if (!(relative_paths && errno==ENOENT &&
429 create_directory_path(fname)==0 &&
430 do_mkdir(fname,file->mode)==0)) {
431 rprintf(FERROR,"mkdir %s : %s (2)\n",
432 fname,strerror(errno));
435 if (set_perms(fname,file,NULL,0) && verbose)
436 rprintf(FINFO,"%s/\n",fname);
440 if (preserve_links && S_ISLNK(file->mode)) {
442 char lnk[MAXPATHLEN];
445 l = readlink(fname,lnk,MAXPATHLEN-1);
448 if (strcmp(lnk,file->link) == 0) {
449 set_perms(fname,file,&st,1);
455 if (do_symlink(file->link,fname) != 0) {
456 rprintf(FERROR,"link %s -> %s : %s\n",
457 fname,file->link,strerror(errno));
459 set_perms(fname,file,NULL,0);
461 rprintf(FINFO,"%s -> %s\n",
469 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
471 st.st_mode != file->mode ||
472 st.st_rdev != file->rdev) {
475 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
476 fname,(int)file->mode,(int)file->rdev);
477 if (do_mknod(fname,file->mode,file->rdev) != 0) {
478 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
480 set_perms(fname,file,NULL,0);
482 rprintf(FINFO,"%s\n",fname);
485 set_perms(fname,file,&st,1);
491 if (preserve_hard_links && check_hard_link(file)) {
493 rprintf(FINFO,"%s is a hard link\n",f_name(file));
497 if (!S_ISREG(file->mode)) {
498 rprintf(FINFO,"skipping non-regular file %s\n",fname);
503 if (errno == ENOENT) {
505 if (!dry_run) send_sums(NULL,f_out);
508 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
513 if (!S_ISREG(st.st_mode)) {
514 if (delete_file(fname) != 0) {
518 /* now pretend the file didn't exist */
520 if (!dry_run) send_sums(NULL,f_out);
524 if (update_only && st.st_mtime > file->modtime) {
526 rprintf(FINFO,"%s is newer\n",fname);
530 if (skip_file(fname, file, &st)) {
531 set_perms(fname,file,&st,1);
542 send_sums(NULL,f_out);
547 fd = open(fname,O_RDONLY);
550 rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
551 rprintf(FERROR,"skipping %s\n",fname);
555 if (st.st_size > 0) {
556 buf = map_file(fd,st.st_size);
562 rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
564 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
567 rprintf(FINFO,"sending sums for %d\n",i);
573 if (buf) unmap_file(buf);
580 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
582 int i,n,remainder,len,count;
586 static char file_sum1[MD4_SUM_LENGTH];
587 static char file_sum2[MD4_SUM_LENGTH];
590 count = read_int(f_in);
592 remainder = read_int(f_in);
596 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
599 rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
601 stats.literal_data += i;
602 cleanup_got_literal = 1;
606 if (fd != -1 && write_file(fd,data,i) != i) {
607 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
615 if (i == count-1 && remainder != 0)
618 stats.matched_data += len;
621 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
622 i,len,(int)offset2,(int)offset);
624 map = map_ptr(buf,offset2,len);
629 if (fd != -1 && write_file(fd,map,len) != len) {
630 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
637 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
638 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
644 if (remote_version >= 14) {
645 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
647 rprintf(FINFO,"got file_sum\n");
648 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
655 static void delete_one(struct file_struct *f)
657 if (!S_ISDIR(f->mode)) {
658 if (do_unlink(f_name(f)) != 0) {
659 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
660 } else if (verbose) {
661 rprintf(FINFO,"deleting %s\n",f_name(f));
664 if (do_rmdir(f_name(f)) != 0) {
665 if (errno != ENOTEMPTY && errno != EEXIST)
666 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
667 } else if (verbose) {
668 rprintf(FINFO,"deleting directory %s\n",f_name(f));
675 static struct delete_list {
679 static int dlist_len, dlist_alloc_len;
681 static void add_delete_entry(struct file_struct *file)
683 if (dlist_len == dlist_alloc_len) {
684 dlist_alloc_len += 1024;
685 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
686 if (!delete_list) out_of_memory("add_delete_entry");
689 delete_list[dlist_len].dev = file->dev;
690 delete_list[dlist_len].inode = file->inode;
694 rprintf(FINFO,"added %s to delete list\n", f_name(file));
697 /* yuck! This function wouldn't have been necessary if I had the sorting
698 algorithm right. Unfortunately fixing the sorting algorithm would introduce
699 a backward incompatibility as file list indexes are sent over the link.
701 static int delete_already_done(struct file_list *flist,int j)
706 if (link_stat(f_name(flist->files[j]), &st)) return 1;
708 for (i=0;i<dlist_len;i++) {
709 if (st.st_ino == delete_list[i].inode &&
710 st.st_dev == delete_list[i].dev)
718 /* this deletes any files on the receiving side that are not present
719 on the sending side. For version 1.6.4 I have changed the behaviour
720 to match more closely what most people seem to expect of this option */
721 static void delete_files(struct file_list *flist)
723 struct file_list *local_file_list;
731 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
735 for (j=0;j<flist->count;j++) {
736 if (!S_ISDIR(flist->files[j]->mode) ||
737 !(flist->files[j]->flags & FLAG_DELETE)) continue;
739 if (remote_version < 19 &&
740 delete_already_done(flist, j)) continue;
742 name = strdup(f_name(flist->files[j]));
744 if (!(local_file_list = send_file_list(-1,1,&name))) {
750 rprintf(FINFO,"deleting in %s\n", name);
752 for (i=local_file_list->count-1;i>=0;i--) {
753 if (!local_file_list->files[i]->basename) continue;
754 if (remote_version < 19 &&
755 S_ISDIR(local_file_list->files[i]->mode))
756 add_delete_entry(local_file_list->files[i]);
757 if (-1 == flist_find(flist,local_file_list->files[i])) {
758 delete_one(local_file_list->files[i]);
761 flist_free(local_file_list);
774 static int get_tmpname(char *fnametmp, char *fname)
780 f = strrchr(fname,'/');
785 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
786 rprintf(FERROR,"filename too long\n");
789 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
793 f = strrchr(fname,'/');
795 if (strlen(fname)+9 > MAXPATHLEN) {
796 rprintf(FERROR,"filename too long\n");
802 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
806 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
812 /* finish off a file transfer, renaming the file and setting the permissions
814 static void finish_transfer(char *fname, char *fnametmp, struct file_struct *file)
817 char fnamebak[MAXPATHLEN];
818 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
819 rprintf(FERROR,"backup filename too long\n");
822 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
823 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
824 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
829 /* move tmp file over real file */
830 if (do_rename(fnametmp,fname) != 0) {
831 if (errno == EXDEV) {
832 /* rename failed on cross-filesystem link.
833 Copy the file instead. */
834 if (copy_file(fnametmp,fname, file->mode)) {
835 rprintf(FERROR,"copy %s -> %s : %s\n",
836 fnametmp,fname,strerror(errno));
838 set_perms(fname,file,NULL,0);
842 rprintf(FERROR,"rename %s -> %s : %s\n",
843 fnametmp,fname,strerror(errno));
847 set_perms(fname,file,NULL,0);
852 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
857 char fnametmp[MAXPATHLEN];
858 struct map_struct *buf;
860 struct file_struct *file;
865 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
868 if (recurse && delete_mode && !local_name && flist->count>0) {
873 cleanup_fname = NULL;
874 cleanup_got_literal = 0;
878 if (phase==0 && remote_version >= 13) {
880 csum_length = SUM_LENGTH;
882 rprintf(FINFO,"recv_files phase=%d\n",phase);
889 if (i < 0 || i >= flist->count) {
890 rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
895 file = flist->files[i];
896 fname = f_name(file);
898 stats.num_transferred_files++;
899 stats.total_transferred_size += file->length;
905 if (!am_server && verbose)
906 printf("%s\n",fname);
911 rprintf(FINFO,"recv_files(%s)\n",fname);
914 fd1 = open(fname,O_RDONLY);
916 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
917 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
918 receive_data(f_in,NULL,-1,NULL);
923 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
924 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
925 receive_data(f_in,NULL,-1,NULL);
930 if (fd1 != -1 && st.st_size > 0) {
931 buf = map_file(fd1,st.st_size);
933 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
938 if (!get_tmpname(fnametmp,fname)) {
939 if (buf) unmap_file(buf);
944 if (NULL == do_mktemp(fnametmp)) {
945 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
946 receive_data(f_in,buf,-1,NULL);
947 if (buf) unmap_file(buf);
952 /* we initially set the perms without the
953 setuid/setgid bits to ensure that there is no race
954 condition. They are then correctly updated after
955 the lchown. Thanks to snabb@epipe.fi for pointing
957 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
958 file->mode & ACCESSPERMS);
960 if (fd2 == -1 && relative_paths && errno == ENOENT &&
961 create_directory_path(fnametmp) == 0) {
962 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
963 file->mode & ACCESSPERMS);
966 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
967 receive_data(f_in,buf,-1,NULL);
968 if (buf) unmap_file(buf);
973 cleanup_fname = fnametmp;
974 cleanup_new_fname = fname;
977 if (!am_server && verbose)
978 printf("%s\n",fname);
981 recv_ok = receive_data(f_in,buf,fd2,fname);
983 if (buf) unmap_file(buf);
990 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
992 finish_transfer(fname, fnametmp, file);
994 cleanup_fname = NULL;
997 if (csum_length == SUM_LENGTH) {
998 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
1002 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
1008 if (preserve_hard_links)
1009 do_hard_links(flist);
1011 /* now we need to fix any directory permissions that were
1012 modified during the transfer */
1013 for (i = 0; i < flist->count; i++) {
1014 file = flist->files[i];
1015 if (!file->basename || !S_ISDIR(file->mode)) continue;
1016 recv_generator(f_name(file),flist,i,-1);
1020 rprintf(FINFO,"recv_files finished\n");
1027 void send_files(struct file_list *flist,int f_out,int f_in)
1030 struct sum_struct *s;
1031 struct map_struct *buf;
1033 char fname[MAXPATHLEN];
1035 struct file_struct *file;
1039 rprintf(FINFO,"send_files starting\n");
1041 setup_readbuffer(f_in);
1048 if (phase==0 && remote_version >= 13) {
1050 csum_length = SUM_LENGTH;
1051 write_int(f_out,-1);
1053 rprintf(FINFO,"send_files phase=%d\n",phase);
1059 if (i < 0 || i >= flist->count) {
1060 rprintf(FERROR,"Invalid file index %d (count=%d)\n",
1065 file = flist->files[i];
1067 stats.num_transferred_files++;
1068 stats.total_transferred_size += file->length;
1071 if (file->basedir) {
1072 strlcpy(fname,file->basedir,MAXPATHLEN-1);
1073 if (strlen(fname) == MAXPATHLEN-1) {
1075 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1079 strlcat(fname,"/",MAXPATHLEN-1);
1080 offset = strlen(file->basedir)+1;
1082 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1085 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1088 if (!am_server && verbose)
1089 printf("%s\n",fname);
1094 s = receive_sums(f_in);
1097 rprintf(FERROR,"receive_sums failed\n");
1101 fd = open(fname,O_RDONLY);
1104 rprintf(FERROR,"send_files failed to open %s: %s\n",
1105 fname,strerror(errno));
1110 /* map the local file */
1111 if (do_fstat(fd,&st) != 0) {
1113 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1119 if (st.st_size > 0) {
1120 buf = map_file(fd,st.st_size);
1126 rprintf(FINFO,"send_files mapped %s of size %d\n",
1127 fname,(int)st.st_size);
1131 write_int(f_out,s->count);
1132 write_int(f_out,s->n);
1133 write_int(f_out,s->remainder);
1136 rprintf(FINFO,"calling match_sums %s\n",fname);
1138 if (!am_server && verbose)
1139 printf("%s\n",fname+offset);
1141 match_sums(f_out,s,buf,st.st_size);
1143 if (buf) unmap_file(buf);
1149 rprintf(FINFO,"sender finished %s\n",fname);
1153 rprintf(FINFO,"send files finished\n");
1157 write_int(f_out,-1);
1162 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1168 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1169 (int)getpid(),flist->count);
1171 for (i = 0; i < flist->count; i++) {
1172 struct file_struct *file = flist->files[i];
1173 mode_t saved_mode = file->mode;
1174 if (!file->basename) continue;
1176 /* we need to ensure that any directories we create have writeable
1177 permissions initially so that we can create the files within
1178 them. This is then fixed after the files are transferred */
1179 if (!am_root && S_ISDIR(file->mode)) {
1180 file->mode |= S_IWUSR; /* user write */
1183 recv_generator(local_name?local_name:f_name(file),
1186 file->mode = saved_mode;
1190 csum_length = SUM_LENGTH;
1194 rprintf(FINFO,"generate_files phase=%d\n",phase);
1198 /* we expect to just sit around now, so don't exit on a timeout. If we
1199 really get a timeout then the other process should exit */
1202 if (remote_version >= 13) {
1203 /* in newer versions of the protocol the files can cycle through
1204 the system more than once to catch initial checksum errors */
1205 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1206 struct file_struct *file = flist->files[i];
1207 recv_generator(local_name?local_name:f_name(file),
1213 rprintf(FINFO,"generate_files phase=%d\n",phase);