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