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   write_flush(f_out);
 151 }
 152
 153
 154 /*
 155   generate a stream of signatures/checksums that describe a buffer
 156
 157   generate approximately one checksum every n bytes
 158   */
 159 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
 160 {
 161   int i;
 162   struct sum_struct *s;
 163   int count;
 164   int block_len = n;
 165   int remainder = (len%block_len);
 166   OFF_T offset = 0;
 167
 168   count = (len+(block_len-1))/block_len;
 169
 170   s = (struct sum_struct *)malloc(sizeof(*s));
 171   if (!s) out_of_memory("generate_sums");
 172
 173   s->count = count;
 174   s->remainder = remainder;
 175   s->n = n;
 176   s->flength = len;
 177
 178   if (count==0) {
 179     s->sums = NULL;
 180     return s;
 181   }
 182
 183   if (verbose > 3)
 184     rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
 185             s->count,s->remainder,s->n,(int)s->flength);
 186
 187   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
 188   if (!s->sums) out_of_memory("generate_sums");
 189
 190   for (i=0;i<count;i++) {
 191     int n1 = MIN(len,n);
 192     char *map = map_ptr(buf,offset,n1);
 193
 194     s->sums[i].sum1 = get_checksum1(map,n1);
 195     get_checksum2(map,n1,s->sums[i].sum2);
 196
 197     s->sums[i].offset = offset;
 198     s->sums[i].len = n1;
 199     s->sums[i].i = i;
 200
 201     if (verbose > 3)
 202       rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
 203               i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
 204
 205     len -= n1;
 206     offset += n1;
 207   }
 208
 209   return s;
 210 }
 211
 212
 213 /*
 214   receive the checksums for a buffer
 215   */
 216 static struct sum_struct *receive_sums(int f)
 217 {
 218   struct sum_struct *s;
 219   int i;
 220   OFF_T offset = 0;
 221
 222   s = (struct sum_struct *)malloc(sizeof(*s));
 223   if (!s) out_of_memory("receive_sums");
 224
 225   s->count = read_int(f);
 226   s->n = read_int(f);
 227   s->remainder = read_int(f);
 228   s->sums = NULL;
 229
 230   if (verbose > 3)
 231     rprintf(FINFO,"count=%d n=%d rem=%d\n",
 232             s->count,s->n,s->remainder);
 233
 234   if (s->count == 0)
 235     return(s);
 236
 237   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
 238   if (!s->sums) out_of_memory("receive_sums");
 239
 240   for (i=0;i<s->count;i++) {
 241     s->sums[i].sum1 = read_int(f);
 242     read_buf(f,s->sums[i].sum2,csum_length);
 243
 244     s->sums[i].offset = offset;
 245     s->sums[i].i = i;
 246
 247     if (i == s->count-1 && s->remainder != 0) {
 248       s->sums[i].len = s->remainder;
 249     } else {
 250       s->sums[i].len = s->n;
 251     }
 252     offset += s->sums[i].len;
 253
 254     if (verbose > 3)
 255       rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
 256               i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
 257   }
 258
 259   s->flength = offset;
 260
 261   return s;
 262 }
 263
 264
 265 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
 266                      int report)
 267 {
 268   int updated = 0;
 269   STRUCT_STAT st2;
 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 && preserve_uid && st->st_uid != file->uid) ||
 304       (preserve_gid && st->st_gid != file->gid)) {
 305           if (do_lchown(fname,
 306                         (am_root&&preserve_uid)?file->uid:-1,
 307                         preserve_gid?file->gid:-1) != 0) {
 308                   if (preserve_uid && st->st_uid != file->uid)
 309                           updated = 1;
 310                   if (verbose>1 || preserve_uid)
 311                           rprintf(FERROR,"chown %s : %s\n",
 312                                   fname,strerror(errno));
 313                   return updated;
 314           }
 315           updated = 1;
 316   }
 317
 318   if (verbose > 1 && report) {
 319           if (updated)
 320                   rprintf(FINFO,"%s\n",fname);
 321           else
 322                   rprintf(FINFO,"%s is uptodate\n",fname);
 323   }
 324   return updated;
 325 }
 326
 327
 328 /* choose whether to skip a particular file */
 329 static int skip_file(char *fname,
 330                      struct file_struct *file, STRUCT_STAT *st)
 331 {
 332         if (st->st_size != file->length) {
 333                 return 0;
 334         }
 335
 336         /* if always checksum is set then we use the checksum instead
 337            of the file time to determine whether to sync */
 338         if (always_checksum && S_ISREG(st->st_mode)) {
 339                 char sum[MD4_SUM_LENGTH];
 340                 file_checksum(fname,sum,st->st_size);
 341                 return (memcmp(sum,file->sum,csum_length) == 0);
 342         }
 343
 344         if (ignore_times) {
 345                 return 0;
 346         }
 347
 348         return (st->st_mtime == file->modtime);
 349 }
 350
 351
 352 /* use a larger block size for really big files */
 353 int adapt_block_size(struct file_struct *file, int bsize)
 354 {
 355         int ret = file->length / (10000); /* rough heuristic */
 356         ret = ret & ~15; /* multiple of 16 */
 357         if (ret < bsize) ret = bsize;
 358         if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
 359         return ret;
 360 }
 361
 362 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 363 {
 364   int fd;
 365   STRUCT_STAT st;
 366   struct map_struct *buf;
 367   struct sum_struct *s;
 368   int statret;
 369   struct file_struct *file = flist->files[i];
 370
 371   if (verbose > 2)
 372     rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
 373
 374   statret = link_stat(fname,&st);
 375
 376   if (S_ISDIR(file->mode)) {
 377     if (dry_run) return;
 378     if (statret == 0 && !S_ISDIR(st.st_mode)) {
 379       if (do_unlink(fname) != 0) {
 380         rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
 381         return;
 382       }
 383       statret = -1;
 384     }
 385     if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
 386             if (!(relative_paths && errno==ENOENT &&
 387                   create_directory_path(fname)==0 &&
 388                   do_mkdir(fname,file->mode)==0)) {
 389                     rprintf(FERROR,"mkdir %s : %s (2)\n",
 390                             fname,strerror(errno));
 391             }
 392     }
 393     if (set_perms(fname,file,NULL,0) && verbose)
 394       rprintf(FINFO,"%s/\n",fname);
 395     return;
 396   }
 397
 398   if (preserve_links && S_ISLNK(file->mode)) {
 399 #if SUPPORT_LINKS
 400     char lnk[MAXPATHLEN];
 401     int l;
 402     if (statret == 0) {
 403       l = readlink(fname,lnk,MAXPATHLEN-1);
 404       if (l > 0) {
 405         lnk[l] = 0;
 406         if (strcmp(lnk,file->link) == 0) {
 407           set_perms(fname,file,&st,1);
 408           return;
 409         }
 410       }
 411     }
 412     delete_file(fname);
 413     if (do_symlink(file->link,fname) != 0) {
 414       rprintf(FERROR,"link %s -> %s : %s\n",
 415               fname,file->link,strerror(errno));
 416     } else {
 417       set_perms(fname,file,NULL,0);
 418       if (verbose)
 419         rprintf(FINFO,"%s -> %s\n",
 420                 fname,file->link);
 421     }
 422 #endif
 423     return;
 424   }
 425
 426 #ifdef HAVE_MKNOD
 427   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
 428     if (statret != 0 ||
 429         st.st_mode != file->mode ||
 430         st.st_rdev != file->rdev) {
 431       delete_file(fname);
 432       if (verbose > 2)
 433         rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
 434                 fname,(int)file->mode,(int)file->rdev);
 435       if (do_mknod(fname,file->mode,file->rdev) != 0) {
 436         rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
 437       } else {
 438         set_perms(fname,file,NULL,0);
 439         if (verbose)
 440           rprintf(FINFO,"%s\n",fname);
 441       }
 442     } else {
 443       set_perms(fname,file,&st,1);
 444     }
 445     return;
 446   }
 447 #endif
 448
 449   if (preserve_hard_links && check_hard_link(file)) {
 450     if (verbose > 1)
 451       rprintf(FINFO,"%s is a hard link\n",f_name(file));
 452     return;
 453   }
 454
 455   if (!S_ISREG(file->mode)) {
 456     rprintf(FINFO,"skipping non-regular file %s\n",fname);
 457     return;
 458   }
 459
 460   if (statret == -1) {
 461     if (errno == ENOENT) {
 462       write_int(f_out,i);
 463       if (!dry_run) send_sums(NULL,f_out);
 464     } else {
 465       if (verbose > 1)
 466         rprintf(FERROR,"recv_generator failed to open %s\n",fname);
 467     }
 468     return;
 469   }
 470
 471   if (!S_ISREG(st.st_mode)) {
 472     if (delete_file(fname) != 0) {
 473       return;
 474     }
 475
 476     /* now pretend the file didn't exist */
 477     write_int(f_out,i);
 478     if (!dry_run) send_sums(NULL,f_out);
 479     return;
 480   }
 481
 482   if (update_only && st.st_mtime > file->modtime) {
 483     if (verbose > 1)
 484       rprintf(FINFO,"%s is newer\n",fname);
 485     return;
 486   }
 487
 488   if (skip_file(fname, file, &st)) {
 489     set_perms(fname,file,&st,1);
 490     return;
 491   }
 492
 493   if (dry_run) {
 494     write_int(f_out,i);
 495     return;
 496   }
 497
 498   if (whole_file) {
 499     write_int(f_out,i);
 500     send_sums(NULL,f_out);
 501     return;
 502   }
 503
 504   /* open the file */
 505   fd = open(fname,O_RDONLY);
 506
 507   if (fd == -1) {
 508     rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
 509     rprintf(FERROR,"skipping %s\n",fname);
 510     return;
 511   }
 512
 513   if (st.st_size > 0) {
 514     buf = map_file(fd,st.st_size);
 515   } else {
 516     buf = NULL;
 517   }
 518
 519   if (verbose > 3)
 520     rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
 521
 522   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
 523
 524   if (verbose > 2)
 525     rprintf(FINFO,"sending sums for %d\n",i);
 526
 527   write_int(f_out,i);
 528   send_sums(s,f_out);
 529   write_flush(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 (delete_already_done(flist, j)) continue;
 698
 699                 name = strdup(f_name(flist->files[j]));
 700
 701                 if (!(local_file_list = send_file_list(-1,1,&name))) {
 702                         free(name);
 703                         continue;
 704                 }
 705
 706                 if (verbose > 1)
 707                         rprintf(FINFO,"deleting in %s\n", name);
 708
 709                 for (i=local_file_list->count-1;i>=0;i--) {
 710                         if (!local_file_list->files[i]->basename) continue;
 711                         if (S_ISDIR(local_file_list->files[i]->mode))
 712                                 add_delete_entry(local_file_list->files[i]);
 713                         if (-1 == flist_find(flist,local_file_list->files[i])) {
 714                                 delete_one(local_file_list->files[i]);
 715                         }
 716                 }
 717                 flist_free(local_file_list);
 718                 free(name);
 719         }
 720 }
 721
 722 static char *cleanup_fname;
 723
 724 void exit_cleanup(int code)
 725 {
 726         io_flush();
 727         if (cleanup_fname)
 728                 do_unlink(cleanup_fname);
 729         signal(SIGUSR1, SIG_IGN);
 730         if (code) {
 731                 kill_all(SIGUSR1);
 732         }
 733         exit(code);
 734 }
 735
 736 void sig_int(void)
 737 {
 738   exit_cleanup(1);
 739 }
 740
 741
 742 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 743 {
 744   int fd1,fd2;
 745   STRUCT_STAT st;
 746   char *fname;
 747   char fnametmp[MAXPATHLEN];
 748   struct map_struct *buf;
 749   int i;
 750   struct file_struct *file;
 751   int phase=0;
 752   int recv_ok;
 753
 754   if (verbose > 2) {
 755     rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
 756   }
 757
 758   if (recurse && delete_mode && !local_name && flist->count>0) {
 759     delete_files(flist);
 760   }
 761
 762   while (1)
 763     {
 764       i = read_int(f_in);
 765       if (i == -1) {
 766         if (phase==0 && remote_version >= 13) {
 767           phase++;
 768           csum_length = SUM_LENGTH;
 769           if (verbose > 2)
 770             rprintf(FINFO,"recv_files phase=%d\n",phase);
 771           write_int(f_gen,-1);
 772           write_flush(f_gen);
 773           continue;
 774         }
 775         break;
 776       }
 777
 778       file = flist->files[i];
 779       fname = f_name(file);
 780
 781       if (local_name)
 782         fname = local_name;
 783
 784       if (dry_run) {
 785         if (!am_server && verbose)
 786           printf("%s\n",fname);
 787         continue;
 788       }
 789
 790       if (verbose > 2)
 791         rprintf(FINFO,"recv_files(%s)\n",fname);
 792
 793       /* open the file */
 794       fd1 = open(fname,O_RDONLY);
 795
 796       if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
 797         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 798         receive_data(f_in,NULL,-1,NULL);
 799         close(fd1);
 800         continue;
 801       }
 802
 803       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 804         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 805         receive_data(f_in,NULL,-1,NULL);
 806         close(fd1);
 807         continue;
 808       }
 809
 810       if (fd1 != -1 && st.st_size > 0) {
 811         buf = map_file(fd1,st.st_size);
 812         if (verbose > 2)
 813           rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 814       } else {
 815         buf = NULL;
 816       }
 817
 818       /* open tmp file */
 819       if (tmpdir) {
 820               char *f;
 821               f = strrchr(fname,'/');
 822               if (f == NULL)
 823                       f = fname;
 824               else
 825                       f++;
 826               if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
 827                       rprintf(FERROR,"filename too long\n");
 828                       if (buf) unmap_file(buf);
 829                       close(fd1);
 830                       continue;
 831               }
 832               slprintf(fnametmp,sizeof(fnametmp)-1, "%s/.%s.XXXXXX",tmpdir,f);
 833       } else {
 834               char *f = strrchr(fname,'/');
 835
 836               if (strlen(fname)+9 > MAXPATHLEN) {
 837                       rprintf(FERROR,"filename too long\n");
 838                       if (buf) unmap_file(buf);
 839                       close(fd1);
 840                       continue;
 841               }
 842
 843               if (f) {
 844                       *f = 0;
 845                       slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
 846                       *f = '/';
 847               } else {
 848                       slprintf(fnametmp,sizeof(fnametmp)-1,".%s.XXXXXX",fname);
 849               }
 850       }
 851       if (NULL == do_mktemp(fnametmp)) {
 852         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
 853         receive_data(f_in,buf,-1,NULL);
 854         if (buf) unmap_file(buf);
 855         close(fd1);
 856         continue;
 857       }
 858       fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 859       if (fd2 == -1 && relative_paths && errno == ENOENT &&
 860           create_directory_path(fnametmp) == 0) {
 861               fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 862       }
 863       if (fd2 == -1) {
 864         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 865         receive_data(f_in,buf,-1,NULL);
 866         if (buf) unmap_file(buf);
 867         close(fd1);
 868         continue;
 869       }
 870
 871       cleanup_fname = fnametmp;
 872
 873       if (!am_server && verbose)
 874         printf("%s\n",fname);
 875
 876       /* recv file data */
 877       recv_ok = receive_data(f_in,buf,fd2,fname);
 878
 879       if (buf) unmap_file(buf);
 880       if (fd1 != -1) {
 881         close(fd1);
 882       }
 883       close(fd2);
 884
 885       if (verbose > 2)
 886         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
 887
 888       if (make_backups) {
 889         char fnamebak[MAXPATHLEN];
 890         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 891                 rprintf(FERROR,"backup filename too long\n");
 892                 continue;
 893         }
 894         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
 895         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
 896           rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 897           continue;
 898         }
 899       }
 900
 901       /* move tmp file over real file */
 902       if (do_rename(fnametmp,fname) != 0) {
 903               if (errno == EXDEV) {
 904                       /* rename failed on cross-filesystem link.
 905                          Copy the file instead. */
 906                       if (copy_file(fnametmp,fname, file->mode)) {
 907                               rprintf(FERROR,"copy %s -> %s : %s\n",
 908                                       fnametmp,fname,strerror(errno));
 909                       } else {
 910                               set_perms(fname,file,NULL,0);
 911                       }
 912                       do_unlink(fnametmp);
 913               } else {
 914                       rprintf(FERROR,"rename %s -> %s : %s\n",
 915                               fnametmp,fname,strerror(errno));
 916                       do_unlink(fnametmp);
 917               }
 918       } else {
 919               set_perms(fname,file,NULL,0);
 920       }
 921
 922       cleanup_fname = NULL;
 923
 924
 925       if (!recv_ok) {
 926               if (csum_length == SUM_LENGTH) {
 927                       rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
 928                               fname);
 929               } else {
 930                       if (verbose > 1)
 931                               rprintf(FINFO,"redoing %s(%d)\n",fname,i);
 932                       write_int(f_gen,i);
 933               }
 934       }
 935     }
 936
 937   if (preserve_hard_links)
 938           do_hard_links(flist);
 939
 940   /* now we need to fix any directory permissions that were
 941      modified during the transfer */
 942   for (i = 0; i < flist->count; i++) {
 943           struct file_struct *file = flist->files[i];
 944           if (!file->basename || !S_ISDIR(file->mode)) continue;
 945           recv_generator(f_name(file),flist,i,-1);
 946   }
 947
 948   if (verbose > 2)
 949     rprintf(FINFO,"recv_files finished\n");
 950
 951   return 0;
 952 }
 953
 954
 955
 956 void send_files(struct file_list *flist,int f_out,int f_in)
 957 {
 958   int fd;
 959   struct sum_struct *s;
 960   struct map_struct *buf;
 961   STRUCT_STAT st;
 962   char fname[MAXPATHLEN];
 963   int i;
 964   struct file_struct *file;
 965   int phase = 0;
 966   int offset=0;
 967
 968   if (verbose > 2)
 969     rprintf(FINFO,"send_files starting\n");
 970
 971   setup_nonblocking(f_in,f_out);
 972
 973   while (1) {
 974           i = read_int(f_in);
 975           if (i == -1) {
 976                   if (phase==0 && remote_version >= 13) {
 977                           phase++;
 978                           csum_length = SUM_LENGTH;
 979                           write_int(f_out,-1);
 980                           write_flush(f_out);
 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           write_flush(f_out);
1063
1064           if (buf) unmap_file(buf);
1065           close(fd);
1066
1067           free_sums(s);
1068
1069           if (verbose > 2)
1070                   rprintf(FINFO,"sender finished %s\n",fname);
1071   }
1072
1073   if (verbose > 2)
1074           rprintf(FINFO,"send files finished\n");
1075
1076   match_report();
1077
1078   write_int(f_out,-1);
1079   write_flush(f_out);
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   write_flush(f);
1120
1121   /* we expect to just sit around now, so don't exit on a timeout. If we
1122      really get a timeout then the other process should exit */
1123   io_timeout = 0;
1124
1125   if (remote_version >= 13) {
1126     /* in newer versions of the protocol the files can cycle through
1127        the system more than once to catch initial checksum errors */
1128     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1129       struct file_struct *file = flist->files[i];
1130       recv_generator(local_name?local_name:f_name(file),
1131                      flist,i,f);
1132     }
1133
1134     phase++;
1135     if (verbose > 2)
1136       rprintf(FINFO,"generate_files phase=%d\n",phase);
1137
1138     write_int(f,-1);
1139     write_flush(f);
1140   }
1141
1142
1143   if (verbose > 2)
1144     rprintf(FINFO,"generator wrote %ld\n",(long)write_total());
1145 }
1146
1147