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 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 <xgetcwd.h> 26#include <unlinkdir.h> 27#include <utimens.h> 28 29#if HAVE_STROPTS_H 30# include <stropts.h> 31#endif 32#if HAVE_SYS_FILIO_H 33# include <sys/filio.h> 34#endif 35 36 37/* Handling strings. */ 38 39/* Assign STRING to a copy of VALUE if not zero, or to zero. If 40 STRING was nonzero, it is freed first. */ 41void 42assign_string (char **string, const char *value) 43{ 44 if (*string) 45 free (*string); 46 *string = value ? xstrdup (value) : 0; 47} 48 49/* Allocate a copy of the string quoted as in C, and returns that. If 50 the string does not have to be quoted, it returns a null pointer. 51 The allocated copy should normally be freed with free() after the 52 caller is done with it. 53 54 This is used in one context only: generating the directory file in 55 incremental dumps. The quoted string is not intended for human 56 consumption; it is intended only for unquote_string. The quoting 57 is locale-independent, so that users needn't worry about locale 58 when reading directory files. This means that we can't use 59 quotearg, as quotearg is locale-dependent and is meant for human 60 consumption. */ 61char * 62quote_copy_string (const char *string) 63{ 64 const char *source = string; 65 char *destination = 0; 66 char *buffer = 0; 67 int copying = 0; 68 69 while (*source) 70 { 71 int character = *source++; 72 73 switch (character) 74 { 75 case '\n': case '\\': 76 if (!copying) 77 { 78 size_t length = (source - string) - 1; 79 80 copying = 1; 81 buffer = xmalloc (length + 2 + 2 * strlen (source) + 1); 82 memcpy (buffer, string, length); 83 destination = buffer + length; 84 } 85 *destination++ = '\\'; 86 *destination++ = character == '\\' ? '\\' : 'n'; 87 break; 88 89 default: 90 if (copying) 91 *destination++ = character; 92 break; 93 } 94 } 95 if (copying) 96 { 97 *destination = '\0'; 98 return buffer; 99 } 100 return 0; 101} 102 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. */ 113int 114unquote_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/* Handling numbers. */ 219 220/* Output fraction and trailing digits appropriate for a nanoseconds 221 count equal to NS, but don't output unnecessary '.' or trailing 222 zeros. */ 223 224void 225code_ns_fraction (int ns, char *p) 226{ 227 if (ns == 0) 228 *p = '\0'; 229 else 230 { 231 int i = 9; 232 *p++ = '.'; 233 234 while (ns % 10 == 0) 235 { 236 ns /= 10; 237 i--; 238 } 239 240 p[i] = '\0'; 241 242 for (;;) 243 { 244 p[--i] = '0' + ns % 10; 245 if (i == 0) 246 break; 247 ns /= 10; 248 } 249 } 250} 251 252char const * 253code_timespec (struct timespec t, char sbuf[TIMESPEC_STRSIZE_BOUND]) 254{ 255 time_t s = t.tv_sec; 256 int ns = t.tv_nsec; 257 char *np; 258 bool negative = s < 0; 259 260 if (negative && ns != 0) 261 { 262 s++; 263 ns = BILLION - ns; 264 } 265 266 np = umaxtostr (negative ? - (uintmax_t) s : (uintmax_t) s, sbuf + 1); 267 if (negative) 268 *--np = '-'; 269 code_ns_fraction (ns, sbuf + UINTMAX_STRSIZE_BOUND); 270 return np; 271} 272 273/* File handling. */ 274 275/* Saved names in case backup needs to be undone. */ 276static char *before_backup_name; 277static char *after_backup_name; 278 279/* Return 1 if FILE_NAME is obviously "." or "/". */ 280static bool 281must_be_dot_or_slash (char const *file_name) 282{ 283 file_name += FILE_SYSTEM_PREFIX_LEN (file_name); 284 285 if (ISSLASH (file_name[0])) 286 { 287 for (;;) 288 if (ISSLASH (file_name[1])) 289 file_name++; 290 else if (file_name[1] == '.' 291 && ISSLASH (file_name[2 + (file_name[2] == '.')])) 292 file_name += 2 + (file_name[2] == '.'); 293 else 294 return ! file_name[1]; 295 } 296 else 297 { 298 while (file_name[0] == '.' && ISSLASH (file_name[1])) 299 { 300 file_name += 2; 301 while (ISSLASH (*file_name)) 302 file_name++; 303 } 304 305 return ! file_name[0] || (file_name[0] == '.' && ! file_name[1]); 306 } 307} 308 309/* Some implementations of rmdir let you remove '.' or '/'. 310 Report an error with errno set to zero for obvious cases of this; 311 otherwise call rmdir. */ 312static int 313safer_rmdir (const char *file_name) 314{ 315 if (must_be_dot_or_slash (file_name)) 316 { 317 errno = 0; 318 return -1; 319 } 320 321 return rmdir (file_name); 322} 323 324/* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory, 325 then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME 326 recursively; otherwise, remove it only if it is empty. If FILE_NAME is 327 a directory that cannot be removed (e.g., because it is nonempty) 328 and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1. 329 Return 0 on error, with errno set; if FILE_NAME is obviously the working 330 directory return zero with errno set to zero. */ 331int 332remove_any_file (const char *file_name, enum remove_option option) 333{ 334 /* Try unlink first if we cannot unlink directories, as this saves 335 us a system call in the common case where we're removing a 336 non-directory. */ 337 bool try_unlink_first = cannot_unlink_dir (); 338 339 if (try_unlink_first) 340 { 341 if (unlink (file_name) == 0) 342 return 1; 343 344 /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a 345 directory without appropriate privileges, but many Linux 346 kernels return the more-sensible EISDIR. */ 347 if (errno != EPERM && errno != EISDIR) 348 return 0; 349 } 350 351 if (safer_rmdir (file_name) == 0) 352 return 1; 353 354 switch (errno) 355 { 356 case ENOTDIR: 357 return !try_unlink_first && unlink (file_name) == 0; 358 359 case 0: 360 case EEXIST: 361#if defined ENOTEMPTY && ENOTEMPTY != EEXIST 362 case ENOTEMPTY: 363#endif 364 switch (option) 365 { 366 case ORDINARY_REMOVE_OPTION: 367 break; 368 369 case WANT_DIRECTORY_REMOVE_OPTION: 370 return -1; 371 372 case RECURSIVE_REMOVE_OPTION: 373 { 374 char *directory = savedir (file_name); 375 char const *entry; 376 size_t entrylen; 377 378 if (! directory) 379 return 0; 380 381 for (entry = directory; 382 (entrylen = strlen (entry)) != 0; 383 entry += entrylen + 1) 384 { 385 char *file_name_buffer = new_name (file_name, entry); 386 int r = remove_any_file (file_name_buffer, 387 RECURSIVE_REMOVE_OPTION); 388 int e = errno; 389 free (file_name_buffer); 390 391 if (! r) 392 { 393 free (directory); 394 errno = e; 395 return 0; 396 } 397 } 398 399 free (directory); 400 return safer_rmdir (file_name) == 0; 401 } 402 } 403 break; 404 } 405 406 return 0; 407} 408 409/* Check if FILE_NAME already exists and make a backup of it right now. 410 Return success (nonzero) only if the backup is either unneeded, or 411 successful. For now, directories are considered to never need 412 backup. If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and 413 so, we do not have to backup block or character devices, nor remote 414 entities. */ 415bool 416maybe_backup_file (const char *file_name, bool this_is_the_archive) 417{ 418 struct stat file_stat; 419 420 /* Check if we really need to backup the file. */ 421 422 if (this_is_the_archive && _remdev (file_name)) 423 return true; 424 425 if (stat (file_name, &file_stat)) 426 { 427 if (errno == ENOENT) 428 return true; 429 430 stat_error (file_name); 431 return false; 432 } 433 434 if (S_ISDIR (file_stat.st_mode)) 435 return true; 436 437 if (this_is_the_archive 438 && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode))) 439 return true; 440 441 assign_string (&before_backup_name, file_name); 442 443 /* A run situation may exist between Emacs or other GNU programs trying to 444 make a backup for the same file simultaneously. If theoretically 445 possible, real problems are unlikely. Doing any better would require a 446 convention, GNU-wide, for all programs doing backups. */ 447 448 assign_string (&after_backup_name, 0); 449 after_backup_name = find_backup_file_name (file_name, backup_type); 450 if (! after_backup_name) 451 xalloc_die (); 452 453 if (rename (before_backup_name, after_backup_name) == 0) 454 { 455 if (verbose_option) 456 fprintf (stdlis, _("Renaming %s to %s\n"), 457 quote_n (0, before_backup_name), 458 quote_n (1, after_backup_name)); 459 return true; 460 } 461 else 462 { 463 /* The backup operation failed. */ 464 int e = errno; 465 ERROR ((0, e, _("%s: Cannot rename to %s"), 466 quotearg_colon (before_backup_name), 467 quote_n (1, after_backup_name))); 468 assign_string (&after_backup_name, 0); 469 return false; 470 } 471} 472 473/* Try to restore the recently backed up file to its original name. 474 This is usually only needed after a failed extraction. */ 475void 476undo_last_backup (void) 477{ 478 if (after_backup_name) 479 { 480 if (rename (after_backup_name, before_backup_name) != 0) 481 { 482 int e = errno; 483 ERROR ((0, e, _("%s: Cannot rename to %s"), 484 quotearg_colon (after_backup_name), 485 quote_n (1, before_backup_name))); 486 } 487 if (verbose_option) 488 fprintf (stdlis, _("Renaming %s back to %s\n"), 489 quote_n (0, after_backup_name), 490 quote_n (1, before_backup_name)); 491 assign_string (&after_backup_name, 0); 492 } 493} 494 495/* Depending on DEREF, apply either stat or lstat to (NAME, BUF). */ 496int 497deref_stat (bool deref, char const *name, struct stat *buf) 498{ 499 return deref ? stat (name, buf) : lstat (name, buf); 500} 501 502/* Set FD's (i.e., FILE's) access time to TIMESPEC[0]. If that's not 503 possible to do by itself, set its access and data modification 504 times to TIMESPEC[0] and TIMESPEC[1], respectively. */ 505int 506set_file_atime (int fd, char const *file, struct timespec const timespec[2]) 507{ 508#ifdef _FIOSATIME 509 if (0 <= fd) 510 { 511 struct timeval timeval; 512 timeval.tv_sec = timespec[0].tv_sec; 513 timeval.tv_usec = timespec[0].tv_nsec / 1000; 514 if (ioctl (fd, _FIOSATIME, &timeval) == 0) 515 return 0; 516 } 517#endif 518 519 return gl_futimens (fd, file, timespec); 520} 521 522/* A description of a working directory. */ 523struct wd 524{ 525 char const *name; 526 int saved; 527 struct saved_cwd saved_cwd; 528}; 529 530/* A vector of chdir targets. wd[0] is the initial working directory. */ 531static struct wd *wd; 532 533/* The number of working directories in the vector. */ 534static size_t wds; 535 536/* The allocated size of the vector. */ 537static size_t wd_alloc; 538 539/* DIR is the operand of a -C option; add it to vector of chdir targets, 540 and return the index of its location. */ 541int 542chdir_arg (char const *dir) 543{ 544 if (wds == wd_alloc) 545 { 546 if (wd_alloc == 0) 547 { 548 wd_alloc = 2; 549 wd = xmalloc (sizeof *wd * wd_alloc); 550 } 551 else 552 wd = x2nrealloc (wd, &wd_alloc, sizeof *wd); 553 554 if (! wds) 555 { 556 wd[wds].name = "."; 557 wd[wds].saved = 0; 558 wds++; 559 } 560 } 561 562 /* Optimize the common special case of the working directory, 563 or the working directory as a prefix. */ 564 if (dir[0]) 565 { 566 while (dir[0] == '.' && ISSLASH (dir[1])) 567 for (dir += 2; ISSLASH (*dir); dir++) 568 continue; 569 if (! dir[dir[0] == '.']) 570 return wds - 1; 571 } 572 573 wd[wds].name = dir; 574 wd[wds].saved = 0; 575 return wds++; 576} 577 578/* Change to directory I. If I is 0, change to the initial working 579 directory; otherwise, I must be a value returned by chdir_arg. */ 580void 581chdir_do (int i) 582{ 583 static int previous; 584 585 if (previous != i) 586 { 587 struct wd *prev = &wd[previous]; 588 struct wd *curr = &wd[i]; 589 590 if (! prev->saved) 591 { 592 int err = 0; 593 prev->saved = 1; 594 if (save_cwd (&prev->saved_cwd) != 0) 595 err = errno; 596 else if (0 <= prev->saved_cwd.desc) 597 { 598 /* Make sure we still have at least one descriptor available. */ 599 int fd1 = prev->saved_cwd.desc; 600 int fd2 = dup (fd1); 601 if (0 <= fd2) 602 close (fd2); 603 else if (errno == EMFILE) 604 { 605 /* Force restore_cwd to use chdir_long. */ 606 close (fd1); 607 prev->saved_cwd.desc = -1; 608 prev->saved_cwd.name = xgetcwd (); 609 } 610 else 611 err = errno; 612 } 613 614 if (err) 615 FATAL_ERROR ((0, err, _("Cannot save working directory"))); 616 } 617 618 if (curr->saved) 619 { 620 if (restore_cwd (&curr->saved_cwd)) 621 FATAL_ERROR ((0, 0, _("Cannot change working directory"))); 622 } 623 else 624 { 625 if (i && ! ISSLASH (curr->name[0])) 626 chdir_do (i - 1); 627 if (chdir (curr->name) != 0) 628 chdir_fatal (curr->name); 629 } 630 631 previous = i; 632 } 633} 634 635void 636close_diag (char const *name) 637{ 638 if (ignore_failed_read_option) 639 close_warn (name); 640 else 641 close_error (name); 642} 643 644void 645open_diag (char const *name) 646{ 647 if (ignore_failed_read_option) 648 open_warn (name); 649 else 650 open_error (name); 651} 652 653void 654read_diag_details (char const *name, off_t offset, size_t size) 655{ 656 if (ignore_failed_read_option) 657 read_warn_details (name, offset, size); 658 else 659 read_error_details (name, offset, size); 660} 661 662void 663readlink_diag (char const *name) 664{ 665 if (ignore_failed_read_option) 666 readlink_warn (name); 667 else 668 readlink_error (name); 669} 670 671void 672savedir_diag (char const *name) 673{ 674 if (ignore_failed_read_option) 675 savedir_warn (name); 676 else 677 savedir_error (name); 678} 679 680void 681seek_diag_details (char const *name, off_t offset) 682{ 683 if (ignore_failed_read_option) 684 seek_warn_details (name, offset); 685 else 686 seek_error_details (name, offset); 687} 688 689void 690stat_diag (char const *name) 691{ 692 if (ignore_failed_read_option) 693 stat_warn (name); 694 else 695 stat_error (name); 696} 697 698void 699write_fatal_details (char const *name, ssize_t status, size_t size) 700{ 701 write_error_details (name, status, size); 702 fatal_exit (); 703} 704 705/* Fork, aborting if unsuccessful. */ 706pid_t 707xfork (void) 708{ 709 pid_t p = fork (); 710 if (p == (pid_t) -1) 711 call_arg_fatal ("fork", _("child process")); 712 return p; 713} 714 715/* Create a pipe, aborting if unsuccessful. */ 716void 717xpipe (int fd[2]) 718{ 719 if (pipe (fd) < 0) 720 call_arg_fatal ("pipe", _("interprocess channel")); 721} 722 723/* Return PTR, aligned upward to the next multiple of ALIGNMENT. 724 ALIGNMENT must be nonzero. The caller must arrange for ((char *) 725 PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable 726 locations. */ 727 728static inline void * 729ptr_align (void *ptr, size_t alignment) 730{ 731 char *p0 = ptr; 732 char *p1 = p0 + alignment - 1; 733 return p1 - (size_t) p1 % alignment; 734} 735 736/* Return the address of a page-aligned buffer of at least SIZE bytes. 737 The caller should free *PTR when done with the buffer. */ 738 739void * 740page_aligned_alloc (void **ptr, size_t size) 741{ 742 size_t alignment = getpagesize (); 743 size_t size1 = size + alignment; 744 if (size1 < size) 745 xalloc_die (); 746 *ptr = xmalloc (size1); 747 return ptr_align (*ptr, alignment); 748} 749