git.gag.com Git - debian/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 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    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "system.h"
  21 #include "rmt.h"
  22 #include "common.h"
  23 #include <quotearg.h>
  24 #include <save-cwd.h>
  25
  26 static void call_arg_fatal (char const *, char const *)
  27      __attribute__ ((noreturn));
  28 \f
  29 /* Handling strings.  */
  30
  31 /* Assign STRING to a copy of VALUE if not zero, or to zero.  If
  32    STRING was nonzero, it is freed first.  */
  33 void
  34 assign_string (char **string, const char *value)
  35 {
  36   if (*string)
  37     free (*string);
  38   *string = value ? xstrdup (value) : 0;
  39 }
  40
  41 /* Allocate a copy of the string quoted as in C, and returns that.  If
  42    the string does not have to be quoted, it returns a null pointer.
  43    The allocated copy should normally be freed with free() after the
  44    caller is done with it.
  45
  46    This is used in one context only: generating the directory file in
  47    incremental dumps.  The quoted string is not intended for human
  48    consumption; it is intended only for unquote_string.  The quoting
  49    is locale-independent, so that users needn't worry about locale
  50    when reading directory files.  This means that we can't use
  51    quotearg, as quotearg is locale-dependent and is meant for human
  52    consumption.  */
  53 char *
  54 quote_copy_string (const char *string)
  55 {
  56   const char *source = string;
  57   char *destination = 0;
  58   char *buffer = 0;
  59   int copying = 0;
  60
  61   while (*source)
  62     {
  63       int character = *source++;
  64
  65       switch (character)
  66         {
  67         case '\n': case '\\':
  68           if (!copying)
  69             {
  70               size_t length = (source - string) - 1;
  71
  72               copying = 1;
  73               buffer = xmalloc (length + 2 + 2 * strlen (source) + 1);
  74               memcpy (buffer, string, length);
  75               destination = buffer + length;
  76             }
  77           *destination++ = '\\';
  78           *destination++ = character == '\\' ? '\\' : 'n';
  79           break;
  80
  81         default:
  82           if (copying)
  83             *destination++ = character;
  84           break;
  85         }
  86     }
  87   if (copying)
  88     {
  89       *destination = '\0';
  90       return buffer;
  91     }
  92   return 0;
  93 }
  94
  95 /* Takes a quoted C string (like those produced by quote_copy_string)
  96    and turns it back into the un-quoted original.  This is done in
  97    place.  Returns 0 only if the string was not properly quoted, but
  98    completes the unquoting anyway.
  99
 100    This is used for reading the saved directory file in incremental
 101    dumps.  It is used for decoding old `N' records (demangling names).
 102    But also, it is used for decoding file arguments, would they come
 103    from the shell or a -T file, and for decoding the --exclude
 104    argument.  */
 105 int
 106 unquote_string (char *string)
 107 {
 108   int result = 1;
 109   char *source = string;
 110   char *destination = string;
 111
 112   /* Escape sequences other than \\ and \n are no longer generated by
 113      quote_copy_string, but accept them for backwards compatibility,
 114      and also because unquote_string is used for purposes other than
 115      parsing the output of quote_copy_string.  */
 116
 117   while (*source)
 118     if (*source == '\\')
 119       switch (*++source)
 120         {
 121         case '\\':
 122           *destination++ = '\\';
 123           source++;
 124           break;
 125
 126         case 'n':
 127           *destination++ = '\n';
 128           source++;
 129           break;
 130
 131         case 't':
 132           *destination++ = '\t';
 133           source++;
 134           break;
 135
 136         case 'f':
 137           *destination++ = '\f';
 138           source++;
 139           break;
 140
 141         case 'b':
 142           *destination++ = '\b';
 143           source++;
 144           break;
 145
 146         case 'r':
 147           *destination++ = '\r';
 148           source++;
 149           break;
 150
 151         case '?':
 152           *destination++ = 0177;
 153           source++;
 154           break;
 155
 156         case '0':
 157         case '1':
 158         case '2':
 159         case '3':
 160         case '4':
 161         case '5':
 162         case '6':
 163         case '7':
 164           {
 165             int value = *source++ - '0';
 166
 167             if (*source < '0' || *source > '7')
 168               {
 169                 *destination++ = value;
 170                 break;
 171               }
 172             value = value * 8 + *source++ - '0';
 173             if (*source < '0' || *source > '7')
 174               {
 175                 *destination++ = value;
 176                 break;
 177               }
 178             value = value * 8 + *source++ - '0';
 179             *destination++ = value;
 180             break;
 181           }
 182
 183         default:
 184           result = 0;
 185           *destination++ = '\\';
 186           if (*source)
 187             *destination++ = *source++;
 188           break;
 189         }
 190     else if (source != destination)
 191       *destination++ = *source++;
 192     else
 193       source++, destination++;
 194
 195   if (source != destination)
 196     *destination = '\0';
 197   return result;
 198 }
 199 \f
 200 /* File handling.  */
 201
 202 /* Saved names in case backup needs to be undone.  */
 203 static char *before_backup_name;
 204 static char *after_backup_name;
 205
 206 /* Return 1 if PATH is obviously "." or "/".  */
 207 static bool
 208 must_be_dot_or_slash (char const *path)
 209 {
 210   path += FILESYSTEM_PREFIX_LEN (path);
 211
 212   if (ISSLASH (path[0]))
 213     {
 214       for (;;)
 215         if (ISSLASH (path[1]))
 216           path++;
 217         else if (path[1] == '.' && ISSLASH (path[2 + (path[2] == '.')]))
 218           path += 2 + (path[2] == '.');
 219         else
 220           return ! path[1];
 221     }
 222   else
 223     {
 224       while (path[0] == '.' && ISSLASH (path[1]))
 225         {
 226           path += 2;
 227           while (ISSLASH (*path))
 228             path++;
 229         }
 230
 231       return ! path[0] || (path[0] == '.' && ! path[1]);
 232     }
 233 }
 234
 235 /* Some implementations of rmdir let you remove '.' or '/'.
 236    Report an error with errno set to zero for obvious cases of this;
 237    otherwise call rmdir.  */
 238 static int
 239 safer_rmdir (const char *path)
 240 {
 241   if (must_be_dot_or_slash (path))
 242     {
 243       errno = 0;
 244       return -1;
 245     }
 246
 247   return rmdir (path);
 248 }
 249
 250 /* Remove PATH, returning 1 on success.  If PATH is a directory, then
 251    if OPTION is RECURSIVE_REMOVE_OPTION is set remove PATH
 252    recursively; otherwise, remove it only if it is empty.  If PATH is
 253    a directory that cannot be removed (e.g., because it is nonempty)
 254    and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
 255    Return 0 on error, with errno set; if PATH is obviously the working
 256    directory return zero with errno set to zero.  */
 257 int
 258 remove_any_file (const char *path, enum remove_option option)
 259 {
 260   /* Try unlink first if we are not root, as this saves us a system
 261      call in the common case where we're removing a non-directory.  */
 262   if (! we_are_root)
 263     {
 264       if (unlink (path) == 0)
 265         return 1;
 266
 267       /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
 268          directory without appropriate privileges, but many Linux
 269          kernels return the more-sensible EISDIR.  */
 270       if (errno != EPERM && errno != EISDIR)
 271         return 0;
 272     }
 273
 274   if (safer_rmdir (path) == 0)
 275     return 1;
 276
 277   switch (errno)
 278     {
 279     case ENOTDIR:
 280       return we_are_root && unlink (path) == 0;
 281
 282     case 0:
 283     case EEXIST:
 284 #if defined ENOTEMPTY && ENOTEMPTY != EEXIST
 285     case ENOTEMPTY:
 286 #endif
 287       switch (option)
 288         {
 289         case ORDINARY_REMOVE_OPTION:
 290           break;
 291
 292         case WANT_DIRECTORY_REMOVE_OPTION:
 293           return -1;
 294
 295         case RECURSIVE_REMOVE_OPTION:
 296           {
 297             char *directory = savedir (path);
 298             char const *entry;
 299             size_t entrylen;
 300
 301             if (! directory)
 302               return 0;
 303
 304             for (entry = directory;
 305                  (entrylen = strlen (entry)) != 0;
 306                  entry += entrylen + 1)
 307               {
 308                 char *path_buffer = new_name (path, entry);
 309                 int r = remove_any_file (path_buffer, 1);
 310                 int e = errno;
 311                 free (path_buffer);
 312
 313                 if (! r)
 314                   {
 315                     free (directory);
 316                     errno = e;
 317                     return 0;
 318                   }
 319               }
 320
 321             free (directory);
 322             return safer_rmdir (path) == 0;
 323           }
 324         }
 325       break;
 326     }
 327
 328   return 0;
 329 }
 330
 331 /* Check if PATH already exists and make a backup of it right now.
 332    Return success (nonzero) only if the backup is either unneeded, or
 333    successful.  For now, directories are considered to never need
 334    backup.  If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
 335    so, we do not have to backup block or character devices, nor remote
 336    entities.  */
 337 bool
 338 maybe_backup_file (const char *path, int this_is_the_archive)
 339 {
 340   struct stat file_stat;
 341
 342   /* Check if we really need to backup the file.  */
 343
 344   if (this_is_the_archive && _remdev (path))
 345     return true;
 346
 347   if (stat (path, &file_stat))
 348     {
 349       if (errno == ENOENT)
 350         return true;
 351
 352       stat_error (path);
 353       return false;
 354     }
 355
 356   if (S_ISDIR (file_stat.st_mode))
 357     return true;
 358
 359   if (this_is_the_archive
 360       && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
 361     return true;
 362
 363   assign_string (&before_backup_name, path);
 364
 365   /* A run situation may exist between Emacs or other GNU programs trying to
 366      make a backup for the same file simultaneously.  If theoretically
 367      possible, real problems are unlikely.  Doing any better would require a
 368      convention, GNU-wide, for all programs doing backups.  */
 369
 370   assign_string (&after_backup_name, 0);
 371   after_backup_name = find_backup_file_name (path, backup_type);
 372   if (! after_backup_name)
 373     xalloc_die ();
 374
 375   if (rename (before_backup_name, after_backup_name) == 0)
 376     {
 377       if (verbose_option)
 378         fprintf (stdlis, _("Renaming %s to %s\n"),
 379                  quote_n (0, before_backup_name),
 380                  quote_n (1, after_backup_name));
 381       return true;
 382     }
 383   else
 384     {
 385       /* The backup operation failed.  */
 386       int e = errno;
 387       ERROR ((0, e, _("%s: Cannot rename to %s"),
 388               quotearg_colon (before_backup_name),
 389               quote_n (1, after_backup_name)));
 390       assign_string (&after_backup_name, 0);
 391       return false;
 392     }
 393 }
 394
 395 /* Try to restore the recently backed up file to its original name.
 396    This is usually only needed after a failed extraction.  */
 397 void
 398 undo_last_backup (void)
 399 {
 400   if (after_backup_name)
 401     {
 402       if (rename (after_backup_name, before_backup_name) != 0)
 403         {
 404           int e = errno;
 405           ERROR ((0, e, _("%s: Cannot rename to %s"),
 406                   quotearg_colon (after_backup_name),
 407                   quote_n (1, before_backup_name)));
 408         }
 409       if (verbose_option)
 410         fprintf (stdlis, _("Renaming %s back to %s\n"),
 411                  quote_n (0, after_backup_name),
 412                  quote_n (1, before_backup_name));
 413       assign_string (&after_backup_name, 0);
 414     }
 415 }
 416
 417 /* Depending on DEREF, apply either stat or lstat to (NAME, BUF).  */
 418 int
 419 deref_stat (bool deref, char const *name, struct stat *buf)
 420 {
 421   return deref ? stat (name, buf) : lstat (name, buf);
 422 }
 423
 424 /* A description of a working directory.  */
 425 struct wd
 426 {
 427   char const *name;
 428   int saved;
 429   struct saved_cwd saved_cwd;
 430 };
 431
 432 /* A vector of chdir targets.  wd[0] is the initial working directory.  */
 433 static struct wd *wd;
 434
 435 /* The number of working directories in the vector.  */
 436 static size_t wds;
 437
 438 /* The allocated size of the vector.  */
 439 static size_t wd_alloc;
 440
 441 /* DIR is the operand of a -C option; add it to vector of chdir targets,
 442    and return the index of its location.  */
 443 int
 444 chdir_arg (char const *dir)
 445 {
 446   if (wds == wd_alloc)
 447     {
 448       wd_alloc = 2 * (wd_alloc + 1);
 449       wd = xrealloc (wd, sizeof *wd * wd_alloc);
 450       if (! wds)
 451         {
 452           wd[wds].name = ".";
 453           wd[wds].saved = 0;
 454           wds++;
 455         }
 456     }
 457
 458   /* Optimize the common special case of the working directory,
 459      or the working directory as a prefix.  */
 460   if (dir[0])
 461     {
 462       while (dir[0] == '.' && ISSLASH (dir[1]))
 463         for (dir += 2;  ISSLASH (*dir);  dir++)
 464           continue;
 465       if (! dir[dir[0] == '.'])
 466         return wds - 1;
 467     }
 468
 469   wd[wds].name = dir;
 470   wd[wds].saved = 0;
 471   return wds++;
 472 }
 473
 474 /* Change to directory I.  If I is 0, change to the initial working
 475    directory; otherwise, I must be a value returned by chdir_arg.  */
 476 void
 477 chdir_do (int i)
 478 {
 479   static int previous;
 480
 481   if (previous != i)
 482     {
 483       struct wd *prev = &wd[previous];
 484       struct wd *curr = &wd[i];
 485
 486       if (! prev->saved)
 487         {
 488           prev->saved = 1;
 489           if (save_cwd (&prev->saved_cwd) != 0)
 490             FATAL_ERROR ((0, 0, _("Cannot save working directory")));
 491         }
 492
 493       if (curr->saved)
 494         {
 495           if (restore_cwd (&curr->saved_cwd))
 496             FATAL_ERROR ((0, 0, _("Cannot change working directory")));
 497         }
 498       else
 499         {
 500           if (i && ! ISSLASH (curr->name[0]))
 501             chdir_do (i - 1);
 502           if (chdir (curr->name) != 0)
 503             chdir_fatal (curr->name);
 504         }
 505
 506       previous = i;
 507     }
 508 }
 509 \f
 510 /* Decode MODE from its binary form in a stat structure, and encode it
 511    into a 9-byte string STRING, terminated with a NUL.  */
 512
 513 void
 514 decode_mode (mode_t mode, char *string)
 515 {
 516   *string++ = mode & S_IRUSR ? 'r' : '-';
 517   *string++ = mode & S_IWUSR ? 'w' : '-';
 518   *string++ = (mode & S_ISUID
 519                ? (mode & S_IXUSR ? 's' : 'S')
 520                : (mode & S_IXUSR ? 'x' : '-'));
 521   *string++ = mode & S_IRGRP ? 'r' : '-';
 522   *string++ = mode & S_IWGRP ? 'w' : '-';
 523   *string++ = (mode & S_ISGID
 524                ? (mode & S_IXGRP ? 's' : 'S')
 525                : (mode & S_IXGRP ? 'x' : '-'));
 526   *string++ = mode & S_IROTH ? 'r' : '-';
 527   *string++ = mode & S_IWOTH ? 'w' : '-';
 528   *string++ = (mode & S_ISVTX
 529                ? (mode & S_IXOTH ? 't' : 'T')
 530                : (mode & S_IXOTH ? 'x' : '-'));
 531   *string = '\0';
 532 }
 533
 534 /* Report an error associated with the system call CALL and the
 535    optional name NAME.  */
 536 static void
 537 call_arg_error (char const *call, char const *name)
 538 {
 539   int e = errno;
 540   ERROR ((0, e, _("%s: Cannot %s"), quotearg_colon (name), call));
 541 }
 542
 543 /* Report a fatal error associated with the system call CALL and
 544    the optional file name NAME.  */
 545 static void
 546 call_arg_fatal (char const *call, char const *name)
 547 {
 548   int e = errno;
 549   FATAL_ERROR ((0, e, _("%s: Cannot %s"), quotearg_colon (name),  call));
 550 }
 551
 552 /* Report a warning associated with the system call CALL and
 553    the optional file name NAME.  */
 554 static void
 555 call_arg_warn (char const *call, char const *name)
 556 {
 557   int e = errno;
 558   WARN ((0, e, _("%s: Warning: Cannot %s"), quotearg_colon (name), call));
 559 }
 560
 561 void
 562 chdir_fatal (char const *name)
 563 {
 564   call_arg_fatal ("chdir", name);
 565 }
 566
 567 void
 568 chmod_error_details (char const *name, mode_t mode)
 569 {
 570   int e = errno;
 571   char buf[10];
 572   decode_mode (mode, buf);
 573   ERROR ((0, e, _("%s: Cannot change mode to %s"),
 574           quotearg_colon (name), buf));
 575 }
 576
 577 void
 578 chown_error_details (char const *name, uid_t uid, gid_t gid)
 579 {
 580   int e = errno;
 581   ERROR ((0, e, _("%s: Cannot change ownership to uid %lu, gid %lu"),
 582           quotearg_colon (name), (unsigned long) uid, (unsigned long) gid));
 583 }
 584
 585 void
 586 close_error (char const *name)
 587 {
 588   call_arg_error ("close", name);
 589 }
 590
 591 void
 592 close_warn (char const *name)
 593 {
 594   call_arg_warn ("close", name);
 595 }
 596
 597 void
 598 close_diag (char const *name)
 599 {
 600   if (ignore_failed_read_option)
 601     close_warn (name);
 602   else
 603     close_error (name);
 604 }
 605
 606 void
 607 exec_fatal (char const *name)
 608 {
 609   call_arg_fatal ("exec", name);
 610 }
 611
 612 void
 613 link_error (char const *target, char const *source)
 614 {
 615   int e = errno;
 616   ERROR ((0, e, _("%s: Cannot hard link to %s"),
 617           quotearg_colon (source), quote_n (1, target)));
 618 }
 619
 620 void
 621 mkdir_error (char const *name)
 622 {
 623   call_arg_error ("mkdir", name);
 624 }
 625
 626 void
 627 mkfifo_error (char const *name)
 628 {
 629   call_arg_error ("mkfifo", name);
 630 }
 631
 632 void
 633 mknod_error (char const *name)
 634 {
 635   call_arg_error ("mknod", name);
 636 }
 637
 638 void
 639 open_error (char const *name)
 640 {
 641   call_arg_error ("open", name);
 642 }
 643
 644 void
 645 open_fatal (char const *name)
 646 {
 647   call_arg_fatal ("open", name);
 648 }
 649
 650 void
 651 open_warn (char const *name)
 652 {
 653   call_arg_warn ("open", name);
 654 }
 655
 656 void
 657 open_diag (char const *name)
 658 {
 659   if (ignore_failed_read_option)
 660     open_warn (name);
 661   else
 662     open_error (name);
 663 }
 664
 665 void
 666 read_error (char const *name)
 667 {
 668   call_arg_error ("read", name);
 669 }
 670
 671 void
 672 read_error_details (char const *name, off_t offset, size_t size)
 673 {
 674   char buf[UINTMAX_STRSIZE_BOUND];
 675   int e = errno;
 676   ERROR ((0, e,
 677           ngettext ("%s: Read error at byte %s, reading %lu byte",
 678                     "%s: Read error at byte %s, reading %lu bytes",
 679                     size),
 680           quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
 681           (unsigned long) size));
 682 }
 683
 684 void
 685 read_warn_details (char const *name, off_t offset, size_t size)
 686 {
 687   char buf[UINTMAX_STRSIZE_BOUND];
 688   int e = errno;
 689   WARN ((0, e,
 690          ngettext ("%s: Warning: Read error at byte %s, reading %lu byte",
 691                    "%s: Warning: Read error at byte %s, reading %lu bytes",
 692                    size),
 693          quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
 694          (unsigned long) size));
 695 }
 696
 697 void
 698 read_diag_details (char const *name, off_t offset, size_t size)
 699 {
 700   if (ignore_failed_read_option)
 701     read_warn_details (name, offset, size);
 702   else
 703     read_error_details (name, offset, size);
 704 }
 705
 706 void
 707 read_fatal (char const *name)
 708 {
 709   call_arg_fatal ("read", name);
 710 }
 711
 712 void
 713 read_fatal_details (char const *name, off_t offset, size_t size)
 714 {
 715   char buf[UINTMAX_STRSIZE_BOUND];
 716   int e = errno;
 717   FATAL_ERROR ((0, e,
 718                 ngettext ("%s: Read error at byte %s, reading %lu byte",
 719                           "%s: Read error at byte %s, reading %lu bytes",
 720                           size),
 721                 quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
 722                 (unsigned long) size));
 723 }
 724
 725 void
 726 readlink_error (char const *name)
 727 {
 728   call_arg_error ("readlink", name);
 729 }
 730
 731 void
 732 readlink_warn (char const *name)
 733 {
 734   call_arg_warn ("readlink", name);
 735 }
 736
 737 void
 738 readlink_diag (char const *name)
 739 {
 740   if (ignore_failed_read_option)
 741     readlink_warn (name);
 742   else
 743     readlink_error (name);
 744 }
 745
 746 void
 747 savedir_error (char const *name)
 748 {
 749   call_arg_error ("savedir", name);
 750 }
 751
 752 void
 753 savedir_warn (char const *name)
 754 {
 755   call_arg_warn ("savedir", name);
 756 }
 757
 758 void
 759 savedir_diag (char const *name)
 760 {
 761   if (ignore_failed_read_option)
 762     savedir_warn (name);
 763   else
 764     savedir_error (name);
 765 }
 766
 767 void
 768 seek_error (char const *name)
 769 {
 770   call_arg_error ("seek", name);
 771 }
 772
 773 void
 774 seek_error_details (char const *name, off_t offset)
 775 {
 776   char buf[UINTMAX_STRSIZE_BOUND];
 777   int e = errno;
 778   ERROR ((0, e, _("%s: Cannot seek to %s"),
 779           quotearg_colon (name),
 780           STRINGIFY_BIGINT (offset, buf)));
 781 }
 782
 783 void
 784 seek_warn (char const *name)
 785 {
 786   call_arg_warn ("seek", name);
 787 }
 788
 789 void
 790 seek_warn_details (char const *name, off_t offset)
 791 {
 792   char buf[UINTMAX_STRSIZE_BOUND];
 793   int e = errno;
 794   WARN ((0, e, _("%s: Warning: Cannot seek to %s"),
 795          quotearg_colon (name),
 796          STRINGIFY_BIGINT (offset, buf)));
 797 }
 798
 799 void
 800 seek_diag_details (char const *name, off_t offset)
 801 {
 802   if (ignore_failed_read_option)
 803     seek_warn_details (name, offset);
 804   else
 805     seek_error_details (name, offset);
 806 }
 807
 808 void
 809 symlink_error (char const *contents, char const *name)
 810 {
 811   int e = errno;
 812   ERROR ((0, e, _("%s: Cannot create symlink to %s"),
 813           quotearg_colon (name), quote_n (1, contents)));
 814 }
 815
 816 void
 817 stat_error (char const *name)
 818 {
 819   call_arg_error ("stat", name);
 820 }
 821
 822 void
 823 stat_warn (char const *name)
 824 {
 825   call_arg_warn ("stat", name);
 826 }
 827
 828 void
 829 stat_diag (char const *name)
 830 {
 831   if (ignore_failed_read_option)
 832     stat_warn (name);
 833   else
 834     stat_error (name);
 835 }
 836
 837 void
 838 truncate_error (char const *name)
 839 {
 840   call_arg_error ("truncate", name);
 841 }
 842
 843 void
 844 truncate_warn (char const *name)
 845 {
 846   call_arg_warn ("truncate", name);
 847 }
 848
 849 void
 850 unlink_error (char const *name)
 851 {
 852   call_arg_error ("unlink", name);
 853 }
 854
 855 void
 856 utime_error (char const *name)
 857 {
 858   call_arg_error ("utime", name);
 859 }
 860
 861 void
 862 waitpid_error (char const *name)
 863 {
 864   call_arg_error ("waitpid", name);
 865 }
 866
 867 void
 868 write_error (char const *name)
 869 {
 870   call_arg_error ("write", name);
 871 }
 872
 873 void
 874 write_error_details (char const *name, size_t status, size_t size)
 875 {
 876   if (status == 0)
 877     write_error (name);
 878   else
 879     ERROR ((0, 0,
 880             ngettext ("%s: Wrote only %lu of %lu byte",
 881                       "%s: Wrote only %lu of %lu bytes",
 882                       size),
 883             name, (unsigned long int) status, (unsigned long int) size));
 884 }
 885
 886 void
 887 write_fatal (char const *name)
 888 {
 889   call_arg_fatal ("write", name);
 890 }
 891
 892 void
 893 write_fatal_details (char const *name, ssize_t status, size_t size)
 894 {
 895   write_error_details (name, status, size);
 896   fatal_exit ();
 897 }
 898
 899
 900 /* Fork, aborting if unsuccessful.  */
 901 pid_t
 902 xfork (void)
 903 {
 904   pid_t p = fork ();
 905   if (p == (pid_t) -1)
 906     call_arg_fatal ("fork", _("child process"));
 907   return p;
 908 }
 909
 910 /* Create a pipe, aborting if unsuccessful.  */
 911 void
 912 xpipe (int fd[2])
 913 {
 914   if (pipe (fd) < 0)
 915     call_arg_fatal ("pipe", _("interprocess channel"));
 916 }
 917
 918 /* Return an unambiguous printable representation, allocated in slot N,
 919    for NAME, suitable for diagnostics.  */
 920 char const *
 921 quote_n (int n, char const *name)
 922 {
 923   return quotearg_n_style (n, locale_quoting_style, name);
 924 }
 925
 926 /* Return an unambiguous printable representation of NAME, suitable
 927    for diagnostics.  */
 928 char const *
 929 quote (char const *name)
 930 {
 931   return quote_n (0, name);
 932 }