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