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 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 in either unneeded, or
 333    successful.  For now, directories are considered to never need
 334    backup.  If ARCHIVE is nonzero, this is the archive and so, we do
 335    not have to backup block or character devices, nor remote entities.  */
 336 int
 337 maybe_backup_file (const char *path, int archive)
 338 {
 339   struct stat file_stat;
 340
 341   /* Check if we really need to backup the file.  */
 342
 343   if (archive && _remdev (path))
 344     return 1;
 345
 346   if (stat (path, &file_stat))
 347     {
 348       if (errno == ENOENT)
 349         return 1;
 350
 351       stat_error (path);
 352       return 0;
 353     }
 354
 355   if (S_ISDIR (file_stat.st_mode))
 356     return 1;
 357
 358   if (archive && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
 359     return 1;
 360
 361   assign_string (&before_backup_name, path);
 362
 363   /* A run situation may exist between Emacs or other GNU programs trying to
 364      make a backup for the same file simultaneously.  If theoretically
 365      possible, real problems are unlikely.  Doing any better would require a
 366      convention, GNU-wide, for all programs doing backups.  */
 367
 368   assign_string (&after_backup_name, 0);
 369   after_backup_name = find_backup_file_name (path, backup_type);
 370   if (! after_backup_name)
 371     xalloc_die ();
 372
 373   if (rename (before_backup_name, after_backup_name) == 0)
 374     {
 375       if (verbose_option)
 376         fprintf (stdlis, _("Renaming %s to %s\n"),
 377                  quote_n (0, before_backup_name),
 378                  quote_n (1, after_backup_name));
 379       return 1;
 380     }
 381   else
 382     {
 383       /* The backup operation failed.  */
 384       int e = errno;
 385       ERROR ((0, e, _("%s: Cannot rename to %s"),
 386               quotearg_colon (before_backup_name),
 387               quote_n (1, after_backup_name)));
 388       assign_string (&after_backup_name, 0);
 389       return 0;
 390     }
 391 }
 392
 393 /* Try to restore the recently backed up file to its original name.
 394    This is usually only needed after a failed extraction.  */
 395 void
 396 undo_last_backup (void)
 397 {
 398   if (after_backup_name)
 399     {
 400       if (rename (after_backup_name, before_backup_name) != 0)
 401         {
 402           int e = errno;
 403           ERROR ((0, e, _("%s: Cannot rename to %s"),
 404                   quotearg_colon (after_backup_name),
 405                   quote_n (1, before_backup_name)));
 406         }
 407       if (verbose_option)
 408         fprintf (stdlis, _("Renaming %s back to %s\n"),
 409                  quote_n (0, after_backup_name),
 410                  quote_n (1, before_backup_name));
 411       assign_string (&after_backup_name, 0);
 412     }
 413 }
 414
 415 /* Depending on DEREF, apply either stat or lstat to (NAME, BUF).  */
 416 int
 417 deref_stat (bool deref, char const *name, struct stat *buf)
 418 {
 419   return deref ? stat (name, buf) : lstat (name, buf);
 420 }
 421
 422 /* A description of a working directory.  */
 423 struct wd
 424 {
 425   char const *name;
 426   int saved;
 427   struct saved_cwd saved_cwd;
 428 };
 429
 430 /* A vector of chdir targets.  wd[0] is the initial working directory.  */
 431 static struct wd *wd;
 432
 433 /* The number of working directories in the vector.  */
 434 static size_t wds;
 435
 436 /* The allocated size of the vector.  */
 437 static size_t wd_alloc;
 438
 439 /* DIR is the operand of a -C option; add it to vector of chdir targets,
 440    and return the index of its location.  */
 441 int
 442 chdir_arg (char const *dir)
 443 {
 444   if (wds == wd_alloc)
 445     {
 446       wd_alloc = 2 * (wd_alloc + 1);
 447       wd = xrealloc (wd, sizeof *wd * wd_alloc);
 448       if (! wds)
 449         {
 450           wd[wds].name = ".";
 451           wd[wds].saved = 0;
 452           wds++;
 453         }
 454     }
 455
 456   /* Optimize the common special case of the working directory,
 457      or the working directory as a prefix.  */
 458   if (dir[0])
 459     {
 460       while (dir[0] == '.' && ISSLASH (dir[1]))
 461         for (dir += 2;  ISSLASH (*dir);  dir++)
 462           continue;
 463       if (! dir[dir[0] == '.'])
 464         return wds - 1;
 465     }
 466
 467   wd[wds].name = dir;
 468   wd[wds].saved = 0;
 469   return wds++;
 470 }
 471
 472 /* Change to directory I.  If I is 0, change to the initial working
 473    directory; otherwise, I must be a value returned by chdir_arg.  */
 474 void
 475 chdir_do (int i)
 476 {
 477   static int previous;
 478
 479   if (previous != i)
 480     {
 481       struct wd *prev = &wd[previous];
 482       struct wd *curr = &wd[i];
 483
 484       if (! prev->saved)
 485         {
 486           prev->saved = 1;
 487           if (save_cwd (&prev->saved_cwd) != 0)
 488             FATAL_ERROR ((0, 0, _("Cannot save working directory")));
 489         }
 490
 491       if (curr->saved)
 492         {
 493           if (restore_cwd (&curr->saved_cwd))
 494             FATAL_ERROR ((0, 0, _("Cannot change working directory")));
 495         }
 496       else
 497         {
 498           if (i && ! ISSLASH (curr->name[0]))
 499             chdir_do (i - 1);
 500           if (chdir (curr->name) != 0)
 501             chdir_fatal (curr->name);
 502         }
 503
 504       previous = i;
 505     }
 506 }
 507 \f
 508 /* Decode MODE from its binary form in a stat structure, and encode it
 509    into a 9-byte string STRING, terminated with a NUL.  */
 510
 511 void
 512 decode_mode (mode_t mode, char *string)
 513 {
 514   *string++ = mode & S_IRUSR ? 'r' : '-';
 515   *string++ = mode & S_IWUSR ? 'w' : '-';
 516   *string++ = (mode & S_ISUID
 517                ? (mode & S_IXUSR ? 's' : 'S')
 518                : (mode & S_IXUSR ? 'x' : '-'));
 519   *string++ = mode & S_IRGRP ? 'r' : '-';
 520   *string++ = mode & S_IWGRP ? 'w' : '-';
 521   *string++ = (mode & S_ISGID
 522                ? (mode & S_IXGRP ? 's' : 'S')
 523                : (mode & S_IXGRP ? 'x' : '-'));
 524   *string++ = mode & S_IROTH ? 'r' : '-';
 525   *string++ = mode & S_IWOTH ? 'w' : '-';
 526   *string++ = (mode & S_ISVTX
 527                ? (mode & S_IXOTH ? 't' : 'T')
 528                : (mode & S_IXOTH ? 'x' : '-'));
 529   *string = '\0';
 530 }
 531
 532 /* Report an error associated with the system call CALL and the
 533    optional name NAME.  */
 534 static void
 535 call_arg_error (char const *call, char const *name)
 536 {
 537   int e = errno;
 538   ERROR ((0, e, _("%s: Cannot %s"), quotearg_colon (name), call));
 539 }
 540
 541 /* Report a fatal error associated with the system call CALL and
 542    the optional file name NAME.  */
 543 static void
 544 call_arg_fatal (char const *call, char const *name)
 545 {
 546   int e = errno;
 547   FATAL_ERROR ((0, e, _("%s: Cannot %s"), quotearg_colon (name),  call));
 548 }
 549
 550 /* Report a warning associated with the system call CALL and
 551    the optional file name NAME.  */
 552 static void
 553 call_arg_warn (char const *call, char const *name)
 554 {
 555   int e = errno;
 556   WARN ((0, e, _("%s: Warning: Cannot %s"), quotearg_colon (name), call));
 557 }
 558
 559 void
 560 chdir_fatal (char const *name)
 561 {
 562   call_arg_fatal ("chdir", name);
 563 }
 564
 565 void
 566 chmod_error_details (char const *name, mode_t mode)
 567 {
 568   int e = errno;
 569   char buf[10];
 570   decode_mode (mode, buf);
 571   ERROR ((0, e, _("%s: Cannot change mode to %s"),
 572           quotearg_colon (name), buf));
 573 }
 574
 575 void
 576 chown_error_details (char const *name, uid_t uid, gid_t gid)
 577 {
 578   int e = errno;
 579   ERROR ((0, e, _("%s: Cannot change ownership to uid %lu, gid %lu"),
 580           quotearg_colon (name), (unsigned long) uid, (unsigned long) gid));
 581 }
 582
 583 void
 584 close_error (char const *name)
 585 {
 586   call_arg_error ("close", name);
 587 }
 588
 589 void
 590 close_fatal (char const *name)
 591 {
 592   call_arg_fatal ("close", name);
 593 }
 594
 595 void
 596 close_warn (char const *name)
 597 {
 598   call_arg_warn ("close", name);
 599 }
 600
 601 void
 602 exec_fatal (char const *name)
 603 {
 604   call_arg_fatal ("exec", name);
 605 }
 606
 607 void
 608 link_error (char const *target, char const *source)
 609 {
 610   int e = errno;
 611   ERROR ((0, e, _("%s: Cannot hard link to %s"),
 612           quotearg_colon (source), quote_n (1, target)));
 613 }
 614
 615 void
 616 mkdir_error (char const *name)
 617 {
 618   call_arg_error ("mkdir", name);
 619 }
 620
 621 void
 622 mkfifo_error (char const *name)
 623 {
 624   call_arg_error ("mkfifo", name);
 625 }
 626
 627 void
 628 mknod_error (char const *name)
 629 {
 630   call_arg_error ("mknod", name);
 631 }
 632
 633 void
 634 open_error (char const *name)
 635 {
 636   call_arg_error ("open", name);
 637 }
 638
 639 void
 640 open_fatal (char const *name)
 641 {
 642   call_arg_fatal ("open", name);
 643 }
 644
 645 void
 646 open_warn (char const *name)
 647 {
 648   call_arg_warn ("open", name);
 649 }
 650
 651 void
 652 read_error (char const *name)
 653 {
 654   call_arg_error ("read", name);
 655 }
 656
 657 void
 658 read_error_details (char const *name, off_t offset, size_t size)
 659 {
 660   char buf[UINTMAX_STRSIZE_BOUND];
 661   int e = errno;
 662   ERROR ((0, e,
 663           _("%s: Read error at byte %s, reading %lu bytes"),
 664           quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
 665           (unsigned long) size));
 666 }
 667
 668 void
 669 read_warn_details (char const *name, off_t offset, size_t size)
 670 {
 671   char buf[UINTMAX_STRSIZE_BOUND];
 672   int e = errno;
 673   WARN ((0, e,
 674          _("%s: Warning: Read error at byte %s, reading %lu bytes"),
 675          quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
 676          (unsigned long) size));
 677 }
 678
 679 void
 680 read_fatal (char const *name)
 681 {
 682   call_arg_fatal ("read", name);
 683 }
 684
 685 void
 686 read_fatal_details (char const *name, off_t offset, size_t size)
 687 {
 688   char buf[UINTMAX_STRSIZE_BOUND];
 689   int e = errno;
 690   FATAL_ERROR ((0, e,
 691                 _("%s: Read error at byte %s, reading %lu bytes"),
 692                 quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
 693                 (unsigned long) size));
 694 }
 695
 696 void
 697 readlink_error (char const *name)
 698 {
 699   call_arg_error ("readlink", name);
 700 }
 701
 702 void
 703 readlink_warn (char const *name)
 704 {
 705   call_arg_warn ("readlink", name);
 706 }
 707
 708 void
 709 savedir_error (char const *name)
 710 {
 711   call_arg_error ("savedir", name);
 712 }
 713
 714 void
 715 savedir_warn (char const *name)
 716 {
 717   call_arg_warn ("savedir", name);
 718 }
 719
 720 void
 721 seek_error (char const *name)
 722 {
 723   call_arg_error ("seek", name);
 724 }
 725
 726 void
 727 seek_error_details (char const *name, off_t offset)
 728 {
 729   char buf[UINTMAX_STRSIZE_BOUND];
 730   int e = errno;
 731   ERROR ((0, e, _("%s: Cannot seek to %s"),
 732           quotearg_colon (name),
 733           STRINGIFY_BIGINT (offset, buf)));
 734 }
 735
 736 void
 737 seek_warn (char const *name)
 738 {
 739   call_arg_warn ("seek", name);
 740 }
 741
 742 void
 743 seek_warn_details (char const *name, off_t offset)
 744 {
 745   char buf[UINTMAX_STRSIZE_BOUND];
 746   int e = errno;
 747   WARN ((0, e, _("%s: Warning: Cannot seek to %s"),
 748          quotearg_colon (name),
 749          STRINGIFY_BIGINT (offset, buf)));
 750 }
 751
 752 void
 753 symlink_error (char const *contents, char const *name)
 754 {
 755   int e = errno;
 756   ERROR ((0, e, _("%s: Cannot create symlink to %s"),
 757           quotearg_colon (name), quote_n (1, contents)));
 758 }
 759
 760 void
 761 stat_error (char const *name)
 762 {
 763   call_arg_error ("stat", name);
 764 }
 765
 766 void
 767 stat_warn (char const *name)
 768 {
 769   call_arg_warn ("stat", name);
 770 }
 771
 772 void
 773 truncate_error (char const *name)
 774 {
 775   call_arg_error ("truncate", name);
 776 }
 777
 778 void
 779 truncate_warn (char const *name)
 780 {
 781   call_arg_warn ("truncate", name);
 782 }
 783
 784 void
 785 unlink_error (char const *name)
 786 {
 787   call_arg_error ("unlink", name);
 788 }
 789
 790 void
 791 utime_error (char const *name)
 792 {
 793   call_arg_error ("utime", name);
 794 }
 795
 796 void
 797 waitpid_error (char const *name)
 798 {
 799   call_arg_error ("waitpid", name);
 800 }
 801
 802 void
 803 write_error (char const *name)
 804 {
 805   call_arg_error ("write", name);
 806 }
 807
 808 void
 809 write_error_details (char const *name, ssize_t status, size_t size)
 810 {
 811   if (status < 0)
 812     write_error (name);
 813   else
 814     ERROR ((0, 0, _("%s: Wrote only %lu of %lu bytes"),
 815             name, (unsigned long) status, (unsigned long) record_size));
 816 }
 817
 818 void
 819 write_fatal (char const *name)
 820 {
 821   call_arg_fatal ("write", name);
 822 }
 823
 824 void
 825 write_fatal_details (char const *name, ssize_t status, size_t size)
 826 {
 827   write_error_details (name, status, size);
 828   fatal_exit ();
 829 }
 830
 831
 832 /* Fork, aborting if unsuccessful.  */
 833 pid_t
 834 xfork (void)
 835 {
 836   pid_t p = fork ();
 837   if (p == (pid_t) -1)
 838     call_arg_fatal ("fork", _("child process"));
 839   return p;
 840 }
 841
 842 /* Create a pipe, aborting if unsuccessful.  */
 843 void
 844 xpipe (int fd[2])
 845 {
 846   if (pipe (fd) < 0)
 847     call_arg_fatal ("pipe", _("interprocess channel"));
 848 }
 849
 850 /* Return an unambiguous printable representation, allocated in slot N,
 851    for NAME, suitable for diagnostics.  */
 852 char const *
 853 quote_n (int n, char const *name)
 854 {
 855   return quotearg_n_style (n, locale_quoting_style, name);
 856 }
 857
 858 /* Return an unambiguous printable representation of NAME, suitable
 859    for diagnostics.  */
 860 char const *
 861 quote (char const *name)
 862 {
 863   return quote_n (0, name);
 864 }