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