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         if (cleanup_fname)
 727                 do_unlink(cleanup_fname);
 728         signal(SIGUSR1, SIG_IGN);
 729         if (code) {
 730                 kill_all(SIGUSR1);
 731         }
 732         exit(code);
 733 }
 734
 735 void sig_int(void)
 736 {
 737   exit_cleanup(1);
 738 }
 739
 740
 741 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 742 {
 743   int fd1,fd2;
 744   STRUCT_STAT st;
 745   char *fname;
 746   char fnametmp[MAXPATHLEN];
 747   struct map_struct *buf;
 748   int i;
 749   struct file_struct *file;
 750   int phase=0;
 751   int recv_ok;
 752
 753   if (verbose > 2) {
 754     rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
 755   }
 756
 757   if (recurse && delete_mode && !local_name && flist->count>0) {
 758     delete_files(flist);
 759   }
 760
 761   while (1)
 762     {
 763       i = read_int(f_in);
 764       if (i == -1) {
 765         if (phase==0 && remote_version >= 13) {
 766           phase++;
 767           csum_length = SUM_LENGTH;
 768           if (verbose > 2)
 769             rprintf(FINFO,"recv_files phase=%d\n",phase);
 770           write_int(f_gen,-1);
 771           write_flush(f_gen);
 772           continue;
 773         }
 774         break;
 775       }
 776
 777       file = flist->files[i];
 778       fname = f_name(file);
 779
 780       if (local_name)
 781         fname = local_name;
 782
 783       if (dry_run) {
 784         if (!am_server && verbose)
 785           printf("%s\n",fname);
 786         continue;
 787       }
 788
 789       if (verbose > 2)
 790         rprintf(FINFO,"recv_files(%s)\n",fname);
 791
 792       /* open the file */
 793       fd1 = open(fname,O_RDONLY);
 794
 795       if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
 796         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 797         receive_data(f_in,NULL,-1,NULL);
 798         close(fd1);
 799         continue;
 800       }
 801
 802       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 803         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 804         receive_data(f_in,NULL,-1,NULL);
 805         close(fd1);
 806         continue;
 807       }
 808
 809       if (fd1 != -1 && st.st_size > 0) {
 810         buf = map_file(fd1,st.st_size);
 811         if (verbose > 2)
 812           rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 813       } else {
 814         buf = NULL;
 815       }
 816
 817       /* open tmp file */
 818       if (tmpdir) {
 819               char *f;
 820               f = strrchr(fname,'/');
 821               if (f == NULL)
 822                       f = fname;
 823               else
 824                       f++;
 825               if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
 826                       rprintf(FERROR,"filename too long\n");
 827                       if (buf) unmap_file(buf);
 828                       close(fd1);
 829                       continue;
 830               }
 831               slprintf(fnametmp,sizeof(fnametmp)-1, "%s/.%s.XXXXXX",tmpdir,f);
 832       } else {
 833               char *f = strrchr(fname,'/');
 834
 835               if (strlen(fname)+9 > MAXPATHLEN) {
 836                       rprintf(FERROR,"filename too long\n");
 837                       if (buf) unmap_file(buf);
 838                       close(fd1);
 839                       continue;
 840               }
 841
 842               if (f) {
 843                       *f = 0;
 844                       slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
 845                       *f = '/';
 846               } else {
 847                       slprintf(fnametmp,sizeof(fnametmp)-1,".%s.XXXXXX",fname);
 848               }
 849       }
 850       if (NULL == do_mktemp(fnametmp)) {
 851         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
 852         receive_data(f_in,buf,-1,NULL);
 853         if (buf) unmap_file(buf);
 854         close(fd1);
 855         continue;
 856       }
 857       fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 858       if (fd2 == -1 && relative_paths && errno == ENOENT &&
 859           create_directory_path(fnametmp) == 0) {
 860               fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 861       }
 862       if (fd2 == -1) {
 863         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 864         receive_data(f_in,buf,-1,NULL);
 865         if (buf) unmap_file(buf);
 866         close(fd1);
 867         continue;
 868       }
 869
 870       cleanup_fname = fnametmp;
 871
 872       if (!am_server && verbose)
 873         printf("%s\n",fname);
 874
 875       /* recv file data */
 876       recv_ok = receive_data(f_in,buf,fd2,fname);
 877
 878       if (buf) unmap_file(buf);
 879       if (fd1 != -1) {
 880         close(fd1);
 881       }
 882       close(fd2);
 883
 884       if (verbose > 2)
 885         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
 886
 887       if (make_backups) {
 888         char fnamebak[MAXPATHLEN];
 889         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 890                 rprintf(FERROR,"backup filename too long\n");
 891                 continue;
 892         }
 893         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
 894         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
 895           rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 896           continue;
 897         }
 898       }
 899
 900       /* move tmp file over real file */
 901       if (do_rename(fnametmp,fname) != 0) {
 902               if (errno == EXDEV) {
 903                       /* rename failed on cross-filesystem link.
 904                          Copy the file instead. */
 905                       if (copy_file(fnametmp,fname, file->mode)) {
 906                               rprintf(FERROR,"copy %s -> %s : %s\n",
 907                                       fnametmp,fname,strerror(errno));
 908                       } else {
 909                               set_perms(fname,file,NULL,0);
 910                       }
 911                       do_unlink(fnametmp);
 912               } else {
 913                       rprintf(FERROR,"rename %s -> %s : %s\n",
 914                               fnametmp,fname,strerror(errno));
 915                       do_unlink(fnametmp);
 916               }
 917       } else {
 918               set_perms(fname,file,NULL,0);
 919       }
 920
 921       cleanup_fname = NULL;
 922
 923
 924       if (!recv_ok) {
 925               if (csum_length == SUM_LENGTH) {
 926                       rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
 927                               fname);
 928               } else {
 929                       if (verbose > 1)
 930                               rprintf(FINFO,"redoing %s(%d)\n",fname,i);
 931                       write_int(f_gen,i);
 932               }
 933       }
 934     }
 935
 936   if (preserve_hard_links)
 937           do_hard_links(flist);
 938
 939   /* now we need to fix any directory permissions that were
 940      modified during the transfer */
 941   for (i = 0; i < flist->count; i++) {
 942           struct file_struct *file = flist->files[i];
 943           if (!file->basename || !S_ISDIR(file->mode)) continue;
 944           recv_generator(f_name(file),flist,i,-1);
 945   }
 946
 947   if (verbose > 2)
 948     rprintf(FINFO,"recv_files finished\n");
 949
 950   return 0;
 951 }
 952
 953
 954
 955 void send_files(struct file_list *flist,int f_out,int f_in)
 956 {
 957   int fd;
 958   struct sum_struct *s;
 959   struct map_struct *buf;
 960   STRUCT_STAT st;
 961   char fname[MAXPATHLEN];
 962   int i;
 963   struct file_struct *file;
 964   int phase = 0;
 965   int offset=0;
 966
 967   if (verbose > 2)
 968     rprintf(FINFO,"send_files starting\n");
 969
 970   setup_nonblocking(f_in,f_out);
 971
 972   while (1) {
 973           i = read_int(f_in);
 974           if (i == -1) {
 975                   if (phase==0 && remote_version >= 13) {
 976                           phase++;
 977                           csum_length = SUM_LENGTH;
 978                           write_int(f_out,-1);
 979                           write_flush(f_out);
 980                           if (verbose > 2)
 981                                   rprintf(FINFO,"send_files phase=%d\n",phase);
 982                           continue;
 983                   }
 984                   break;
 985           }
 986
 987           file = flist->files[i];
 988
 989           fname[0] = 0;
 990           if (file->basedir) {
 991                   strlcpy(fname,file->basedir,MAXPATHLEN-1);
 992                   if (strlen(fname) == MAXPATHLEN-1) {
 993                           io_error = 1;
 994                           rprintf(FERROR, "send_files failed on long-named directory %s\n",
 995                                   fname);
 996                           return;
 997                   }
 998                   strlcat(fname,"/",MAXPATHLEN-1);
 999                   offset = strlen(file->basedir)+1;
1000           }
1001           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1002
1003           if (verbose > 2)
1004                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1005
1006           if (dry_run) {
1007                   if (!am_server && verbose)
1008                           printf("%s\n",fname);
1009                   write_int(f_out,i);
1010                   continue;
1011           }
1012
1013           s = receive_sums(f_in);
1014           if (!s) {
1015                   io_error = 1;
1016                   rprintf(FERROR,"receive_sums failed\n");
1017                   return;
1018           }
1019
1020           fd = open(fname,O_RDONLY);
1021           if (fd == -1) {
1022                   io_error = 1;
1023                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1024                           fname,strerror(errno));
1025                   free_sums(s);
1026                   continue;
1027           }
1028
1029           /* map the local file */
1030           if (do_fstat(fd,&st) != 0) {
1031                   io_error = 1;
1032                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1033                   free_sums(s);
1034                   close(fd);
1035                   return;
1036           }
1037
1038           if (st.st_size > 0) {
1039                   buf = map_file(fd,st.st_size);
1040           } else {
1041                   buf = NULL;
1042           }
1043
1044           if (verbose > 2)
1045                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1046                           fname,(int)st.st_size);
1047
1048           write_int(f_out,i);
1049
1050           write_int(f_out,s->count);
1051           write_int(f_out,s->n);
1052           write_int(f_out,s->remainder);
1053
1054           if (verbose > 2)
1055                   rprintf(FINFO,"calling match_sums %s\n",fname);
1056
1057           if (!am_server && verbose)
1058                   printf("%s\n",fname+offset);
1059
1060           match_sums(f_out,s,buf,st.st_size);
1061           write_flush(f_out);
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   write_flush(f_out);
1079 }
1080
1081
1082
1083 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1084 {
1085   int i;
1086   int phase=0;
1087
1088   if (verbose > 2)
1089     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1090             (int)getpid(),flist->count);
1091
1092   for (i = 0; i < flist->count; i++) {
1093     struct file_struct *file = flist->files[i];
1094     mode_t saved_mode = file->mode;
1095     if (!file->basename) continue;
1096
1097     /* we need to ensure that any directories we create have writeable
1098        permissions initially so that we can create the files within
1099        them. This is then fixed after the files are transferred */
1100     if (!am_root && S_ISDIR(file->mode)) {
1101       file->mode |= S_IWUSR; /* user write */
1102     }
1103
1104     recv_generator(local_name?local_name:f_name(file),
1105                    flist,i,f);
1106
1107     file->mode = saved_mode;
1108   }
1109
1110   phase++;
1111   csum_length = SUM_LENGTH;
1112   ignore_times=1;
1113
1114   if (verbose > 2)
1115     rprintf(FINFO,"generate_files phase=%d\n",phase);
1116
1117   write_int(f,-1);
1118   write_flush(f);
1119
1120   /* we expect to just sit around now, so don't exit on a timeout. If we
1121      really get a timeout then the other process should exit */
1122   io_timeout = 0;
1123
1124   if (remote_version >= 13) {
1125     /* in newer versions of the protocol the files can cycle through
1126        the system more than once to catch initial checksum errors */
1127     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1128       struct file_struct *file = flist->files[i];
1129       recv_generator(local_name?local_name:f_name(file),
1130                      flist,i,f);
1131     }
1132
1133     phase++;
1134     if (verbose > 2)
1135       rprintf(FINFO,"generate_files phase=%d\n",phase);
1136
1137     write_int(f,-1);
1138     write_flush(f);
1139   }
1140
1141
1142   if (verbose > 2)
1143     rprintf(FINFO,"generator wrote %ld\n",(long)write_total());
1144 }
1145
1146