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 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 281 {
 282   int fd;
 283   struct stat st;
 284   struct map_struct *buf;
 285   struct sum_struct *s;
 286   int statret;
 287   struct file_struct *file = flist->files[i];
 288
 289   if (verbose > 2)
 290     fprintf(FERROR,"recv_generator(%s,%d)\n",fname,i);
 291
 292   statret = link_stat(fname,&st);
 293
 294   if (S_ISDIR(file->mode)) {
 295     if (dry_run) return;
 296     if (statret == 0 && !S_ISDIR(st.st_mode)) {
 297       if (unlink(fname) != 0) {
 298         fprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
 299         return;
 300       }
 301       statret = -1;
 302     }
 303     if (statret != 0 && mkdir(fname,file->mode) != 0 && errno != EEXIST) {
 304             if (!(relative_paths && errno==ENOENT &&
 305                   create_directory_path(fname)==0 &&
 306                   mkdir(fname,file->mode)==0)) {
 307                     fprintf(FERROR,"mkdir %s : %s (2)\n",
 308                             fname,strerror(errno));
 309             }
 310     }
 311     if (set_perms(fname,file,NULL,0) && verbose)
 312       fprintf(FINFO,"%s/\n",fname);
 313     return;
 314   }
 315
 316   if (preserve_links && S_ISLNK(file->mode)) {
 317 #if SUPPORT_LINKS
 318     char lnk[MAXPATHLEN];
 319     int l;
 320     if (statret == 0) {
 321       l = readlink(fname,lnk,MAXPATHLEN-1);
 322       if (l > 0) {
 323         lnk[l] = 0;
 324         if (strcmp(lnk,file->link) == 0) {
 325           set_perms(fname,file,&st,1);
 326           return;
 327         }
 328       }
 329     }
 330     if (!dry_run) unlink(fname);
 331     if (!dry_run && symlink(file->link,fname) != 0) {
 332       fprintf(FERROR,"link %s -> %s : %s\n",
 333               fname,file->link,strerror(errno));
 334     } else {
 335       set_perms(fname,file,NULL,0);
 336       if (verbose)
 337         fprintf(FINFO,"%s -> %s\n",
 338                 fname,file->link);
 339     }
 340 #endif
 341     return;
 342   }
 343
 344 #ifdef HAVE_MKNOD
 345   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
 346     if (statret != 0 ||
 347         st.st_mode != file->mode ||
 348         st.st_rdev != file->rdev) {
 349       if (!dry_run) unlink(fname);
 350       if (verbose > 2)
 351         fprintf(FERROR,"mknod(%s,0%o,0x%x)\n",
 352                 fname,(int)file->mode,(int)file->rdev);
 353       if (!dry_run &&
 354           mknod(fname,file->mode,file->rdev) != 0) {
 355         fprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
 356       } else {
 357         set_perms(fname,file,NULL,0);
 358         if (verbose)
 359           fprintf(FINFO,"%s\n",fname);
 360       }
 361     } else {
 362       set_perms(fname,file,&st,1);
 363     }
 364     return;
 365   }
 366 #endif
 367
 368   if (preserve_hard_links && check_hard_link(file)) {
 369     if (verbose > 1)
 370       fprintf(FINFO,"%s is a hard link\n",f_name(file));
 371     return;
 372   }
 373
 374   if (!S_ISREG(file->mode)) {
 375     fprintf(FERROR,"skipping non-regular file %s\n",fname);
 376     return;
 377   }
 378
 379   if (statret == -1) {
 380     if (errno == ENOENT) {
 381       write_int(f_out,i);
 382       if (!dry_run) send_sums(NULL,f_out);
 383     } else {
 384       if (verbose > 1)
 385         fprintf(FERROR,"recv_generator failed to open %s\n",fname);
 386     }
 387     return;
 388   }
 389
 390   if (!S_ISREG(st.st_mode)) {
 391     /* its not a regular file on the receiving end, but it is on the
 392        sending end. If its a directory then skip it (too dangerous to
 393        do a recursive deletion??) otherwise try to unlink it */
 394     if (S_ISDIR(st.st_mode)) {
 395       fprintf(FERROR,"ERROR: %s is a directory\n",fname);
 396       return;
 397     }
 398     if (unlink(fname) != 0) {
 399       fprintf(FERROR,"%s : not a regular file (generator)\n",fname);
 400       return;
 401     }
 402
 403     /* now pretend the file didn't exist */
 404     write_int(f_out,i);
 405     if (!dry_run) send_sums(NULL,f_out);
 406     return;
 407   }
 408
 409   if (update_only && st.st_mtime > file->modtime) {
 410     if (verbose > 1)
 411       fprintf(FERROR,"%s is newer\n",fname);
 412     return;
 413   }
 414
 415   if (skip_file(fname, file, &st)) {
 416     set_perms(fname,file,&st,1);
 417     return;
 418   }
 419
 420   if (dry_run) {
 421     write_int(f_out,i);
 422     return;
 423   }
 424
 425   if (whole_file) {
 426     write_int(f_out,i);
 427     send_sums(NULL,f_out);
 428     return;
 429   }
 430
 431   /* open the file */
 432   fd = open(fname,O_RDONLY);
 433
 434   if (fd == -1) {
 435     fprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
 436     fprintf(FERROR,"skipping %s\n",fname);
 437     return;
 438   }
 439
 440   if (st.st_size > 0) {
 441     buf = map_file(fd,st.st_size);
 442   } else {
 443     buf = NULL;
 444   }
 445
 446   if (verbose > 3)
 447     fprintf(FERROR,"gen mapped %s of size %d\n",fname,(int)st.st_size);
 448
 449   s = generate_sums(buf,st.st_size,block_size);
 450
 451   if (verbose > 2)
 452     fprintf(FERROR,"sending sums for %d\n",i);
 453
 454   write_int(f_out,i);
 455   send_sums(s,f_out);
 456   write_flush(f_out);
 457
 458   close(fd);
 459   if (buf) unmap_file(buf);
 460
 461   free_sums(s);
 462 }
 463
 464
 465
 466 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
 467 {
 468   int i,n,remainder,len,count;
 469   off_t offset = 0;
 470   off_t offset2;
 471   char *data;
 472   static char file_sum1[MD4_SUM_LENGTH];
 473   static char file_sum2[MD4_SUM_LENGTH];
 474   char *map=NULL;
 475
 476   count = read_int(f_in);
 477   n = read_int(f_in);
 478   remainder = read_int(f_in);
 479
 480   sum_init();
 481
 482   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
 483     if (i > 0) {
 484       if (verbose > 3)
 485         fprintf(FERROR,"data recv %d at %d\n",i,(int)offset);
 486
 487       sum_update(data,i);
 488
 489       if (fd != -1 && write_sparse(fd,data,i) != i) {
 490         fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 491         exit_cleanup(1);
 492       }
 493       offset += i;
 494     } else {
 495       i = -(i+1);
 496       offset2 = i*n;
 497       len = n;
 498       if (i == count-1 && remainder != 0)
 499         len = remainder;
 500
 501       if (verbose > 3)
 502         fprintf(FERROR,"chunk[%d] of size %d at %d offset=%d\n",
 503                 i,len,(int)offset2,(int)offset);
 504
 505       map = map_ptr(buf,offset2,len);
 506
 507       see_token(map, len);
 508       sum_update(map,len);
 509
 510       if (fd != -1 && write_sparse(fd,map,len) != len) {
 511         fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 512         exit_cleanup(1);
 513       }
 514       offset += len;
 515     }
 516   }
 517
 518   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
 519     fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 520     exit_cleanup(1);
 521   }
 522
 523   sum_end(file_sum1);
 524
 525   if (remote_version >= 14) {
 526     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
 527     if (verbose > 2)
 528       fprintf(FERROR,"got file_sum\n");
 529     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
 530       return 0;
 531   }
 532   return 1;
 533 }
 534
 535
 536 static void delete_one(struct file_struct *f)
 537 {
 538   if (!S_ISDIR(f->mode)) {
 539     if (!dry_run && unlink(f_name(f)) != 0) {
 540       fprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
 541     } else if (verbose) {
 542       fprintf(FERROR,"deleting %s\n",f_name(f));
 543     }
 544   } else {
 545     if (!dry_run && rmdir(f_name(f)) != 0) {
 546       if (errno != ENOTEMPTY)
 547         fprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
 548     } else if (verbose) {
 549       fprintf(FERROR,"deleting directory %s\n",f_name(f));
 550     }
 551   }
 552 }
 553
 554
 555 /* yuck! This function wouldn't have been necessary if I had the sorting
 556    algorithm right. Unfortunately fixing the sorting algorithm would introduce
 557    a backward incompatibility as file list indexes are sent over the link.
 558
 559    The aim is to see if a directory has already had the deletion algorithm applied
 560    to it (due to recursion), and if so to skip it. The bisection is to
 561    prevent this being an n^2 algorithm */
 562 static int delete_already_done(struct file_list *flist,int j)
 563 {
 564         int low=0,high=j-1;
 565         char *name;
 566         char *p;
 567
 568         if (j == 0) return 0;
 569
 570         name = strdup(f_name(flist->files[j]));
 571
 572         if (!name) {
 573                 fprintf(FERROR,"out of memory in delete_already_done");
 574                 exit_cleanup(1);
 575         }
 576
 577         p = strrchr(name,'/');
 578         if (!p) {
 579                 free(name);
 580                 return 0;
 581         }
 582         *p = 0;
 583
 584         while (low != high) {
 585                 int mid = (low+high)/2;
 586                 int ret = strcmp(f_name(flist->files[flist_up(flist, mid)]),name);
 587                 if (ret == 0) {
 588                         free(name);
 589                         return 1;
 590                 }
 591                 if (ret > 0) {
 592                         high=mid;
 593                 } else {
 594                         low=mid+1;
 595                 }
 596         }
 597
 598         low = flist_up(flist, low);
 599
 600         if (strcmp(f_name(flist->files[low]),name) == 0) {
 601                 free(name);
 602                 return 1;
 603         }
 604
 605         free(name);
 606         return 0;
 607 }
 608
 609
 610 /* this deletes any files on the receiving side that are not present
 611    on the sending side. For version 1.6.4 I have changed the behaviour
 612    to match more closely what most people seem to expect of this option */
 613 static void delete_files(struct file_list *flist)
 614 {
 615   struct file_list *local_file_list;
 616   int i, j;
 617
 618   if (cvs_exclude)
 619     add_cvs_excludes();
 620
 621   for (j=0;j<flist->count;j++) {
 622           char *name = f_name(flist->files[j]);
 623
 624           if (!S_ISDIR(flist->files[j]->mode)) continue;
 625
 626           if (delete_already_done(flist, j)) continue;
 627
 628           if (!(local_file_list = send_file_list(-1,1,&name)))
 629                   continue;
 630
 631           if (verbose > 1)
 632                   fprintf(FINFO,"deleting in %s\n", name);
 633
 634           for (i=local_file_list->count-1;i>=0;i--) {
 635                   if (!local_file_list->files[i]->basename) continue;
 636                   if (-1 == flist_find(flist,local_file_list->files[i])) {
 637                           delete_one(local_file_list->files[i]);
 638                   }
 639           }
 640           flist_free(local_file_list);
 641   }
 642 }
 643
 644 static char *cleanup_fname = NULL;
 645
 646 void exit_cleanup(int code)
 647 {
 648         if (cleanup_fname)
 649                 unlink(cleanup_fname);
 650         signal(SIGUSR1, SIG_IGN);
 651         if (code) {
 652 #ifdef GETPGRP_VOID
 653                 kill(-getpgrp(), SIGUSR1);
 654 #else
 655                 kill(-getpgrp(getpid()), SIGUSR1);
 656 #endif
 657         }
 658         exit(code);
 659 }
 660
 661 void sig_int(void)
 662 {
 663   exit_cleanup(1);
 664 }
 665
 666
 667 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 668 {
 669   int fd1,fd2;
 670   struct stat st;
 671   char *fname;
 672   char fnametmp[MAXPATHLEN];
 673   struct map_struct *buf;
 674   int i;
 675   struct file_struct *file;
 676   int phase=0;
 677   int recv_ok;
 678
 679   if (verbose > 2) {
 680     fprintf(FERROR,"recv_files(%d) starting\n",flist->count);
 681   }
 682
 683   if (recurse && delete_mode && !local_name && flist->count>0) {
 684     delete_files(flist);
 685   }
 686
 687   while (1)
 688     {
 689       i = read_int(f_in);
 690       if (i == -1) {
 691         if (phase==0 && remote_version >= 13) {
 692           phase++;
 693           csum_length = SUM_LENGTH;
 694           if (verbose > 2)
 695             fprintf(FERROR,"recv_files phase=%d\n",phase);
 696           write_int(f_gen,-1);
 697           write_flush(f_gen);
 698           continue;
 699         }
 700         break;
 701       }
 702
 703       file = flist->files[i];
 704       fname = f_name(file);
 705
 706       if (local_name)
 707         fname = local_name;
 708
 709       if (dry_run) {
 710         if (!am_server && verbose)
 711           printf("%s\n",fname);
 712         continue;
 713       }
 714
 715       if (verbose > 2)
 716         fprintf(FERROR,"recv_files(%s)\n",fname);
 717
 718       /* open the file */
 719       fd1 = open(fname,O_RDONLY);
 720
 721       if (fd1 != -1 && fstat(fd1,&st) != 0) {
 722         fprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 723         receive_data(f_in,NULL,-1,NULL);
 724         close(fd1);
 725         continue;
 726       }
 727
 728       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 729         fprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 730         receive_data(f_in,NULL,-1,NULL);
 731         close(fd1);
 732         continue;
 733       }
 734
 735       if (fd1 != -1 && st.st_size > 0) {
 736         buf = map_file(fd1,st.st_size);
 737         if (verbose > 2)
 738           fprintf(FERROR,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 739       } else {
 740         buf = NULL;
 741       }
 742
 743       /* open tmp file */
 744       if (strlen(fname) > (MAXPATHLEN-8)) {
 745         fprintf(FERROR,"filename too long\n");
 746         if (buf) unmap_file(buf);
 747         close(fd1);
 748         continue;
 749       }
 750       if (tmpdir) {
 751               char *f;
 752               f = strrchr(fname,'/');
 753               if (f == NULL)
 754                       f = fname;
 755               else
 756                       f++;
 757               sprintf(fnametmp,"%s/%s.XXXXXX",tmpdir,f);
 758       } else {
 759               sprintf(fnametmp,"%s.XXXXXX",fname);
 760       }
 761       if (NULL == mktemp(fnametmp)) {
 762         fprintf(FERROR,"mktemp %s failed\n",fnametmp);
 763         receive_data(f_in,buf,-1,NULL);
 764         if (buf) unmap_file(buf);
 765         close(fd1);
 766         continue;
 767       }
 768       fd2 = open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 769       if (fd2 == -1 && relative_paths && errno == ENOENT &&
 770           create_directory_path(fnametmp) == 0) {
 771               fd2 = open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 772       }
 773       if (fd2 == -1) {
 774         fprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 775         receive_data(f_in,buf,-1,NULL);
 776         if (buf) unmap_file(buf);
 777         close(fd1);
 778         continue;
 779       }
 780
 781       cleanup_fname = fnametmp;
 782
 783       if (!am_server && verbose)
 784         printf("%s\n",fname);
 785
 786       /* recv file data */
 787       recv_ok = receive_data(f_in,buf,fd2,fname);
 788
 789       if (buf) unmap_file(buf);
 790       if (fd1 != -1) {
 791         close(fd1);
 792       }
 793       close(fd2);
 794
 795       if (verbose > 2)
 796         fprintf(FERROR,"renaming %s to %s\n",fnametmp,fname);
 797
 798       if (make_backups) {
 799         char fnamebak[MAXPATHLEN];
 800         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 801                 fprintf(FERROR,"backup filename too long\n");
 802                 continue;
 803         }
 804         sprintf(fnamebak,"%s%s",fname,backup_suffix);
 805         if (rename(fname,fnamebak) != 0 && errno != ENOENT) {
 806           fprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 807           continue;
 808         }
 809       }
 810
 811       /* move tmp file over real file */
 812       if (rename(fnametmp,fname) != 0) {
 813               if (errno == EXDEV) {
 814                       /* rename failed on cross-filesystem link.
 815                          Copy the file instead. */
 816                       if (copy_file(fnametmp,fname, file->mode)) {
 817                               fprintf(FERROR,"copy %s -> %s : %s\n",
 818                                       fnametmp,fname,strerror(errno));
 819                       } else {
 820                               set_perms(fname,file,NULL,0);
 821                       }
 822                       unlink(fnametmp);
 823               } else {
 824                       fprintf(FERROR,"rename %s -> %s : %s\n",
 825                               fnametmp,fname,strerror(errno));
 826                       unlink(fnametmp);
 827               }
 828       } else {
 829               set_perms(fname,file,NULL,0);
 830       }
 831
 832       cleanup_fname = NULL;
 833
 834
 835       if (!recv_ok) {
 836         if (verbose > 1)
 837           fprintf(FERROR,"redoing %s(%d)\n",fname,i);
 838         if (csum_length == SUM_LENGTH)
 839           fprintf(FERROR,"ERROR: file corruption in %s\n",fname);
 840         write_int(f_gen,i);
 841       }
 842     }
 843
 844   if (preserve_hard_links)
 845           do_hard_links(flist);
 846
 847   /* now we need to fix any directory permissions that were
 848      modified during the transfer */
 849   for (i = 0; i < flist->count; i++) {
 850           struct file_struct *file = flist->files[i];
 851           if (!file->basename || !S_ISDIR(file->mode)) continue;
 852           recv_generator(f_name(file),flist,i,-1);
 853   }
 854
 855   if (verbose > 2)
 856     fprintf(FERROR,"recv_files finished\n");
 857
 858   return 0;
 859 }
 860
 861
 862
 863 off_t send_files(struct file_list *flist,int f_out,int f_in)
 864 {
 865   int fd;
 866   struct sum_struct *s;
 867   struct map_struct *buf;
 868   struct stat st;
 869   char fname[MAXPATHLEN];
 870   off_t total=0;
 871   int i;
 872   struct file_struct *file;
 873   int phase = 0;
 874
 875   if (verbose > 2)
 876     fprintf(FERROR,"send_files starting\n");
 877
 878   setup_nonblocking(f_in,f_out);
 879
 880   while (1)
 881     {
 882       i = read_int(f_in);
 883       if (i == -1) {
 884         if (phase==0 && remote_version >= 13) {
 885           phase++;
 886           csum_length = SUM_LENGTH;
 887           write_int(f_out,-1);
 888           write_flush(f_out);
 889           if (verbose > 2)
 890             fprintf(FERROR,"send_files phase=%d\n",phase);
 891           continue;
 892         }
 893         break;
 894       }
 895
 896       file = flist->files[i];
 897
 898       fname[0] = 0;
 899       if (file->basedir) {
 900               strncpy(fname,file->basedir,MAXPATHLEN-1);
 901               fname[MAXPATHLEN-1] = 0;
 902               if (strlen(fname) == MAXPATHLEN-1) {
 903                       fprintf(FERROR, "send_files failed on long-named directory %s\n",
 904                               fname);
 905                       return -1;
 906               }
 907               strcat(fname,"/");
 908       }
 909       strncat(fname,f_name(file),MAXPATHLEN-strlen(fname));
 910
 911       if (verbose > 2)
 912         fprintf(FERROR,"send_files(%d,%s)\n",i,fname);
 913
 914       if (dry_run) {
 915         if (!am_server && verbose)
 916           printf("%s\n",fname);
 917         write_int(f_out,i);
 918         continue;
 919       }
 920
 921       s = receive_sums(f_in);
 922       if (!s) {
 923         fprintf(FERROR,"receive_sums failed\n");
 924         return -1;
 925       }
 926
 927       fd = open(fname,O_RDONLY);
 928       if (fd == -1) {
 929         fprintf(FERROR,"send_files failed to open %s: %s\n",
 930                 fname,strerror(errno));
 931         continue;
 932       }
 933
 934       /* map the local file */
 935       if (fstat(fd,&st) != 0) {
 936         fprintf(FERROR,"fstat failed : %s\n",strerror(errno));
 937         close(fd);
 938         return -1;
 939       }
 940
 941       if (st.st_size > 0) {
 942         buf = map_file(fd,st.st_size);
 943       } else {
 944         buf = NULL;
 945       }
 946
 947       if (verbose > 2)
 948         fprintf(FERROR,"send_files mapped %s of size %d\n",
 949                 fname,(int)st.st_size);
 950
 951       write_int(f_out,i);
 952
 953       write_int(f_out,s->count);
 954       write_int(f_out,s->n);
 955       write_int(f_out,s->remainder);
 956
 957       if (verbose > 2)
 958         fprintf(FERROR,"calling match_sums %s\n",fname);
 959
 960       if (!am_server && verbose)
 961         printf("%s\n",fname);
 962
 963       match_sums(f_out,s,buf,st.st_size);
 964       write_flush(f_out);
 965
 966       if (buf) unmap_file(buf);
 967       close(fd);
 968
 969       free_sums(s);
 970
 971       if (verbose > 2)
 972         fprintf(FERROR,"sender finished %s\n",fname);
 973
 974       total += st.st_size;
 975     }
 976
 977   if (verbose > 2)
 978     fprintf(FERROR,"send files finished\n");
 979
 980   match_report();
 981
 982   write_int(f_out,-1);
 983   write_flush(f_out);
 984
 985   return total;
 986 }
 987
 988
 989
 990 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
 991 {
 992   int i;
 993   int phase=0;
 994
 995   if (verbose > 2)
 996     fprintf(FERROR,"generator starting pid=%d count=%d\n",
 997             (int)getpid(),flist->count);
 998
 999   for (i = 0; i < flist->count; i++) {
1000     struct file_struct *file = flist->files[i];
1001     mode_t saved_mode = file->mode;
1002     if (!file->basename) continue;
1003
1004     /* we need to ensure that any directories we create have writeable
1005        permissions initially so that we can create the files within
1006        them. This is then fixed after the files are transferred */
1007     if (!am_root && S_ISDIR(file->mode)) {
1008       file->mode |= S_IWUSR; /* user write */
1009     }
1010
1011     recv_generator(local_name?local_name:f_name(file),
1012                    flist,i,f);
1013
1014     file->mode = saved_mode;
1015   }
1016
1017   phase++;
1018   csum_length = SUM_LENGTH;
1019   ignore_times=1;
1020
1021   if (verbose > 2)
1022     fprintf(FERROR,"generate_files phase=%d\n",phase);
1023
1024   write_int(f,-1);
1025   write_flush(f);
1026
1027   if (remote_version >= 13) {
1028     /* in newer versions of the protocol the files can cycle through
1029        the system more than once to catch initial checksum errors */
1030     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1031       struct file_struct *file = flist->files[i];
1032       recv_generator(local_name?local_name:f_name(file),
1033                      flist,i,f);
1034     }
1035
1036     phase++;
1037     if (verbose > 2)
1038       fprintf(FERROR,"generate_files phase=%d\n",phase);
1039
1040     write_int(f,-1);
1041     write_flush(f);
1042   }
1043
1044
1045   if (verbose > 2)
1046     fprintf(FERROR,"generator wrote %d\n",write_total());
1047 }
1048
1049