added --stats option for verbose stats on the file transfer
[rsync.git] / rsync.c
1 /* 
2    Copyright (C) Andrew Tridgell 1996
3    Copyright (C) Paul Mackerras 1996
4    
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.
9    
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.
14    
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.
18 */
19
20 #include "rsync.h"
21
22 extern int csum_length;
23
24 extern int verbose;
25 extern int am_server;
26 extern int always_checksum;
27 extern time_t starttime;
28
29 extern int remote_version;
30
31 extern char *backup_suffix;
32 extern char *tmpdir;
33
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;
45 extern int dry_run;
46 extern int ignore_times;
47 extern int recurse;
48 extern int delete_mode;
49 extern int cvs_exclude;
50 extern int am_root;
51 extern int relative_paths;
52 extern int io_timeout;
53 extern int io_error;
54 extern struct stats stats;
55
56 /*
57   free a sums struct
58   */
59 static void free_sums(struct sum_struct *s)
60 {
61   if (s->sums) free(s->sums);
62   free(s);
63 }
64
65
66 /*
67  * delete a file or directory. If force_delet is set then delete 
68  * recursively 
69  */
70 static int delete_file(char *fname)
71 {
72         DIR *d;
73         struct dirent *di;
74         char buf[MAXPATHLEN];
75         extern int force_delete;
76         STRUCT_STAT st;
77         int ret;
78         extern int recurse;
79
80         if (do_unlink(fname) == 0 || errno == ENOENT) return 0;
81
82 #if SUPPORT_LINKS
83         ret = do_lstat(fname, &st);
84 #else
85         ret = do_stat(fname, &st);
86 #endif
87         if (ret) {
88                 rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
89                 return -1;
90         }
91
92         if (!S_ISDIR(st.st_mode)) {
93                 rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno));
94                 return -1;
95         }
96
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));
101                 return -1;
102         }
103
104         /* now we do a recsursive delete on the directory ... */
105         d = opendir(fname);
106         if (!d) {
107                 rprintf(FERROR,"opendir(%s): %s\n",
108                         fname,strerror(errno));
109                 return -1;
110         }
111
112         for (di=readdir(d); di; di=readdir(d)) {
113                 char *dname = d_name(di);
114                 if (strcmp(dname,".")==0 ||
115                     strcmp(dname,"..")==0)
116                         continue;
117                 slprintf(buf, sizeof(buf)-1, "%s/%s", fname, dname);
118                 if (verbose > 0)
119                         rprintf(FINFO,"deleting %s\n", buf);
120                 if (delete_file(buf) != 0) {
121                         closedir(d);
122                         return -1;
123                 }
124         }       
125
126         closedir(d);
127         
128         if (do_rmdir(fname) != 0) {
129                 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
130                 return -1;
131         }
132
133         return 0;
134 }
135
136 /*
137   send a sums struct down a fd
138   */
139 static void send_sums(struct sum_struct *s,int f_out)
140 {
141   int i;
142
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);
148   if (s)
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);
152     }
153 }
154
155
156 /*
157   generate a stream of signatures/checksums that describe a buffer
158
159   generate approximately one checksum every n bytes
160   */
161 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
162 {
163   int i;
164   struct sum_struct *s;
165   int count;
166   int block_len = n;
167   int remainder = (len%block_len);
168   OFF_T offset = 0;
169
170   count = (len+(block_len-1))/block_len;
171
172   s = (struct sum_struct *)malloc(sizeof(*s));
173   if (!s) out_of_memory("generate_sums");
174
175   s->count = count;
176   s->remainder = remainder;
177   s->n = n;
178   s->flength = len;
179
180   if (count==0) {
181     s->sums = NULL;
182     return s;
183   }
184
185   if (verbose > 3)
186     rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
187             s->count,s->remainder,s->n,(int)s->flength);
188
189   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
190   if (!s->sums) out_of_memory("generate_sums");
191   
192   for (i=0;i<count;i++) {
193     int n1 = MIN(len,n);
194     char *map = map_ptr(buf,offset,n1);
195
196     s->sums[i].sum1 = get_checksum1(map,n1);
197     get_checksum2(map,n1,s->sums[i].sum2);
198
199     s->sums[i].offset = offset;
200     s->sums[i].len = n1;
201     s->sums[i].i = i;
202
203     if (verbose > 3)
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);
206
207     len -= n1;
208     offset += n1;
209   }
210
211   return s;
212 }
213
214
215 /*
216   receive the checksums for a buffer
217   */
218 static struct sum_struct *receive_sums(int f)
219 {
220   struct sum_struct *s;
221   int i;
222   OFF_T offset = 0;
223
224   s = (struct sum_struct *)malloc(sizeof(*s));
225   if (!s) out_of_memory("receive_sums");
226
227   s->count = read_int(f);
228   s->n = read_int(f);
229   s->remainder = read_int(f);  
230   s->sums = NULL;
231
232   if (verbose > 3)
233     rprintf(FINFO,"count=%d n=%d rem=%d\n",
234             s->count,s->n,s->remainder);
235
236   if (s->count == 0) 
237     return(s);
238
239   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
240   if (!s->sums) out_of_memory("receive_sums");
241
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);
245
246     s->sums[i].offset = offset;
247     s->sums[i].i = i;
248
249     if (i == s->count-1 && s->remainder != 0) {
250       s->sums[i].len = s->remainder;
251     } else {
252       s->sums[i].len = s->n;
253     }
254     offset += s->sums[i].len;
255
256     if (verbose > 3)
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);
259   }
260
261   s->flength = offset;
262
263   return s;
264 }
265
266
267 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
268                      int report)
269 {
270   int updated = 0;
271   STRUCT_STAT st2;
272   extern int am_daemon;
273
274   if (dry_run) return 0;
275
276   if (!st) {
277     if (link_stat(fname,&st2) != 0) {
278       rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
279       return 0;
280     }
281     st = &st2;
282   }
283
284   if (preserve_times && !S_ISLNK(st->st_mode) &&
285       st->st_mtime != file->modtime) {
286     updated = 1;
287     if (set_modtime(fname,file->modtime) != 0) {
288       rprintf(FERROR,"failed to set times on %s : %s\n",
289               fname,strerror(errno));
290       return 0;
291     }
292   }
293
294 #ifdef HAVE_CHMOD
295   if (preserve_perms && !S_ISLNK(st->st_mode) &&
296       st->st_mode != file->mode) {
297     updated = 1;
298     if (do_chmod(fname,file->mode) != 0) {
299       rprintf(FERROR,"failed to set permissions on %s : %s\n",
300               fname,strerror(errno));
301       return 0;
302     }
303   }
304 #endif
305
306   if ((am_root || !am_daemon) &&
307       ((am_root && preserve_uid && st->st_uid != file->uid) || 
308        (preserve_gid && st->st_gid != file->gid))) {
309           if (do_lchown(fname,
310                         (am_root&&preserve_uid)?file->uid:-1,
311                         preserve_gid?file->gid:-1) != 0) {
312                   if (preserve_uid && st->st_uid != file->uid)
313                           updated = 1;
314                   if (verbose>1 || preserve_uid)
315                           rprintf(FERROR,"chown %s : %s\n",
316                                   fname,strerror(errno));
317                   return updated;
318           }
319           updated = 1;
320   }
321     
322   if (verbose > 1 && report) {
323           if (updated)
324                   rprintf(FINFO,"%s\n",fname);
325           else
326                   rprintf(FINFO,"%s is uptodate\n",fname);
327   }
328   return updated;
329 }
330
331
332 /* choose whether to skip a particular file */
333 static int skip_file(char *fname,
334                      struct file_struct *file, STRUCT_STAT *st)
335 {
336         if (st->st_size != file->length) {
337                 return 0;
338         }
339         
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);
346         }
347
348         if (ignore_times) {
349                 return 0;
350         }
351
352         return (st->st_mtime == file->modtime);
353 }
354
355
356 /* use a larger block size for really big files */
357 int adapt_block_size(struct file_struct *file, int bsize)
358 {
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;
363         return ret;
364 }
365
366 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
367 {  
368   int fd;
369   STRUCT_STAT st;
370   struct map_struct *buf;
371   struct sum_struct *s;
372   int statret;
373   struct file_struct *file = flist->files[i];
374
375   if (verbose > 2)
376     rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
377
378   statret = link_stat(fname,&st);
379
380   if (S_ISDIR(file->mode)) {
381     if (dry_run) return;
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));
385         return;
386       }
387       statret = -1;
388     }
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));
395             }
396     }
397     if (set_perms(fname,file,NULL,0) && verbose) 
398       rprintf(FINFO,"%s/\n",fname);
399     return;
400   }
401
402   if (preserve_links && S_ISLNK(file->mode)) {
403 #if SUPPORT_LINKS
404     char lnk[MAXPATHLEN];
405     int l;
406     if (statret == 0) {
407       l = readlink(fname,lnk,MAXPATHLEN-1);
408       if (l > 0) {
409         lnk[l] = 0;
410         if (strcmp(lnk,file->link) == 0) {
411           set_perms(fname,file,&st,1);
412           return;
413         }
414       }
415     }
416     delete_file(fname);
417     if (do_symlink(file->link,fname) != 0) {
418       rprintf(FERROR,"link %s -> %s : %s\n",
419               fname,file->link,strerror(errno));
420     } else {
421       set_perms(fname,file,NULL,0);
422       if (verbose) 
423         rprintf(FINFO,"%s -> %s\n",
424                 fname,file->link);
425     }
426 #endif
427     return;
428   }
429
430 #ifdef HAVE_MKNOD
431   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
432     if (statret != 0 || 
433         st.st_mode != file->mode ||
434         st.st_rdev != file->rdev) {     
435       delete_file(fname);
436       if (verbose > 2)
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));
441       } else {
442         set_perms(fname,file,NULL,0);
443         if (verbose)
444           rprintf(FINFO,"%s\n",fname);
445       }
446     } else {
447       set_perms(fname,file,&st,1);
448     }
449     return;
450   }
451 #endif
452
453   if (preserve_hard_links && check_hard_link(file)) {
454     if (verbose > 1)
455       rprintf(FINFO,"%s is a hard link\n",f_name(file));
456     return;
457   }
458
459   if (!S_ISREG(file->mode)) {
460     rprintf(FINFO,"skipping non-regular file %s\n",fname);
461     return;
462   }
463
464   if (statret == -1) {
465     if (errno == ENOENT) {
466       write_int(f_out,i);
467       if (!dry_run) send_sums(NULL,f_out);
468     } else {
469       if (verbose > 1)
470         rprintf(FERROR,"recv_generator failed to open %s\n",fname);
471     }
472     return;
473   }
474
475   if (!S_ISREG(st.st_mode)) {
476     if (delete_file(fname) != 0) {
477       return;
478     }
479
480     /* now pretend the file didn't exist */
481     write_int(f_out,i);
482     if (!dry_run) send_sums(NULL,f_out);    
483     return;
484   }
485
486   if (update_only && st.st_mtime > file->modtime) {
487     if (verbose > 1)
488       rprintf(FINFO,"%s is newer\n",fname);
489     return;
490   }
491
492   if (skip_file(fname, file, &st)) {
493     set_perms(fname,file,&st,1);
494     return;
495   }
496
497   if (dry_run) {
498     write_int(f_out,i);
499     return;
500   }
501
502   if (whole_file) {
503     write_int(f_out,i);
504     send_sums(NULL,f_out);    
505     return;
506   }
507
508   /* open the file */  
509   fd = open(fname,O_RDONLY);
510
511   if (fd == -1) {
512     rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
513     rprintf(FERROR,"skipping %s\n",fname);
514     return;
515   }
516
517   if (st.st_size > 0) {
518     buf = map_file(fd,st.st_size);
519   } else {
520     buf = NULL;
521   }
522
523   if (verbose > 3)
524     rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
525
526   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
527
528   if (verbose > 2)
529     rprintf(FINFO,"sending sums for %d\n",i);
530
531   write_int(f_out,i);
532   send_sums(s,f_out);
533
534   close(fd);
535   if (buf) unmap_file(buf);
536
537   free_sums(s);
538 }
539
540
541
542 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
543 {
544   int i,n,remainder,len,count;
545   OFF_T offset = 0;
546   OFF_T offset2;
547   char *data;
548   static char file_sum1[MD4_SUM_LENGTH];
549   static char file_sum2[MD4_SUM_LENGTH];
550   char *map=NULL;
551
552   count = read_int(f_in);
553   n = read_int(f_in);
554   remainder = read_int(f_in);
555
556   sum_init();
557
558   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
559     if (i > 0) {
560       if (verbose > 3)
561         rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
562
563       stats.literal_data += i;
564       sum_update(data,i);
565
566       if (fd != -1 && write_file(fd,data,i) != i) {
567         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
568         exit_cleanup(1);
569       }
570       offset += i;
571     } else {
572       i = -(i+1);
573       offset2 = i*n;
574       len = n;
575       if (i == count-1 && remainder != 0)
576         len = remainder;
577
578       stats.matched_data += len;
579
580       if (verbose > 3)
581         rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
582                 i,len,(int)offset2,(int)offset);
583
584       map = map_ptr(buf,offset2,len);
585
586       see_token(map, len);
587       sum_update(map,len);
588
589       if (fd != -1 && write_file(fd,map,len) != len) {
590         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
591         exit_cleanup(1);
592       }
593       offset += len;
594     }
595   }
596
597   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
598     rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
599     exit_cleanup(1);
600   }
601
602   sum_end(file_sum1);
603
604   if (remote_version >= 14) {
605     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
606     if (verbose > 2)
607       rprintf(FINFO,"got file_sum\n");
608     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
609       return 0;
610   }
611   return 1;
612 }
613
614
615 static void delete_one(struct file_struct *f)
616 {
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));
622     }
623   } else {    
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));      
629     }
630   }
631 }
632
633
634
635 static struct delete_list {
636         dev_t dev;
637         ino_t inode;
638 } *delete_list;
639 static int dlist_len, dlist_alloc_len;
640
641 static void add_delete_entry(struct file_struct *file)
642 {
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");
647         }
648
649         delete_list[dlist_len].dev = file->dev;
650         delete_list[dlist_len].inode = file->inode;
651         dlist_len++;
652
653         if (verbose > 3)
654                 rprintf(FINFO,"added %s to delete list\n", f_name(file));
655 }
656
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.
660 */
661 static int delete_already_done(struct file_list *flist,int j)
662 {
663         int i;
664         STRUCT_STAT st;
665
666         if (link_stat(f_name(flist->files[j]), &st)) return 1;
667
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)
671                         return 1;
672         }
673
674         return 0;
675 }
676
677
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)
682 {
683         struct file_list *local_file_list;
684         int i, j;
685         char *name;
686
687         if (cvs_exclude)
688                 add_cvs_excludes();
689
690         if (io_error) {
691                 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
692                 return;
693         }
694
695         for (j=0;j<flist->count;j++) {
696                 if (!S_ISDIR(flist->files[j]->mode) || 
697                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
698
699                 if (remote_version < 19 &&
700                     delete_already_done(flist, j)) continue;
701
702                 name = strdup(f_name(flist->files[j]));
703
704                 if (!(local_file_list = send_file_list(-1,1,&name))) {
705                         free(name);
706                         continue;
707                 }
708
709                 if (verbose > 1)
710                         rprintf(FINFO,"deleting in %s\n", name);
711
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]);
719                         }    
720                 }
721                 flist_free(local_file_list);
722                 free(name);
723         }
724 }
725
726 static char *cleanup_fname;
727
728 void exit_cleanup(int code)
729 {
730         io_flush();
731         if (cleanup_fname)
732                 do_unlink(cleanup_fname);
733         signal(SIGUSR1, SIG_IGN);
734         if (code) {
735                 kill_all(SIGUSR1);
736         }
737         exit(code);
738 }
739
740 void sig_int(void)
741 {
742   exit_cleanup(1);
743 }
744
745
746
747
748 static int get_tmpname(char *fnametmp, char *fname)
749 {
750         char *f;
751
752         /* open tmp file */
753         if (tmpdir) {
754                 f = strrchr(fname,'/');
755                 if (f == NULL) 
756                         f = fname;
757                 else 
758                         f++;
759                 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
760                         rprintf(FERROR,"filename too long\n");
761                         return 0;
762                 }
763                 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
764                 return 1;
765         } 
766
767         f = strrchr(fname,'/');
768
769         if (strlen(fname)+9 > MAXPATHLEN) {
770                 rprintf(FERROR,"filename too long\n");
771                 return 0;
772         }
773
774         if (f) {
775                 *f = 0;
776                 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
777                          fname,f+1);
778                 *f = '/';
779         } else {
780                 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
781         }
782
783         return 1;
784 }
785
786 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
787 {  
788         int fd1,fd2;
789         STRUCT_STAT st;
790         char *fname;
791         char fnametmp[MAXPATHLEN];
792         struct map_struct *buf;
793         int i;
794         struct file_struct *file;
795         int phase=0;
796         int recv_ok;
797         
798         if (verbose > 2) {
799                 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
800         }
801
802         if (recurse && delete_mode && !local_name && flist->count>0) {
803                 delete_files(flist);
804         }
805
806         while (1) {      
807                 i = read_int(f_in);
808                 if (i == -1) {
809                         if (phase==0 && remote_version >= 13) {
810                                 phase++;
811                                 csum_length = SUM_LENGTH;
812                                 if (verbose > 2)
813                                         rprintf(FINFO,"recv_files phase=%d\n",phase);
814                                 write_int(f_gen,-1);
815                                 continue;
816                         }
817                         break;
818                 }
819
820                 if (i < 0 || i >= flist->count) {
821                         rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n", 
822                                 i, flist->count);
823                         exit_cleanup(1);
824                 }
825
826                 file = flist->files[i];
827                 fname = f_name(file);
828
829                 stats.num_transferred_files++;
830                 stats.total_transferred_size += file->length;
831
832                 if (local_name)
833                         fname = local_name;
834
835                 if (dry_run) {
836                         if (!am_server && verbose)
837                                 printf("%s\n",fname);
838                         continue;
839                 }
840
841                 if (verbose > 2)
842                         rprintf(FINFO,"recv_files(%s)\n",fname);
843
844                 /* open the file */  
845                 fd1 = open(fname,O_RDONLY);
846
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);
850                         close(fd1);
851                         continue;
852                 }
853
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);
857                         close(fd1);
858                         continue;
859                 }
860
861                 if (fd1 != -1 && st.st_size > 0) {
862                         buf = map_file(fd1,st.st_size);
863                         if (verbose > 2)
864                                 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
865                 } else {
866                         buf = NULL;
867                 }
868
869                 if (!get_tmpname(fnametmp,fname)) {
870                         if (buf) unmap_file(buf);
871                         close(fd1);
872                         continue;
873                 }
874
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);
879                         close(fd1);
880                         continue;
881                 }
882
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);
887                 }
888                 if (fd2 == -1) {
889                         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
890                         receive_data(f_in,buf,-1,NULL);
891                         if (buf) unmap_file(buf);
892                         close(fd1);
893                         continue;
894                 }
895       
896                 cleanup_fname = fnametmp;
897
898                 if (!am_server && verbose)
899                         printf("%s\n",fname);
900                 
901                 /* recv file data */
902                 recv_ok = receive_data(f_in,buf,fd2,fname);
903                 
904                 if (buf) unmap_file(buf);
905                 if (fd1 != -1) {
906                         close(fd1);
907                 }
908                 close(fd2);
909                 
910                 if (verbose > 2)
911                         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
912                 
913                 if (make_backups) {
914                         char fnamebak[MAXPATHLEN];
915                         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
916                                 rprintf(FERROR,"backup filename too long\n");
917                                 continue;
918                         }
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));
922                                 continue;
923                         }
924                 }
925
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));
934                                 } else {
935                                         set_perms(fname,file,NULL,0);
936                                 }
937                                 do_unlink(fnametmp);
938                         } else {
939                                 rprintf(FERROR,"rename %s -> %s : %s\n",
940                                         fnametmp,fname,strerror(errno));
941                                 do_unlink(fnametmp);
942                         }
943                 } else {
944                         set_perms(fname,file,NULL,0);
945                 }
946
947                 cleanup_fname = NULL;
948
949                 
950                 if (!recv_ok) {
951                         if (csum_length == SUM_LENGTH) {
952                                 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
953                                         fname);
954                         } else {
955                                 if (verbose > 1)
956                                         rprintf(FINFO,"redoing %s(%d)\n",fname,i);
957                                 write_int(f_gen,i);
958                         }
959                 }
960         }
961
962         if (preserve_hard_links)
963                 do_hard_links(flist);
964
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);
971         }
972
973         if (verbose > 2)
974                 rprintf(FINFO,"recv_files finished\n");
975         
976         return 0;
977 }
978
979
980
981 void send_files(struct file_list *flist,int f_out,int f_in)
982
983   int fd;
984   struct sum_struct *s;
985   struct map_struct *buf;
986   STRUCT_STAT st;
987   char fname[MAXPATHLEN];  
988   int i;
989   struct file_struct *file;
990   int phase = 0;
991
992   if (verbose > 2)
993     rprintf(FINFO,"send_files starting\n");
994
995   setup_readbuffer(f_in);
996
997   while (1) {
998           int offset=0;
999
1000           i = read_int(f_in);
1001           if (i == -1) {
1002                   if (phase==0 && remote_version >= 13) {
1003                           phase++;
1004                           csum_length = SUM_LENGTH;
1005                           write_int(f_out,-1);
1006                           if (verbose > 2)
1007                                   rprintf(FINFO,"send_files phase=%d\n",phase);
1008                           continue;
1009                   }
1010                   break;
1011           }
1012
1013           if (i < 0 || i >= flist->count) {
1014                   rprintf(FERROR,"Invalid file index %d (count=%d)\n", 
1015                           i, flist->count);
1016                   exit_cleanup(1);
1017           }
1018
1019           file = flist->files[i];
1020
1021           stats.num_transferred_files++;
1022           stats.total_transferred_size += file->length;
1023
1024           fname[0] = 0;
1025           if (file->basedir) {
1026                   strlcpy(fname,file->basedir,MAXPATHLEN-1);
1027                   if (strlen(fname) == MAXPATHLEN-1) {
1028                           io_error = 1;
1029                           rprintf(FERROR, "send_files failed on long-named directory %s\n",
1030                                   fname);
1031                           return;
1032                   }
1033                   strlcat(fname,"/",MAXPATHLEN-1);
1034                   offset = strlen(file->basedir)+1;
1035           }
1036           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1037           
1038           if (verbose > 2) 
1039                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1040           
1041           if (dry_run) {        
1042                   if (!am_server && verbose)
1043                           printf("%s\n",fname);
1044                   write_int(f_out,i);
1045                   continue;
1046           }
1047
1048           s = receive_sums(f_in);
1049           if (!s) {
1050                   io_error = 1;
1051                   rprintf(FERROR,"receive_sums failed\n");
1052                   return;
1053           }
1054           
1055           fd = open(fname,O_RDONLY);
1056           if (fd == -1) {
1057                   io_error = 1;
1058                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1059                           fname,strerror(errno));
1060                   free_sums(s);
1061                   continue;
1062           }
1063           
1064           /* map the local file */
1065           if (do_fstat(fd,&st) != 0) {
1066                   io_error = 1;
1067                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1068                   free_sums(s);
1069                   close(fd);
1070                   return;
1071           }
1072           
1073           if (st.st_size > 0) {
1074                   buf = map_file(fd,st.st_size);
1075           } else {
1076                   buf = NULL;
1077           }
1078           
1079           if (verbose > 2)
1080                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1081                           fname,(int)st.st_size);
1082           
1083           write_int(f_out,i);
1084           
1085           write_int(f_out,s->count);
1086           write_int(f_out,s->n);
1087           write_int(f_out,s->remainder);
1088           
1089           if (verbose > 2)
1090                   rprintf(FINFO,"calling match_sums %s\n",fname);
1091           
1092           if (!am_server && verbose)
1093                   printf("%s\n",fname+offset);
1094           
1095           match_sums(f_out,s,buf,st.st_size);
1096           
1097           if (buf) unmap_file(buf);
1098           close(fd);
1099           
1100           free_sums(s);
1101           
1102           if (verbose > 2)
1103                   rprintf(FINFO,"sender finished %s\n",fname);
1104   }
1105
1106   if (verbose > 2)
1107           rprintf(FINFO,"send files finished\n");
1108
1109   match_report();
1110
1111   write_int(f_out,-1);
1112 }
1113
1114
1115
1116 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1117 {
1118   int i;
1119   int phase=0;
1120
1121   if (verbose > 2)
1122     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1123             (int)getpid(),flist->count);
1124
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;
1129
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 */
1135     }
1136
1137     recv_generator(local_name?local_name:f_name(file),
1138                    flist,i,f);
1139
1140     file->mode = saved_mode;
1141   }
1142
1143   phase++;
1144   csum_length = SUM_LENGTH;
1145   ignore_times=1;
1146
1147   if (verbose > 2)
1148     rprintf(FINFO,"generate_files phase=%d\n",phase);
1149
1150   write_int(f,-1);
1151
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 */
1154   io_timeout = 0;
1155
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),
1162                      flist,i,f);    
1163     }
1164
1165     phase++;
1166     if (verbose > 2)
1167       rprintf(FINFO,"generate_files phase=%d\n",phase);
1168
1169     write_int(f,-1);
1170   }
1171 }
1172
1173