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