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