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   extern int am_daemon;
 271
 272   if (dry_run) return 0;
 273
 274   if (!st) {
 275     if (link_stat(fname,&st2) != 0) {
 276       rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
 277       return 0;
 278     }
 279     st = &st2;
 280   }
 281
 282   if (preserve_times && !S_ISLNK(st->st_mode) &&
 283       st->st_mtime != file->modtime) {
 284     updated = 1;
 285     if (set_modtime(fname,file->modtime) != 0) {
 286       rprintf(FERROR,"failed to set times on %s : %s\n",
 287               fname,strerror(errno));
 288       return 0;
 289     }
 290   }
 291
 292 #ifdef HAVE_CHMOD
 293   if (preserve_perms && !S_ISLNK(st->st_mode) &&
 294       st->st_mode != file->mode) {
 295     updated = 1;
 296     if (do_chmod(fname,file->mode) != 0) {
 297       rprintf(FERROR,"failed to set permissions on %s : %s\n",
 298               fname,strerror(errno));
 299       return 0;
 300     }
 301   }
 302 #endif
 303
 304   if ((am_root || !am_daemon) &&
 305       ((am_root && preserve_uid && st->st_uid != file->uid) ||
 306        (preserve_gid && st->st_gid != file->gid))) {
 307           if (do_lchown(fname,
 308                         (am_root&&preserve_uid)?file->uid:-1,
 309                         preserve_gid?file->gid:-1) != 0) {
 310                   if (preserve_uid && st->st_uid != file->uid)
 311                           updated = 1;
 312                   if (verbose>1 || preserve_uid)
 313                           rprintf(FERROR,"chown %s : %s\n",
 314                                   fname,strerror(errno));
 315                   return updated;
 316           }
 317           updated = 1;
 318   }
 319
 320   if (verbose > 1 && report) {
 321           if (updated)
 322                   rprintf(FINFO,"%s\n",fname);
 323           else
 324                   rprintf(FINFO,"%s is uptodate\n",fname);
 325   }
 326   return updated;
 327 }
 328
 329
 330 /* choose whether to skip a particular file */
 331 static int skip_file(char *fname,
 332                      struct file_struct *file, STRUCT_STAT *st)
 333 {
 334         if (st->st_size != file->length) {
 335                 return 0;
 336         }
 337
 338         /* if always checksum is set then we use the checksum instead
 339            of the file time to determine whether to sync */
 340         if (always_checksum && S_ISREG(st->st_mode)) {
 341                 char sum[MD4_SUM_LENGTH];
 342                 file_checksum(fname,sum,st->st_size);
 343                 return (memcmp(sum,file->sum,csum_length) == 0);
 344         }
 345
 346         if (ignore_times) {
 347                 return 0;
 348         }
 349
 350         return (st->st_mtime == file->modtime);
 351 }
 352
 353
 354 /* use a larger block size for really big files */
 355 int adapt_block_size(struct file_struct *file, int bsize)
 356 {
 357         int ret = file->length / (10000); /* rough heuristic */
 358         ret = ret & ~15; /* multiple of 16 */
 359         if (ret < bsize) ret = bsize;
 360         if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
 361         return ret;
 362 }
 363
 364 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 365 {
 366   int fd;
 367   STRUCT_STAT st;
 368   struct map_struct *buf;
 369   struct sum_struct *s;
 370   int statret;
 371   struct file_struct *file = flist->files[i];
 372
 373   if (verbose > 2)
 374     rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
 375
 376   statret = link_stat(fname,&st);
 377
 378   if (S_ISDIR(file->mode)) {
 379     if (dry_run) return;
 380     if (statret == 0 && !S_ISDIR(st.st_mode)) {
 381       if (do_unlink(fname) != 0) {
 382         rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
 383         return;
 384       }
 385       statret = -1;
 386     }
 387     if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
 388             if (!(relative_paths && errno==ENOENT &&
 389                   create_directory_path(fname)==0 &&
 390                   do_mkdir(fname,file->mode)==0)) {
 391                     rprintf(FERROR,"mkdir %s : %s (2)\n",
 392                             fname,strerror(errno));
 393             }
 394     }
 395     if (set_perms(fname,file,NULL,0) && verbose)
 396       rprintf(FINFO,"%s/\n",fname);
 397     return;
 398   }
 399
 400   if (preserve_links && S_ISLNK(file->mode)) {
 401 #if SUPPORT_LINKS
 402     char lnk[MAXPATHLEN];
 403     int l;
 404     if (statret == 0) {
 405       l = readlink(fname,lnk,MAXPATHLEN-1);
 406       if (l > 0) {
 407         lnk[l] = 0;
 408         if (strcmp(lnk,file->link) == 0) {
 409           set_perms(fname,file,&st,1);
 410           return;
 411         }
 412       }
 413     }
 414     delete_file(fname);
 415     if (do_symlink(file->link,fname) != 0) {
 416       rprintf(FERROR,"link %s -> %s : %s\n",
 417               fname,file->link,strerror(errno));
 418     } else {
 419       set_perms(fname,file,NULL,0);
 420       if (verbose)
 421         rprintf(FINFO,"%s -> %s\n",
 422                 fname,file->link);
 423     }
 424 #endif
 425     return;
 426   }
 427
 428 #ifdef HAVE_MKNOD
 429   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
 430     if (statret != 0 ||
 431         st.st_mode != file->mode ||
 432         st.st_rdev != file->rdev) {
 433       delete_file(fname);
 434       if (verbose > 2)
 435         rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
 436                 fname,(int)file->mode,(int)file->rdev);
 437       if (do_mknod(fname,file->mode,file->rdev) != 0) {
 438         rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
 439       } else {
 440         set_perms(fname,file,NULL,0);
 441         if (verbose)
 442           rprintf(FINFO,"%s\n",fname);
 443       }
 444     } else {
 445       set_perms(fname,file,&st,1);
 446     }
 447     return;
 448   }
 449 #endif
 450
 451   if (preserve_hard_links && check_hard_link(file)) {
 452     if (verbose > 1)
 453       rprintf(FINFO,"%s is a hard link\n",f_name(file));
 454     return;
 455   }
 456
 457   if (!S_ISREG(file->mode)) {
 458     rprintf(FINFO,"skipping non-regular file %s\n",fname);
 459     return;
 460   }
 461
 462   if (statret == -1) {
 463     if (errno == ENOENT) {
 464       write_int(f_out,i);
 465       if (!dry_run) send_sums(NULL,f_out);
 466     } else {
 467       if (verbose > 1)
 468         rprintf(FERROR,"recv_generator failed to open %s\n",fname);
 469     }
 470     return;
 471   }
 472
 473   if (!S_ISREG(st.st_mode)) {
 474     if (delete_file(fname) != 0) {
 475       return;
 476     }
 477
 478     /* now pretend the file didn't exist */
 479     write_int(f_out,i);
 480     if (!dry_run) send_sums(NULL,f_out);
 481     return;
 482   }
 483
 484   if (update_only && st.st_mtime > file->modtime) {
 485     if (verbose > 1)
 486       rprintf(FINFO,"%s is newer\n",fname);
 487     return;
 488   }
 489
 490   if (skip_file(fname, file, &st)) {
 491     set_perms(fname,file,&st,1);
 492     return;
 493   }
 494
 495   if (dry_run) {
 496     write_int(f_out,i);
 497     return;
 498   }
 499
 500   if (whole_file) {
 501     write_int(f_out,i);
 502     send_sums(NULL,f_out);
 503     return;
 504   }
 505
 506   /* open the file */
 507   fd = open(fname,O_RDONLY);
 508
 509   if (fd == -1) {
 510     rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
 511     rprintf(FERROR,"skipping %s\n",fname);
 512     return;
 513   }
 514
 515   if (st.st_size > 0) {
 516     buf = map_file(fd,st.st_size);
 517   } else {
 518     buf = NULL;
 519   }
 520
 521   if (verbose > 3)
 522     rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
 523
 524   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
 525
 526   if (verbose > 2)
 527     rprintf(FINFO,"sending sums for %d\n",i);
 528
 529   write_int(f_out,i);
 530   send_sums(s,f_out);
 531   write_flush(f_out);
 532
 533   close(fd);
 534   if (buf) unmap_file(buf);
 535
 536   free_sums(s);
 537 }
 538
 539
 540
 541 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
 542 {
 543   int i,n,remainder,len,count;
 544   OFF_T offset = 0;
 545   OFF_T offset2;
 546   char *data;
 547   static char file_sum1[MD4_SUM_LENGTH];
 548   static char file_sum2[MD4_SUM_LENGTH];
 549   char *map=NULL;
 550
 551   count = read_int(f_in);
 552   n = read_int(f_in);
 553   remainder = read_int(f_in);
 554
 555   sum_init();
 556
 557   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
 558     if (i > 0) {
 559       if (verbose > 3)
 560         rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
 561
 562       sum_update(data,i);
 563
 564       if (fd != -1 && write_file(fd,data,i) != i) {
 565         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 566         exit_cleanup(1);
 567       }
 568       offset += i;
 569     } else {
 570       i = -(i+1);
 571       offset2 = i*n;
 572       len = n;
 573       if (i == count-1 && remainder != 0)
 574         len = remainder;
 575
 576       if (verbose > 3)
 577         rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
 578                 i,len,(int)offset2,(int)offset);
 579
 580       map = map_ptr(buf,offset2,len);
 581
 582       see_token(map, len);
 583       sum_update(map,len);
 584
 585       if (fd != -1 && write_file(fd,map,len) != len) {
 586         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 587         exit_cleanup(1);
 588       }
 589       offset += len;
 590     }
 591   }
 592
 593   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
 594     rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 595     exit_cleanup(1);
 596   }
 597
 598   sum_end(file_sum1);
 599
 600   if (remote_version >= 14) {
 601     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
 602     if (verbose > 2)
 603       rprintf(FINFO,"got file_sum\n");
 604     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
 605       return 0;
 606   }
 607   return 1;
 608 }
 609
 610
 611 static void delete_one(struct file_struct *f)
 612 {
 613   if (!S_ISDIR(f->mode)) {
 614     if (do_unlink(f_name(f)) != 0) {
 615       rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
 616     } else if (verbose) {
 617       rprintf(FINFO,"deleting %s\n",f_name(f));
 618     }
 619   } else {
 620     if (do_rmdir(f_name(f)) != 0) {
 621       if (errno != ENOTEMPTY && errno != EEXIST)
 622         rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
 623     } else if (verbose) {
 624       rprintf(FINFO,"deleting directory %s\n",f_name(f));
 625     }
 626   }
 627 }
 628
 629
 630
 631 static struct delete_list {
 632         dev_t dev;
 633         ino_t inode;
 634 } *delete_list;
 635 static int dlist_len, dlist_alloc_len;
 636
 637 static void add_delete_entry(struct file_struct *file)
 638 {
 639         if (dlist_len == dlist_alloc_len) {
 640                 dlist_alloc_len += 1024;
 641                 if (!delete_list) {
 642                         delete_list = (struct delete_list *)malloc(sizeof(delete_list[0])*dlist_alloc_len);
 643                 } else {
 644                         delete_list = (struct delete_list *)realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
 645                 }
 646                 if (!delete_list) out_of_memory("add_delete_entry");
 647         }
 648
 649         delete_list[dlist_len].dev = file->dev;
 650         delete_list[dlist_len].inode = file->inode;
 651         dlist_len++;
 652
 653         if (verbose > 3)
 654                 rprintf(FINFO,"added %s to delete list\n", f_name(file));
 655 }
 656
 657 /* yuck! This function wouldn't have been necessary if I had the sorting
 658    algorithm right. Unfortunately fixing the sorting algorithm would introduce
 659    a backward incompatibility as file list indexes are sent over the link.
 660 */
 661 static int delete_already_done(struct file_list *flist,int j)
 662 {
 663         int i;
 664         STRUCT_STAT st;
 665
 666         if (link_stat(f_name(flist->files[j]), &st)) return 1;
 667
 668         for (i=0;i<dlist_len;i++) {
 669                 if (st.st_ino == delete_list[i].inode &&
 670                     st.st_dev == delete_list[i].dev)
 671                         return 1;
 672         }
 673
 674         return 0;
 675 }
 676
 677
 678 /* this deletes any files on the receiving side that are not present
 679    on the sending side. For version 1.6.4 I have changed the behaviour
 680    to match more closely what most people seem to expect of this option */
 681 static void delete_files(struct file_list *flist)
 682 {
 683         struct file_list *local_file_list;
 684         int i, j;
 685         char *name;
 686
 687         if (cvs_exclude)
 688                 add_cvs_excludes();
 689
 690         if (io_error) {
 691                 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
 692                 return;
 693         }
 694
 695         for (j=0;j<flist->count;j++) {
 696                 if (!S_ISDIR(flist->files[j]->mode) ||
 697                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
 698
 699                 if (delete_already_done(flist, j)) continue;
 700
 701                 name = strdup(f_name(flist->files[j]));
 702
 703                 if (!(local_file_list = send_file_list(-1,1,&name))) {
 704                         free(name);
 705                         continue;
 706                 }
 707
 708                 if (verbose > 1)
 709                         rprintf(FINFO,"deleting in %s\n", name);
 710
 711                 for (i=local_file_list->count-1;i>=0;i--) {
 712                         if (!local_file_list->files[i]->basename) continue;
 713                         if (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           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               slprintf(fnametmp,sizeof(fnametmp)-1, "%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                       slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
 848                       *f = '/';
 849               } else {
 850                       slprintf(fnametmp,sizeof(fnametmp)-1,".%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         slprintf(fnamebak,sizeof(fnamebak)-1,"%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           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                   strlcat(fname,"/",MAXPATHLEN-1);
1002                   offset = strlen(file->basedir)+1;
1003           }
1004           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1005
1006           if (verbose > 2)
1007                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1008
1009           if (dry_run) {
1010                   if (!am_server && verbose)
1011                           printf("%s\n",fname);
1012                   write_int(f_out,i);
1013                   continue;
1014           }
1015
1016           s = receive_sums(f_in);
1017           if (!s) {
1018                   io_error = 1;
1019                   rprintf(FERROR,"receive_sums failed\n");
1020                   return;
1021           }
1022
1023           fd = open(fname,O_RDONLY);
1024           if (fd == -1) {
1025                   io_error = 1;
1026                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1027                           fname,strerror(errno));
1028                   free_sums(s);
1029                   continue;
1030           }
1031
1032           /* map the local file */
1033           if (do_fstat(fd,&st) != 0) {
1034                   io_error = 1;
1035                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1036                   free_sums(s);
1037                   close(fd);
1038                   return;
1039           }
1040
1041           if (st.st_size > 0) {
1042                   buf = map_file(fd,st.st_size);
1043           } else {
1044                   buf = NULL;
1045           }
1046
1047           if (verbose > 2)
1048                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1049                           fname,(int)st.st_size);
1050
1051           write_int(f_out,i);
1052
1053           write_int(f_out,s->count);
1054           write_int(f_out,s->n);
1055           write_int(f_out,s->remainder);
1056
1057           if (verbose > 2)
1058                   rprintf(FINFO,"calling match_sums %s\n",fname);
1059
1060           if (!am_server && verbose)
1061                   printf("%s\n",fname+offset);
1062
1063           match_sums(f_out,s,buf,st.st_size);
1064           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