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