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         if ((am_root || !am_daemon) &&
 295             ((am_root && preserve_uid && st->st_uid != file->uid) ||
 296              (preserve_gid && st->st_gid != file->gid))) {
 297                 if (do_lchown(fname,
 298                               (am_root&&preserve_uid)?file->uid:-1,
 299                               preserve_gid?file->gid:-1) != 0) {
 300                         if (preserve_uid && st->st_uid != file->uid)
 301                                 updated = 1;
 302                         if (verbose>1 || preserve_uid) {
 303                                 rprintf(FERROR,"chown %s : %s\n",
 304                                         fname,strerror(errno));
 305                                 return 0;
 306                         }
 307                 } else {
 308                         updated = 1;
 309                 }
 310         }
 311
 312 #ifdef HAVE_CHMOD
 313         if (preserve_perms && !S_ISLNK(st->st_mode) &&
 314             st->st_mode != file->mode) {
 315                 updated = 1;
 316                 if (do_chmod(fname,file->mode) != 0) {
 317                         rprintf(FERROR,"failed to set permissions on %s : %s\n",
 318                                 fname,strerror(errno));
 319                         return 0;
 320                 }
 321         }
 322 #endif
 323
 324         if (verbose > 1 && report) {
 325                 if (updated)
 326                         rprintf(FINFO,"%s\n",fname);
 327                 else
 328                         rprintf(FINFO,"%s is uptodate\n",fname);
 329         }
 330         return updated;
 331 }
 332
 333
 334 /* choose whether to skip a particular file */
 335 static int skip_file(char *fname,
 336                      struct file_struct *file, STRUCT_STAT *st)
 337 {
 338         if (st->st_size != file->length) {
 339                 return 0;
 340         }
 341
 342         /* if always checksum is set then we use the checksum instead
 343            of the file time to determine whether to sync */
 344         if (always_checksum && S_ISREG(st->st_mode)) {
 345                 char sum[MD4_SUM_LENGTH];
 346                 file_checksum(fname,sum,st->st_size);
 347                 return (memcmp(sum,file->sum,csum_length) == 0);
 348         }
 349
 350         if (ignore_times) {
 351                 return 0;
 352         }
 353
 354         return (st->st_mtime == file->modtime);
 355 }
 356
 357
 358 /* use a larger block size for really big files */
 359 int adapt_block_size(struct file_struct *file, int bsize)
 360 {
 361         int ret;
 362
 363         if (bsize != BLOCK_SIZE) return bsize;
 364
 365         ret = file->length / (10000); /* rough heuristic */
 366         ret = ret & ~15; /* multiple of 16 */
 367         if (ret < bsize) ret = bsize;
 368         if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
 369         return ret;
 370 }
 371
 372 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 373 {
 374   int fd;
 375   STRUCT_STAT st;
 376   struct map_struct *buf;
 377   struct sum_struct *s;
 378   int statret;
 379   struct file_struct *file = flist->files[i];
 380
 381   if (verbose > 2)
 382     rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
 383
 384   statret = link_stat(fname,&st);
 385
 386   if (S_ISDIR(file->mode)) {
 387     if (dry_run) return;
 388     if (statret == 0 && !S_ISDIR(st.st_mode)) {
 389       if (do_unlink(fname) != 0) {
 390         rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
 391         return;
 392       }
 393       statret = -1;
 394     }
 395     if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
 396             if (!(relative_paths && errno==ENOENT &&
 397                   create_directory_path(fname)==0 &&
 398                   do_mkdir(fname,file->mode)==0)) {
 399                     rprintf(FERROR,"mkdir %s : %s (2)\n",
 400                             fname,strerror(errno));
 401             }
 402     }
 403     if (set_perms(fname,file,NULL,0) && verbose)
 404       rprintf(FINFO,"%s/\n",fname);
 405     return;
 406   }
 407
 408   if (preserve_links && S_ISLNK(file->mode)) {
 409 #if SUPPORT_LINKS
 410     char lnk[MAXPATHLEN];
 411     int l;
 412     if (statret == 0) {
 413       l = readlink(fname,lnk,MAXPATHLEN-1);
 414       if (l > 0) {
 415         lnk[l] = 0;
 416         if (strcmp(lnk,file->link) == 0) {
 417           set_perms(fname,file,&st,1);
 418           return;
 419         }
 420       }
 421     }
 422     delete_file(fname);
 423     if (do_symlink(file->link,fname) != 0) {
 424       rprintf(FERROR,"link %s -> %s : %s\n",
 425               fname,file->link,strerror(errno));
 426     } else {
 427       set_perms(fname,file,NULL,0);
 428       if (verbose)
 429         rprintf(FINFO,"%s -> %s\n",
 430                 fname,file->link);
 431     }
 432 #endif
 433     return;
 434   }
 435
 436 #ifdef HAVE_MKNOD
 437   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
 438     if (statret != 0 ||
 439         st.st_mode != file->mode ||
 440         st.st_rdev != file->rdev) {
 441       delete_file(fname);
 442       if (verbose > 2)
 443         rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
 444                 fname,(int)file->mode,(int)file->rdev);
 445       if (do_mknod(fname,file->mode,file->rdev) != 0) {
 446         rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
 447       } else {
 448         set_perms(fname,file,NULL,0);
 449         if (verbose)
 450           rprintf(FINFO,"%s\n",fname);
 451       }
 452     } else {
 453       set_perms(fname,file,&st,1);
 454     }
 455     return;
 456   }
 457 #endif
 458
 459   if (preserve_hard_links && check_hard_link(file)) {
 460     if (verbose > 1)
 461       rprintf(FINFO,"%s is a hard link\n",f_name(file));
 462     return;
 463   }
 464
 465   if (!S_ISREG(file->mode)) {
 466     rprintf(FINFO,"skipping non-regular file %s\n",fname);
 467     return;
 468   }
 469
 470   if (statret == -1) {
 471     if (errno == ENOENT) {
 472       write_int(f_out,i);
 473       if (!dry_run) send_sums(NULL,f_out);
 474     } else {
 475       if (verbose > 1)
 476         rprintf(FERROR,"recv_generator failed to open %s\n",fname);
 477     }
 478     return;
 479   }
 480
 481   if (!S_ISREG(st.st_mode)) {
 482     if (delete_file(fname) != 0) {
 483       return;
 484     }
 485
 486     /* now pretend the file didn't exist */
 487     write_int(f_out,i);
 488     if (!dry_run) send_sums(NULL,f_out);
 489     return;
 490   }
 491
 492   if (update_only && st.st_mtime > file->modtime) {
 493     if (verbose > 1)
 494       rprintf(FINFO,"%s is newer\n",fname);
 495     return;
 496   }
 497
 498   if (skip_file(fname, file, &st)) {
 499     set_perms(fname,file,&st,1);
 500     return;
 501   }
 502
 503   if (dry_run) {
 504     write_int(f_out,i);
 505     return;
 506   }
 507
 508   if (whole_file) {
 509     write_int(f_out,i);
 510     send_sums(NULL,f_out);
 511     return;
 512   }
 513
 514   /* open the file */
 515   fd = open(fname,O_RDONLY);
 516
 517   if (fd == -1) {
 518     rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
 519     rprintf(FERROR,"skipping %s\n",fname);
 520     return;
 521   }
 522
 523   if (st.st_size > 0) {
 524     buf = map_file(fd,st.st_size);
 525   } else {
 526     buf = NULL;
 527   }
 528
 529   if (verbose > 3)
 530     rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
 531
 532   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
 533
 534   if (verbose > 2)
 535     rprintf(FINFO,"sending sums for %d\n",i);
 536
 537   write_int(f_out,i);
 538   send_sums(s,f_out);
 539
 540   close(fd);
 541   if (buf) unmap_file(buf);
 542
 543   free_sums(s);
 544 }
 545
 546
 547
 548 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
 549 {
 550   int i,n,remainder,len,count;
 551   OFF_T offset = 0;
 552   OFF_T offset2;
 553   char *data;
 554   static char file_sum1[MD4_SUM_LENGTH];
 555   static char file_sum2[MD4_SUM_LENGTH];
 556   char *map=NULL;
 557
 558   count = read_int(f_in);
 559   n = read_int(f_in);
 560   remainder = read_int(f_in);
 561
 562   sum_init();
 563
 564   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
 565     if (i > 0) {
 566       if (verbose > 3)
 567         rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
 568
 569       stats.literal_data += i;
 570       sum_update(data,i);
 571
 572       if (fd != -1 && write_file(fd,data,i) != i) {
 573         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 574         exit_cleanup(1);
 575       }
 576       offset += i;
 577     } else {
 578       i = -(i+1);
 579       offset2 = i*n;
 580       len = n;
 581       if (i == count-1 && remainder != 0)
 582         len = remainder;
 583
 584       stats.matched_data += len;
 585
 586       if (verbose > 3)
 587         rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
 588                 i,len,(int)offset2,(int)offset);
 589
 590       map = map_ptr(buf,offset2,len);
 591
 592       see_token(map, len);
 593       sum_update(map,len);
 594
 595       if (fd != -1 && write_file(fd,map,len) != len) {
 596         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 597         exit_cleanup(1);
 598       }
 599       offset += len;
 600     }
 601   }
 602
 603   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
 604     rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 605     exit_cleanup(1);
 606   }
 607
 608   sum_end(file_sum1);
 609
 610   if (remote_version >= 14) {
 611     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
 612     if (verbose > 2)
 613       rprintf(FINFO,"got file_sum\n");
 614     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
 615       return 0;
 616   }
 617   return 1;
 618 }
 619
 620
 621 static void delete_one(struct file_struct *f)
 622 {
 623   if (!S_ISDIR(f->mode)) {
 624     if (do_unlink(f_name(f)) != 0) {
 625       rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
 626     } else if (verbose) {
 627       rprintf(FINFO,"deleting %s\n",f_name(f));
 628     }
 629   } else {
 630     if (do_rmdir(f_name(f)) != 0) {
 631       if (errno != ENOTEMPTY && errno != EEXIST)
 632         rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
 633     } else if (verbose) {
 634       rprintf(FINFO,"deleting directory %s\n",f_name(f));
 635     }
 636   }
 637 }
 638
 639
 640
 641 static struct delete_list {
 642         dev_t dev;
 643         ino_t inode;
 644 } *delete_list;
 645 static int dlist_len, dlist_alloc_len;
 646
 647 static void add_delete_entry(struct file_struct *file)
 648 {
 649         if (dlist_len == dlist_alloc_len) {
 650                 dlist_alloc_len += 1024;
 651                 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
 652                 if (!delete_list) out_of_memory("add_delete_entry");
 653         }
 654
 655         delete_list[dlist_len].dev = file->dev;
 656         delete_list[dlist_len].inode = file->inode;
 657         dlist_len++;
 658
 659         if (verbose > 3)
 660                 rprintf(FINFO,"added %s to delete list\n", f_name(file));
 661 }
 662
 663 /* yuck! This function wouldn't have been necessary if I had the sorting
 664    algorithm right. Unfortunately fixing the sorting algorithm would introduce
 665    a backward incompatibility as file list indexes are sent over the link.
 666 */
 667 static int delete_already_done(struct file_list *flist,int j)
 668 {
 669         int i;
 670         STRUCT_STAT st;
 671
 672         if (link_stat(f_name(flist->files[j]), &st)) return 1;
 673
 674         for (i=0;i<dlist_len;i++) {
 675                 if (st.st_ino == delete_list[i].inode &&
 676                     st.st_dev == delete_list[i].dev)
 677                         return 1;
 678         }
 679
 680         return 0;
 681 }
 682
 683
 684 /* this deletes any files on the receiving side that are not present
 685    on the sending side. For version 1.6.4 I have changed the behaviour
 686    to match more closely what most people seem to expect of this option */
 687 static void delete_files(struct file_list *flist)
 688 {
 689         struct file_list *local_file_list;
 690         int i, j;
 691         char *name;
 692
 693         if (cvs_exclude)
 694                 add_cvs_excludes();
 695
 696         if (io_error) {
 697                 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
 698                 return;
 699         }
 700
 701         for (j=0;j<flist->count;j++) {
 702                 if (!S_ISDIR(flist->files[j]->mode) ||
 703                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
 704
 705                 if (remote_version < 19 &&
 706                     delete_already_done(flist, j)) continue;
 707
 708                 name = strdup(f_name(flist->files[j]));
 709
 710                 if (!(local_file_list = send_file_list(-1,1,&name))) {
 711                         free(name);
 712                         continue;
 713                 }
 714
 715                 if (verbose > 1)
 716                         rprintf(FINFO,"deleting in %s\n", name);
 717
 718                 for (i=local_file_list->count-1;i>=0;i--) {
 719                         if (!local_file_list->files[i]->basename) continue;
 720                         if (remote_version < 19 &&
 721                             S_ISDIR(local_file_list->files[i]->mode))
 722                                 add_delete_entry(local_file_list->files[i]);
 723                         if (-1 == flist_find(flist,local_file_list->files[i])) {
 724                                 delete_one(local_file_list->files[i]);
 725                         }
 726                 }
 727                 flist_free(local_file_list);
 728                 free(name);
 729         }
 730 }
 731
 732 static char *cleanup_fname;
 733
 734 void exit_cleanup(int code)
 735 {
 736         io_flush();
 737         if (cleanup_fname)
 738                 do_unlink(cleanup_fname);
 739         signal(SIGUSR1, SIG_IGN);
 740         if (code) {
 741                 kill_all(SIGUSR1);
 742         }
 743         exit(code);
 744 }
 745
 746 void sig_int(void)
 747 {
 748   exit_cleanup(1);
 749 }
 750
 751
 752
 753
 754 static int get_tmpname(char *fnametmp, char *fname)
 755 {
 756         char *f;
 757
 758         /* open tmp file */
 759         if (tmpdir) {
 760                 f = strrchr(fname,'/');
 761                 if (f == NULL)
 762                         f = fname;
 763                 else
 764                         f++;
 765                 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
 766                         rprintf(FERROR,"filename too long\n");
 767                         return 0;
 768                 }
 769                 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
 770                 return 1;
 771         }
 772
 773         f = strrchr(fname,'/');
 774
 775         if (strlen(fname)+9 > MAXPATHLEN) {
 776                 rprintf(FERROR,"filename too long\n");
 777                 return 0;
 778         }
 779
 780         if (f) {
 781                 *f = 0;
 782                 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
 783                          fname,f+1);
 784                 *f = '/';
 785         } else {
 786                 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
 787         }
 788
 789         return 1;
 790 }
 791
 792 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 793 {
 794         int fd1,fd2;
 795         STRUCT_STAT st;
 796         char *fname;
 797         char fnametmp[MAXPATHLEN];
 798         struct map_struct *buf;
 799         int i;
 800         struct file_struct *file;
 801         int phase=0;
 802         int recv_ok;
 803
 804         if (verbose > 2) {
 805                 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
 806         }
 807
 808         if (recurse && delete_mode && !local_name && flist->count>0) {
 809                 delete_files(flist);
 810         }
 811
 812         while (1) {
 813                 i = read_int(f_in);
 814                 if (i == -1) {
 815                         if (phase==0 && remote_version >= 13) {
 816                                 phase++;
 817                                 csum_length = SUM_LENGTH;
 818                                 if (verbose > 2)
 819                                         rprintf(FINFO,"recv_files phase=%d\n",phase);
 820                                 write_int(f_gen,-1);
 821                                 continue;
 822                         }
 823                         break;
 824                 }
 825
 826                 if (i < 0 || i >= flist->count) {
 827                         rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
 828                                 i, flist->count);
 829                         exit_cleanup(1);
 830                 }
 831
 832                 file = flist->files[i];
 833                 fname = f_name(file);
 834
 835                 stats.num_transferred_files++;
 836                 stats.total_transferred_size += file->length;
 837
 838                 if (local_name)
 839                         fname = local_name;
 840
 841                 if (dry_run) {
 842                         if (!am_server && verbose)
 843                                 printf("%s\n",fname);
 844                         continue;
 845                 }
 846
 847                 if (verbose > 2)
 848                         rprintf(FINFO,"recv_files(%s)\n",fname);
 849
 850                 /* open the file */
 851                 fd1 = open(fname,O_RDONLY);
 852
 853                 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
 854                         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 855                         receive_data(f_in,NULL,-1,NULL);
 856                         close(fd1);
 857                         continue;
 858                 }
 859
 860                 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 861                         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 862                         receive_data(f_in,NULL,-1,NULL);
 863                         close(fd1);
 864                         continue;
 865                 }
 866
 867                 if (fd1 != -1 && st.st_size > 0) {
 868                         buf = map_file(fd1,st.st_size);
 869                         if (verbose > 2)
 870                                 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 871                 } else {
 872                         buf = NULL;
 873                 }
 874
 875                 if (!get_tmpname(fnametmp,fname)) {
 876                         if (buf) unmap_file(buf);
 877                         close(fd1);
 878                         continue;
 879                 }
 880
 881                 if (NULL == do_mktemp(fnametmp)) {
 882                         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
 883                         receive_data(f_in,buf,-1,NULL);
 884                         if (buf) unmap_file(buf);
 885                         close(fd1);
 886                         continue;
 887                 }
 888
 889                 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 890                 if (fd2 == -1 && relative_paths && errno == ENOENT &&
 891                     create_directory_path(fnametmp) == 0) {
 892                         fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 893                 }
 894                 if (fd2 == -1) {
 895                         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 896                         receive_data(f_in,buf,-1,NULL);
 897                         if (buf) unmap_file(buf);
 898                         close(fd1);
 899                         continue;
 900                 }
 901
 902                 cleanup_fname = fnametmp;
 903
 904                 if (!am_server && verbose)
 905                         printf("%s\n",fname);
 906
 907                 /* recv file data */
 908                 recv_ok = receive_data(f_in,buf,fd2,fname);
 909
 910                 if (buf) unmap_file(buf);
 911                 if (fd1 != -1) {
 912                         close(fd1);
 913                 }
 914                 close(fd2);
 915
 916                 if (verbose > 2)
 917                         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
 918
 919                 if (make_backups) {
 920                         char fnamebak[MAXPATHLEN];
 921                         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 922                                 rprintf(FERROR,"backup filename too long\n");
 923                                 continue;
 924                         }
 925                         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
 926                         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
 927                                 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 928                                 continue;
 929                         }
 930                 }
 931
 932                 /* move tmp file over real file */
 933                 if (do_rename(fnametmp,fname) != 0) {
 934                         if (errno == EXDEV) {
 935                                 /* rename failed on cross-filesystem link.
 936                                    Copy the file instead. */
 937                                 if (copy_file(fnametmp,fname, file->mode)) {
 938                                         rprintf(FERROR,"copy %s -> %s : %s\n",
 939                                                 fnametmp,fname,strerror(errno));
 940                                 } else {
 941                                         set_perms(fname,file,NULL,0);
 942                                 }
 943                                 do_unlink(fnametmp);
 944                         } else {
 945                                 rprintf(FERROR,"rename %s -> %s : %s\n",
 946                                         fnametmp,fname,strerror(errno));
 947                                 do_unlink(fnametmp);
 948                         }
 949                 } else {
 950                         set_perms(fname,file,NULL,0);
 951                 }
 952
 953                 cleanup_fname = NULL;
 954
 955
 956                 if (!recv_ok) {
 957                         if (csum_length == SUM_LENGTH) {
 958                                 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
 959                                         fname);
 960                         } else {
 961                                 if (verbose > 1)
 962                                         rprintf(FINFO,"redoing %s(%d)\n",fname,i);
 963                                 write_int(f_gen,i);
 964                         }
 965                 }
 966         }
 967
 968         if (preserve_hard_links)
 969                 do_hard_links(flist);
 970
 971         /* now we need to fix any directory permissions that were
 972            modified during the transfer */
 973         for (i = 0; i < flist->count; i++) {
 974                 file = flist->files[i];
 975                 if (!file->basename || !S_ISDIR(file->mode)) continue;
 976                 recv_generator(f_name(file),flist,i,-1);
 977         }
 978
 979         if (verbose > 2)
 980                 rprintf(FINFO,"recv_files finished\n");
 981
 982         return 0;
 983 }
 984
 985
 986
 987 void send_files(struct file_list *flist,int f_out,int f_in)
 988 {
 989   int fd;
 990   struct sum_struct *s;
 991   struct map_struct *buf;
 992   STRUCT_STAT st;
 993   char fname[MAXPATHLEN];
 994   int i;
 995   struct file_struct *file;
 996   int phase = 0;
 997
 998   if (verbose > 2)
 999     rprintf(FINFO,"send_files starting\n");
1000
1001   setup_readbuffer(f_in);
1002
1003   while (1) {
1004           int offset=0;
1005
1006           i = read_int(f_in);
1007           if (i == -1) {
1008                   if (phase==0 && remote_version >= 13) {
1009                           phase++;
1010                           csum_length = SUM_LENGTH;
1011                           write_int(f_out,-1);
1012                           if (verbose > 2)
1013                                   rprintf(FINFO,"send_files phase=%d\n",phase);
1014                           continue;
1015                   }
1016                   break;
1017           }
1018
1019           if (i < 0 || i >= flist->count) {
1020                   rprintf(FERROR,"Invalid file index %d (count=%d)\n",
1021                           i, flist->count);
1022                   exit_cleanup(1);
1023           }
1024
1025           file = flist->files[i];
1026
1027           stats.num_transferred_files++;
1028           stats.total_transferred_size += file->length;
1029
1030           fname[0] = 0;
1031           if (file->basedir) {
1032                   strlcpy(fname,file->basedir,MAXPATHLEN-1);
1033                   if (strlen(fname) == MAXPATHLEN-1) {
1034                           io_error = 1;
1035                           rprintf(FERROR, "send_files failed on long-named directory %s\n",
1036                                   fname);
1037                           return;
1038                   }
1039                   strlcat(fname,"/",MAXPATHLEN-1);
1040                   offset = strlen(file->basedir)+1;
1041           }
1042           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1043
1044           if (verbose > 2)
1045                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1046
1047           if (dry_run) {
1048                   if (!am_server && verbose)
1049                           printf("%s\n",fname);
1050                   write_int(f_out,i);
1051                   continue;
1052           }
1053
1054           s = receive_sums(f_in);
1055           if (!s) {
1056                   io_error = 1;
1057                   rprintf(FERROR,"receive_sums failed\n");
1058                   return;
1059           }
1060
1061           fd = open(fname,O_RDONLY);
1062           if (fd == -1) {
1063                   io_error = 1;
1064                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1065                           fname,strerror(errno));
1066                   free_sums(s);
1067                   continue;
1068           }
1069
1070           /* map the local file */
1071           if (do_fstat(fd,&st) != 0) {
1072                   io_error = 1;
1073                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1074                   free_sums(s);
1075                   close(fd);
1076                   return;
1077           }
1078
1079           if (st.st_size > 0) {
1080                   buf = map_file(fd,st.st_size);
1081           } else {
1082                   buf = NULL;
1083           }
1084
1085           if (verbose > 2)
1086                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1087                           fname,(int)st.st_size);
1088
1089           write_int(f_out,i);
1090
1091           write_int(f_out,s->count);
1092           write_int(f_out,s->n);
1093           write_int(f_out,s->remainder);
1094
1095           if (verbose > 2)
1096                   rprintf(FINFO,"calling match_sums %s\n",fname);
1097
1098           if (!am_server && verbose)
1099                   printf("%s\n",fname+offset);
1100
1101           match_sums(f_out,s,buf,st.st_size);
1102
1103           if (buf) unmap_file(buf);
1104           close(fd);
1105
1106           free_sums(s);
1107
1108           if (verbose > 2)
1109                   rprintf(FINFO,"sender finished %s\n",fname);
1110   }
1111
1112   if (verbose > 2)
1113           rprintf(FINFO,"send files finished\n");
1114
1115   match_report();
1116
1117   write_int(f_out,-1);
1118 }
1119
1120
1121
1122 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1123 {
1124   int i;
1125   int phase=0;
1126
1127   if (verbose > 2)
1128     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1129             (int)getpid(),flist->count);
1130
1131   for (i = 0; i < flist->count; i++) {
1132     struct file_struct *file = flist->files[i];
1133     mode_t saved_mode = file->mode;
1134     if (!file->basename) continue;
1135
1136     /* we need to ensure that any directories we create have writeable
1137        permissions initially so that we can create the files within
1138        them. This is then fixed after the files are transferred */
1139     if (!am_root && S_ISDIR(file->mode)) {
1140       file->mode |= S_IWUSR; /* user write */
1141     }
1142
1143     recv_generator(local_name?local_name:f_name(file),
1144                    flist,i,f);
1145
1146     file->mode = saved_mode;
1147   }
1148
1149   phase++;
1150   csum_length = SUM_LENGTH;
1151   ignore_times=1;
1152
1153   if (verbose > 2)
1154     rprintf(FINFO,"generate_files phase=%d\n",phase);
1155
1156   write_int(f,-1);
1157
1158   /* we expect to just sit around now, so don't exit on a timeout. If we
1159      really get a timeout then the other process should exit */
1160   io_timeout = 0;
1161
1162   if (remote_version >= 13) {
1163     /* in newer versions of the protocol the files can cycle through
1164        the system more than once to catch initial checksum errors */
1165     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1166       struct file_struct *file = flist->files[i];
1167       recv_generator(local_name?local_name:f_name(file),
1168                      flist,i,f);
1169     }
1170
1171     phase++;
1172     if (verbose > 2)
1173       rprintf(FINFO,"generate_files phase=%d\n",phase);
1174
1175     write_int(f,-1);
1176   }
1177 }
1178
1179