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                 if (!delete_list) {
 642                         delete_list = (struct delete_list *)malloc(sizeof(delete_list[0])*dlist_alloc_len);
 643                 } else {
 644                         delete_list = (struct delete_list *)realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
 645                 }
 646                 if (!delete_list) out_of_memory("add_delete_entry");
 647         }
 648
 649         delete_list[dlist_len].dev = file->dev;
 650         delete_list[dlist_len].inode = file->inode;
 651         dlist_len++;
 652
 653         if (verbose > 3)
 654                 rprintf(FINFO,"added %s to delete list\n", f_name(file));
 655 }
 656
 657 /* yuck! This function wouldn't have been necessary if I had the sorting
 658    algorithm right. Unfortunately fixing the sorting algorithm would introduce
 659    a backward incompatibility as file list indexes are sent over the link.
 660 */
 661 static int delete_already_done(struct file_list *flist,int j)
 662 {
 663         int i;
 664         STRUCT_STAT st;
 665
 666         if (link_stat(f_name(flist->files[j]), &st)) return 1;
 667
 668         for (i=0;i<dlist_len;i++) {
 669                 if (st.st_ino == delete_list[i].inode &&
 670                     st.st_dev == delete_list[i].dev)
 671                         return 1;
 672         }
 673
 674         return 0;
 675 }
 676
 677
 678 /* this deletes any files on the receiving side that are not present
 679    on the sending side. For version 1.6.4 I have changed the behaviour
 680    to match more closely what most people seem to expect of this option */
 681 static void delete_files(struct file_list *flist)
 682 {
 683         struct file_list *local_file_list;
 684         int i, j;
 685         char *name;
 686
 687         if (cvs_exclude)
 688                 add_cvs_excludes();
 689
 690         if (io_error) {
 691                 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
 692                 return;
 693         }
 694
 695         for (j=0;j<flist->count;j++) {
 696                 if (!S_ISDIR(flist->files[j]->mode) ||
 697                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
 698
 699                 if (remote_version < 19 &&
 700                     delete_already_done(flist, j)) continue;
 701
 702                 name = strdup(f_name(flist->files[j]));
 703
 704                 if (!(local_file_list = send_file_list(-1,1,&name))) {
 705                         free(name);
 706                         continue;
 707                 }
 708
 709                 if (verbose > 1)
 710                         rprintf(FINFO,"deleting in %s\n", name);
 711
 712                 for (i=local_file_list->count-1;i>=0;i--) {
 713                         if (!local_file_list->files[i]->basename) continue;
 714                         if (remote_version < 19 &&
 715                             S_ISDIR(local_file_list->files[i]->mode))
 716                                 add_delete_entry(local_file_list->files[i]);
 717                         if (-1 == flist_find(flist,local_file_list->files[i])) {
 718                                 delete_one(local_file_list->files[i]);
 719                         }
 720                 }
 721                 flist_free(local_file_list);
 722                 free(name);
 723         }
 724 }
 725
 726 static char *cleanup_fname;
 727
 728 void exit_cleanup(int code)
 729 {
 730         io_flush();
 731         if (cleanup_fname)
 732                 do_unlink(cleanup_fname);
 733         signal(SIGUSR1, SIG_IGN);
 734         if (code) {
 735                 kill_all(SIGUSR1);
 736         }
 737         exit(code);
 738 }
 739
 740 void sig_int(void)
 741 {
 742   exit_cleanup(1);
 743 }
 744
 745
 746 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 747 {
 748   int fd1,fd2;
 749   STRUCT_STAT st;
 750   char *fname;
 751   char fnametmp[MAXPATHLEN];
 752   struct map_struct *buf;
 753   int i;
 754   struct file_struct *file;
 755   int phase=0;
 756   int recv_ok;
 757
 758   if (verbose > 2) {
 759     rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
 760   }
 761
 762   if (recurse && delete_mode && !local_name && flist->count>0) {
 763     delete_files(flist);
 764   }
 765
 766   while (1)
 767     {
 768       i = read_int(f_in);
 769       if (i == -1) {
 770         if (phase==0 && remote_version >= 13) {
 771           phase++;
 772           csum_length = SUM_LENGTH;
 773           if (verbose > 2)
 774             rprintf(FINFO,"recv_files phase=%d\n",phase);
 775           write_int(f_gen,-1);
 776           continue;
 777         }
 778         break;
 779       }
 780
 781       file = flist->files[i];
 782       fname = f_name(file);
 783
 784       if (local_name)
 785         fname = local_name;
 786
 787       if (dry_run) {
 788         if (!am_server && verbose)
 789           printf("%s\n",fname);
 790         continue;
 791       }
 792
 793       if (verbose > 2)
 794         rprintf(FINFO,"recv_files(%s)\n",fname);
 795
 796       /* open the file */
 797       fd1 = open(fname,O_RDONLY);
 798
 799       if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
 800         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 801         receive_data(f_in,NULL,-1,NULL);
 802         close(fd1);
 803         continue;
 804       }
 805
 806       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 807         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 808         receive_data(f_in,NULL,-1,NULL);
 809         close(fd1);
 810         continue;
 811       }
 812
 813       if (fd1 != -1 && st.st_size > 0) {
 814         buf = map_file(fd1,st.st_size);
 815         if (verbose > 2)
 816           rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 817       } else {
 818         buf = NULL;
 819       }
 820
 821       /* open tmp file */
 822       if (tmpdir) {
 823               char *f;
 824               f = strrchr(fname,'/');
 825               if (f == NULL)
 826                       f = fname;
 827               else
 828                       f++;
 829               if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
 830                       rprintf(FERROR,"filename too long\n");
 831                       if (buf) unmap_file(buf);
 832                       close(fd1);
 833                       continue;
 834               }
 835               slprintf(fnametmp,sizeof(fnametmp)-1, "%s/.%s.XXXXXX",tmpdir,f);
 836       } else {
 837               char *f = strrchr(fname,'/');
 838
 839               if (strlen(fname)+9 > MAXPATHLEN) {
 840                       rprintf(FERROR,"filename too long\n");
 841                       if (buf) unmap_file(buf);
 842                       close(fd1);
 843                       continue;
 844               }
 845
 846               if (f) {
 847                       *f = 0;
 848                       slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
 849                       *f = '/';
 850               } else {
 851                       slprintf(fnametmp,sizeof(fnametmp)-1,".%s.XXXXXX",fname);
 852               }
 853       }
 854       if (NULL == do_mktemp(fnametmp)) {
 855         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
 856         receive_data(f_in,buf,-1,NULL);
 857         if (buf) unmap_file(buf);
 858         close(fd1);
 859         continue;
 860       }
 861       fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 862       if (fd2 == -1 && relative_paths && errno == ENOENT &&
 863           create_directory_path(fnametmp) == 0) {
 864               fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 865       }
 866       if (fd2 == -1) {
 867         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 868         receive_data(f_in,buf,-1,NULL);
 869         if (buf) unmap_file(buf);
 870         close(fd1);
 871         continue;
 872       }
 873
 874       cleanup_fname = fnametmp;
 875
 876       if (!am_server && verbose)
 877         printf("%s\n",fname);
 878
 879       /* recv file data */
 880       recv_ok = receive_data(f_in,buf,fd2,fname);
 881
 882       if (buf) unmap_file(buf);
 883       if (fd1 != -1) {
 884         close(fd1);
 885       }
 886       close(fd2);
 887
 888       if (verbose > 2)
 889         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
 890
 891       if (make_backups) {
 892         char fnamebak[MAXPATHLEN];
 893         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 894                 rprintf(FERROR,"backup filename too long\n");
 895                 continue;
 896         }
 897         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
 898         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
 899           rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 900           continue;
 901         }
 902       }
 903
 904       /* move tmp file over real file */
 905       if (do_rename(fnametmp,fname) != 0) {
 906               if (errno == EXDEV) {
 907                       /* rename failed on cross-filesystem link.
 908                          Copy the file instead. */
 909                       if (copy_file(fnametmp,fname, file->mode)) {
 910                               rprintf(FERROR,"copy %s -> %s : %s\n",
 911                                       fnametmp,fname,strerror(errno));
 912                       } else {
 913                               set_perms(fname,file,NULL,0);
 914                       }
 915                       do_unlink(fnametmp);
 916               } else {
 917                       rprintf(FERROR,"rename %s -> %s : %s\n",
 918                               fnametmp,fname,strerror(errno));
 919                       do_unlink(fnametmp);
 920               }
 921       } else {
 922               set_perms(fname,file,NULL,0);
 923       }
 924
 925       cleanup_fname = NULL;
 926
 927
 928       if (!recv_ok) {
 929               if (csum_length == SUM_LENGTH) {
 930                       rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
 931                               fname);
 932               } else {
 933                       if (verbose > 1)
 934                               rprintf(FINFO,"redoing %s(%d)\n",fname,i);
 935                       write_int(f_gen,i);
 936               }
 937       }
 938     }
 939
 940   if (preserve_hard_links)
 941           do_hard_links(flist);
 942
 943   /* now we need to fix any directory permissions that were
 944      modified during the transfer */
 945   for (i = 0; i < flist->count; i++) {
 946           file = flist->files[i];
 947           if (!file->basename || !S_ISDIR(file->mode)) continue;
 948           recv_generator(f_name(file),flist,i,-1);
 949   }
 950
 951   if (verbose > 2)
 952     rprintf(FINFO,"recv_files finished\n");
 953
 954   return 0;
 955 }
 956
 957
 958
 959 void send_files(struct file_list *flist,int f_out,int f_in)
 960 {
 961   int fd;
 962   struct sum_struct *s;
 963   struct map_struct *buf;
 964   STRUCT_STAT st;
 965   char fname[MAXPATHLEN];
 966   int i;
 967   struct file_struct *file;
 968   int phase = 0;
 969   int offset=0;
 970
 971   if (verbose > 2)
 972     rprintf(FINFO,"send_files starting\n");
 973
 974   setup_readbuffer(f_in);
 975
 976   while (1) {
 977           i = read_int(f_in);
 978           if (i == -1) {
 979                   if (phase==0 && remote_version >= 13) {
 980                           phase++;
 981                           csum_length = SUM_LENGTH;
 982                           write_int(f_out,-1);
 983                           if (verbose > 2)
 984                                   rprintf(FINFO,"send_files phase=%d\n",phase);
 985                           continue;
 986                   }
 987                   break;
 988           }
 989
 990           file = flist->files[i];
 991
 992           fname[0] = 0;
 993           if (file->basedir) {
 994                   strlcpy(fname,file->basedir,MAXPATHLEN-1);
 995                   if (strlen(fname) == MAXPATHLEN-1) {
 996                           io_error = 1;
 997                           rprintf(FERROR, "send_files failed on long-named directory %s\n",
 998                                   fname);
 999                           return;
1000                   }
1001                   strlcat(fname,"/",MAXPATHLEN-1);
1002                   offset = strlen(file->basedir)+1;
1003           }
1004           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1005
1006           if (verbose > 2)
1007                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1008
1009           if (dry_run) {
1010                   if (!am_server && verbose)
1011                           printf("%s\n",fname);
1012                   write_int(f_out,i);
1013                   continue;
1014           }
1015
1016           s = receive_sums(f_in);
1017           if (!s) {
1018                   io_error = 1;
1019                   rprintf(FERROR,"receive_sums failed\n");
1020                   return;
1021           }
1022
1023           fd = open(fname,O_RDONLY);
1024           if (fd == -1) {
1025                   io_error = 1;
1026                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1027                           fname,strerror(errno));
1028                   free_sums(s);
1029                   continue;
1030           }
1031
1032           /* map the local file */
1033           if (do_fstat(fd,&st) != 0) {
1034                   io_error = 1;
1035                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1036                   free_sums(s);
1037                   close(fd);
1038                   return;
1039           }
1040
1041           if (st.st_size > 0) {
1042                   buf = map_file(fd,st.st_size);
1043           } else {
1044                   buf = NULL;
1045           }
1046
1047           if (verbose > 2)
1048                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1049                           fname,(int)st.st_size);
1050
1051           write_int(f_out,i);
1052
1053           write_int(f_out,s->count);
1054           write_int(f_out,s->n);
1055           write_int(f_out,s->remainder);
1056
1057           if (verbose > 2)
1058                   rprintf(FINFO,"calling match_sums %s\n",fname);
1059
1060           if (!am_server && verbose)
1061                   printf("%s\n",fname+offset);
1062
1063           match_sums(f_out,s,buf,st.st_size);
1064
1065           if (buf) unmap_file(buf);
1066           close(fd);
1067
1068           free_sums(s);
1069
1070           if (verbose > 2)
1071                   rprintf(FINFO,"sender finished %s\n",fname);
1072   }
1073
1074   if (verbose > 2)
1075           rprintf(FINFO,"send files finished\n");
1076
1077   match_report();
1078
1079   write_int(f_out,-1);
1080 }
1081
1082
1083
1084 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1085 {
1086   int i;
1087   int phase=0;
1088
1089   if (verbose > 2)
1090     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1091             (int)getpid(),flist->count);
1092
1093   for (i = 0; i < flist->count; i++) {
1094     struct file_struct *file = flist->files[i];
1095     mode_t saved_mode = file->mode;
1096     if (!file->basename) continue;
1097
1098     /* we need to ensure that any directories we create have writeable
1099        permissions initially so that we can create the files within
1100        them. This is then fixed after the files are transferred */
1101     if (!am_root && S_ISDIR(file->mode)) {
1102       file->mode |= S_IWUSR; /* user write */
1103     }
1104
1105     recv_generator(local_name?local_name:f_name(file),
1106                    flist,i,f);
1107
1108     file->mode = saved_mode;
1109   }
1110
1111   phase++;
1112   csum_length = SUM_LENGTH;
1113   ignore_times=1;
1114
1115   if (verbose > 2)
1116     rprintf(FINFO,"generate_files phase=%d\n",phase);
1117
1118   write_int(f,-1);
1119
1120   /* we expect to just sit around now, so don't exit on a timeout. If we
1121      really get a timeout then the other process should exit */
1122   io_timeout = 0;
1123
1124   if (remote_version >= 13) {
1125     /* in newer versions of the protocol the files can cycle through
1126        the system more than once to catch initial checksum errors */
1127     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1128       struct file_struct *file = flist->files[i];
1129       recv_generator(local_name?local_name:f_name(file),
1130                      flist,i,f);
1131     }
1132
1133     phase++;
1134     if (verbose > 2)
1135       rprintf(FINFO,"generate_files phase=%d\n",phase);
1136
1137     write_int(f,-1);
1138   }
1139
1140
1141   if (verbose > 2)
1142     rprintf(FINFO,"generator wrote %ld\n",(long)write_total());
1143 }
1144
1145