if the user passes a block size on the command line then don't adapt
[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;
360
361         if (bsize != BLOCK_SIZE) return bsize;
362
363         ret = file->length / (10000); /* rough heuristic */
364         ret = ret & ~15; /* multiple of 16 */
365         if (ret < bsize) ret = bsize;
366         if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
367         return ret;
368 }
369
370 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
371 {  
372   int fd;
373   STRUCT_STAT st;
374   struct map_struct *buf;
375   struct sum_struct *s;
376   int statret;
377   struct file_struct *file = flist->files[i];
378
379   if (verbose > 2)
380     rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
381
382   statret = link_stat(fname,&st);
383
384   if (S_ISDIR(file->mode)) {
385     if (dry_run) return;
386     if (statret == 0 && !S_ISDIR(st.st_mode)) {
387       if (do_unlink(fname) != 0) {
388         rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
389         return;
390       }
391       statret = -1;
392     }
393     if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
394             if (!(relative_paths && errno==ENOENT && 
395                   create_directory_path(fname)==0 && 
396                   do_mkdir(fname,file->mode)==0)) {
397                     rprintf(FERROR,"mkdir %s : %s (2)\n",
398                             fname,strerror(errno));
399             }
400     }
401     if (set_perms(fname,file,NULL,0) && verbose) 
402       rprintf(FINFO,"%s/\n",fname);
403     return;
404   }
405
406   if (preserve_links && S_ISLNK(file->mode)) {
407 #if SUPPORT_LINKS
408     char lnk[MAXPATHLEN];
409     int l;
410     if (statret == 0) {
411       l = readlink(fname,lnk,MAXPATHLEN-1);
412       if (l > 0) {
413         lnk[l] = 0;
414         if (strcmp(lnk,file->link) == 0) {
415           set_perms(fname,file,&st,1);
416           return;
417         }
418       }
419     }
420     delete_file(fname);
421     if (do_symlink(file->link,fname) != 0) {
422       rprintf(FERROR,"link %s -> %s : %s\n",
423               fname,file->link,strerror(errno));
424     } else {
425       set_perms(fname,file,NULL,0);
426       if (verbose) 
427         rprintf(FINFO,"%s -> %s\n",
428                 fname,file->link);
429     }
430 #endif
431     return;
432   }
433
434 #ifdef HAVE_MKNOD
435   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
436     if (statret != 0 || 
437         st.st_mode != file->mode ||
438         st.st_rdev != file->rdev) {     
439       delete_file(fname);
440       if (verbose > 2)
441         rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
442                 fname,(int)file->mode,(int)file->rdev);
443       if (do_mknod(fname,file->mode,file->rdev) != 0) {
444         rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
445       } else {
446         set_perms(fname,file,NULL,0);
447         if (verbose)
448           rprintf(FINFO,"%s\n",fname);
449       }
450     } else {
451       set_perms(fname,file,&st,1);
452     }
453     return;
454   }
455 #endif
456
457   if (preserve_hard_links && check_hard_link(file)) {
458     if (verbose > 1)
459       rprintf(FINFO,"%s is a hard link\n",f_name(file));
460     return;
461   }
462
463   if (!S_ISREG(file->mode)) {
464     rprintf(FINFO,"skipping non-regular file %s\n",fname);
465     return;
466   }
467
468   if (statret == -1) {
469     if (errno == ENOENT) {
470       write_int(f_out,i);
471       if (!dry_run) send_sums(NULL,f_out);
472     } else {
473       if (verbose > 1)
474         rprintf(FERROR,"recv_generator failed to open %s\n",fname);
475     }
476     return;
477   }
478
479   if (!S_ISREG(st.st_mode)) {
480     if (delete_file(fname) != 0) {
481       return;
482     }
483
484     /* now pretend the file didn't exist */
485     write_int(f_out,i);
486     if (!dry_run) send_sums(NULL,f_out);    
487     return;
488   }
489
490   if (update_only && st.st_mtime > file->modtime) {
491     if (verbose > 1)
492       rprintf(FINFO,"%s is newer\n",fname);
493     return;
494   }
495
496   if (skip_file(fname, file, &st)) {
497     set_perms(fname,file,&st,1);
498     return;
499   }
500
501   if (dry_run) {
502     write_int(f_out,i);
503     return;
504   }
505
506   if (whole_file) {
507     write_int(f_out,i);
508     send_sums(NULL,f_out);    
509     return;
510   }
511
512   /* open the file */  
513   fd = open(fname,O_RDONLY);
514
515   if (fd == -1) {
516     rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
517     rprintf(FERROR,"skipping %s\n",fname);
518     return;
519   }
520
521   if (st.st_size > 0) {
522     buf = map_file(fd,st.st_size);
523   } else {
524     buf = NULL;
525   }
526
527   if (verbose > 3)
528     rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
529
530   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
531
532   if (verbose > 2)
533     rprintf(FINFO,"sending sums for %d\n",i);
534
535   write_int(f_out,i);
536   send_sums(s,f_out);
537
538   close(fd);
539   if (buf) unmap_file(buf);
540
541   free_sums(s);
542 }
543
544
545
546 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
547 {
548   int i,n,remainder,len,count;
549   OFF_T offset = 0;
550   OFF_T offset2;
551   char *data;
552   static char file_sum1[MD4_SUM_LENGTH];
553   static char file_sum2[MD4_SUM_LENGTH];
554   char *map=NULL;
555
556   count = read_int(f_in);
557   n = read_int(f_in);
558   remainder = read_int(f_in);
559
560   sum_init();
561
562   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
563     if (i > 0) {
564       if (verbose > 3)
565         rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
566
567       stats.literal_data += i;
568       sum_update(data,i);
569
570       if (fd != -1 && write_file(fd,data,i) != i) {
571         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
572         exit_cleanup(1);
573       }
574       offset += i;
575     } else {
576       i = -(i+1);
577       offset2 = i*n;
578       len = n;
579       if (i == count-1 && remainder != 0)
580         len = remainder;
581
582       stats.matched_data += len;
583
584       if (verbose > 3)
585         rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
586                 i,len,(int)offset2,(int)offset);
587
588       map = map_ptr(buf,offset2,len);
589
590       see_token(map, len);
591       sum_update(map,len);
592
593       if (fd != -1 && write_file(fd,map,len) != len) {
594         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
595         exit_cleanup(1);
596       }
597       offset += len;
598     }
599   }
600
601   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
602     rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
603     exit_cleanup(1);
604   }
605
606   sum_end(file_sum1);
607
608   if (remote_version >= 14) {
609     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
610     if (verbose > 2)
611       rprintf(FINFO,"got file_sum\n");
612     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
613       return 0;
614   }
615   return 1;
616 }
617
618
619 static void delete_one(struct file_struct *f)
620 {
621   if (!S_ISDIR(f->mode)) {
622     if (do_unlink(f_name(f)) != 0) {
623       rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
624     } else if (verbose) {
625       rprintf(FINFO,"deleting %s\n",f_name(f));
626     }
627   } else {    
628     if (do_rmdir(f_name(f)) != 0) {
629       if (errno != ENOTEMPTY && errno != EEXIST)
630         rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
631     } else if (verbose) {
632       rprintf(FINFO,"deleting directory %s\n",f_name(f));      
633     }
634   }
635 }
636
637
638
639 static struct delete_list {
640         dev_t dev;
641         ino_t inode;
642 } *delete_list;
643 static int dlist_len, dlist_alloc_len;
644
645 static void add_delete_entry(struct file_struct *file)
646 {
647         if (dlist_len == dlist_alloc_len) {
648                 dlist_alloc_len += 1024;
649                 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
650                 if (!delete_list) out_of_memory("add_delete_entry");
651         }
652
653         delete_list[dlist_len].dev = file->dev;
654         delete_list[dlist_len].inode = file->inode;
655         dlist_len++;
656
657         if (verbose > 3)
658                 rprintf(FINFO,"added %s to delete list\n", f_name(file));
659 }
660
661 /* yuck! This function wouldn't have been necessary if I had the sorting
662    algorithm right. Unfortunately fixing the sorting algorithm would introduce
663    a backward incompatibility as file list indexes are sent over the link.
664 */
665 static int delete_already_done(struct file_list *flist,int j)
666 {
667         int i;
668         STRUCT_STAT st;
669
670         if (link_stat(f_name(flist->files[j]), &st)) return 1;
671
672         for (i=0;i<dlist_len;i++) {
673                 if (st.st_ino == delete_list[i].inode &&
674                     st.st_dev == delete_list[i].dev)
675                         return 1;
676         }
677
678         return 0;
679 }
680
681
682 /* this deletes any files on the receiving side that are not present
683    on the sending side. For version 1.6.4 I have changed the behaviour
684    to match more closely what most people seem to expect of this option */
685 static void delete_files(struct file_list *flist)
686 {
687         struct file_list *local_file_list;
688         int i, j;
689         char *name;
690
691         if (cvs_exclude)
692                 add_cvs_excludes();
693
694         if (io_error) {
695                 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
696                 return;
697         }
698
699         for (j=0;j<flist->count;j++) {
700                 if (!S_ISDIR(flist->files[j]->mode) || 
701                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
702
703                 if (remote_version < 19 &&
704                     delete_already_done(flist, j)) continue;
705
706                 name = strdup(f_name(flist->files[j]));
707
708                 if (!(local_file_list = send_file_list(-1,1,&name))) {
709                         free(name);
710                         continue;
711                 }
712
713                 if (verbose > 1)
714                         rprintf(FINFO,"deleting in %s\n", name);
715
716                 for (i=local_file_list->count-1;i>=0;i--) {
717                         if (!local_file_list->files[i]->basename) continue;
718                         if (remote_version < 19 &&
719                             S_ISDIR(local_file_list->files[i]->mode))
720                                 add_delete_entry(local_file_list->files[i]);
721                         if (-1 == flist_find(flist,local_file_list->files[i])) {
722                                 delete_one(local_file_list->files[i]);
723                         }    
724                 }
725                 flist_free(local_file_list);
726                 free(name);
727         }
728 }
729
730 static char *cleanup_fname;
731
732 void exit_cleanup(int code)
733 {
734         io_flush();
735         if (cleanup_fname)
736                 do_unlink(cleanup_fname);
737         signal(SIGUSR1, SIG_IGN);
738         if (code) {
739                 kill_all(SIGUSR1);
740         }
741         exit(code);
742 }
743
744 void sig_int(void)
745 {
746   exit_cleanup(1);
747 }
748
749
750
751
752 static int get_tmpname(char *fnametmp, char *fname)
753 {
754         char *f;
755
756         /* open tmp file */
757         if (tmpdir) {
758                 f = strrchr(fname,'/');
759                 if (f == NULL) 
760                         f = fname;
761                 else 
762                         f++;
763                 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
764                         rprintf(FERROR,"filename too long\n");
765                         return 0;
766                 }
767                 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
768                 return 1;
769         } 
770
771         f = strrchr(fname,'/');
772
773         if (strlen(fname)+9 > MAXPATHLEN) {
774                 rprintf(FERROR,"filename too long\n");
775                 return 0;
776         }
777
778         if (f) {
779                 *f = 0;
780                 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
781                          fname,f+1);
782                 *f = '/';
783         } else {
784                 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
785         }
786
787         return 1;
788 }
789
790 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
791 {  
792         int fd1,fd2;
793         STRUCT_STAT st;
794         char *fname;
795         char fnametmp[MAXPATHLEN];
796         struct map_struct *buf;
797         int i;
798         struct file_struct *file;
799         int phase=0;
800         int recv_ok;
801         
802         if (verbose > 2) {
803                 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
804         }
805
806         if (recurse && delete_mode && !local_name && flist->count>0) {
807                 delete_files(flist);
808         }
809
810         while (1) {      
811                 i = read_int(f_in);
812                 if (i == -1) {
813                         if (phase==0 && remote_version >= 13) {
814                                 phase++;
815                                 csum_length = SUM_LENGTH;
816                                 if (verbose > 2)
817                                         rprintf(FINFO,"recv_files phase=%d\n",phase);
818                                 write_int(f_gen,-1);
819                                 continue;
820                         }
821                         break;
822                 }
823
824                 if (i < 0 || i >= flist->count) {
825                         rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n", 
826                                 i, flist->count);
827                         exit_cleanup(1);
828                 }
829
830                 file = flist->files[i];
831                 fname = f_name(file);
832
833                 stats.num_transferred_files++;
834                 stats.total_transferred_size += file->length;
835
836                 if (local_name)
837                         fname = local_name;
838
839                 if (dry_run) {
840                         if (!am_server && verbose)
841                                 printf("%s\n",fname);
842                         continue;
843                 }
844
845                 if (verbose > 2)
846                         rprintf(FINFO,"recv_files(%s)\n",fname);
847
848                 /* open the file */  
849                 fd1 = open(fname,O_RDONLY);
850
851                 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
852                         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
853                         receive_data(f_in,NULL,-1,NULL);
854                         close(fd1);
855                         continue;
856                 }
857
858                 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
859                         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
860                         receive_data(f_in,NULL,-1,NULL);
861                         close(fd1);
862                         continue;
863                 }
864
865                 if (fd1 != -1 && st.st_size > 0) {
866                         buf = map_file(fd1,st.st_size);
867                         if (verbose > 2)
868                                 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
869                 } else {
870                         buf = NULL;
871                 }
872
873                 if (!get_tmpname(fnametmp,fname)) {
874                         if (buf) unmap_file(buf);
875                         close(fd1);
876                         continue;
877                 }
878
879                 if (NULL == do_mktemp(fnametmp)) {
880                         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
881                         receive_data(f_in,buf,-1,NULL);
882                         if (buf) unmap_file(buf);
883                         close(fd1);
884                         continue;
885                 }
886
887                 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
888                 if (fd2 == -1 && relative_paths && errno == ENOENT && 
889                     create_directory_path(fnametmp) == 0) {
890                         fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
891                 }
892                 if (fd2 == -1) {
893                         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
894                         receive_data(f_in,buf,-1,NULL);
895                         if (buf) unmap_file(buf);
896                         close(fd1);
897                         continue;
898                 }
899       
900                 cleanup_fname = fnametmp;
901
902                 if (!am_server && verbose)
903                         printf("%s\n",fname);
904                 
905                 /* recv file data */
906                 recv_ok = receive_data(f_in,buf,fd2,fname);
907                 
908                 if (buf) unmap_file(buf);
909                 if (fd1 != -1) {
910                         close(fd1);
911                 }
912                 close(fd2);
913                 
914                 if (verbose > 2)
915                         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
916                 
917                 if (make_backups) {
918                         char fnamebak[MAXPATHLEN];
919                         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
920                                 rprintf(FERROR,"backup filename too long\n");
921                                 continue;
922                         }
923                         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
924                         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
925                                 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
926                                 continue;
927                         }
928                 }
929
930                 /* move tmp file over real file */
931                 if (do_rename(fnametmp,fname) != 0) {
932                         if (errno == EXDEV) {
933                                 /* rename failed on cross-filesystem link.  
934                                    Copy the file instead. */
935                                 if (copy_file(fnametmp,fname, file->mode)) {
936                                         rprintf(FERROR,"copy %s -> %s : %s\n",
937                                                 fnametmp,fname,strerror(errno));
938                                 } else {
939                                         set_perms(fname,file,NULL,0);
940                                 }
941                                 do_unlink(fnametmp);
942                         } else {
943                                 rprintf(FERROR,"rename %s -> %s : %s\n",
944                                         fnametmp,fname,strerror(errno));
945                                 do_unlink(fnametmp);
946                         }
947                 } else {
948                         set_perms(fname,file,NULL,0);
949                 }
950
951                 cleanup_fname = NULL;
952
953                 
954                 if (!recv_ok) {
955                         if (csum_length == SUM_LENGTH) {
956                                 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
957                                         fname);
958                         } else {
959                                 if (verbose > 1)
960                                         rprintf(FINFO,"redoing %s(%d)\n",fname,i);
961                                 write_int(f_gen,i);
962                         }
963                 }
964         }
965
966         if (preserve_hard_links)
967                 do_hard_links(flist);
968
969         /* now we need to fix any directory permissions that were 
970            modified during the transfer */
971         for (i = 0; i < flist->count; i++) {
972                 file = flist->files[i];
973                 if (!file->basename || !S_ISDIR(file->mode)) continue;
974                 recv_generator(f_name(file),flist,i,-1);
975         }
976
977         if (verbose > 2)
978                 rprintf(FINFO,"recv_files finished\n");
979         
980         return 0;
981 }
982
983
984
985 void send_files(struct file_list *flist,int f_out,int f_in)
986
987   int fd;
988   struct sum_struct *s;
989   struct map_struct *buf;
990   STRUCT_STAT st;
991   char fname[MAXPATHLEN];  
992   int i;
993   struct file_struct *file;
994   int phase = 0;
995
996   if (verbose > 2)
997     rprintf(FINFO,"send_files starting\n");
998
999   setup_readbuffer(f_in);
1000
1001   while (1) {
1002           int offset=0;
1003
1004           i = read_int(f_in);
1005           if (i == -1) {
1006                   if (phase==0 && remote_version >= 13) {
1007                           phase++;
1008                           csum_length = SUM_LENGTH;
1009                           write_int(f_out,-1);
1010                           if (verbose > 2)
1011                                   rprintf(FINFO,"send_files phase=%d\n",phase);
1012                           continue;
1013                   }
1014                   break;
1015           }
1016
1017           if (i < 0 || i >= flist->count) {
1018                   rprintf(FERROR,"Invalid file index %d (count=%d)\n", 
1019                           i, flist->count);
1020                   exit_cleanup(1);
1021           }
1022
1023           file = flist->files[i];
1024
1025           stats.num_transferred_files++;
1026           stats.total_transferred_size += file->length;
1027
1028           fname[0] = 0;
1029           if (file->basedir) {
1030                   strlcpy(fname,file->basedir,MAXPATHLEN-1);
1031                   if (strlen(fname) == MAXPATHLEN-1) {
1032                           io_error = 1;
1033                           rprintf(FERROR, "send_files failed on long-named directory %s\n",
1034                                   fname);
1035                           return;
1036                   }
1037                   strlcat(fname,"/",MAXPATHLEN-1);
1038                   offset = strlen(file->basedir)+1;
1039           }
1040           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1041           
1042           if (verbose > 2) 
1043                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1044           
1045           if (dry_run) {        
1046                   if (!am_server && verbose)
1047                           printf("%s\n",fname);
1048                   write_int(f_out,i);
1049                   continue;
1050           }
1051
1052           s = receive_sums(f_in);
1053           if (!s) {
1054                   io_error = 1;
1055                   rprintf(FERROR,"receive_sums failed\n");
1056                   return;
1057           }
1058           
1059           fd = open(fname,O_RDONLY);
1060           if (fd == -1) {
1061                   io_error = 1;
1062                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1063                           fname,strerror(errno));
1064                   free_sums(s);
1065                   continue;
1066           }
1067           
1068           /* map the local file */
1069           if (do_fstat(fd,&st) != 0) {
1070                   io_error = 1;
1071                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1072                   free_sums(s);
1073                   close(fd);
1074                   return;
1075           }
1076           
1077           if (st.st_size > 0) {
1078                   buf = map_file(fd,st.st_size);
1079           } else {
1080                   buf = NULL;
1081           }
1082           
1083           if (verbose > 2)
1084                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1085                           fname,(int)st.st_size);
1086           
1087           write_int(f_out,i);
1088           
1089           write_int(f_out,s->count);
1090           write_int(f_out,s->n);
1091           write_int(f_out,s->remainder);
1092           
1093           if (verbose > 2)
1094                   rprintf(FINFO,"calling match_sums %s\n",fname);
1095           
1096           if (!am_server && verbose)
1097                   printf("%s\n",fname+offset);
1098           
1099           match_sums(f_out,s,buf,st.st_size);
1100           
1101           if (buf) unmap_file(buf);
1102           close(fd);
1103           
1104           free_sums(s);
1105           
1106           if (verbose > 2)
1107                   rprintf(FINFO,"sender finished %s\n",fname);
1108   }
1109
1110   if (verbose > 2)
1111           rprintf(FINFO,"send files finished\n");
1112
1113   match_report();
1114
1115   write_int(f_out,-1);
1116 }
1117
1118
1119
1120 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1121 {
1122   int i;
1123   int phase=0;
1124
1125   if (verbose > 2)
1126     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1127             (int)getpid(),flist->count);
1128
1129   for (i = 0; i < flist->count; i++) {
1130     struct file_struct *file = flist->files[i];
1131     mode_t saved_mode = file->mode;
1132     if (!file->basename) continue;
1133
1134     /* we need to ensure that any directories we create have writeable
1135        permissions initially so that we can create the files within
1136        them. This is then fixed after the files are transferred */
1137     if (!am_root && S_ISDIR(file->mode)) {
1138       file->mode |= S_IWUSR; /* user write */
1139     }
1140
1141     recv_generator(local_name?local_name:f_name(file),
1142                    flist,i,f);
1143
1144     file->mode = saved_mode;
1145   }
1146
1147   phase++;
1148   csum_length = SUM_LENGTH;
1149   ignore_times=1;
1150
1151   if (verbose > 2)
1152     rprintf(FINFO,"generate_files phase=%d\n",phase);
1153
1154   write_int(f,-1);
1155
1156   /* we expect to just sit around now, so don't exit on a timeout. If we
1157      really get a timeout then the other process should exit */
1158   io_timeout = 0;
1159
1160   if (remote_version >= 13) {
1161     /* in newer versions of the protocol the files can cycle through
1162        the system more than once to catch initial checksum errors */
1163     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1164       struct file_struct *file = flist->files[i];
1165       recv_generator(local_name?local_name:f_name(file),
1166                      flist,i,f);    
1167     }
1168
1169     phase++;
1170     if (verbose > 2)
1171       rprintf(FINFO,"generate_files phase=%d\n",phase);
1172
1173     write_int(f,-1);
1174   }
1175 }
1176
1177