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