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 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 2, 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 #include <system.h>
  21 #include <rmt.h>
  22 #include "common.h"
  23 #include <quotearg.h>
  24 #include <save-cwd.h>
  25 #include <unlinkdir.h>
  26
  27 \f
  28 /* Handling strings.  */
  29
  30 /* Assign STRING to a copy of VALUE if not zero, or to zero.  If
  31    STRING was nonzero, it is freed first.  */
  32 void
  33 assign_string (char **string, const char *value)
  34 {
  35   if (*string)
  36     free (*string);
  37   *string = value ? xstrdup (value) : 0;
  38 }
  39
  40 /* Allocate a copy of the string quoted as in C, and returns that.  If
  41    the string does not have to be quoted, it returns a null pointer.
  42    The allocated copy should normally be freed with free() after the
  43    caller is done with it.
  44
  45    This is used in one context only: generating the directory file in
  46    incremental dumps.  The quoted string is not intended for human
  47    consumption; it is intended only for unquote_string.  The quoting
  48    is locale-independent, so that users needn't worry about locale
  49    when reading directory files.  This means that we can't use
  50    quotearg, as quotearg is locale-dependent and is meant for human
  51    consumption.  */
  52 char *
  53 quote_copy_string (const char *string)
  54 {
  55   const char *source = string;
  56   char *destination = 0;
  57   char *buffer = 0;
  58   int copying = 0;
  59
  60   while (*source)
  61     {
  62       int character = *source++;
  63
  64       switch (character)
  65         {
  66         case '\n': case '\\':
  67           if (!copying)
  68             {
  69               size_t length = (source - string) - 1;
  70
  71               copying = 1;
  72               buffer = xmalloc (length + 2 + 2 * strlen (source) + 1);
  73               memcpy (buffer, string, length);
  74               destination = buffer + length;
  75             }
  76           *destination++ = '\\';
  77           *destination++ = character == '\\' ? '\\' : 'n';
  78           break;
  79
  80         default:
  81           if (copying)
  82             *destination++ = character;
  83           break;
  84         }
  85     }
  86   if (copying)
  87     {
  88       *destination = '\0';
  89       return buffer;
  90     }
  91   return 0;
  92 }
  93
  94 /* Takes a quoted C string (like those produced by quote_copy_string)
  95    and turns it back into the un-quoted original.  This is done in
  96    place.  Returns 0 only if the string was not properly quoted, but
  97    completes the unquoting anyway.
  98
  99    This is used for reading the saved directory file in incremental
 100    dumps.  It is used for decoding old `N' records (demangling names).
 101    But also, it is used for decoding file arguments, would they come
 102    from the shell or a -T file, and for decoding the --exclude
 103    argument.  */
 104 int
 105 unquote_string (char *string)
 106 {
 107   int result = 1;
 108   char *source = string;
 109   char *destination = string;
 110
 111   /* Escape sequences other than \\ and \n are no longer generated by
 112      quote_copy_string, but accept them for backwards compatibility,
 113      and also because unquote_string is used for purposes other than
 114      parsing the output of quote_copy_string.  */
 115
 116   while (*source)
 117     if (*source == '\\')
 118       switch (*++source)
 119         {
 120         case '\\':
 121           *destination++ = '\\';
 122           source++;
 123           break;
 124
 125         case 'a':
 126           *destination++ = '\a';
 127           source++;
 128           break;
 129
 130         case 'b':
 131           *destination++ = '\b';
 132           source++;
 133           break;
 134
 135         case 'f':
 136           *destination++ = '\f';
 137           source++;
 138           break;
 139
 140         case 'n':
 141           *destination++ = '\n';
 142           source++;
 143           break;
 144
 145         case 'r':
 146           *destination++ = '\r';
 147           source++;
 148           break;
 149
 150         case 't':
 151           *destination++ = '\t';
 152           source++;
 153           break;
 154
 155         case 'v':
 156           *destination++ = '\v';
 157           source++;
 158           break;
 159
 160         case '?':
 161           *destination++ = 0177;
 162           source++;
 163           break;
 164
 165         case '0':
 166         case '1':
 167         case '2':
 168         case '3':
 169         case '4':
 170         case '5':
 171         case '6':
 172         case '7':
 173           {
 174             int value = *source++ - '0';
 175
 176             if (*source < '0' || *source > '7')
 177               {
 178                 *destination++ = value;
 179                 break;
 180               }
 181             value = value * 8 + *source++ - '0';
 182             if (*source < '0' || *source > '7')
 183               {
 184                 *destination++ = value;
 185                 break;
 186               }
 187             value = value * 8 + *source++ - '0';
 188             *destination++ = value;
 189             break;
 190           }
 191
 192         default:
 193           result = 0;
 194           *destination++ = '\\';
 195           if (*source)
 196             *destination++ = *source++;
 197           break;
 198         }
 199     else if (source != destination)
 200       *destination++ = *source++;
 201     else
 202       source++, destination++;
 203
 204   if (source != destination)
 205     *destination = '\0';
 206   return result;
 207 }
 208 \f
 209 /* File handling.  */
 210
 211 /* Saved names in case backup needs to be undone.  */
 212 static char *before_backup_name;
 213 static char *after_backup_name;
 214
 215 /* Return 1 if FILE_NAME is obviously "." or "/".  */
 216 static bool
 217 must_be_dot_or_slash (char const *file_name)
 218 {
 219   file_name += FILE_SYSTEM_PREFIX_LEN (file_name);
 220
 221   if (ISSLASH (file_name[0]))
 222     {
 223       for (;;)
 224         if (ISSLASH (file_name[1]))
 225           file_name++;
 226         else if (file_name[1] == '.'
 227                  && ISSLASH (file_name[2 + (file_name[2] == '.')]))
 228           file_name += 2 + (file_name[2] == '.');
 229         else
 230           return ! file_name[1];
 231     }
 232   else
 233     {
 234       while (file_name[0] == '.' && ISSLASH (file_name[1]))
 235         {
 236           file_name += 2;
 237           while (ISSLASH (*file_name))
 238             file_name++;
 239         }
 240
 241       return ! file_name[0] || (file_name[0] == '.' && ! file_name[1]);
 242     }
 243 }
 244
 245 /* Some implementations of rmdir let you remove '.' or '/'.
 246    Report an error with errno set to zero for obvious cases of this;
 247    otherwise call rmdir.  */
 248 static int
 249 safer_rmdir (const char *file_name)
 250 {
 251   if (must_be_dot_or_slash (file_name))
 252     {
 253       errno = 0;
 254       return -1;
 255     }
 256
 257   return rmdir (file_name);
 258 }
 259
 260 /* Remove FILE_NAME, returning 1 on success.  If FILE_NAME is a directory,
 261    then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
 262    recursively; otherwise, remove it only if it is empty.  If FILE_NAME is
 263    a directory that cannot be removed (e.g., because it is nonempty)
 264    and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
 265    Return 0 on error, with errno set; if FILE_NAME is obviously the working
 266    directory return zero with errno set to zero.  */
 267 int
 268 remove_any_file (const char *file_name, enum remove_option option)
 269 {
 270   /* Try unlink first if we cannot unlink directories, as this saves
 271      us a system call in the common case where we're removing a
 272      non-directory.  */
 273   bool try_unlink_first = cannot_unlink_dir ();
 274
 275   if (try_unlink_first)
 276     {
 277       if (unlink (file_name) == 0)
 278         return 1;
 279
 280       /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
 281          directory without appropriate privileges, but many Linux
 282          kernels return the more-sensible EISDIR.  */
 283       if (errno != EPERM && errno != EISDIR)
 284         return 0;
 285     }
 286
 287   if (safer_rmdir (file_name) == 0)
 288     return 1;
 289
 290   switch (errno)
 291     {
 292     case ENOTDIR:
 293       return !try_unlink_first && unlink (file_name) == 0;
 294
 295     case 0:
 296     case EEXIST:
 297 #if defined ENOTEMPTY && ENOTEMPTY != EEXIST
 298     case ENOTEMPTY:
 299 #endif
 300       switch (option)
 301         {
 302         case ORDINARY_REMOVE_OPTION:
 303           break;
 304
 305         case WANT_DIRECTORY_REMOVE_OPTION:
 306           return -1;
 307
 308         case RECURSIVE_REMOVE_OPTION:
 309           {
 310             char *directory = savedir (file_name);
 311             char const *entry;
 312             size_t entrylen;
 313
 314             if (! directory)
 315               return 0;
 316
 317             for (entry = directory;
 318                  (entrylen = strlen (entry)) != 0;
 319                  entry += entrylen + 1)
 320               {
 321                 char *file_name_buffer = new_name (file_name, entry);
 322                 int r = remove_any_file (file_name_buffer,
 323                                          RECURSIVE_REMOVE_OPTION);
 324                 int e = errno;
 325                 free (file_name_buffer);
 326
 327                 if (! r)
 328                   {
 329                     free (directory);
 330                     errno = e;
 331                     return 0;
 332                   }
 333               }
 334
 335             free (directory);
 336             return safer_rmdir (file_name) == 0;
 337           }
 338         }
 339       break;
 340     }
 341
 342   return 0;
 343 }
 344
 345 /* Check if FILE_NAME already exists and make a backup of it right now.
 346    Return success (nonzero) only if the backup is either unneeded, or
 347    successful.  For now, directories are considered to never need
 348    backup.  If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
 349    so, we do not have to backup block or character devices, nor remote
 350    entities.  */
 351 bool
 352 maybe_backup_file (const char *file_name, int this_is_the_archive)
 353 {
 354   struct stat file_stat;
 355
 356   /* Check if we really need to backup the file.  */
 357
 358   if (this_is_the_archive && _remdev (file_name))
 359     return true;
 360
 361   if (stat (file_name, &file_stat))
 362     {
 363       if (errno == ENOENT)
 364         return true;
 365
 366       stat_error (file_name);
 367       return false;
 368     }
 369
 370   if (S_ISDIR (file_stat.st_mode))
 371     return true;
 372
 373   if (this_is_the_archive
 374       && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
 375     return true;
 376
 377   assign_string (&before_backup_name, file_name);
 378
 379   /* A run situation may exist between Emacs or other GNU programs trying to
 380      make a backup for the same file simultaneously.  If theoretically
 381      possible, real problems are unlikely.  Doing any better would require a
 382      convention, GNU-wide, for all programs doing backups.  */
 383
 384   assign_string (&after_backup_name, 0);
 385   after_backup_name = find_backup_file_name (file_name, backup_type);
 386   if (! after_backup_name)
 387     xalloc_die ();
 388
 389   if (rename (before_backup_name, after_backup_name) == 0)
 390     {
 391       if (verbose_option)
 392         fprintf (stdlis, _("Renaming %s to %s\n"),
 393                  quote_n (0, before_backup_name),
 394                  quote_n (1, after_backup_name));
 395       return true;
 396     }
 397   else
 398     {
 399       /* The backup operation failed.  */
 400       int e = errno;
 401       ERROR ((0, e, _("%s: Cannot rename to %s"),
 402               quotearg_colon (before_backup_name),
 403               quote_n (1, after_backup_name)));
 404       assign_string (&after_backup_name, 0);
 405       return false;
 406     }
 407 }
 408
 409 /* Try to restore the recently backed up file to its original name.
 410    This is usually only needed after a failed extraction.  */
 411 void
 412 undo_last_backup (void)
 413 {
 414   if (after_backup_name)
 415     {
 416       if (rename (after_backup_name, before_backup_name) != 0)
 417         {
 418           int e = errno;
 419           ERROR ((0, e, _("%s: Cannot rename to %s"),
 420                   quotearg_colon (after_backup_name),
 421                   quote_n (1, before_backup_name)));
 422         }
 423       if (verbose_option)
 424         fprintf (stdlis, _("Renaming %s back to %s\n"),
 425                  quote_n (0, after_backup_name),
 426                  quote_n (1, before_backup_name));
 427       assign_string (&after_backup_name, 0);
 428     }
 429 }
 430
 431 /* Depending on DEREF, apply either stat or lstat to (NAME, BUF).  */
 432 int
 433 deref_stat (bool deref, char const *name, struct stat *buf)
 434 {
 435   return deref ? stat (name, buf) : lstat (name, buf);
 436 }
 437
 438 /* A description of a working directory.  */
 439 struct wd
 440 {
 441   char const *name;
 442   int saved;
 443   struct saved_cwd saved_cwd;
 444 };
 445
 446 /* A vector of chdir targets.  wd[0] is the initial working directory.  */
 447 static struct wd *wd;
 448
 449 /* The number of working directories in the vector.  */
 450 static size_t wds;
 451
 452 /* The allocated size of the vector.  */
 453 static size_t wd_alloc;
 454
 455 /* DIR is the operand of a -C option; add it to vector of chdir targets,
 456    and return the index of its location.  */
 457 int
 458 chdir_arg (char const *dir)
 459 {
 460   if (wds == wd_alloc)
 461     {
 462       wd_alloc = 2 * (wd_alloc + 1);
 463       wd = xrealloc (wd, sizeof *wd * wd_alloc);
 464       if (! wds)
 465         {
 466           wd[wds].name = ".";
 467           wd[wds].saved = 0;
 468           wds++;
 469         }
 470     }
 471
 472   /* Optimize the common special case of the working directory,
 473      or the working directory as a prefix.  */
 474   if (dir[0])
 475     {
 476       while (dir[0] == '.' && ISSLASH (dir[1]))
 477         for (dir += 2;  ISSLASH (*dir);  dir++)
 478           continue;
 479       if (! dir[dir[0] == '.'])
 480         return wds - 1;
 481     }
 482
 483   wd[wds].name = dir;
 484   wd[wds].saved = 0;
 485   return wds++;
 486 }
 487
 488 /* Change to directory I.  If I is 0, change to the initial working
 489    directory; otherwise, I must be a value returned by chdir_arg.  */
 490 void
 491 chdir_do (int i)
 492 {
 493   static int previous;
 494
 495   if (previous != i)
 496     {
 497       struct wd *prev = &wd[previous];
 498       struct wd *curr = &wd[i];
 499
 500       if (! prev->saved)
 501         {
 502           prev->saved = 1;
 503           if (save_cwd (&prev->saved_cwd) != 0)
 504             FATAL_ERROR ((0, 0, _("Cannot save working directory")));
 505         }
 506
 507       if (curr->saved)
 508         {
 509           if (restore_cwd (&curr->saved_cwd))
 510             FATAL_ERROR ((0, 0, _("Cannot change working directory")));
 511         }
 512       else
 513         {
 514           if (i && ! ISSLASH (curr->name[0]))
 515             chdir_do (i - 1);
 516           if (chdir (curr->name) != 0)
 517             chdir_fatal (curr->name);
 518         }
 519
 520       previous = i;
 521     }
 522 }
 523 \f
 524 void
 525 close_diag (char const *name)
 526 {
 527   if (ignore_failed_read_option)
 528     close_warn (name);
 529   else
 530     close_error (name);
 531 }
 532
 533 void
 534 open_diag (char const *name)
 535 {
 536   if (ignore_failed_read_option)
 537     open_warn (name);
 538   else
 539     open_error (name);
 540 }
 541
 542 void
 543 read_diag_details (char const *name, off_t offset, size_t size)
 544 {
 545   if (ignore_failed_read_option)
 546     read_warn_details (name, offset, size);
 547   else
 548     read_error_details (name, offset, size);
 549 }
 550
 551 void
 552 readlink_diag (char const *name)
 553 {
 554   if (ignore_failed_read_option)
 555     readlink_warn (name);
 556   else
 557     readlink_error (name);
 558 }
 559
 560 void
 561 savedir_diag (char const *name)
 562 {
 563   if (ignore_failed_read_option)
 564     savedir_warn (name);
 565   else
 566     savedir_error (name);
 567 }
 568
 569 void
 570 seek_diag_details (char const *name, off_t offset)
 571 {
 572   if (ignore_failed_read_option)
 573     seek_warn_details (name, offset);
 574   else
 575     seek_error_details (name, offset);
 576 }
 577
 578 void
 579 stat_diag (char const *name)
 580 {
 581   if (ignore_failed_read_option)
 582     stat_warn (name);
 583   else
 584     stat_error (name);
 585 }
 586
 587 void
 588 write_fatal_details (char const *name, ssize_t status, size_t size)
 589 {
 590   write_error_details (name, status, size);
 591   fatal_exit ();
 592 }
 593
 594 /* Fork, aborting if unsuccessful.  */
 595 pid_t
 596 xfork (void)
 597 {
 598   pid_t p = fork ();
 599   if (p == (pid_t) -1)
 600     call_arg_fatal ("fork", _("child process"));
 601   return p;
 602 }
 603
 604 /* Create a pipe, aborting if unsuccessful.  */
 605 void
 606 xpipe (int fd[2])
 607 {
 608   if (pipe (fd) < 0)
 609     call_arg_fatal ("pipe", _("interprocess channel"));
 610 }
 611
 612 /* Return PTR, aligned upward to the next multiple of ALIGNMENT.
 613    ALIGNMENT must be nonzero.  The caller must arrange for ((char *)
 614    PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable
 615    locations.  */
 616
 617 static inline void *
 618 ptr_align (void *ptr, size_t alignment)
 619 {
 620   char *p0 = ptr;
 621   char *p1 = p0 + alignment - 1;
 622   return p1 - (size_t) p1 % alignment;
 623 }
 624
 625 /* Return the address of a page-aligned buffer of at least SIZE bytes.
 626    The caller should free *PTR when done with the buffer.  */
 627
 628 void *
 629 page_aligned_alloc (void **ptr, size_t size)
 630 {
 631   size_t alignment = getpagesize ();
 632   size_t size1 = size + alignment;
 633   if (size1 < size)
 634     xalloc_die ();
 635   *ptr = xmalloc (size1);
 636   return ptr_align (*ptr, alignment);
 637 }