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