Dogcows Code - chaz/tar/blob - src/misc.c

   1 /* Miscellaneous functions, not really specific to GNU tar.
   2
   3    Copyright 1988, 1992, 1994-1997, 1999-2001, 2003-2007, 2009-2010,
   4    2012-2014 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 3, or (at your option) any later
   9    version.
  10
  11    This program is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  14    Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License along
  17    with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #define COMMON_INLINE _GL_EXTERN_INLINE
  20 #include <system.h>
  21 #include <rmt.h>
  22 #include "common.h"
  23 #include <quotearg.h>
  24 #include <xgetcwd.h>
  25 #include <unlinkdir.h>
  26 #include <utimens.h>
  27
  28 #ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
  29 # define DOUBLE_SLASH_IS_DISTINCT_ROOT 0
  30 #endif
  31
  32 static const char *tar_getcdpath (int);
  33
  34 \f
  35 /* Handling strings.  */
  36
  37 /* Assign STRING to a copy of VALUE if not zero, or to zero.  If
  38    STRING was nonzero, it is freed first.  */
  39 void
  40 assign_string (char **string, const char *value)
  41 {
  42   free (*string);
  43   *string = value ? xstrdup (value) : 0;
  44 }
  45
  46 #if 0
  47 /* This function is currently unused; perhaps it should be removed?  */
  48
  49 /* Allocate a copy of the string quoted as in C, and returns that.  If
  50    the string does not have to be quoted, it returns a null pointer.
  51    The allocated copy should normally be freed with free() after the
  52    caller is done with it.
  53
  54    This is used in one context only: generating the directory file in
  55    incremental dumps.  The quoted string is not intended for human
  56    consumption; it is intended only for unquote_string.  The quoting
  57    is locale-independent, so that users needn't worry about locale
  58    when reading directory files.  This means that we can't use
  59    quotearg, as quotearg is locale-dependent and is meant for human
  60    consumption.  */
  61 static char *
  62 quote_copy_string (const char *string)
  63 {
  64   const char *source = string;
  65   char *destination = 0;
  66   char *buffer = 0;
  67   int copying = 0;
  68
  69   while (*source)
  70     {
  71       int character = *source++;
  72
  73       switch (character)
  74         {
  75         case '\n': case '\\':
  76           if (!copying)
  77             {
  78               size_t length = (source - string) - 1;
  79
  80               copying = 1;
  81               buffer = xmalloc (length + 2 + 2 * strlen (source) + 1);
  82               memcpy (buffer, string, length);
  83               destination = buffer + length;
  84             }
  85           *destination++ = '\\';
  86           *destination++ = character == '\\' ? '\\' : 'n';
  87           break;
  88
  89         default:
  90           if (copying)
  91             *destination++ = character;
  92           break;
  93         }
  94     }
  95   if (copying)
  96     {
  97       *destination = '\0';
  98       return buffer;
  99     }
 100   return 0;
 101 }
 102 #endif
 103
 104 /* Takes a quoted C string (like those produced by quote_copy_string)
 105    and turns it back into the un-quoted original.  This is done in
 106    place.  Returns 0 only if the string was not properly quoted, but
 107    completes the unquoting anyway.
 108
 109    This is used for reading the saved directory file in incremental
 110    dumps.  It is used for decoding old 'N' records (demangling names).
 111    But also, it is used for decoding file arguments, would they come
 112    from the shell or a -T file, and for decoding the --exclude
 113    argument.  */
 114 int
 115 unquote_string (char *string)
 116 {
 117   int result = 1;
 118   char *source = string;
 119   char *destination = string;
 120
 121   /* Escape sequences other than \\ and \n are no longer generated by
 122      quote_copy_string, but accept them for backwards compatibility,
 123      and also because unquote_string is used for purposes other than
 124      parsing the output of quote_copy_string.  */
 125
 126   while (*source)
 127     if (*source == '\\')
 128       switch (*++source)
 129         {
 130         case '\\':
 131           *destination++ = '\\';
 132           source++;
 133           break;
 134
 135         case 'a':
 136           *destination++ = '\a';
 137           source++;
 138           break;
 139
 140         case 'b':
 141           *destination++ = '\b';
 142           source++;
 143           break;
 144
 145         case 'f':
 146           *destination++ = '\f';
 147           source++;
 148           break;
 149
 150         case 'n':
 151           *destination++ = '\n';
 152           source++;
 153           break;
 154
 155         case 'r':
 156           *destination++ = '\r';
 157           source++;
 158           break;
 159
 160         case 't':
 161           *destination++ = '\t';
 162           source++;
 163           break;
 164
 165         case 'v':
 166           *destination++ = '\v';
 167           source++;
 168           break;
 169
 170         case '?':
 171           *destination++ = 0177;
 172           source++;
 173           break;
 174
 175         case '0':
 176         case '1':
 177         case '2':
 178         case '3':
 179         case '4':
 180         case '5':
 181         case '6':
 182         case '7':
 183           {
 184             int value = *source++ - '0';
 185
 186             if (*source < '0' || *source > '7')
 187               {
 188                 *destination++ = value;
 189                 break;
 190               }
 191             value = value * 8 + *source++ - '0';
 192             if (*source < '0' || *source > '7')
 193               {
 194                 *destination++ = value;
 195                 break;
 196               }
 197             value = value * 8 + *source++ - '0';
 198             *destination++ = value;
 199             break;
 200           }
 201
 202         default:
 203           result = 0;
 204           *destination++ = '\\';
 205           if (*source)
 206             *destination++ = *source++;
 207           break;
 208         }
 209     else if (source != destination)
 210       *destination++ = *source++;
 211     else
 212       source++, destination++;
 213
 214   if (source != destination)
 215     *destination = '\0';
 216   return result;
 217 }
 218
 219 /* Zap trailing slashes.  */
 220 char *
 221 zap_slashes (char *name)
 222 {
 223   char *q;
 224
 225   if (!name || *name == 0)
 226     return name;
 227   q = name + strlen (name) - 1;
 228   while (q > name && ISSLASH (*q))
 229     *q-- = '\0';
 230   return name;
 231 }
 232
 233 /* Normalize FILE_NAME by removing redundant slashes and "."
 234    components, including redundant trailing slashes.
 235    Leave ".." alone, as it may be significant in the presence
 236    of symlinks and on platforms where "/.." != "/".
 237
 238    Destructive version: modifies its argument. */
 239 void
 240 normalize_filename_x (char *file_name)
 241 {
 242   char *name = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
 243   char *p;
 244   char const *q;
 245   char c;
 246
 247   /* Don't squeeze leading "//" to "/", on hosts where they're distinct.  */
 248   name += (DOUBLE_SLASH_IS_DISTINCT_ROOT
 249            && ISSLASH (*name) && ISSLASH (name[1]) && ! ISSLASH (name[2]));
 250
 251   /* Omit redundant leading "." components.  */
 252   for (q = p = name; (*p = *q) == '.' && ISSLASH (q[1]); p += !*q)
 253     for (q += 2; ISSLASH (*q); q++)
 254       continue;
 255
 256   /* Copy components from Q to P, omitting redundant slashes and
 257      internal "."  components.  */
 258   while ((*p++ = c = *q++) != '\0')
 259     if (ISSLASH (c))
 260       while (ISSLASH (q[*q == '.']))
 261         q += (*q == '.') + 1;
 262
 263   /* Omit redundant trailing "." component and slash.  */
 264   if (2 < p - name)
 265     {
 266       p -= p[-2] == '.' && ISSLASH (p[-3]);
 267       p -= 2 < p - name && ISSLASH (p[-2]);
 268       p[-1] = '\0';
 269     }
 270 }
 271
 272 /* Normalize NAME by removing redundant slashes and "." components,
 273    including redundant trailing slashes.
 274
 275    Return a normalized newly-allocated copy.  */
 276
 277 char *
 278 normalize_filename (int cdidx, const char *name)
 279 {
 280   char *copy = NULL;
 281
 282   if (IS_RELATIVE_FILE_NAME (name))
 283     {
 284       /* Set COPY to the absolute path for this name.
 285
 286          FIXME: There should be no need to get the absolute file name.
 287          tar_getcdpath does not return a true "canonical" path, so
 288          this following approach may lead to situations where the same
 289          file or directory is processed twice under different absolute
 290          paths without that duplication being detected.  Perhaps we
 291          should use dev+ino pairs instead of names?  (See listed03.at for
 292          a related test case.) */
 293       const char *cdpath = tar_getcdpath (cdidx);
 294       size_t copylen;
 295       bool need_separator;
 296
 297       if (!cdpath)
 298         call_arg_fatal ("getcwd", ".");
 299       copylen = strlen (cdpath);
 300       need_separator = ! (DOUBLE_SLASH_IS_DISTINCT_ROOT
 301                           && copylen == 2 && ISSLASH (cdpath[1]));
 302       copy = xmalloc (copylen + need_separator + strlen (name) + 1);
 303       strcpy (copy, cdpath);
 304       copy[copylen] = DIRECTORY_SEPARATOR;
 305       strcpy (copy + copylen + need_separator, name);
 306     }
 307
 308   if (!copy)
 309     copy = xstrdup (name);
 310   normalize_filename_x (copy);
 311   return copy;
 312 }
 313
 314 \f
 315 void
 316 replace_prefix (char **pname, const char *samp, size_t slen,
 317                 const char *repl, size_t rlen)
 318 {
 319   char *name = *pname;
 320   size_t nlen = strlen (name);
 321   if (nlen > slen && memcmp (name, samp, slen) == 0 && ISSLASH (name[slen]))
 322     {
 323       if (rlen > slen)
 324         {
 325           name = xrealloc (name, nlen - slen + rlen + 1);
 326           *pname = name;
 327         }
 328       memmove (name + rlen, name + slen, nlen - slen + 1);
 329       memcpy (name, repl, rlen);
 330     }
 331 }
 332
 333 \f
 334 /* Handling numbers.  */
 335
 336 /* Convert VALUE, which is converted from a system integer type whose
 337    minimum value is MINVAL and maximum MINVAL, to an decimal
 338    integer string.  Use the storage in BUF and return a pointer to the
 339    converted string.  If VALUE is converted from a negative integer in
 340    the range MINVAL .. -1, represent it with a string representation
 341    of the negative integer, using leading '-'.  */
 342 #if ! (INTMAX_MAX <= UINTMAX_MAX / 2)
 343 # error "sysinttostr: uintmax_t cannot represent all intmax_t values"
 344 #endif
 345 char *
 346 sysinttostr (uintmax_t value, intmax_t minval, uintmax_t maxval,
 347              char buf[SYSINT_BUFSIZE])
 348 {
 349   if (value <= maxval)
 350     return umaxtostr (value, buf);
 351   else
 352     {
 353       intmax_t i = value - minval;
 354       return imaxtostr (i + minval, buf);
 355     }
 356 }
 357
 358 /* Convert a prefix of the string ARG to a system integer type whose
 359    minimum value is MINVAL and maximum MAXVAL.  If MINVAL is negative,
 360    negative integers MINVAL .. -1 are assumed to be represented using
 361    leading '-' in the usual way.  If the represented value exceeds
 362    INTMAX_MAX, return a negative integer V such that (uintmax_t) V
 363    yields the represented value.  If ARGLIM is nonnull, store into
 364    *ARGLIM a pointer to the first character after the prefix.
 365
 366    This is the inverse of sysinttostr.
 367
 368    On a normal return, set errno = 0.
 369    On conversion error, return 0 and set errno = EINVAL.
 370    On overflow, return an extreme value and set errno = ERANGE.  */
 371 #if ! (INTMAX_MAX <= UINTMAX_MAX)
 372 # error "strtosysint: nonnegative intmax_t does not fit in uintmax_t"
 373 #endif
 374 intmax_t
 375 strtosysint (char const *arg, char **arglim, intmax_t minval, uintmax_t maxval)
 376 {
 377   errno = 0;
 378   if (maxval <= INTMAX_MAX)
 379     {
 380       if (ISDIGIT (arg[*arg == '-']))
 381         {
 382           intmax_t i = strtoimax (arg, arglim, 10);
 383           intmax_t imaxval = maxval;
 384           if (minval <= i && i <= imaxval)
 385             return i;
 386           errno = ERANGE;
 387           return i < minval ? minval : maxval;
 388         }
 389     }
 390   else
 391     {
 392       if (ISDIGIT (*arg))
 393         {
 394           uintmax_t i = strtoumax (arg, arglim, 10);
 395           if (i <= maxval)
 396             return represent_uintmax (i);
 397           errno = ERANGE;
 398           return maxval;
 399         }
 400     }
 401
 402   errno = EINVAL;
 403   return 0;
 404 }
 405
 406 /* Output fraction and trailing digits appropriate for a nanoseconds
 407    count equal to NS, but don't output unnecessary '.' or trailing
 408    zeros.  */
 409
 410 void
 411 code_ns_fraction (int ns, char *p)
 412 {
 413   if (ns == 0)
 414     *p = '\0';
 415   else
 416     {
 417       int i = 9;
 418       *p++ = '.';
 419
 420       while (ns % 10 == 0)
 421         {
 422           ns /= 10;
 423           i--;
 424         }
 425
 426       p[i] = '\0';
 427
 428       for (;;)
 429         {
 430           p[--i] = '0' + ns % 10;
 431           if (i == 0)
 432             break;
 433           ns /= 10;
 434         }
 435     }
 436 }
 437
 438 char const *
 439 code_timespec (struct timespec t, char sbuf[TIMESPEC_STRSIZE_BOUND])
 440 {
 441   time_t s = t.tv_sec;
 442   int ns = t.tv_nsec;
 443   char *np;
 444   bool negative = s < 0;
 445
 446   /* ignore invalid values of ns */
 447   if (BILLION <= ns || ns < 0)
 448     ns = 0;
 449
 450   if (negative && ns != 0)
 451     {
 452       s++;
 453       ns = BILLION - ns;
 454     }
 455
 456   np = umaxtostr (negative ? - (uintmax_t) s : (uintmax_t) s, sbuf + 1);
 457   if (negative)
 458     *--np = '-';
 459   code_ns_fraction (ns, sbuf + UINTMAX_STRSIZE_BOUND);
 460   return np;
 461 }
 462
 463 struct timespec
 464 decode_timespec (char const *arg, char **arg_lim, bool parse_fraction)
 465 {
 466   time_t s = TYPE_MINIMUM (time_t);
 467   int ns = -1;
 468   char const *p = arg;
 469   bool negative = *arg == '-';
 470   struct timespec r;
 471
 472   if (! ISDIGIT (arg[negative]))
 473     errno = EINVAL;
 474   else
 475     {
 476       errno = 0;
 477
 478       if (negative)
 479         {
 480           intmax_t i = strtoimax (arg, arg_lim, 10);
 481           if (TYPE_SIGNED (time_t) ? TYPE_MINIMUM (time_t) <= i : 0 <= i)
 482             s = i;
 483           else
 484             errno = ERANGE;
 485         }
 486       else
 487         {
 488           uintmax_t i = strtoumax (arg, arg_lim, 10);
 489           if (i <= TYPE_MAXIMUM (time_t))
 490             s = i;
 491           else
 492             errno = ERANGE;
 493         }
 494
 495       p = *arg_lim;
 496       ns = 0;
 497
 498       if (parse_fraction && *p == '.')
 499         {
 500           int digits = 0;
 501           bool trailing_nonzero = false;
 502
 503           while (ISDIGIT (*++p))
 504             if (digits < LOG10_BILLION)
 505               digits++, ns = 10 * ns + (*p - '0');
 506             else
 507               trailing_nonzero |= *p != '0';
 508
 509           while (digits < LOG10_BILLION)
 510             digits++, ns *= 10;
 511
 512           if (negative)
 513             {
 514               /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
 515                  I.e., truncate time stamps towards minus infinity while
 516                  converting them to internal form.  */
 517               ns += trailing_nonzero;
 518               if (ns != 0)
 519                 {
 520                   if (s == TYPE_MINIMUM (time_t))
 521                     ns = -1;
 522                   else
 523                     {
 524                       s--;
 525                       ns = BILLION - ns;
 526                     }
 527                 }
 528             }
 529         }
 530
 531       if (errno == ERANGE)
 532         ns = -1;
 533     }
 534
 535   *arg_lim = (char *) p;
 536   r.tv_sec = s;
 537   r.tv_nsec = ns;
 538   return r;
 539 }
 540 \f
 541 /* File handling.  */
 542
 543 /* Saved names in case backup needs to be undone.  */
 544 static char *before_backup_name;
 545 static char *after_backup_name;
 546
 547 /* Return 1 if FILE_NAME is obviously "." or "/".  */
 548 bool
 549 must_be_dot_or_slash (char const *file_name)
 550 {
 551   file_name += FILE_SYSTEM_PREFIX_LEN (file_name);
 552
 553   if (ISSLASH (file_name[0]))
 554     {
 555       for (;;)
 556         if (ISSLASH (file_name[1]))
 557           file_name++;
 558         else if (file_name[1] == '.'
 559                  && ISSLASH (file_name[2 + (file_name[2] == '.')]))
 560           file_name += 2 + (file_name[2] == '.');
 561         else
 562           return ! file_name[1];
 563     }
 564   else
 565     {
 566       while (file_name[0] == '.' && ISSLASH (file_name[1]))
 567         {
 568           file_name += 2;
 569           while (ISSLASH (*file_name))
 570             file_name++;
 571         }
 572
 573       return ! file_name[0] || (file_name[0] == '.' && ! file_name[1]);
 574     }
 575 }
 576
 577 /* Some implementations of rmdir let you remove '.' or '/'.
 578    Report an error with errno set to zero for obvious cases of this;
 579    otherwise call rmdir.  */
 580 static int
 581 safer_rmdir (const char *file_name)
 582 {
 583   if (must_be_dot_or_slash (file_name))
 584     {
 585       errno = 0;
 586       return -1;
 587     }
 588
 589   if (unlinkat (chdir_fd, file_name, AT_REMOVEDIR) == 0)
 590     {
 591       remove_delayed_set_stat (file_name);
 592       return 0;
 593     }
 594   return -1;
 595 }
 596
 597 /* Remove FILE_NAME, returning 1 on success.  If FILE_NAME is a directory,
 598    then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
 599    recursively; otherwise, remove it only if it is empty.  If FILE_NAME is
 600    a directory that cannot be removed (e.g., because it is nonempty)
 601    and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
 602    Return 0 on error, with errno set; if FILE_NAME is obviously the working
 603    directory return zero with errno set to zero.  */
 604 int
 605 remove_any_file (const char *file_name, enum remove_option option)
 606 {
 607   /* Try unlink first if we cannot unlink directories, as this saves
 608      us a system call in the common case where we're removing a
 609      non-directory.  */
 610   bool try_unlink_first = cannot_unlink_dir ();
 611
 612   if (try_unlink_first)
 613     {
 614       if (unlinkat (chdir_fd, file_name, 0) == 0)
 615         return 1;
 616
 617       /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
 618          directory without appropriate privileges, but many Linux
 619          kernels return the more-sensible EISDIR.  */
 620       if (errno != EPERM && errno != EISDIR)
 621         return 0;
 622     }
 623
 624   if (safer_rmdir (file_name) == 0)
 625     return 1;
 626
 627   switch (errno)
 628     {
 629     case ENOTDIR:
 630       return !try_unlink_first && unlinkat (chdir_fd, file_name, 0) == 0;
 631
 632     case 0:
 633     case EEXIST:
 634 #if defined ENOTEMPTY && ENOTEMPTY != EEXIST
 635     case ENOTEMPTY:
 636 #endif
 637       switch (option)
 638         {
 639         case ORDINARY_REMOVE_OPTION:
 640           break;
 641
 642         case WANT_DIRECTORY_REMOVE_OPTION:
 643           return -1;
 644
 645         case RECURSIVE_REMOVE_OPTION:
 646           {
 647             char *directory = tar_savedir (file_name, 0);
 648             char const *entry;
 649             size_t entrylen;
 650
 651             if (! directory)
 652               return 0;
 653
 654             for (entry = directory;
 655                  (entrylen = strlen (entry)) != 0;
 656                  entry += entrylen + 1)
 657               {
 658                 char *file_name_buffer = new_name (file_name, entry);
 659                 int r = remove_any_file (file_name_buffer,
 660                                          RECURSIVE_REMOVE_OPTION);
 661                 int e = errno;
 662                 free (file_name_buffer);
 663
 664                 if (! r)
 665                   {
 666                     free (directory);
 667                     errno = e;
 668                     return 0;
 669                   }
 670               }
 671
 672             free (directory);
 673             return safer_rmdir (file_name) == 0;
 674           }
 675         }
 676       break;
 677     }
 678
 679   return 0;
 680 }
 681
 682 /* Check if FILE_NAME already exists and make a backup of it right now.
 683    Return success (nonzero) only if the backup is either unneeded, or
 684    successful.  For now, directories are considered to never need
 685    backup.  If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
 686    so, we do not have to backup block or character devices, nor remote
 687    entities.  */
 688 bool
 689 maybe_backup_file (const char *file_name, bool this_is_the_archive)
 690 {
 691   struct stat file_stat;
 692
 693   assign_string (&before_backup_name, file_name);
 694
 695   /* A run situation may exist between Emacs or other GNU programs trying to
 696      make a backup for the same file simultaneously.  If theoretically
 697      possible, real problems are unlikely.  Doing any better would require a
 698      convention, GNU-wide, for all programs doing backups.  */
 699
 700   assign_string (&after_backup_name, 0);
 701
 702   /* Check if we really need to backup the file.  */
 703
 704   if (this_is_the_archive && _remdev (file_name))
 705     return true;
 706
 707   if (deref_stat (file_name, &file_stat) != 0)
 708     {
 709       if (errno == ENOENT)
 710         return true;
 711
 712       stat_error (file_name);
 713       return false;
 714     }
 715
 716   if (S_ISDIR (file_stat.st_mode))
 717     return true;
 718
 719   if (this_is_the_archive
 720       && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
 721     return true;
 722
 723   after_backup_name = find_backup_file_name (file_name, backup_type);
 724   if (! after_backup_name)
 725     xalloc_die ();
 726
 727   if (renameat (chdir_fd, before_backup_name, chdir_fd, after_backup_name)
 728       == 0)
 729     {
 730       if (verbose_option)
 731         fprintf (stdlis, _("Renaming %s to %s\n"),
 732                  quote_n (0, before_backup_name),
 733                  quote_n (1, after_backup_name));
 734       return true;
 735     }
 736   else
 737     {
 738       /* The backup operation failed.  */
 739       int e = errno;
 740       ERROR ((0, e, _("%s: Cannot rename to %s"),
 741               quotearg_colon (before_backup_name),
 742               quote_n (1, after_backup_name)));
 743       assign_string (&after_backup_name, 0);
 744       return false;
 745     }
 746 }
 747
 748 /* Try to restore the recently backed up file to its original name.
 749    This is usually only needed after a failed extraction.  */
 750 void
 751 undo_last_backup (void)
 752 {
 753   if (after_backup_name)
 754     {
 755       if (renameat (chdir_fd, after_backup_name, chdir_fd, before_backup_name)
 756           != 0)
 757         {
 758           int e = errno;
 759           ERROR ((0, e, _("%s: Cannot rename to %s"),
 760                   quotearg_colon (after_backup_name),
 761                   quote_n (1, before_backup_name)));
 762         }
 763       if (verbose_option)
 764         fprintf (stdlis, _("Renaming %s back to %s\n"),
 765                  quote_n (0, after_backup_name),
 766                  quote_n (1, before_backup_name));
 767       assign_string (&after_backup_name, 0);
 768     }
 769 }
 770
 771 /* Apply either stat or lstat to (NAME, BUF), depending on the
 772    presence of the --dereference option.  NAME is relative to the
 773    most-recent argument to chdir_do.  */
 774 int
 775 deref_stat (char const *name, struct stat *buf)
 776 {
 777   return fstatat (chdir_fd, name, buf, fstatat_flags);
 778 }
 779
 780 /* Read from FD into the buffer BUF with COUNT bytes.  Attempt to fill
 781    BUF.  Wait until input is available; this matters because files are
 782    opened O_NONBLOCK for security reasons, and on some file systems
 783    this can cause read to fail with errno == EAGAIN.  Return the
 784    actual number of bytes read, zero for EOF, or
 785    SAFE_READ_ERROR upon error.  */
 786 size_t
 787 blocking_read (int fd, void *buf, size_t count)
 788 {
 789   size_t bytes = safe_read (fd, buf, count);
 790
 791 #if defined F_SETFL && O_NONBLOCK
 792   if (bytes == SAFE_READ_ERROR && errno == EAGAIN)
 793     {
 794       int flags = fcntl (fd, F_GETFL);
 795       if (0 <= flags && flags & O_NONBLOCK
 796           && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
 797         bytes = safe_read (fd, buf, count);
 798     }
 799 #endif
 800
 801   return bytes;
 802 }
 803
 804 /* Write to FD from the buffer BUF with COUNT bytes.  Do a full write.
 805    Wait until an output buffer is available; this matters because
 806    files are opened O_NONBLOCK for security reasons, and on some file
 807    systems this can cause write to fail with errno == EAGAIN.  Return
 808    the actual number of bytes written, setting errno if that is less
 809    than COUNT.  */
 810 size_t
 811 blocking_write (int fd, void const *buf, size_t count)
 812 {
 813   size_t bytes = full_write (fd, buf, count);
 814
 815 #if defined F_SETFL && O_NONBLOCK
 816   if (bytes < count && errno == EAGAIN)
 817     {
 818       int flags = fcntl (fd, F_GETFL);
 819       if (0 <= flags && flags & O_NONBLOCK
 820           && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
 821         {
 822           char const *buffer = buf;
 823           bytes += full_write (fd, buffer + bytes, count - bytes);
 824         }
 825     }
 826 #endif
 827
 828   return bytes;
 829 }
 830
 831 /* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's)
 832    access time to ATIME.  */
 833 int
 834 set_file_atime (int fd, int parentfd, char const *file, struct timespec atime)
 835 {
 836   struct timespec ts[2];
 837   ts[0] = atime;
 838   ts[1].tv_nsec = UTIME_OMIT;
 839   return fdutimensat (fd, parentfd, file, ts, fstatat_flags);
 840 }
 841
 842 /* A description of a working directory.  */
 843 struct wd
 844 {
 845   /* The directory's name.  */
 846   char const *name;
 847   /* "Absolute" path representing this directory; in the contrast to
 848      the real absolute pathname, it can contain /../ components (see
 849      normalize_filename_x for the reason of it).  It is NULL if the
 850      absolute path could not be determined.  */
 851   char *abspath;
 852   /* If nonzero, the file descriptor of the directory, or AT_FDCWD if
 853      the working directory.  If zero, the directory needs to be opened
 854      to be used.  */
 855   int fd;
 856 };
 857
 858 /* A vector of chdir targets.  wd[0] is the initial working directory.  */
 859 static struct wd *wd;
 860
 861 /* The number of working directories in the vector.  */
 862 static size_t wd_count;
 863
 864 /* The allocated size of the vector.  */
 865 static size_t wd_alloc;
 866
 867 /* The maximum number of chdir targets with open directories.
 868    Don't make it too large, as many operating systems have a small
 869    limit on the number of open file descriptors.  Also, the current
 870    implementation does not scale well.  */
 871 enum { CHDIR_CACHE_SIZE = 16 };
 872
 873 /* Indexes into WD of chdir targets with open file descriptors, sorted
 874    most-recently used first.  Zero indexes are unused.  */
 875 static int wdcache[CHDIR_CACHE_SIZE];
 876
 877 /* Number of nonzero entries in WDCACHE.  */
 878 static size_t wdcache_count;
 879
 880 int
 881 chdir_count (void)
 882 {
 883   if (wd_count == 0)
 884     return wd_count;
 885   return wd_count - 1;
 886 }
 887
 888 /* DIR is the operand of a -C option; add it to vector of chdir targets,
 889    and return the index of its location.  */
 890 int
 891 chdir_arg (char const *dir)
 892 {
 893   char *absdir;
 894
 895   if (wd_count == wd_alloc)
 896     {
 897       if (wd_alloc == 0)
 898         wd_alloc = 2;
 899       wd = x2nrealloc (wd, &wd_alloc, sizeof *wd);
 900
 901       if (! wd_count)
 902         {
 903           wd[wd_count].name = ".";
 904           wd[wd_count].abspath = xgetcwd ();
 905           wd[wd_count].fd = AT_FDCWD;
 906           wd_count++;
 907         }
 908     }
 909
 910   /* Optimize the common special case of the working directory,
 911      or the working directory as a prefix.  */
 912   if (dir[0])
 913     {
 914       while (dir[0] == '.' && ISSLASH (dir[1]))
 915         for (dir += 2;  ISSLASH (*dir);  dir++)
 916           continue;
 917       if (! dir[dir[0] == '.'])
 918         return wd_count - 1;
 919     }
 920
 921
 922   /* If the given name is absolute, use it to represent this directory;
 923      otherwise, construct a name based on the previous -C option.  */
 924   if (IS_ABSOLUTE_FILE_NAME (dir))
 925     absdir = xstrdup (dir);
 926   else if (wd[wd_count - 1].abspath)
 927     {
 928       namebuf_t nbuf = namebuf_create (wd[wd_count - 1].abspath);
 929       namebuf_add_dir (nbuf, dir);
 930       absdir = namebuf_finish (nbuf);
 931     }
 932   else
 933     absdir = 0;
 934
 935   wd[wd_count].name = dir;
 936   wd[wd_count].abspath = absdir;
 937   wd[wd_count].fd = 0;
 938   return wd_count++;
 939 }
 940
 941 /* Index of current directory.  */
 942 int chdir_current;
 943
 944 /* Value suitable for use as the first argument to openat, and in
 945    similar locations for fstatat, etc.  This is an open file
 946    descriptor, or AT_FDCWD if the working directory is current.  It is
 947    valid until the next invocation of chdir_do.  */
 948 int chdir_fd = AT_FDCWD;
 949
 950 /* Change to directory I, in a virtual way.  This does not actually
 951    invoke chdir; it merely sets chdir_fd to an int suitable as the
 952    first argument for openat, etc.  If I is 0, change to the initial
 953    working directory; otherwise, I must be a value returned by
 954    chdir_arg.  */
 955 void
 956 chdir_do (int i)
 957 {
 958   if (chdir_current != i)
 959     {
 960       struct wd *curr = &wd[i];
 961       int fd = curr->fd;
 962
 963       if (! fd)
 964         {
 965           if (! IS_ABSOLUTE_FILE_NAME (curr->name))
 966             chdir_do (i - 1);
 967           fd = openat (chdir_fd, curr->name,
 968                        open_searchdir_flags & ~ O_NOFOLLOW);
 969           if (fd < 0)
 970             open_fatal (curr->name);
 971
 972           curr->fd = fd;
 973
 974           /* Add I to the cache, tossing out the lowest-ranking entry if the
 975              cache is full.  */
 976           if (wdcache_count < CHDIR_CACHE_SIZE)
 977             wdcache[wdcache_count++] = i;
 978           else
 979             {
 980               struct wd *stale = &wd[wdcache[CHDIR_CACHE_SIZE - 1]];
 981               if (close (stale->fd) != 0)
 982                 close_diag (stale->name);
 983               stale->fd = 0;
 984               wdcache[CHDIR_CACHE_SIZE - 1] = i;
 985             }
 986         }
 987
 988       if (0 < fd)
 989         {
 990           /* Move the i value to the front of the cache.  This is
 991              O(CHDIR_CACHE_SIZE), but the cache is small.  */
 992           size_t ci;
 993           int prev = wdcache[0];
 994           for (ci = 1; prev != i; ci++)
 995             {
 996               int cur = wdcache[ci];
 997               wdcache[ci] = prev;
 998               if (cur == i)
 999                 break;
1000               prev = cur;
1001             }
1002           wdcache[0] = i;
1003         }
1004
1005       chdir_current = i;
1006       chdir_fd = fd;
1007     }
1008 }
1009 \f
1010 const char *
1011 tar_dirname (void)
1012 {
1013   return wd[chdir_current].name;
1014 }
1015
1016 /* Return the absolute path that represents the working
1017    directory referenced by IDX.
1018
1019    If wd is empty, then there were no -C options given, and
1020    chdir_args() has never been called, so we simply return the
1021    process's actual cwd.  (Note that in this case IDX is ignored,
1022    since it should always be 0.) */
1023 static const char *
1024 tar_getcdpath (int idx)
1025 {
1026   if (!wd)
1027     {
1028       static char *cwd;
1029       if (!cwd)
1030         cwd = xgetcwd ();
1031       return cwd;
1032     }
1033   return wd[idx].abspath;
1034 }
1035 \f
1036 void
1037 close_diag (char const *name)
1038 {
1039   if (ignore_failed_read_option)
1040     close_warn (name);
1041   else
1042     close_error (name);
1043 }
1044
1045 void
1046 open_diag (char const *name)
1047 {
1048   if (ignore_failed_read_option)
1049     open_warn (name);
1050   else
1051     open_error (name);
1052 }
1053
1054 void
1055 read_diag_details (char const *name, off_t offset, size_t size)
1056 {
1057   if (ignore_failed_read_option)
1058     read_warn_details (name, offset, size);
1059   else
1060     read_error_details (name, offset, size);
1061 }
1062
1063 void
1064 readlink_diag (char const *name)
1065 {
1066   if (ignore_failed_read_option)
1067     readlink_warn (name);
1068   else
1069     readlink_error (name);
1070 }
1071
1072 void
1073 savedir_diag (char const *name)
1074 {
1075   if (ignore_failed_read_option)
1076     savedir_warn (name);
1077   else
1078     savedir_error (name);
1079 }
1080
1081 void
1082 seek_diag_details (char const *name, off_t offset)
1083 {
1084   if (ignore_failed_read_option)
1085     seek_warn_details (name, offset);
1086   else
1087     seek_error_details (name, offset);
1088 }
1089
1090 void
1091 stat_diag (char const *name)
1092 {
1093   if (ignore_failed_read_option)
1094     stat_warn (name);
1095   else
1096     stat_error (name);
1097 }
1098
1099 void
1100 file_removed_diag (const char *name, bool top_level,
1101                    void (*diagfn) (char const *name))
1102 {
1103   if (!top_level && errno == ENOENT)
1104     {
1105       WARNOPT (WARN_FILE_REMOVED,
1106                (0, 0, _("%s: File removed before we read it"),
1107                 quotearg_colon (name)));
1108       set_exit_status (TAREXIT_DIFFERS);
1109     }
1110   else
1111     diagfn (name);
1112 }
1113
1114 void
1115 write_fatal_details (char const *name, ssize_t status, size_t size)
1116 {
1117   write_error_details (name, status, size);
1118   fatal_exit ();
1119 }
1120
1121 /* Fork, aborting if unsuccessful.  */
1122 pid_t
1123 xfork (void)
1124 {
1125   pid_t p = fork ();
1126   if (p == (pid_t) -1)
1127     call_arg_fatal ("fork", _("child process"));
1128   return p;
1129 }
1130
1131 /* Create a pipe, aborting if unsuccessful.  */
1132 void
1133 xpipe (int fd[2])
1134 {
1135   if (pipe (fd) < 0)
1136     call_arg_fatal ("pipe", _("interprocess channel"));
1137 }
1138
1139 /* Return PTR, aligned upward to the next multiple of ALIGNMENT.
1140    ALIGNMENT must be nonzero.  The caller must arrange for ((char *)
1141    PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable
1142    locations.  */
1143
1144 static inline void *
1145 ptr_align (void *ptr, size_t alignment)
1146 {
1147   char *p0 = ptr;
1148   char *p1 = p0 + alignment - 1;
1149   return p1 - (size_t) p1 % alignment;
1150 }
1151
1152 /* Return the address of a page-aligned buffer of at least SIZE bytes.
1153    The caller should free *PTR when done with the buffer.  */
1154
1155 void *
1156 page_aligned_alloc (void **ptr, size_t size)
1157 {
1158   size_t alignment = getpagesize ();
1159   size_t size1 = size + alignment;
1160   if (size1 < size)
1161     xalloc_die ();
1162   *ptr = xmalloc (size1);
1163   return ptr_align (*ptr, alignment);
1164 }
1165
1166 \f
1167
1168 struct namebuf
1169 {
1170   char *buffer;         /* directory, '/', and directory member */
1171   size_t buffer_size;   /* allocated size of name_buffer */
1172   size_t dir_length;    /* length of directory part in buffer */
1173 };
1174
1175 namebuf_t
1176 namebuf_create (const char *dir)
1177 {
1178   namebuf_t buf = xmalloc (sizeof (*buf));
1179   buf->buffer_size = strlen (dir) + 2;
1180   buf->buffer = xmalloc (buf->buffer_size);
1181   strcpy (buf->buffer, dir);
1182   buf->dir_length = strlen (buf->buffer);
1183   if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
1184     buf->buffer[buf->dir_length++] = DIRECTORY_SEPARATOR;
1185   return buf;
1186 }
1187
1188 void
1189 namebuf_free (namebuf_t buf)
1190 {
1191   free (buf->buffer);
1192   free (buf);
1193 }
1194
1195 char *
1196 namebuf_name (namebuf_t buf, const char *name)
1197 {
1198   size_t len = strlen (name);
1199   while (buf->dir_length + len + 1 >= buf->buffer_size)
1200     buf->buffer = x2realloc (buf->buffer, &buf->buffer_size);
1201   strcpy (buf->buffer + buf->dir_length, name);
1202   return buf->buffer;
1203 }
1204
1205 void
1206 namebuf_add_dir (namebuf_t buf, const char *name)
1207 {
1208   static char dirsep[] = { DIRECTORY_SEPARATOR, 0 };
1209   if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
1210     {
1211       namebuf_name (buf, dirsep);
1212       buf->dir_length++;
1213     }
1214   namebuf_name (buf, name);
1215   buf->dir_length += strlen (name);
1216 }
1217
1218 char *
1219 namebuf_finish (namebuf_t buf)
1220 {
1221   char *res = buf->buffer;
1222
1223   if (ISSLASH (buf->buffer[buf->dir_length - 1]))
1224     buf->buffer[buf->dir_length] = 0;
1225   free (buf);
1226   return res;
1227 }
1228
1229 /* Return the filenames in directory NAME, relative to the chdir_fd.
1230    If the directory does not exist, report error if MUST_EXIST is
1231    true.
1232
1233    Return NULL on errors.
1234 */
1235 char *
1236 tar_savedir (const char *name, int must_exist)
1237 {
1238   char *ret = NULL;
1239   DIR *dir = NULL;
1240   int fd = openat (chdir_fd, name, open_read_flags | O_DIRECTORY);
1241   if (fd < 0)
1242     {
1243       if (!must_exist && errno == ENOENT)
1244         return NULL;
1245       open_error (name);
1246     }
1247   else if (! ((dir = fdopendir (fd))
1248               && (ret = streamsavedir (dir, savedir_sort_order))))
1249     savedir_error (name);
1250
1251   if (dir ? closedir (dir) != 0 : 0 <= fd && close (fd) != 0)
1252     savedir_error (name);
1253
1254   return ret;
1255 }