flist.c

   1 /*
   2    Copyright (C) Andrew Tridgell 1996
   3    Copyright (C) Paul Mackerras 1996
   4    Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 /** @file flist.c
  22  * Generate and receive file lists
  23  *
  24  * @todo Get rid of the string_area optimization.  Efficiently
  25  * allocating blocks is the responsibility of the system's malloc
  26  * library, not of rsync.
  27  *
  28  * @sa http://lists.samba.org/pipermail/rsync/2000-June/002351.html
  29  *
  30  **/
  31
  32 #include "rsync.h"
  33
  34 extern struct stats stats;
  35
  36 extern int verbose;
  37 extern int do_progress;
  38 extern int am_server;
  39 extern int always_checksum;
  40
  41 extern int cvs_exclude;
  42
  43 extern int recurse;
  44
  45 extern int one_file_system;
  46 extern int make_backups;
  47 extern int preserve_links;
  48 extern int preserve_hard_links;
  49 extern int preserve_perms;
  50 extern int preserve_devices;
  51 extern int preserve_uid;
  52 extern int preserve_gid;
  53 extern int preserve_times;
  54 extern int relative_paths;
  55 extern int copy_links;
  56 extern int copy_unsafe_links;
  57 extern int remote_version;
  58 extern int io_error;
  59 extern int sanitize_paths;
  60
  61 extern int read_batch;
  62 extern int write_batch;
  63
  64 static char topsrcname[MAXPATHLEN];
  65
  66 static struct exclude_struct **local_exclude_list;
  67
  68 static struct file_struct null_file;
  69
  70 static void clean_flist(struct file_list *flist, int strip_root);
  71
  72
  73 static int show_filelist_p(void)
  74 {
  75         return verbose && recurse && !am_server;
  76 }
  77
  78 static void start_filelist_progress(char *kind)
  79 {
  80         rprintf(FINFO, "%s ... ", kind);
  81         if ((verbose > 1) || do_progress)
  82                 rprintf(FINFO, "\n");
  83         rflush(FINFO);
  84 }
  85
  86
  87 static void emit_filelist_progress(const struct file_list *flist)
  88 {
  89         rprintf(FINFO, " %d files...\r", flist->count);
  90 }
  91
  92
  93 static void maybe_emit_filelist_progress(const struct file_list *flist)
  94 {
  95         if (do_progress && show_filelist_p() && ((flist->count % 100) == 0))
  96                 emit_filelist_progress(flist);
  97 }
  98
  99
 100 static void finish_filelist_progress(const struct file_list *flist)
 101 {
 102         if (do_progress) {
 103                 /* This overwrites the progress line */
 104                 rprintf(FINFO, "%d file%sto consider\n",
 105                         flist->count, flist->count == 1 ? " " : "s ");
 106         } else {
 107                 rprintf(FINFO, "done\n");
 108         }
 109 }
 110
 111 void show_flist_stats(void)
 112 {
 113         /* Nothing yet */
 114 }
 115
 116
 117 static struct string_area *string_area_new(int size)
 118 {
 119         struct string_area *a;
 120
 121         if (size <= 0)
 122                 size = ARENA_SIZE;
 123         a = malloc(sizeof(*a));
 124         if (!a)
 125                 out_of_memory("string_area_new");
 126         a->current = a->base = malloc(size);
 127         if (!a->current)
 128                 out_of_memory("string_area_new buffer");
 129         a->end = a->base + size;
 130         a->next = NULL;
 131
 132         return a;
 133 }
 134
 135 static void string_area_free(struct string_area *a)
 136 {
 137         struct string_area *next;
 138
 139         for (; a; a = next) {
 140                 next = a->next;
 141                 free(a->base);
 142         }
 143 }
 144
 145 static char *string_area_malloc(struct string_area **ap, int size)
 146 {
 147         char *p;
 148         struct string_area *a;
 149
 150         /* does the request fit into the current space? */
 151         a = *ap;
 152         if (a->current + size >= a->end) {
 153                 /* no; get space, move new string_area to front of the list */
 154                 a = string_area_new(size > ARENA_SIZE ? size : ARENA_SIZE);
 155                 a->next = *ap;
 156                 *ap = a;
 157         }
 158
 159         /* have space; do the "allocation." */
 160         p = a->current;
 161         a->current += size;
 162         return p;
 163 }
 164
 165 static char *string_area_strdup(struct string_area **ap, const char *src)
 166 {
 167         char *dest = string_area_malloc(ap, strlen(src) + 1);
 168         return strcpy(dest, src);
 169 }
 170
 171 static void list_file_entry(struct file_struct *f)
 172 {
 173         char perms[11];
 174
 175         if (!f->basename)
 176                 /* this can happen if duplicate names were removed */
 177                 return;
 178
 179         permstring(perms, f->mode);
 180
 181         if (preserve_links && S_ISLNK(f->mode)) {
 182                 rprintf(FINFO, "%s %11.0f %s %s -> %s\n",
 183                         perms,
 184                         (double) f->length, timestring(f->modtime),
 185                         f_name(f), f->link);
 186         } else {
 187                 rprintf(FINFO, "%s %11.0f %s %s\n",
 188                         perms,
 189                         (double) f->length, timestring(f->modtime),
 190                         f_name(f));
 191         }
 192 }
 193
 194
 195 /**
 196  * Stat either a symlink or its referent, depending on the settings of
 197  * copy_links, copy_unsafe_links, etc.
 198  *
 199  * @return -1 on error; or 0.  If a symlink, then @p Linkbuf (of size
 200  * MAXPATHLEN) contains the symlink target.
 201  **/
 202 int readlink_stat(const char *path, STRUCT_STAT * buffer, char *linkbuf)
 203 {
 204 #if SUPPORT_LINKS
 205         if (copy_links) {
 206                 return do_stat(path, buffer);
 207         }
 208         if (do_lstat(path, buffer) == -1) {
 209                 return -1;
 210         }
 211         if (S_ISLNK(buffer->st_mode)) {
 212                 int l;
 213                 l = readlink((char *) path, linkbuf, MAXPATHLEN - 1);
 214                 if (l == -1)
 215                         return -1;
 216                 linkbuf[l] = 0;
 217                 if (copy_unsafe_links && (topsrcname[0] != '\0') &&
 218                     unsafe_symlink(linkbuf, topsrcname)) {
 219                         return do_stat(path, buffer);
 220                 }
 221         }
 222         return 0;
 223 #else
 224         return do_stat(path, buffer);
 225 #endif
 226 }
 227
 228 int link_stat(const char *path, STRUCT_STAT * buffer)
 229 {
 230 #if SUPPORT_LINKS
 231         if (copy_links) {
 232                 return do_stat(path, buffer);
 233         } else {
 234                 return do_lstat(path, buffer);
 235         }
 236 #else
 237         return do_stat(path, buffer);
 238 #endif
 239 }
 240
 241 /*
 242   This function is used to check if a file should be included/excluded
 243   from the list of files based on its name and type etc
 244  */
 245 static int check_exclude_file(int f, char *fname, STRUCT_STAT * st)
 246 {
 247         extern int delete_excluded;
 248
 249         /* f is set to -1 when calculating deletion file list */
 250         if ((f == -1) && delete_excluded) {
 251                 return 0;
 252         }
 253         if (check_exclude(fname, local_exclude_list, st)) {
 254                 return 1;
 255         }
 256         return 0;
 257 }
 258
 259 /* used by the one_file_system code */
 260 static dev_t filesystem_dev;
 261
 262 static void set_filesystem(char *fname)
 263 {
 264         STRUCT_STAT st;
 265         if (link_stat(fname, &st) != 0)
 266                 return;
 267         filesystem_dev = st.st_dev;
 268 }
 269
 270
 271 static int to_wire_mode(mode_t mode)
 272 {
 273         if (S_ISLNK(mode) && (_S_IFLNK != 0120000)) {
 274                 return (mode & ~(_S_IFMT)) | 0120000;
 275         }
 276         return (int) mode;
 277 }
 278
 279 static mode_t from_wire_mode(int mode)
 280 {
 281         if ((mode & (_S_IFMT)) == 0120000 && (_S_IFLNK != 0120000)) {
 282                 return (mode & ~(_S_IFMT)) | _S_IFLNK;
 283         }
 284         return (mode_t) mode;
 285 }
 286
 287
 288 static void send_directory(int f, struct file_list *flist, char *dir);
 289
 290 static char *flist_dir;
 291
 292
 293 /**
 294  * Make sure @p flist is big enough to hold at least @p flist->count
 295  * entries.
 296  **/
 297 static void flist_expand(struct file_list *flist)
 298 {
 299         if (flist->count >= flist->malloced) {
 300                 size_t new_bytes;
 301                 void *new_ptr;
 302
 303                 if (flist->malloced < 1000)
 304                         flist->malloced += 1000;
 305                 else
 306                         flist->malloced *= 2;
 307
 308                 new_bytes = sizeof(flist->files[0]) * flist->malloced;
 309
 310                 if (flist->files)
 311                         new_ptr = realloc(flist->files, new_bytes);
 312                 else
 313                         new_ptr = malloc(new_bytes);
 314
 315                 if (verbose >= 2) {
 316                         rprintf(FINFO, "expand file_list to %.0f bytes, did%s move\n",
 317                                 (double) new_bytes,
 318                                 (new_ptr == flist->files) ? " not" : "");
 319                 }
 320
 321                 flist->files = (struct file_struct **) new_ptr;
 322
 323                 if (!flist->files)
 324                         out_of_memory("flist_expand");
 325         }
 326 }
 327
 328
 329 static void send_file_entry(struct file_struct *file, int f,
 330                             unsigned base_flags)
 331 {
 332         unsigned char flags;
 333         static time_t last_time;
 334         static mode_t last_mode;
 335         static DEV64_T last_rdev;
 336         static uid_t last_uid;
 337         static gid_t last_gid;
 338         static char lastname[MAXPATHLEN];
 339         char *fname;
 340         int l1, l2;
 341
 342         if (f == -1)
 343                 return;
 344
 345         if (!file) {
 346                 write_byte(f, 0);
 347                 return;
 348         }
 349
 350         fname = f_name(file);
 351
 352         flags = base_flags;
 353
 354         if (file->mode == last_mode)
 355                 flags |= SAME_MODE;
 356         if (file->rdev == last_rdev)
 357                 flags |= SAME_RDEV;
 358         if (file->uid == last_uid)
 359                 flags |= SAME_UID;
 360         if (file->gid == last_gid)
 361                 flags |= SAME_GID;
 362         if (file->modtime == last_time)
 363                 flags |= SAME_TIME;
 364
 365         for (l1 = 0;
 366              lastname[l1] && (fname[l1] == lastname[l1]) && (l1 < 255);
 367              l1++);
 368         l2 = strlen(fname) - l1;
 369
 370         if (l1 > 0)
 371                 flags |= SAME_NAME;
 372         if (l2 > 255)
 373                 flags |= LONG_NAME;
 374
 375         /* we must make sure we don't send a zero flags byte or the other
 376            end will terminate the flist transfer */
 377         if (flags == 0 && !S_ISDIR(file->mode))
 378                 flags |= FLAG_DELETE;
 379         if (flags == 0)
 380                 flags |= LONG_NAME;
 381
 382         write_byte(f, flags);
 383         if (flags & SAME_NAME)
 384                 write_byte(f, l1);
 385         if (flags & LONG_NAME)
 386                 write_int(f, l2);
 387         else
 388                 write_byte(f, l2);
 389         write_buf(f, fname + l1, l2);
 390
 391         write_longint(f, file->length);
 392         if (!(flags & SAME_TIME))
 393                 write_int(f, (int) file->modtime);
 394         if (!(flags & SAME_MODE))
 395                 write_int(f, to_wire_mode(file->mode));
 396         if (preserve_uid && !(flags & SAME_UID)) {
 397                 add_uid(file->uid);
 398                 write_int(f, (int) file->uid);
 399         }
 400         if (preserve_gid && !(flags & SAME_GID)) {
 401                 add_gid(file->gid);
 402                 write_int(f, (int) file->gid);
 403         }
 404         if (preserve_devices && IS_DEVICE(file->mode)
 405             && !(flags & SAME_RDEV))
 406                 write_int(f, (int) file->rdev);
 407
 408 #if SUPPORT_LINKS
 409         if (preserve_links && S_ISLNK(file->mode)) {
 410                 write_int(f, strlen(file->link));
 411                 write_buf(f, file->link, strlen(file->link));
 412         }
 413 #endif
 414
 415 #if SUPPORT_HARD_LINKS
 416         if (preserve_hard_links && S_ISREG(file->mode)) {
 417                 if (remote_version < 26) {
 418                         /* 32-bit dev_t and ino_t */
 419                         write_int(f, (int) file->dev);
 420                         write_int(f, (int) file->inode);
 421                 } else {
 422                         /* 64-bit dev_t and ino_t */
 423                         write_longint(f, file->dev);
 424                         write_longint(f, file->inode);
 425                 }
 426         }
 427 #endif
 428
 429         if (always_checksum) {
 430                 if (remote_version < 21) {
 431                         write_buf(f, file->sum, 2);
 432                 } else {
 433                         write_buf(f, file->sum, MD4_SUM_LENGTH);
 434                 }
 435         }
 436
 437         last_mode = file->mode;
 438         last_rdev = file->rdev;
 439         last_uid = file->uid;
 440         last_gid = file->gid;
 441         last_time = file->modtime;
 442
 443         strlcpy(lastname, fname, MAXPATHLEN);
 444         lastname[MAXPATHLEN - 1] = 0;
 445 }
 446
 447
 448
 449 static void receive_file_entry(struct file_struct **fptr,
 450                                unsigned flags, int f)
 451 {
 452         static time_t last_time;
 453         static mode_t last_mode;
 454         static DEV64_T last_rdev;
 455         static uid_t last_uid;
 456         static gid_t last_gid;
 457         static char lastname[MAXPATHLEN];
 458         char thisname[MAXPATHLEN];
 459         unsigned int l1 = 0, l2 = 0;
 460         char *p;
 461         struct file_struct *file;
 462
 463         if (flags & SAME_NAME)
 464                 l1 = read_byte(f);
 465
 466         if (flags & LONG_NAME)
 467                 l2 = read_int(f);
 468         else
 469                 l2 = read_byte(f);
 470
 471         file = (struct file_struct *) malloc(sizeof(*file));
 472         if (!file)
 473                 out_of_memory("receive_file_entry");
 474         memset((char *) file, 0, sizeof(*file));
 475         (*fptr) = file;
 476
 477         if (l2 >= MAXPATHLEN - l1) {
 478                 rprintf(FERROR,
 479                         "overflow: flags=0x%x l1=%d l2=%d lastname=%s\n",
 480                         flags, l1, l2, lastname);
 481                 overflow("receive_file_entry");
 482         }
 483
 484         strlcpy(thisname, lastname, l1 + 1);
 485         read_sbuf(f, &thisname[l1], l2);
 486         thisname[l1 + l2] = 0;
 487
 488         strlcpy(lastname, thisname, MAXPATHLEN);
 489         lastname[MAXPATHLEN - 1] = 0;
 490
 491         clean_fname(thisname);
 492
 493         if (sanitize_paths) {
 494                 sanitize_path(thisname, NULL);
 495         }
 496
 497         if ((p = strrchr(thisname, '/'))) {
 498                 static char *lastdir;
 499                 *p = 0;
 500                 if (lastdir && strcmp(thisname, lastdir) == 0) {
 501                         file->dirname = lastdir;
 502                 } else {
 503                         file->dirname = strdup(thisname);
 504                         lastdir = file->dirname;
 505                 }
 506                 file->basename = strdup(p + 1);
 507         } else {
 508                 file->dirname = NULL;
 509                 file->basename = strdup(thisname);
 510         }
 511
 512         if (!file->basename)
 513                 out_of_memory("receive_file_entry 1");
 514
 515
 516         file->flags = flags;
 517         file->length = read_longint(f);
 518         file->modtime =
 519             (flags & SAME_TIME) ? last_time : (time_t) read_int(f);
 520         file->mode =
 521             (flags & SAME_MODE) ? last_mode : from_wire_mode(read_int(f));
 522         if (preserve_uid)
 523                 file->uid =
 524                     (flags & SAME_UID) ? last_uid : (uid_t) read_int(f);
 525         if (preserve_gid)
 526                 file->gid =
 527                     (flags & SAME_GID) ? last_gid : (gid_t) read_int(f);
 528         if (preserve_devices && IS_DEVICE(file->mode))
 529                 file->rdev =
 530                     (flags & SAME_RDEV) ? last_rdev : (dev_t) read_int(f);
 531
 532         if (preserve_links && S_ISLNK(file->mode)) {
 533                 int l = read_int(f);
 534                 if (l < 0) {
 535                         rprintf(FERROR, "overflow: l=%d\n", l);
 536                         overflow("receive_file_entry");
 537                 }
 538                 file->link = (char *) malloc(l + 1);
 539                 if (!file->link)
 540                         out_of_memory("receive_file_entry 2");
 541                 read_sbuf(f, file->link, l);
 542                 if (sanitize_paths) {
 543                         sanitize_path(file->link, file->dirname);
 544                 }
 545         }
 546 #if SUPPORT_HARD_LINKS
 547         if (preserve_hard_links && S_ISREG(file->mode)) {
 548                 if (remote_version < 26) {
 549                         file->dev = read_int(f);
 550                         file->inode = read_int(f);
 551                 } else {
 552                         file->dev = read_longint(f);
 553                         file->inode = read_longint(f);
 554                 }
 555         }
 556 #endif
 557
 558         if (always_checksum) {
 559                 file->sum = (char *) malloc(MD4_SUM_LENGTH);
 560                 if (!file->sum)
 561                         out_of_memory("md4 sum");
 562                 if (remote_version < 21) {
 563                         read_buf(f, file->sum, 2);
 564                 } else {
 565                         read_buf(f, file->sum, MD4_SUM_LENGTH);
 566                 }
 567         }
 568
 569         last_mode = file->mode;
 570         last_rdev = file->rdev;
 571         last_uid = file->uid;
 572         last_gid = file->gid;
 573         last_time = file->modtime;
 574
 575         if (!preserve_perms) {
 576                 extern int orig_umask;
 577                 /* set an appropriate set of permissions based on original
 578                    permissions and umask. This emulates what GNU cp does */
 579                 file->mode &= ~orig_umask;
 580         }
 581 }
 582
 583
 584 /* determine if a file in a different filesstem should be skipped
 585    when one_file_system is set. We bascally only want to include
 586    the mount points - but they can be hard to find! */
 587 static int skip_filesystem(char *fname, STRUCT_STAT * st)
 588 {
 589         STRUCT_STAT st2;
 590         char *p = strrchr(fname, '/');
 591
 592         /* skip all but directories */
 593         if (!S_ISDIR(st->st_mode))
 594                 return 1;
 595
 596         /* if its not a subdirectory then allow */
 597         if (!p)
 598                 return 0;
 599
 600         *p = 0;
 601         if (link_stat(fname, &st2)) {
 602                 *p = '/';
 603                 return 0;
 604         }
 605         *p = '/';
 606
 607         return (st2.st_dev != filesystem_dev);
 608 }
 609
 610 #define STRDUP(ap, p)   (ap ? string_area_strdup(ap, p) : strdup(p))
 611 /* IRIX cc cares that the operands to the ternary have the same type. */
 612 #define MALLOC(ap, i)   (ap ? (void*) string_area_malloc(ap, i) : malloc(i))
 613
 614 /**
 615  * Create a file_struct for a named file by reading its stat()
 616  * information and performing extensive checks against global
 617  * options.
 618  *
 619  * @return the new file, or NULL if there was an error or this file
 620  * should be excluded.
 621  *
 622  * @todo There is a small optimization opportunity here to avoid
 623  * stat()ing the file in some circumstances, which has a certain cost.
 624  * We are called immediately after doing readdir(), and so we may
 625  * already know the d_type of the file.  We could for example avoid
 626  * statting directories if we're not recursing, but this is not a very
 627  * important case.  Some systems may not have d_type.
 628  **/
 629 struct file_struct *make_file(int f, char *fname, struct string_area **ap,
 630                               int noexcludes)
 631 {
 632         struct file_struct *file;
 633         STRUCT_STAT st;
 634         char sum[SUM_LENGTH];
 635         char *p;
 636         char cleaned_name[MAXPATHLEN];
 637         char linkbuf[MAXPATHLEN];
 638         extern int module_id;
 639
 640         strlcpy(cleaned_name, fname, MAXPATHLEN);
 641         cleaned_name[MAXPATHLEN - 1] = 0;
 642         clean_fname(cleaned_name);
 643         if (sanitize_paths) {
 644                 sanitize_path(cleaned_name, NULL);
 645         }
 646         fname = cleaned_name;
 647
 648         memset(sum, 0, SUM_LENGTH);
 649
 650         if (readlink_stat(fname, &st, linkbuf) != 0) {
 651                 int save_errno = errno;
 652                 if ((errno == ENOENT) && copy_links && !noexcludes) {
 653                         /* symlink pointing nowhere, see if excluded */
 654                         memset((char *) &st, 0, sizeof(st));
 655                         if (check_exclude_file(f, fname, &st)) {
 656                                 /* file is excluded anyway, ignore silently */
 657                                 return NULL;
 658                         }
 659                 }
 660                 io_error = 1;
 661                 rprintf(FERROR, "readlink %s: %s\n",
 662                         fname, strerror(save_errno));
 663                 return NULL;
 664         }
 665
 666         /* we use noexcludes from backup.c */
 667         if (noexcludes)
 668                 goto skip_excludes;
 669
 670         if (S_ISDIR(st.st_mode) && !recurse) {
 671                 rprintf(FINFO, "skipping directory %s\n", fname);
 672                 return NULL;
 673         }
 674
 675         if (one_file_system && st.st_dev != filesystem_dev) {
 676                 if (skip_filesystem(fname, &st))
 677                         return NULL;
 678         }
 679
 680         if (check_exclude_file(f, fname, &st))
 681                 return NULL;
 682
 683
 684         if (lp_ignore_nonreadable(module_id) && access(fname, R_OK) != 0)
 685                 return NULL;
 686
 687       skip_excludes:
 688
 689         if (verbose > 2)
 690                 rprintf(FINFO, "make_file(%d,%s)\n", f, fname);
 691
 692         file = (struct file_struct *) malloc(sizeof(*file));
 693         if (!file)
 694                 out_of_memory("make_file");
 695         memset((char *) file, 0, sizeof(*file));
 696
 697         if ((p = strrchr(fname, '/'))) {
 698                 static char *lastdir;
 699                 *p = 0;
 700                 if (lastdir && strcmp(fname, lastdir) == 0) {
 701                         file->dirname = lastdir;
 702                 } else {
 703                         file->dirname = strdup(fname);
 704                         lastdir = file->dirname;
 705                 }
 706                 file->basename = STRDUP(ap, p + 1);
 707                 *p = '/';
 708         } else {
 709                 file->dirname = NULL;
 710                 file->basename = STRDUP(ap, fname);
 711         }
 712
 713         file->modtime = st.st_mtime;
 714         file->length = st.st_size;
 715         file->mode = st.st_mode;
 716         file->uid = st.st_uid;
 717         file->gid = st.st_gid;
 718         file->dev = st.st_dev;
 719         file->inode = st.st_ino;
 720 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 721         file->rdev = st.st_rdev;
 722 #endif
 723
 724 #if SUPPORT_LINKS
 725         if (S_ISLNK(st.st_mode)) {
 726                 file->link = STRDUP(ap, linkbuf);
 727         }
 728 #endif
 729
 730         if (always_checksum) {
 731                 file->sum = (char *) MALLOC(ap, MD4_SUM_LENGTH);
 732                 if (!file->sum)
 733                         out_of_memory("md4 sum");
 734                 /* drat. we have to provide a null checksum for non-regular
 735                    files in order to be compatible with earlier versions
 736                    of rsync */
 737                 if (S_ISREG(st.st_mode)) {
 738                         file_checksum(fname, file->sum, st.st_size);
 739                 } else {
 740                         memset(file->sum, 0, MD4_SUM_LENGTH);
 741                 }
 742         }
 743
 744         if (flist_dir) {
 745                 static char *lastdir;
 746                 if (lastdir && strcmp(lastdir, flist_dir) == 0) {
 747                         file->basedir = lastdir;
 748                 } else {
 749                         file->basedir = strdup(flist_dir);
 750                         lastdir = file->basedir;
 751                 }
 752         } else {
 753                 file->basedir = NULL;
 754         }
 755
 756         if (!S_ISDIR(st.st_mode))
 757                 stats.total_size += st.st_size;
 758
 759         return file;
 760 }
 761
 762
 763
 764 void send_file_name(int f, struct file_list *flist, char *fname,
 765                     int recursive, unsigned base_flags)
 766 {
 767         struct file_struct *file;
 768
 769         file = make_file(f, fname, &flist->string_area, 0);
 770
 771         if (!file)
 772                 return;
 773
 774         maybe_emit_filelist_progress(flist);
 775
 776         flist_expand(flist);
 777
 778         if (write_batch)        /*  dw  */
 779                 file->flags = FLAG_DELETE;
 780
 781         if (strcmp(file->basename, "")) {
 782                 flist->files[flist->count++] = file;
 783                 send_file_entry(file, f, base_flags);
 784         }
 785
 786         if (S_ISDIR(file->mode) && recursive) {
 787                 struct exclude_struct **last_exclude_list =
 788                     local_exclude_list;
 789                 send_directory(f, flist, f_name(file));
 790                 local_exclude_list = last_exclude_list;
 791                 return;
 792         }
 793 }
 794
 795
 796
 797 static void send_directory(int f, struct file_list *flist, char *dir)
 798 {
 799         DIR *d;
 800         struct dirent *di;
 801         char fname[MAXPATHLEN];
 802         int l;
 803         char *p;
 804
 805         d = opendir(dir);
 806         if (!d) {
 807                 io_error = 1;
 808                 rprintf(FERROR, "opendir(%s): %s\n", dir, strerror(errno));
 809                 return;
 810         }
 811
 812         strlcpy(fname, dir, MAXPATHLEN);
 813         l = strlen(fname);
 814         if (fname[l - 1] != '/') {
 815                 if (l == MAXPATHLEN - 1) {
 816                         io_error = 1;
 817                         rprintf(FERROR,
 818                                 "skipping long-named directory %s\n",
 819                                 fname);
 820                         closedir(d);
 821                         return;
 822                 }
 823                 strlcat(fname, "/", MAXPATHLEN);
 824                 l++;
 825         }
 826         p = fname + strlen(fname);
 827
 828         local_exclude_list = NULL;
 829
 830         if (cvs_exclude) {
 831                 if (strlen(fname) + strlen(".cvsignore") <= MAXPATHLEN - 1) {
 832                         strcpy(p, ".cvsignore");
 833                         local_exclude_list =
 834                             make_exclude_list(fname, NULL, 0, 0);
 835                 } else {
 836                         io_error = 1;
 837                         rprintf(FINFO,
 838                                 "cannot cvs-exclude in long-named directory %s\n",
 839                                 fname);
 840                 }
 841         }
 842
 843         for (di = readdir(d); di; di = readdir(d)) {
 844                 char *dname = d_name(di);
 845                 if (strcmp(dname, ".") == 0 || strcmp(dname, "..") == 0)
 846                         continue;
 847                 strlcpy(p, dname, MAXPATHLEN - l);
 848                 send_file_name(f, flist, fname, recurse, 0);
 849         }
 850
 851         if (local_exclude_list) {
 852                 add_exclude_list("!", &local_exclude_list, 0);
 853         }
 854
 855         closedir(d);
 856 }
 857
 858
 859 /*
 860  *
 861  * I *think* f==-1 means that the list should just be built in memory
 862  * and not transmitted.  But who can tell? -- mbp
 863  */
 864 struct file_list *send_file_list(int f, int argc, char *argv[])
 865 {
 866         int i, l;
 867         STRUCT_STAT st;
 868         char *p, *dir, *olddir;
 869         char lastpath[MAXPATHLEN] = "";
 870         struct file_list *flist;
 871         int64 start_write;
 872
 873         if (show_filelist_p() && f != -1)
 874                 start_filelist_progress("building file list");
 875
 876         start_write = stats.total_written;
 877
 878         flist = flist_new();
 879
 880         if (f != -1) {
 881                 io_start_buffering(f);
 882         }
 883
 884         for (i = 0; i < argc; i++) {
 885                 char *fname = topsrcname;
 886
 887                 strlcpy(fname, argv[i], MAXPATHLEN);
 888
 889                 l = strlen(fname);
 890                 if (l != 1 && fname[l - 1] == '/') {
 891                         if ((l == 2) && (fname[0] == '.')) {
 892                                 /*  Turn ./ into just . rather than ./.
 893                                    This was put in to avoid a problem with
 894                                    rsync -aR --delete from ./
 895                                    The send_file_name() below of ./ was
 896                                    mysteriously preventing deletes */
 897                                 fname[1] = 0;
 898                         } else {
 899                                 strlcat(fname, ".", MAXPATHLEN);
 900                         }
 901                 }
 902
 903                 if (link_stat(fname, &st) != 0) {
 904                         if (f != -1) {
 905                                 io_error = 1;
 906                                 rprintf(FERROR, "link_stat %s : %s\n",
 907                                         fname, strerror(errno));
 908                         }
 909                         continue;
 910                 }
 911
 912                 if (S_ISDIR(st.st_mode) && !recurse) {
 913                         rprintf(FINFO, "skipping directory %s\n", fname);
 914                         continue;
 915                 }
 916
 917                 dir = NULL;
 918                 olddir = NULL;
 919
 920                 if (!relative_paths) {
 921                         p = strrchr(fname, '/');
 922                         if (p) {
 923                                 *p = 0;
 924                                 if (p == fname)
 925                                         dir = "/";
 926                                 else
 927                                         dir = fname;
 928                                 fname = p + 1;
 929                         }
 930                 } else if (f != -1 && (p = strrchr(fname, '/'))) {
 931                         /* this ensures we send the intermediate directories,
 932                            thus getting their permissions right */
 933                         *p = 0;
 934                         if (strcmp(lastpath, fname)) {
 935                                 strlcpy(lastpath, fname, sizeof(lastpath));
 936                                 *p = '/';
 937                                 for (p = fname + 1; (p = strchr(p, '/'));
 938                                      p++) {
 939                                         int copy_links_saved = copy_links;
 940                                         int recurse_saved = recurse;
 941                                         *p = 0;
 942                                         copy_links = copy_unsafe_links;
 943                                         /* set recurse to 1 to prevent make_file
 944                                            from ignoring directory, but still
 945                                            turn off the recursive parameter to
 946                                            send_file_name */
 947                                         recurse = 1;
 948                                         send_file_name(f, flist, fname, 0,
 949                                                        0);
 950                                         copy_links = copy_links_saved;
 951                                         recurse = recurse_saved;
 952                                         *p = '/';
 953                                 }
 954                         } else {
 955                                 *p = '/';
 956                         }
 957                 }
 958
 959                 if (!*fname)
 960                         fname = ".";
 961
 962                 if (dir && *dir) {
 963                         olddir = push_dir(dir, 1);
 964
 965                         if (!olddir) {
 966                                 io_error = 1;
 967                                 rprintf(FERROR, "push_dir %s : %s\n",
 968                                         dir, strerror(errno));
 969                                 continue;
 970                         }
 971
 972                         flist_dir = dir;
 973                 }
 974
 975                 if (one_file_system)
 976                         set_filesystem(fname);
 977
 978                 send_file_name(f, flist, fname, recurse, FLAG_DELETE);
 979
 980                 if (olddir != NULL) {
 981                         flist_dir = NULL;
 982                         if (pop_dir(olddir) != 0) {
 983                                 rprintf(FERROR, "pop_dir %s : %s\n",
 984                                         dir, strerror(errno));
 985                                 exit_cleanup(RERR_FILESELECT);
 986                         }
 987                 }
 988         }
 989
 990         topsrcname[0] = '\0';
 991
 992         if (f != -1) {
 993                 send_file_entry(NULL, f, 0);
 994         }
 995
 996         if (show_filelist_p() && f != -1) {
 997                 finish_filelist_progress(flist);
 998         }
 999
1000         clean_flist(flist, 0);
1001
1002         /* now send the uid/gid list. This was introduced in protocol
1003            version 15 */
1004         if (f != -1 && remote_version >= 15) {
1005                 send_uid_list(f);
1006         }
1007
1008         /* if protocol version is >= 17 then send the io_error flag */
1009         if (f != -1 && remote_version >= 17) {
1010                 extern int module_id;
1011                 write_int(f, lp_ignore_errors(module_id) ? 0 : io_error);
1012         }
1013
1014         if (f != -1) {
1015                 io_end_buffering();
1016                 stats.flist_size = stats.total_written - start_write;
1017                 stats.num_files = flist->count;
1018                 if (write_batch)        /*  dw  */
1019                         write_batch_flist_info(flist->count, flist->files);
1020         }
1021
1022         if (verbose > 2)
1023                 rprintf(FINFO, "send_file_list done\n");
1024
1025         return flist;
1026 }
1027
1028
1029 struct file_list *recv_file_list(int f)
1030 {
1031         struct file_list *flist;
1032         unsigned char flags;
1033         int64 start_read;
1034         extern int list_only;
1035
1036         if (show_filelist_p())
1037                 start_filelist_progress("receiving file list");
1038
1039         start_read = stats.total_read;
1040
1041         flist = (struct file_list *) malloc(sizeof(flist[0]));
1042         if (!flist)
1043                 goto oom;
1044
1045         flist->count = 0;
1046         flist->malloced = 1000;
1047         flist->files =
1048             (struct file_struct **) malloc(sizeof(flist->files[0]) *
1049                                            flist->malloced);
1050         if (!flist->files)
1051                 goto oom;
1052
1053
1054         for (flags = read_byte(f); flags; flags = read_byte(f)) {
1055                 int i = flist->count;
1056
1057                 flist_expand(flist);
1058
1059                 receive_file_entry(&flist->files[i], flags, f);
1060
1061                 if (S_ISREG(flist->files[i]->mode))
1062                         stats.total_size += flist->files[i]->length;
1063
1064                 flist->count++;
1065
1066                 maybe_emit_filelist_progress(flist);
1067
1068                 if (verbose > 2)
1069                         rprintf(FINFO, "recv_file_name(%s)\n",
1070                                 f_name(flist->files[i]));
1071         }
1072
1073
1074         if (verbose > 2)
1075                 rprintf(FINFO, "received %d names\n", flist->count);
1076
1077         clean_flist(flist, relative_paths);
1078
1079         if (show_filelist_p()) {
1080                 finish_filelist_progress(flist);
1081         }
1082
1083         /* now recv the uid/gid list. This was introduced in protocol version 15 */
1084         if (f != -1 && remote_version >= 15) {
1085                 recv_uid_list(f, flist);
1086         }
1087
1088         /* if protocol version is >= 17 then recv the io_error flag */
1089         if (f != -1 && remote_version >= 17 && !read_batch) {   /* dw-added readbatch */
1090                 extern int module_id;
1091                 extern int ignore_errors;
1092                 if (lp_ignore_errors(module_id) || ignore_errors) {
1093                         read_int(f);
1094                 } else {
1095                         io_error |= read_int(f);
1096                 }
1097         }
1098
1099         if (list_only) {
1100                 int i;
1101                 for (i = 0; i < flist->count; i++) {
1102                         list_file_entry(flist->files[i]);
1103                 }
1104         }
1105
1106
1107         if (verbose > 2)
1108                 rprintf(FINFO, "recv_file_list done\n");
1109
1110         stats.flist_size = stats.total_read - start_read;
1111         stats.num_files = flist->count;
1112
1113         return flist;
1114
1115       oom:
1116         out_of_memory("recv_file_list");
1117         return NULL;            /* not reached */
1118 }
1119
1120
1121 /*
1122  * XXX: This is currently the hottest function while building the file
1123  * list, because building f_name()s every time is expensive.
1124  **/
1125 int file_compare(struct file_struct **f1, struct file_struct **f2)
1126 {
1127         if (!(*f1)->basename && !(*f2)->basename)
1128                 return 0;
1129         if (!(*f1)->basename)
1130                 return -1;
1131         if (!(*f2)->basename)
1132                 return 1;
1133         if ((*f1)->dirname == (*f2)->dirname)
1134                 return u_strcmp((*f1)->basename, (*f2)->basename);
1135         return u_strcmp(f_name(*f1), f_name(*f2));
1136 }
1137
1138
1139 int flist_find(struct file_list *flist, struct file_struct *f)
1140 {
1141         int low = 0, high = flist->count - 1;
1142
1143         if (flist->count <= 0)
1144                 return -1;
1145
1146         while (low != high) {
1147                 int mid = (low + high) / 2;
1148                 int ret =
1149                     file_compare(&flist->files[flist_up(flist, mid)], &f);
1150                 if (ret == 0)
1151                         return flist_up(flist, mid);
1152                 if (ret > 0) {
1153                         high = mid;
1154                 } else {
1155                         low = mid + 1;
1156                 }
1157         }
1158
1159         if (file_compare(&flist->files[flist_up(flist, low)], &f) == 0)
1160                 return flist_up(flist, low);
1161         return -1;
1162 }
1163
1164
1165 /*
1166  * free up one file
1167  */
1168 void free_file(struct file_struct *file)
1169 {
1170         if (!file)
1171                 return;
1172         if (file->basename)
1173                 free(file->basename);
1174         if (file->link)
1175                 free(file->link);
1176         if (file->sum)
1177                 free(file->sum);
1178         *file = null_file;
1179 }
1180
1181
1182 /*
1183  * allocate a new file list
1184  */
1185 struct file_list *flist_new()
1186 {
1187         struct file_list *flist;
1188
1189         flist = (struct file_list *) malloc(sizeof(flist[0]));
1190         if (!flist)
1191                 out_of_memory("send_file_list");
1192
1193         flist->count = 0;
1194         flist->malloced = 0;
1195         flist->files = NULL;
1196
1197 #if ARENA_SIZE > 0
1198         flist->string_area = string_area_new(0);
1199 #else
1200         flist->string_area = NULL;
1201 #endif
1202         return flist;
1203 }
1204
1205 /*
1206  * free up all elements in a flist
1207  */
1208 void flist_free(struct file_list *flist)
1209 {
1210         int i;
1211         for (i = 1; i < flist->count; i++) {
1212                 if (!flist->string_area)
1213                         free_file(flist->files[i]);
1214                 free(flist->files[i]);
1215         }
1216         /* FIXME: I don't think we generally need to blank the flist
1217          * since it's about to be freed.  This will just cause more
1218          * memory traffic.  If you want a freed-memory debugger, you
1219          * know where to get it. */
1220         memset((char *) flist->files, 0,
1221                sizeof(flist->files[0]) * flist->count);
1222         free(flist->files);
1223         if (flist->string_area)
1224                 string_area_free(flist->string_area);
1225         memset((char *) flist, 0, sizeof(*flist));
1226         free(flist);
1227 }
1228
1229
1230 /*
1231  * This routine ensures we don't have any duplicate names in our file list.
1232  * duplicate names can cause corruption because of the pipelining
1233  */
1234 static void clean_flist(struct file_list *flist, int strip_root)
1235 {
1236         int i;
1237
1238         if (!flist || flist->count == 0)
1239                 return;
1240
1241         qsort(flist->files, flist->count,
1242               sizeof(flist->files[0]), (int (*)()) file_compare);
1243
1244         for (i = 1; i < flist->count; i++) {
1245                 if (flist->files[i]->basename &&
1246                     flist->files[i - 1]->basename &&
1247                     strcmp(f_name(flist->files[i]),
1248                            f_name(flist->files[i - 1])) == 0) {
1249                         if (verbose > 1 && !am_server)
1250                                 rprintf(FINFO,
1251                                         "removing duplicate name %s from file list %d\n",
1252                                         f_name(flist->files[i - 1]),
1253                                         i - 1);
1254                         /* it's not great that the flist knows the semantics of the
1255                          * file memory usage, but i'd rather not add a flag byte
1256                          * to that struct. XXX can i use a bit in the flags field? */
1257                         if (flist->string_area)
1258                                 flist->files[i][0] = null_file;
1259                         else
1260                                 free_file(flist->files[i]);
1261                 }
1262         }
1263
1264         /* FIXME: There is a bug here when filenames are repeated more
1265          * than once, because we don't handle freed files when doing
1266          * the comparison. */
1267
1268         if (strip_root) {
1269                 /* we need to strip off the root directory in the case
1270                    of relative paths, but this must be done _after_
1271                    the sorting phase */
1272                 for (i = 0; i < flist->count; i++) {
1273                         if (flist->files[i]->dirname &&
1274                             flist->files[i]->dirname[0] == '/') {
1275                                 memmove(&flist->files[i]->dirname[0],
1276                                         &flist->files[i]->dirname[1],
1277                                         strlen(flist->files[i]->dirname));
1278                         }
1279
1280                         if (flist->files[i]->dirname &&
1281                             !flist->files[i]->dirname[0]) {
1282                                 flist->files[i]->dirname = NULL;
1283                         }
1284                 }
1285         }
1286
1287
1288         if (verbose <= 3)
1289                 return;
1290
1291         for (i = 0; i < flist->count; i++) {
1292                 rprintf(FINFO, "[%d] i=%d %s %s mode=0%o len=%.0f\n",
1293                         (int) getpid(), i,
1294                         NS(flist->files[i]->dirname),
1295                         NS(flist->files[i]->basename),
1296                         (int) flist->files[i]->mode,
1297                         (double) flist->files[i]->length);
1298         }
1299 }
1300
1301
1302 /*
1303  * return the full filename of a flist entry
1304  *
1305  * This function is too expensive at the moment, because it copies
1306  * strings when often we only want to compare them.  In any case,
1307  * using strlcat is silly because it will walk the string repeatedly.
1308  */
1309 char *f_name(struct file_struct *f)
1310 {
1311         static char names[10][MAXPATHLEN];
1312         static int n;
1313         char *p = names[n];
1314
1315         if (!f || !f->basename)
1316                 return NULL;
1317
1318         n = (n + 1) % 10;
1319
1320         if (f->dirname) {
1321                 int off;
1322
1323                 off = strlcpy(p, f->dirname, MAXPATHLEN);
1324                 off += strlcpy(p + off, "/", MAXPATHLEN - off);
1325                 off += strlcpy(p + off, f->basename, MAXPATHLEN - off);
1326         } else {
1327                 strlcpy(p, f->basename, MAXPATHLEN);
1328         }
1329
1330         return p;
1331 }