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