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 static 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 static 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,
583 int i,n,remainder,len,count;
587 static char file_sum1[MD4_SUM_LENGTH];
588 static char file_sum2[MD4_SUM_LENGTH];
591 count = read_int(f_in);
593 remainder = read_int(f_in);
597 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
599 show_progress(offset, total_size);
603 rprintf(FINFO,"data recv %d at %d\n",
607 stats.literal_data += i;
608 cleanup_got_literal = 1;
612 if (fd != -1 && write_file(fd,data,i) != i) {
613 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
623 if (i == count-1 && remainder != 0)
626 stats.matched_data += len;
629 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
630 i,len,(int)offset2,(int)offset);
632 map = map_ptr(buf,offset2,len);
637 if (fd != -1 && write_file(fd,map,len) != len) {
638 rprintf(FERROR,"write failed on %s : %s\n",
639 fname,strerror(errno));
647 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
648 rprintf(FERROR,"write failed on %s : %s\n",
649 fname,strerror(errno));
655 if (remote_version >= 14) {
656 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
658 rprintf(FINFO,"got file_sum\n");
661 memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0) {
669 static void delete_one(struct file_struct *f)
671 if (!S_ISDIR(f->mode)) {
672 if (do_unlink(f_name(f)) != 0) {
673 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
674 } else if (verbose) {
675 rprintf(FINFO,"deleting %s\n",f_name(f));
678 if (do_rmdir(f_name(f)) != 0) {
679 if (errno != ENOTEMPTY && errno != EEXIST)
680 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
681 } else if (verbose) {
682 rprintf(FINFO,"deleting directory %s\n",f_name(f));
689 static struct delete_list {
693 static int dlist_len, dlist_alloc_len;
695 static void add_delete_entry(struct file_struct *file)
697 if (dlist_len == dlist_alloc_len) {
698 dlist_alloc_len += 1024;
699 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
700 if (!delete_list) out_of_memory("add_delete_entry");
703 delete_list[dlist_len].dev = file->dev;
704 delete_list[dlist_len].inode = file->inode;
708 rprintf(FINFO,"added %s to delete list\n", f_name(file));
711 /* yuck! This function wouldn't have been necessary if I had the sorting
712 algorithm right. Unfortunately fixing the sorting algorithm would introduce
713 a backward incompatibility as file list indexes are sent over the link.
715 static int delete_already_done(struct file_list *flist,int j)
720 if (link_stat(f_name(flist->files[j]), &st)) return 1;
722 for (i=0;i<dlist_len;i++) {
723 if (st.st_ino == delete_list[i].inode &&
724 st.st_dev == delete_list[i].dev)
732 /* this deletes any files on the receiving side that are not present
733 on the sending side. For version 1.6.4 I have changed the behaviour
734 to match more closely what most people seem to expect of this option */
735 static void delete_files(struct file_list *flist)
737 struct file_list *local_file_list;
745 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
749 for (j=0;j<flist->count;j++) {
750 if (!S_ISDIR(flist->files[j]->mode) ||
751 !(flist->files[j]->flags & FLAG_DELETE)) continue;
753 if (remote_version < 19 &&
754 delete_already_done(flist, j)) continue;
756 name = strdup(f_name(flist->files[j]));
758 if (!(local_file_list = send_file_list(-1,1,&name))) {
764 rprintf(FINFO,"deleting in %s\n", name);
766 for (i=local_file_list->count-1;i>=0;i--) {
767 if (!local_file_list->files[i]->basename) continue;
768 if (remote_version < 19 &&
769 S_ISDIR(local_file_list->files[i]->mode))
770 add_delete_entry(local_file_list->files[i]);
771 if (-1 == flist_find(flist,local_file_list->files[i])) {
772 delete_one(local_file_list->files[i]);
775 flist_free(local_file_list);
788 static int get_tmpname(char *fnametmp, char *fname)
794 f = strrchr(fname,'/');
799 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
800 rprintf(FERROR,"filename too long\n");
803 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
807 f = strrchr(fname,'/');
809 if (strlen(fname)+9 > MAXPATHLEN) {
810 rprintf(FERROR,"filename too long\n");
816 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
820 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
826 /* finish off a file transfer, renaming the file and setting the permissions
828 static void finish_transfer(char *fname, char *fnametmp, struct file_struct *file)
831 char fnamebak[MAXPATHLEN];
832 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
833 rprintf(FERROR,"backup filename too long\n");
836 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
837 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
838 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
843 /* move tmp file over real file */
844 if (do_rename(fnametmp,fname) != 0) {
845 if (errno == EXDEV) {
846 /* rename failed on cross-filesystem link.
847 Copy the file instead. */
848 if (copy_file(fnametmp,fname, file->mode)) {
849 rprintf(FERROR,"copy %s -> %s : %s\n",
850 fnametmp,fname,strerror(errno));
852 set_perms(fname,file,NULL,0);
856 rprintf(FERROR,"rename %s -> %s : %s\n",
857 fnametmp,fname,strerror(errno));
861 set_perms(fname,file,NULL,0);
866 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
871 char fnametmp[MAXPATHLEN];
872 struct map_struct *buf;
874 struct file_struct *file;
879 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
882 if (recurse && delete_mode && !local_name && flist->count>0) {
887 cleanup_fname = NULL;
888 cleanup_got_literal = 0;
892 if (phase==0 && remote_version >= 13) {
894 csum_length = SUM_LENGTH;
896 rprintf(FINFO,"recv_files phase=%d\n",phase);
903 if (i < 0 || i >= flist->count) {
904 rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
909 file = flist->files[i];
910 fname = f_name(file);
912 stats.num_transferred_files++;
913 stats.total_transferred_size += file->length;
919 if (!am_server && verbose)
920 rprintf(FINFO,"%s\n",fname);
925 rprintf(FINFO,"recv_files(%s)\n",fname);
928 fd1 = open(fname,O_RDONLY);
930 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
931 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
932 receive_data(f_in,NULL,-1,NULL,file->length);
937 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
938 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
939 receive_data(f_in,NULL,-1,NULL,file->length);
944 if (fd1 != -1 && st.st_size > 0) {
945 buf = map_file(fd1,st.st_size);
947 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
952 if (!get_tmpname(fnametmp,fname)) {
953 if (buf) unmap_file(buf);
958 if (NULL == do_mktemp(fnametmp)) {
959 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
960 receive_data(f_in,buf,-1,NULL,file->length);
961 if (buf) unmap_file(buf);
966 /* we initially set the perms without the
967 setuid/setgid bits to ensure that there is no race
968 condition. They are then correctly updated after
969 the lchown. Thanks to snabb@epipe.fi for pointing
971 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
972 file->mode & ACCESSPERMS);
974 if (fd2 == -1 && relative_paths && errno == ENOENT &&
975 create_directory_path(fnametmp) == 0) {
976 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
977 file->mode & ACCESSPERMS);
980 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
981 receive_data(f_in,buf,-1,NULL,file->length);
982 if (buf) unmap_file(buf);
987 cleanup_fname = fnametmp;
988 cleanup_new_fname = fname;
991 if (!am_server && verbose)
992 rprintf(FINFO,"%s\n",fname);
995 recv_ok = receive_data(f_in,buf,fd2,fname,file->length);
997 if (buf) unmap_file(buf);
1004 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
1006 finish_transfer(fname, fnametmp, file);
1008 cleanup_fname = NULL;
1011 if (csum_length == SUM_LENGTH) {
1012 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
1016 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
1022 if (preserve_hard_links)
1023 do_hard_links(flist);
1025 /* now we need to fix any directory permissions that were
1026 modified during the transfer */
1027 for (i = 0; i < flist->count; i++) {
1028 file = flist->files[i];
1029 if (!file->basename || !S_ISDIR(file->mode)) continue;
1030 recv_generator(f_name(file),flist,i,-1);
1034 rprintf(FINFO,"recv_files finished\n");
1041 void send_files(struct file_list *flist,int f_out,int f_in)
1044 struct sum_struct *s;
1045 struct map_struct *buf;
1047 char fname[MAXPATHLEN];
1049 struct file_struct *file;
1053 rprintf(FINFO,"send_files starting\n");
1055 setup_readbuffer(f_in);
1062 if (phase==0 && remote_version >= 13) {
1064 csum_length = SUM_LENGTH;
1065 write_int(f_out,-1);
1067 rprintf(FINFO,"send_files phase=%d\n",phase);
1073 if (i < 0 || i >= flist->count) {
1074 rprintf(FERROR,"Invalid file index %d (count=%d)\n",
1079 file = flist->files[i];
1081 stats.num_transferred_files++;
1082 stats.total_transferred_size += file->length;
1085 if (file->basedir) {
1086 strlcpy(fname,file->basedir,MAXPATHLEN-1);
1087 if (strlen(fname) == MAXPATHLEN-1) {
1089 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1093 strlcat(fname,"/",MAXPATHLEN-1);
1094 offset = strlen(file->basedir)+1;
1096 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1099 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1102 if (!am_server && verbose)
1103 rprintf(FINFO,"%s\n",fname);
1108 s = receive_sums(f_in);
1111 rprintf(FERROR,"receive_sums failed\n");
1115 fd = open(fname,O_RDONLY);
1118 rprintf(FERROR,"send_files failed to open %s: %s\n",
1119 fname,strerror(errno));
1124 /* map the local file */
1125 if (do_fstat(fd,&st) != 0) {
1127 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1133 if (st.st_size > 0) {
1134 buf = map_file(fd,st.st_size);
1140 rprintf(FINFO,"send_files mapped %s of size %d\n",
1141 fname,(int)st.st_size);
1145 write_int(f_out,s->count);
1146 write_int(f_out,s->n);
1147 write_int(f_out,s->remainder);
1150 rprintf(FINFO,"calling match_sums %s\n",fname);
1152 if (!am_server && verbose)
1153 rprintf(FINFO,"%s\n",fname+offset);
1155 match_sums(f_out,s,buf,st.st_size);
1157 if (buf) unmap_file(buf);
1163 rprintf(FINFO,"sender finished %s\n",fname);
1167 rprintf(FINFO,"send files finished\n");
1171 write_int(f_out,-1);
1176 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1182 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1183 (int)getpid(),flist->count);
1185 for (i = 0; i < flist->count; i++) {
1186 struct file_struct *file = flist->files[i];
1187 mode_t saved_mode = file->mode;
1188 if (!file->basename) continue;
1190 /* we need to ensure that any directories we create have writeable
1191 permissions initially so that we can create the files within
1192 them. This is then fixed after the files are transferred */
1193 if (!am_root && S_ISDIR(file->mode)) {
1194 file->mode |= S_IWUSR; /* user write */
1197 recv_generator(local_name?local_name:f_name(file),
1200 file->mode = saved_mode;
1204 csum_length = SUM_LENGTH;
1208 rprintf(FINFO,"generate_files phase=%d\n",phase);
1212 /* we expect to just sit around now, so don't exit on a timeout. If we
1213 really get a timeout then the other process should exit */
1216 if (remote_version >= 13) {
1217 /* in newer versions of the protocol the files can cycle through
1218 the system more than once to catch initial checksum errors */
1219 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1220 struct file_struct *file = flist->files[i];
1221 recv_generator(local_name?local_name:f_name(file),
1227 rprintf(FINFO,"generate_files phase=%d\n",phase);