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
  78         if (do_unlink(fname) == 0 || errno == ENOENT) return 0;
  79
  80 #if SUPPORT_LINKS
  81         ret = do_lstat(fname, &st);
  82 #else
  83         ret = do_stat(fname, &st);
  84 #endif
  85         if (ret) {
  86                 rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
  87                 return -1;
  88         }
  89
  90         if (!S_ISDIR(st.st_mode)) {
  91                 rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno));
  92                 return -1;
  93         }
  94
  95         if (do_rmdir(fname) == 0 || errno == ENOENT) return 0;
  96         if (!force_delete || (errno != ENOTEMPTY && errno != EEXIST)) {
  97                 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
  98                 return -1;
  99         }
 100
 101         /* now we do a recsursive delete on the directory ... */
 102         d = opendir(fname);
 103         if (!d) {
 104                 rprintf(FERROR,"opendir(%s): %s\n",
 105                         fname,strerror(errno));
 106                 return -1;
 107         }
 108
 109         for (di=readdir(d); di; di=readdir(d)) {
 110                 char *dname = d_name(di);
 111                 if (strcmp(dname,".")==0 ||
 112                     strcmp(dname,"..")==0)
 113                         continue;
 114                 strlcpy(buf, fname, (MAXPATHLEN-strlen(dname))-2);
 115                 strcat(buf, "/");
 116                 strcat(buf, dname);
 117                 buf[MAXPATHLEN-1] = 0;
 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   write_flush(f_out);
 154 }
 155
 156
 157 /*
 158   generate a stream of signatures/checksums that describe a buffer
 159
 160   generate approximately one checksum every n bytes
 161   */
 162 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
 163 {
 164   int i;
 165   struct sum_struct *s;
 166   int count;
 167   int block_len = n;
 168   int remainder = (len%block_len);
 169   OFF_T offset = 0;
 170
 171   count = (len+(block_len-1))/block_len;
 172
 173   s = (struct sum_struct *)malloc(sizeof(*s));
 174   if (!s) out_of_memory("generate_sums");
 175
 176   s->count = count;
 177   s->remainder = remainder;
 178   s->n = n;
 179   s->flength = len;
 180
 181   if (count==0) {
 182     s->sums = NULL;
 183     return s;
 184   }
 185
 186   if (verbose > 3)
 187     rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
 188             s->count,s->remainder,s->n,(int)s->flength);
 189
 190   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
 191   if (!s->sums) out_of_memory("generate_sums");
 192
 193   for (i=0;i<count;i++) {
 194     int n1 = MIN(len,n);
 195     char *map = map_ptr(buf,offset,n1);
 196
 197     s->sums[i].sum1 = get_checksum1(map,n1);
 198     get_checksum2(map,n1,s->sums[i].sum2);
 199
 200     s->sums[i].offset = offset;
 201     s->sums[i].len = n1;
 202     s->sums[i].i = i;
 203
 204     if (verbose > 3)
 205       rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
 206               i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
 207
 208     len -= n1;
 209     offset += n1;
 210   }
 211
 212   return s;
 213 }
 214
 215
 216 /*
 217   receive the checksums for a buffer
 218   */
 219 static struct sum_struct *receive_sums(int f)
 220 {
 221   struct sum_struct *s;
 222   int i;
 223   OFF_T offset = 0;
 224
 225   s = (struct sum_struct *)malloc(sizeof(*s));
 226   if (!s) out_of_memory("receive_sums");
 227
 228   s->count = read_int(f);
 229   s->n = read_int(f);
 230   s->remainder = read_int(f);
 231   s->sums = NULL;
 232
 233   if (verbose > 3)
 234     rprintf(FINFO,"count=%d n=%d rem=%d\n",
 235             s->count,s->n,s->remainder);
 236
 237   if (s->count == 0)
 238     return(s);
 239
 240   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
 241   if (!s->sums) out_of_memory("receive_sums");
 242
 243   for (i=0;i<s->count;i++) {
 244     s->sums[i].sum1 = read_int(f);
 245     read_buf(f,s->sums[i].sum2,csum_length);
 246
 247     s->sums[i].offset = offset;
 248     s->sums[i].i = i;
 249
 250     if (i == s->count-1 && s->remainder != 0) {
 251       s->sums[i].len = s->remainder;
 252     } else {
 253       s->sums[i].len = s->n;
 254     }
 255     offset += s->sums[i].len;
 256
 257     if (verbose > 3)
 258       rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
 259               i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
 260   }
 261
 262   s->flength = offset;
 263
 264   return s;
 265 }
 266
 267
 268 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
 269                      int report)
 270 {
 271   int updated = 0;
 272   STRUCT_STAT st2;
 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 && 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   write_flush(f_out);
 533
 534   close(fd);
 535   if (buf) unmap_file(buf);
 536
 537   free_sums(s);
 538 }
 539
 540
 541
 542 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
 543 {
 544   int i,n,remainder,len,count;
 545   OFF_T offset = 0;
 546   OFF_T offset2;
 547   char *data;
 548   static char file_sum1[MD4_SUM_LENGTH];
 549   static char file_sum2[MD4_SUM_LENGTH];
 550   char *map=NULL;
 551
 552   count = read_int(f_in);
 553   n = read_int(f_in);
 554   remainder = read_int(f_in);
 555
 556   sum_init();
 557
 558   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
 559     if (i > 0) {
 560       if (verbose > 3)
 561         rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
 562
 563       sum_update(data,i);
 564
 565       if (fd != -1 && write_file(fd,data,i) != i) {
 566         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 567         exit_cleanup(1);
 568       }
 569       offset += i;
 570     } else {
 571       i = -(i+1);
 572       offset2 = i*n;
 573       len = n;
 574       if (i == count-1 && remainder != 0)
 575         len = remainder;
 576
 577       if (verbose > 3)
 578         rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
 579                 i,len,(int)offset2,(int)offset);
 580
 581       map = map_ptr(buf,offset2,len);
 582
 583       see_token(map, len);
 584       sum_update(map,len);
 585
 586       if (fd != -1 && write_file(fd,map,len) != len) {
 587         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 588         exit_cleanup(1);
 589       }
 590       offset += len;
 591     }
 592   }
 593
 594   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
 595     rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 596     exit_cleanup(1);
 597   }
 598
 599   sum_end(file_sum1);
 600
 601   if (remote_version >= 14) {
 602     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
 603     if (verbose > 2)
 604       rprintf(FINFO,"got file_sum\n");
 605     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
 606       return 0;
 607   }
 608   return 1;
 609 }
 610
 611
 612 static void delete_one(struct file_struct *f)
 613 {
 614   if (!S_ISDIR(f->mode)) {
 615     if (do_unlink(f_name(f)) != 0) {
 616       rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
 617     } else if (verbose) {
 618       rprintf(FINFO,"deleting %s\n",f_name(f));
 619     }
 620   } else {
 621     if (do_rmdir(f_name(f)) != 0) {
 622       if (errno != ENOTEMPTY && errno != EEXIST)
 623         rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
 624     } else if (verbose) {
 625       rprintf(FINFO,"deleting directory %s\n",f_name(f));
 626     }
 627   }
 628 }
 629
 630
 631
 632 static struct delete_list {
 633         dev_t dev;
 634         ino_t inode;
 635 } *delete_list;
 636 static int dlist_len, dlist_alloc_len;
 637
 638 static void add_delete_entry(struct file_struct *file)
 639 {
 640         if (dlist_len == dlist_alloc_len) {
 641                 dlist_alloc_len += 1024;
 642                 if (!delete_list) {
 643                         delete_list = (struct delete_list *)malloc(sizeof(delete_list[0])*dlist_alloc_len);
 644                 } else {
 645                         delete_list = (struct delete_list *)realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
 646                 }
 647                 if (!delete_list) out_of_memory("add_delete_entry");
 648         }
 649
 650         delete_list[dlist_len].dev = file->dev;
 651         delete_list[dlist_len].inode = file->inode;
 652         dlist_len++;
 653
 654         if (verbose > 3)
 655                 rprintf(FINFO,"added %s to delete list\n", f_name(file));
 656 }
 657
 658 /* yuck! This function wouldn't have been necessary if I had the sorting
 659    algorithm right. Unfortunately fixing the sorting algorithm would introduce
 660    a backward incompatibility as file list indexes are sent over the link.
 661 */
 662 static int delete_already_done(struct file_list *flist,int j)
 663 {
 664         int i;
 665         STRUCT_STAT st;
 666
 667         if (link_stat(f_name(flist->files[j]), &st)) return 1;
 668
 669         for (i=0;i<dlist_len;i++) {
 670                 if (st.st_ino == delete_list[i].inode &&
 671                     st.st_dev == delete_list[i].dev)
 672                         return 1;
 673         }
 674
 675         return 0;
 676 }
 677
 678
 679 /* this deletes any files on the receiving side that are not present
 680    on the sending side. For version 1.6.4 I have changed the behaviour
 681    to match more closely what most people seem to expect of this option */
 682 static void delete_files(struct file_list *flist)
 683 {
 684         struct file_list *local_file_list;
 685         int i, j;
 686         char *name;
 687
 688         if (cvs_exclude)
 689                 add_cvs_excludes();
 690
 691         if (io_error) {
 692                 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
 693                 return;
 694         }
 695
 696         for (j=0;j<flist->count;j++) {
 697                 if (!S_ISDIR(flist->files[j]->mode) ||
 698                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
 699
 700                 if (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 (S_ISDIR(local_file_list->files[i]->mode))
 715                                 add_delete_entry(local_file_list->files[i]);
 716                         if (-1 == flist_find(flist,local_file_list->files[i])) {
 717                                 delete_one(local_file_list->files[i]);
 718                         }
 719                 }
 720                 flist_free(local_file_list);
 721                 free(name);
 722         }
 723 }
 724
 725 static char *cleanup_fname;
 726
 727 void exit_cleanup(int code)
 728 {
 729         if (cleanup_fname)
 730                 do_unlink(cleanup_fname);
 731         signal(SIGUSR1, SIG_IGN);
 732         if (code) {
 733                 kill_all(SIGUSR1);
 734         }
 735         exit(code);
 736 }
 737
 738 void sig_int(void)
 739 {
 740   exit_cleanup(1);
 741 }
 742
 743
 744 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 745 {
 746   int fd1,fd2;
 747   STRUCT_STAT st;
 748   char *fname;
 749   char fnametmp[MAXPATHLEN];
 750   struct map_struct *buf;
 751   int i;
 752   struct file_struct *file;
 753   int phase=0;
 754   int recv_ok;
 755
 756   if (verbose > 2) {
 757     rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
 758   }
 759
 760   if (recurse && delete_mode && !local_name && flist->count>0) {
 761     delete_files(flist);
 762   }
 763
 764   while (1)
 765     {
 766       i = read_int(f_in);
 767       if (i == -1) {
 768         if (phase==0 && remote_version >= 13) {
 769           phase++;
 770           csum_length = SUM_LENGTH;
 771           if (verbose > 2)
 772             rprintf(FINFO,"recv_files phase=%d\n",phase);
 773           write_int(f_gen,-1);
 774           write_flush(f_gen);
 775           continue;
 776         }
 777         break;
 778       }
 779
 780       file = flist->files[i];
 781       fname = f_name(file);
 782
 783       if (local_name)
 784         fname = local_name;
 785
 786       if (dry_run) {
 787         if (!am_server && verbose)
 788           printf("%s\n",fname);
 789         continue;
 790       }
 791
 792       if (verbose > 2)
 793         rprintf(FINFO,"recv_files(%s)\n",fname);
 794
 795       /* open the file */
 796       fd1 = open(fname,O_RDONLY);
 797
 798       if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
 799         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 800         receive_data(f_in,NULL,-1,NULL);
 801         close(fd1);
 802         continue;
 803       }
 804
 805       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 806         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 807         receive_data(f_in,NULL,-1,NULL);
 808         close(fd1);
 809         continue;
 810       }
 811
 812       if (fd1 != -1 && st.st_size > 0) {
 813         buf = map_file(fd1,st.st_size);
 814         if (verbose > 2)
 815           rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 816       } else {
 817         buf = NULL;
 818       }
 819
 820       /* open tmp file */
 821       if (tmpdir) {
 822               char *f;
 823               f = strrchr(fname,'/');
 824               if (f == NULL)
 825                       f = fname;
 826               else
 827                       f++;
 828               if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
 829                       rprintf(FERROR,"filename too long\n");
 830                       if (buf) unmap_file(buf);
 831                       close(fd1);
 832                       continue;
 833               }
 834               sprintf(fnametmp,"%s/.%s.XXXXXX",tmpdir,f);
 835       } else {
 836               char *f = strrchr(fname,'/');
 837
 838               if (strlen(fname)+9 > MAXPATHLEN) {
 839                       rprintf(FERROR,"filename too long\n");
 840                       if (buf) unmap_file(buf);
 841                       close(fd1);
 842                       continue;
 843               }
 844
 845               if (f) {
 846                       *f = 0;
 847                       sprintf(fnametmp,"%s/.%s.XXXXXX",fname,f+1);
 848                       *f = '/';
 849               } else {
 850                       sprintf(fnametmp,".%s.XXXXXX",fname);
 851               }
 852       }
 853       if (NULL == do_mktemp(fnametmp)) {
 854         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
 855         receive_data(f_in,buf,-1,NULL);
 856         if (buf) unmap_file(buf);
 857         close(fd1);
 858         continue;
 859       }
 860       fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 861       if (fd2 == -1 && relative_paths && errno == ENOENT &&
 862           create_directory_path(fnametmp) == 0) {
 863               fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 864       }
 865       if (fd2 == -1) {
 866         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 867         receive_data(f_in,buf,-1,NULL);
 868         if (buf) unmap_file(buf);
 869         close(fd1);
 870         continue;
 871       }
 872
 873       cleanup_fname = fnametmp;
 874
 875       if (!am_server && verbose)
 876         printf("%s\n",fname);
 877
 878       /* recv file data */
 879       recv_ok = receive_data(f_in,buf,fd2,fname);
 880
 881       if (buf) unmap_file(buf);
 882       if (fd1 != -1) {
 883         close(fd1);
 884       }
 885       close(fd2);
 886
 887       if (verbose > 2)
 888         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
 889
 890       if (make_backups) {
 891         char fnamebak[MAXPATHLEN];
 892         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 893                 rprintf(FERROR,"backup filename too long\n");
 894                 continue;
 895         }
 896         sprintf(fnamebak,"%s%s",fname,backup_suffix);
 897         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
 898           rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 899           continue;
 900         }
 901       }
 902
 903       /* move tmp file over real file */
 904       if (do_rename(fnametmp,fname) != 0) {
 905               if (errno == EXDEV) {
 906                       /* rename failed on cross-filesystem link.
 907                          Copy the file instead. */
 908                       if (copy_file(fnametmp,fname, file->mode)) {
 909                               rprintf(FERROR,"copy %s -> %s : %s\n",
 910                                       fnametmp,fname,strerror(errno));
 911                       } else {
 912                               set_perms(fname,file,NULL,0);
 913                       }
 914                       do_unlink(fnametmp);
 915               } else {
 916                       rprintf(FERROR,"rename %s -> %s : %s\n",
 917                               fnametmp,fname,strerror(errno));
 918                       do_unlink(fnametmp);
 919               }
 920       } else {
 921               set_perms(fname,file,NULL,0);
 922       }
 923
 924       cleanup_fname = NULL;
 925
 926
 927       if (!recv_ok) {
 928               if (csum_length == SUM_LENGTH) {
 929                       rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
 930                               fname);
 931               } else {
 932                       if (verbose > 1)
 933                               rprintf(FINFO,"redoing %s(%d)\n",fname,i);
 934                       write_int(f_gen,i);
 935               }
 936       }
 937     }
 938
 939   if (preserve_hard_links)
 940           do_hard_links(flist);
 941
 942   /* now we need to fix any directory permissions that were
 943      modified during the transfer */
 944   for (i = 0; i < flist->count; i++) {
 945           struct file_struct *file = flist->files[i];
 946           if (!file->basename || !S_ISDIR(file->mode)) continue;
 947           recv_generator(f_name(file),flist,i,-1);
 948   }
 949
 950   if (verbose > 2)
 951     rprintf(FINFO,"recv_files finished\n");
 952
 953   return 0;
 954 }
 955
 956
 957
 958 void send_files(struct file_list *flist,int f_out,int f_in)
 959 {
 960   int fd;
 961   struct sum_struct *s;
 962   struct map_struct *buf;
 963   STRUCT_STAT st;
 964   char fname[MAXPATHLEN];
 965   int i;
 966   struct file_struct *file;
 967   int phase = 0;
 968   int offset=0;
 969
 970   if (verbose > 2)
 971     rprintf(FINFO,"send_files starting\n");
 972
 973   setup_nonblocking(f_in,f_out);
 974
 975   while (1) {
 976           i = read_int(f_in);
 977           if (i == -1) {
 978                   if (phase==0 && remote_version >= 13) {
 979                           phase++;
 980                           csum_length = SUM_LENGTH;
 981                           write_int(f_out,-1);
 982                           write_flush(f_out);
 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                   strcat(fname,"/");
1002                   offset = strlen(file->basedir)+1;
1003           }
1004           strncat(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           write_flush(f_out);
1065
1066           if (buf) unmap_file(buf);
1067           close(fd);
1068
1069           free_sums(s);
1070
1071           if (verbose > 2)
1072                   rprintf(FINFO,"sender finished %s\n",fname);
1073   }
1074
1075   if (verbose > 2)
1076           rprintf(FINFO,"send files finished\n");
1077
1078   match_report();
1079
1080   write_int(f_out,-1);
1081   write_flush(f_out);
1082 }
1083
1084
1085
1086 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1087 {
1088   int i;
1089   int phase=0;
1090
1091   if (verbose > 2)
1092     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1093             (int)getpid(),flist->count);
1094
1095   for (i = 0; i < flist->count; i++) {
1096     struct file_struct *file = flist->files[i];
1097     mode_t saved_mode = file->mode;
1098     if (!file->basename) continue;
1099
1100     /* we need to ensure that any directories we create have writeable
1101        permissions initially so that we can create the files within
1102        them. This is then fixed after the files are transferred */
1103     if (!am_root && S_ISDIR(file->mode)) {
1104       file->mode |= S_IWUSR; /* user write */
1105     }
1106
1107     recv_generator(local_name?local_name:f_name(file),
1108                    flist,i,f);
1109
1110     file->mode = saved_mode;
1111   }
1112
1113   phase++;
1114   csum_length = SUM_LENGTH;
1115   ignore_times=1;
1116
1117   if (verbose > 2)
1118     rprintf(FINFO,"generate_files phase=%d\n",phase);
1119
1120   write_int(f,-1);
1121   write_flush(f);
1122
1123   /* we expect to just sit around now, so don't exit on a timeout. If we
1124      really get a timeout then the other process should exit */
1125   io_timeout = 0;
1126
1127   if (remote_version >= 13) {
1128     /* in newer versions of the protocol the files can cycle through
1129        the system more than once to catch initial checksum errors */
1130     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1131       struct file_struct *file = flist->files[i];
1132       recv_generator(local_name?local_name:f_name(file),
1133                      flist,i,f);
1134     }
1135
1136     phase++;
1137     if (verbose > 2)
1138       rprintf(FINFO,"generate_files phase=%d\n",phase);
1139
1140     write_int(f,-1);
1141     write_flush(f);
1142   }
1143
1144
1145   if (verbose > 2)
1146     rprintf(FINFO,"generator wrote %ld\n",(long)write_total());
1147 }
1148
1149