rsync.c

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