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

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