1 /* Miscellaneous functions, not really specific to GNU tar.
3 Copyright 1988, 1992, 1994-1997, 1999-2001, 2003-2007, 2009-2010,
4 2012-2013 Free Software Foundation, Inc.
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 3, or (at your option) any later
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.
16 You should have received a copy of the GNU General Public License along
17 with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #define COMMON_INLINE _GL_EXTERN_INLINE
25 #include <unlinkdir.h>
28 #ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
29 # define DOUBLE_SLASH_IS_DISTINCT_ROOT 0
33 /* Handling strings. */
35 /* Assign STRING to a copy of VALUE if not zero, or to zero. If
36 STRING was nonzero, it is freed first. */
38 assign_string (char **string
, const char *value
)
41 *string
= value
? xstrdup (value
) : 0;
45 /* This function is currently unused; perhaps it should be removed? */
47 /* Allocate a copy of the string quoted as in C, and returns that. If
48 the string does not have to be quoted, it returns a null pointer.
49 The allocated copy should normally be freed with free() after the
50 caller is done with it.
52 This is used in one context only: generating the directory file in
53 incremental dumps. The quoted string is not intended for human
54 consumption; it is intended only for unquote_string. The quoting
55 is locale-independent, so that users needn't worry about locale
56 when reading directory files. This means that we can't use
57 quotearg, as quotearg is locale-dependent and is meant for human
60 quote_copy_string (const char *string
)
62 const char *source
= string
;
63 char *destination
= 0;
69 int character
= *source
++;
76 size_t length
= (source
- string
) - 1;
79 buffer
= xmalloc (length
+ 2 + 2 * strlen (source
) + 1);
80 memcpy (buffer
, string
, length
);
81 destination
= buffer
+ length
;
83 *destination
++ = '\\';
84 *destination
++ = character
== '\\' ? '\\' : 'n';
89 *destination
++ = character
;
102 /* Takes a quoted C string (like those produced by quote_copy_string)
103 and turns it back into the un-quoted original. This is done in
104 place. Returns 0 only if the string was not properly quoted, but
105 completes the unquoting anyway.
107 This is used for reading the saved directory file in incremental
108 dumps. It is used for decoding old 'N' records (demangling names).
109 But also, it is used for decoding file arguments, would they come
110 from the shell or a -T file, and for decoding the --exclude
113 unquote_string (char *string
)
116 char *source
= string
;
117 char *destination
= string
;
119 /* Escape sequences other than \\ and \n are no longer generated by
120 quote_copy_string, but accept them for backwards compatibility,
121 and also because unquote_string is used for purposes other than
122 parsing the output of quote_copy_string. */
129 *destination
++ = '\\';
134 *destination
++ = '\a';
139 *destination
++ = '\b';
144 *destination
++ = '\f';
149 *destination
++ = '\n';
154 *destination
++ = '\r';
159 *destination
++ = '\t';
164 *destination
++ = '\v';
169 *destination
++ = 0177;
182 int value
= *source
++ - '0';
184 if (*source
< '0' || *source
> '7')
186 *destination
++ = value
;
189 value
= value
* 8 + *source
++ - '0';
190 if (*source
< '0' || *source
> '7')
192 *destination
++ = value
;
195 value
= value
* 8 + *source
++ - '0';
196 *destination
++ = value
;
202 *destination
++ = '\\';
204 *destination
++ = *source
++;
207 else if (source
!= destination
)
208 *destination
++ = *source
++;
210 source
++, destination
++;
212 if (source
!= destination
)
217 /* Zap trailing slashes. */
219 zap_slashes (char *name
)
223 if (!name
|| *name
== 0)
225 q
= name
+ strlen (name
) - 1;
226 while (q
> name
&& ISSLASH (*q
))
231 /* Normalize FILE_NAME by removing redundant slashes and "."
232 components, including redundant trailing slashes.
233 Leave ".." alone, as it may be significant in the presence
234 of symlinks and on platforms where "/.." != "/".
236 Destructive version: modifies its argument. */
238 normalize_filename_x (char *file_name
)
240 char *name
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
245 /* Don't squeeze leading "//" to "/", on hosts where they're distinct. */
246 name
+= (DOUBLE_SLASH_IS_DISTINCT_ROOT
247 && ISSLASH (*name
) && ISSLASH (name
[1]) && ! ISSLASH (name
[2]));
249 /* Omit redundant leading "." components. */
250 for (q
= p
= name
; (*p
= *q
) == '.' && ISSLASH (q
[1]); p
+= !*q
)
251 for (q
+= 2; ISSLASH (*q
); q
++)
254 /* Copy components from Q to P, omitting redundant slashes and
255 internal "." components. */
256 while ((*p
++ = c
= *q
++) != '\0')
258 while (ISSLASH (q
[*q
== '.']))
259 q
+= (*q
== '.') + 1;
261 /* Omit redundant trailing "." component and slash. */
264 p
-= p
[-2] == '.' && ISSLASH (p
[-3]);
265 p
-= 2 < p
- name
&& ISSLASH (p
[-2]);
270 /* Normalize NAME by removing redundant slashes and "." components,
271 including redundant trailing slashes.
273 Return a normalized newly-allocated copy. */
276 normalize_filename (int cdidx
, const char *name
)
280 if (IS_RELATIVE_FILE_NAME (name
))
282 /* Set COPY to the absolute file name if possible.
284 FIXME: There should be no need to get the absolute file name.
285 getcwd is slow, it might fail, and it does not necessarily
286 return a canonical name even when it succeeds. Perhaps we
287 can use dev+ino pairs instead of names? */
288 const char *cwd
= tar_getcdpath (cdidx
);
292 copylen
= strlen (cwd
);
293 need_separator
= ! (DOUBLE_SLASH_IS_DISTINCT_ROOT
294 && copylen
== 2 && ISSLASH (cwd
[1]));
295 copy
= xmalloc (copylen
+ need_separator
+ strlen (name
) + 1);
297 copy
[copylen
] = DIRECTORY_SEPARATOR
;
298 strcpy (copy
+ copylen
+ need_separator
, name
);
302 copy
= xstrdup (name
);
303 normalize_filename_x (copy
);
309 replace_prefix (char **pname
, const char *samp
, size_t slen
,
310 const char *repl
, size_t rlen
)
313 size_t nlen
= strlen (name
);
314 if (nlen
> slen
&& memcmp (name
, samp
, slen
) == 0 && ISSLASH (name
[slen
]))
318 name
= xrealloc (name
, nlen
- slen
+ rlen
+ 1);
321 memmove (name
+ rlen
, name
+ slen
, nlen
- slen
+ 1);
322 memcpy (name
, repl
, rlen
);
327 /* Handling numbers. */
329 /* Convert VALUE, which is converted from a system integer type whose
330 minimum value is MINVAL and maximum MINVAL, to an decimal
331 integer string. Use the storage in BUF and return a pointer to the
332 converted string. If VALUE is converted from a negative integer in
333 the range MINVAL .. -1, represent it with a string representation
334 of the negative integer, using leading '-'. */
335 #if ! (INTMAX_MAX <= UINTMAX_MAX / 2)
336 # error "sysinttostr: uintmax_t cannot represent all intmax_t values"
339 sysinttostr (uintmax_t value
, intmax_t minval
, uintmax_t maxval
,
340 char buf
[SYSINT_BUFSIZE
])
343 return umaxtostr (value
, buf
);
346 intmax_t i
= value
- minval
;
347 return imaxtostr (i
+ minval
, buf
);
351 /* Convert a prefix of the string ARG to a system integer type whose
352 minimum value is MINVAL and maximum MAXVAL. If MINVAL is negative,
353 negative integers MINVAL .. -1 are assumed to be represented using
354 leading '-' in the usual way. If the represented value exceeds
355 INTMAX_MAX, return a negative integer V such that (uintmax_t) V
356 yields the represented value. If ARGLIM is nonnull, store into
357 *ARGLIM a pointer to the first character after the prefix.
359 This is the inverse of sysinttostr.
361 On a normal return, set errno = 0.
362 On conversion error, return 0 and set errno = EINVAL.
363 On overflow, return an extreme value and set errno = ERANGE. */
364 #if ! (INTMAX_MAX <= UINTMAX_MAX)
365 # error "strtosysint: nonnegative intmax_t does not fit in uintmax_t"
368 strtosysint (char const *arg
, char **arglim
, intmax_t minval
, uintmax_t maxval
)
371 if (maxval
<= INTMAX_MAX
)
373 if (ISDIGIT (arg
[*arg
== '-']))
375 intmax_t i
= strtoimax (arg
, arglim
, 10);
376 intmax_t imaxval
= maxval
;
377 if (minval
<= i
&& i
<= imaxval
)
380 return i
< minval
? minval
: maxval
;
387 uintmax_t i
= strtoumax (arg
, arglim
, 10);
389 return represent_uintmax (i
);
399 /* Output fraction and trailing digits appropriate for a nanoseconds
400 count equal to NS, but don't output unnecessary '.' or trailing
404 code_ns_fraction (int ns
, char *p
)
423 p
[--i
] = '0' + ns
% 10;
432 code_timespec (struct timespec t
, char sbuf
[TIMESPEC_STRSIZE_BOUND
])
437 bool negative
= s
< 0;
439 /* ignore invalid values of ns */
440 if (BILLION
<= ns
|| ns
< 0)
443 if (negative
&& ns
!= 0)
449 np
= umaxtostr (negative
? - (uintmax_t) s
: (uintmax_t) s
, sbuf
+ 1);
452 code_ns_fraction (ns
, sbuf
+ UINTMAX_STRSIZE_BOUND
);
457 decode_timespec (char const *arg
, char **arg_lim
, bool parse_fraction
)
459 time_t s
= TYPE_MINIMUM (time_t);
462 bool negative
= *arg
== '-';
465 if (! ISDIGIT (arg
[negative
]))
473 intmax_t i
= strtoimax (arg
, arg_lim
, 10);
474 if (TYPE_SIGNED (time_t) ? TYPE_MINIMUM (time_t) <= i
: 0 <= i
)
481 uintmax_t i
= strtoumax (arg
, arg_lim
, 10);
482 if (i
<= TYPE_MAXIMUM (time_t))
491 if (parse_fraction
&& *p
== '.')
494 bool trailing_nonzero
= false;
496 while (ISDIGIT (*++p
))
497 if (digits
< LOG10_BILLION
)
498 digits
++, ns
= 10 * ns
+ (*p
- '0');
500 trailing_nonzero
|= *p
!= '0';
502 while (digits
< LOG10_BILLION
)
507 /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
508 I.e., truncate time stamps towards minus infinity while
509 converting them to internal form. */
510 ns
+= trailing_nonzero
;
513 if (s
== TYPE_MINIMUM (time_t))
528 *arg_lim
= (char *) p
;
536 /* Saved names in case backup needs to be undone. */
537 static char *before_backup_name
;
538 static char *after_backup_name
;
540 /* Return 1 if FILE_NAME is obviously "." or "/". */
542 must_be_dot_or_slash (char const *file_name
)
544 file_name
+= FILE_SYSTEM_PREFIX_LEN (file_name
);
546 if (ISSLASH (file_name
[0]))
549 if (ISSLASH (file_name
[1]))
551 else if (file_name
[1] == '.'
552 && ISSLASH (file_name
[2 + (file_name
[2] == '.')]))
553 file_name
+= 2 + (file_name
[2] == '.');
555 return ! file_name
[1];
559 while (file_name
[0] == '.' && ISSLASH (file_name
[1]))
562 while (ISSLASH (*file_name
))
566 return ! file_name
[0] || (file_name
[0] == '.' && ! file_name
[1]);
570 /* Some implementations of rmdir let you remove '.' or '/'.
571 Report an error with errno set to zero for obvious cases of this;
572 otherwise call rmdir. */
574 safer_rmdir (const char *file_name
)
576 if (must_be_dot_or_slash (file_name
))
582 return unlinkat (chdir_fd
, file_name
, AT_REMOVEDIR
);
585 /* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory,
586 then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
587 recursively; otherwise, remove it only if it is empty. If FILE_NAME is
588 a directory that cannot be removed (e.g., because it is nonempty)
589 and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
590 Return 0 on error, with errno set; if FILE_NAME is obviously the working
591 directory return zero with errno set to zero. */
593 remove_any_file (const char *file_name
, enum remove_option option
)
595 /* Try unlink first if we cannot unlink directories, as this saves
596 us a system call in the common case where we're removing a
598 bool try_unlink_first
= cannot_unlink_dir ();
600 if (try_unlink_first
)
602 if (unlinkat (chdir_fd
, file_name
, 0) == 0)
605 /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
606 directory without appropriate privileges, but many Linux
607 kernels return the more-sensible EISDIR. */
608 if (errno
!= EPERM
&& errno
!= EISDIR
)
612 if (safer_rmdir (file_name
) == 0)
618 return !try_unlink_first
&& unlinkat (chdir_fd
, file_name
, 0) == 0;
622 #if defined ENOTEMPTY && ENOTEMPTY != EEXIST
627 case ORDINARY_REMOVE_OPTION
:
630 case WANT_DIRECTORY_REMOVE_OPTION
:
633 case RECURSIVE_REMOVE_OPTION
:
635 char *directory
= tar_savedir (file_name
, 0);
642 for (entry
= directory
;
643 (entrylen
= strlen (entry
)) != 0;
644 entry
+= entrylen
+ 1)
646 char *file_name_buffer
= new_name (file_name
, entry
);
647 int r
= remove_any_file (file_name_buffer
,
648 RECURSIVE_REMOVE_OPTION
);
650 free (file_name_buffer
);
661 return safer_rmdir (file_name
) == 0;
670 /* Check if FILE_NAME already exists and make a backup of it right now.
671 Return success (nonzero) only if the backup is either unneeded, or
672 successful. For now, directories are considered to never need
673 backup. If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
674 so, we do not have to backup block or character devices, nor remote
677 maybe_backup_file (const char *file_name
, bool this_is_the_archive
)
679 struct stat file_stat
;
681 assign_string (&before_backup_name
, file_name
);
683 /* A run situation may exist between Emacs or other GNU programs trying to
684 make a backup for the same file simultaneously. If theoretically
685 possible, real problems are unlikely. Doing any better would require a
686 convention, GNU-wide, for all programs doing backups. */
688 assign_string (&after_backup_name
, 0);
690 /* Check if we really need to backup the file. */
692 if (this_is_the_archive
&& _remdev (file_name
))
695 if (deref_stat (file_name
, &file_stat
) != 0)
700 stat_error (file_name
);
704 if (S_ISDIR (file_stat
.st_mode
))
707 if (this_is_the_archive
708 && (S_ISBLK (file_stat
.st_mode
) || S_ISCHR (file_stat
.st_mode
)))
711 after_backup_name
= find_backup_file_name (file_name
, backup_type
);
712 if (! after_backup_name
)
715 if (renameat (chdir_fd
, before_backup_name
, chdir_fd
, after_backup_name
)
719 fprintf (stdlis
, _("Renaming %s to %s\n"),
720 quote_n (0, before_backup_name
),
721 quote_n (1, after_backup_name
));
726 /* The backup operation failed. */
728 ERROR ((0, e
, _("%s: Cannot rename to %s"),
729 quotearg_colon (before_backup_name
),
730 quote_n (1, after_backup_name
)));
731 assign_string (&after_backup_name
, 0);
736 /* Try to restore the recently backed up file to its original name.
737 This is usually only needed after a failed extraction. */
739 undo_last_backup (void)
741 if (after_backup_name
)
743 if (renameat (chdir_fd
, after_backup_name
, chdir_fd
, before_backup_name
)
747 ERROR ((0, e
, _("%s: Cannot rename to %s"),
748 quotearg_colon (after_backup_name
),
749 quote_n (1, before_backup_name
)));
752 fprintf (stdlis
, _("Renaming %s back to %s\n"),
753 quote_n (0, after_backup_name
),
754 quote_n (1, before_backup_name
));
755 assign_string (&after_backup_name
, 0);
759 /* Apply either stat or lstat to (NAME, BUF), depending on the
760 presence of the --dereference option. NAME is relative to the
761 most-recent argument to chdir_do. */
763 deref_stat (char const *name
, struct stat
*buf
)
765 return fstatat (chdir_fd
, name
, buf
, fstatat_flags
);
768 /* Read from FD into the buffer BUF with COUNT bytes. Attempt to fill
769 BUF. Wait until input is available; this matters because files are
770 opened O_NONBLOCK for security reasons, and on some file systems
771 this can cause read to fail with errno == EAGAIN. Return the
772 actual number of bytes read, zero for EOF, or
773 SAFE_READ_ERROR upon error. */
775 blocking_read (int fd
, void *buf
, size_t count
)
777 size_t bytes
= safe_read (fd
, buf
, count
);
779 #if defined F_SETFL && O_NONBLOCK
780 if (bytes
== SAFE_READ_ERROR
&& errno
== EAGAIN
)
782 int flags
= fcntl (fd
, F_GETFL
);
783 if (0 <= flags
&& flags
& O_NONBLOCK
784 && fcntl (fd
, F_SETFL
, flags
& ~O_NONBLOCK
) != -1)
785 bytes
= safe_read (fd
, buf
, count
);
792 /* Write to FD from the buffer BUF with COUNT bytes. Do a full write.
793 Wait until an output buffer is available; this matters because
794 files are opened O_NONBLOCK for security reasons, and on some file
795 systems this can cause write to fail with errno == EAGAIN. Return
796 the actual number of bytes written, setting errno if that is less
799 blocking_write (int fd
, void const *buf
, size_t count
)
801 size_t bytes
= full_write (fd
, buf
, count
);
803 #if defined F_SETFL && O_NONBLOCK
804 if (bytes
< count
&& errno
== EAGAIN
)
806 int flags
= fcntl (fd
, F_GETFL
);
807 if (0 <= flags
&& flags
& O_NONBLOCK
808 && fcntl (fd
, F_SETFL
, flags
& ~O_NONBLOCK
) != -1)
810 char const *buffer
= buf
;
811 bytes
+= full_write (fd
, buffer
+ bytes
, count
- bytes
);
819 /* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's)
820 access time to ATIME. */
822 set_file_atime (int fd
, int parentfd
, char const *file
, struct timespec atime
)
824 struct timespec ts
[2];
826 ts
[1].tv_nsec
= UTIME_OMIT
;
827 return fdutimensat (fd
, parentfd
, file
, ts
, fstatat_flags
);
830 /* A description of a working directory. */
833 /* The directory's name. */
835 /* Current working directory; initialized by tar_getcwd */
837 /* If nonzero, the file descriptor of the directory, or AT_FDCWD if
838 the working directory. If zero, the directory needs to be opened
843 /* A vector of chdir targets. wd[0] is the initial working directory. */
844 static struct wd
*wd
;
846 /* The number of working directories in the vector. */
847 static size_t wd_count
;
849 /* The allocated size of the vector. */
850 static size_t wd_alloc
;
852 /* The maximum number of chdir targets with open directories.
853 Don't make it too large, as many operating systems have a small
854 limit on the number of open file descriptors. Also, the current
855 implementation does not scale well. */
856 enum { CHDIR_CACHE_SIZE
= 16 };
858 /* Indexes into WD of chdir targets with open file descriptors, sorted
859 most-recently used first. Zero indexes are unused. */
860 static int wdcache
[CHDIR_CACHE_SIZE
];
862 /* Number of nonzero entries in WDCACHE. */
863 static size_t wdcache_count
;
873 /* DIR is the operand of a -C option; add it to vector of chdir targets,
874 and return the index of its location. */
876 chdir_arg (char const *dir
)
878 if (wd_count
== wd_alloc
)
883 wd
= xmalloc (sizeof *wd
* wd_alloc
);
886 wd
= x2nrealloc (wd
, &wd_alloc
, sizeof *wd
);
890 wd
[wd_count
].name
= ".";
891 wd
[wd_count
].cwd
= xgetcwd ();
892 wd
[wd_count
].fd
= AT_FDCWD
;
897 /* Optimize the common special case of the working directory,
898 or the working directory as a prefix. */
901 while (dir
[0] == '.' && ISSLASH (dir
[1]))
902 for (dir
+= 2; ISSLASH (*dir
); dir
++)
904 if (! dir
[dir
[0] == '.'])
908 wd
[wd_count
].name
= dir
;
909 if (IS_ABSOLUTE_FILE_NAME (wd
[wd_count
].name
))
910 wd
[wd_count
].cwd
= xstrdup (wd
[wd_count
].name
);
913 namebuf_t nbuf
= namebuf_create (wd
[wd_count
- 1].cwd
);
914 namebuf_add_dir (nbuf
, wd
[wd_count
].name
);
915 wd
[wd_count
].cwd
= namebuf_finish (nbuf
);
921 /* Index of current directory. */
924 /* Value suitable for use as the first argument to openat, and in
925 similar locations for fstatat, etc. This is an open file
926 descriptor, or AT_FDCWD if the working directory is current. It is
927 valid until the next invocation of chdir_do. */
928 int chdir_fd
= AT_FDCWD
;
930 /* Change to directory I, in a virtual way. This does not actually
931 invoke chdir; it merely sets chdir_fd to an int suitable as the
932 first argument for openat, etc. If I is 0, change to the initial
933 working directory; otherwise, I must be a value returned by
938 if (chdir_current
!= i
)
940 struct wd
*curr
= &wd
[i
];
945 if (! IS_ABSOLUTE_FILE_NAME (curr
->name
))
947 fd
= openat (chdir_fd
, curr
->name
,
948 open_searchdir_flags
& ~ O_NOFOLLOW
);
950 open_fatal (curr
->name
);
954 /* Add I to the cache, tossing out the lowest-ranking entry if the
956 if (wdcache_count
< CHDIR_CACHE_SIZE
)
957 wdcache
[wdcache_count
++] = i
;
960 struct wd
*stale
= &wd
[wdcache
[CHDIR_CACHE_SIZE
- 1]];
961 if (close (stale
->fd
) != 0)
962 close_diag (stale
->name
);
964 wdcache
[CHDIR_CACHE_SIZE
- 1] = i
;
970 /* Move the i value to the front of the cache. This is
971 O(CHDIR_CACHE_SIZE), but the cache is small. */
973 int prev
= wdcache
[0];
974 for (ci
= 1; prev
!= i
; ci
++)
976 int cur
= wdcache
[ci
];
993 return wd
[chdir_current
].name
;
997 tar_getcdpath (int idx
)
1010 close_diag (char const *name
)
1012 if (ignore_failed_read_option
)
1019 open_diag (char const *name
)
1021 if (ignore_failed_read_option
)
1028 read_diag_details (char const *name
, off_t offset
, size_t size
)
1030 if (ignore_failed_read_option
)
1031 read_warn_details (name
, offset
, size
);
1033 read_error_details (name
, offset
, size
);
1037 readlink_diag (char const *name
)
1039 if (ignore_failed_read_option
)
1040 readlink_warn (name
);
1042 readlink_error (name
);
1046 savedir_diag (char const *name
)
1048 if (ignore_failed_read_option
)
1049 savedir_warn (name
);
1051 savedir_error (name
);
1055 seek_diag_details (char const *name
, off_t offset
)
1057 if (ignore_failed_read_option
)
1058 seek_warn_details (name
, offset
);
1060 seek_error_details (name
, offset
);
1064 stat_diag (char const *name
)
1066 if (ignore_failed_read_option
)
1073 file_removed_diag (const char *name
, bool top_level
,
1074 void (*diagfn
) (char const *name
))
1076 if (!top_level
&& errno
== ENOENT
)
1078 WARNOPT (WARN_FILE_REMOVED
,
1079 (0, 0, _("%s: File removed before we read it"),
1080 quotearg_colon (name
)));
1081 set_exit_status (TAREXIT_DIFFERS
);
1088 write_fatal_details (char const *name
, ssize_t status
, size_t size
)
1090 write_error_details (name
, status
, size
);
1094 /* Fork, aborting if unsuccessful. */
1099 if (p
== (pid_t
) -1)
1100 call_arg_fatal ("fork", _("child process"));
1104 /* Create a pipe, aborting if unsuccessful. */
1109 call_arg_fatal ("pipe", _("interprocess channel"));
1112 /* Return PTR, aligned upward to the next multiple of ALIGNMENT.
1113 ALIGNMENT must be nonzero. The caller must arrange for ((char *)
1114 PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable
1117 static inline void *
1118 ptr_align (void *ptr
, size_t alignment
)
1121 char *p1
= p0
+ alignment
- 1;
1122 return p1
- (size_t) p1
% alignment
;
1125 /* Return the address of a page-aligned buffer of at least SIZE bytes.
1126 The caller should free *PTR when done with the buffer. */
1129 page_aligned_alloc (void **ptr
, size_t size
)
1131 size_t alignment
= getpagesize ();
1132 size_t size1
= size
+ alignment
;
1135 *ptr
= xmalloc (size1
);
1136 return ptr_align (*ptr
, alignment
);
1143 char *buffer
; /* directory, '/', and directory member */
1144 size_t buffer_size
; /* allocated size of name_buffer */
1145 size_t dir_length
; /* length of directory part in buffer */
1149 namebuf_create (const char *dir
)
1151 namebuf_t buf
= xmalloc (sizeof (*buf
));
1152 buf
->buffer_size
= strlen (dir
) + 2;
1153 buf
->buffer
= xmalloc (buf
->buffer_size
);
1154 strcpy (buf
->buffer
, dir
);
1155 buf
->dir_length
= strlen (buf
->buffer
);
1156 if (!ISSLASH (buf
->buffer
[buf
->dir_length
- 1]))
1157 buf
->buffer
[buf
->dir_length
++] = DIRECTORY_SEPARATOR
;
1162 namebuf_free (namebuf_t buf
)
1169 namebuf_name (namebuf_t buf
, const char *name
)
1171 size_t len
= strlen (name
);
1172 while (buf
->dir_length
+ len
+ 1 >= buf
->buffer_size
)
1173 buf
->buffer
= x2realloc (buf
->buffer
, &buf
->buffer_size
);
1174 strcpy (buf
->buffer
+ buf
->dir_length
, name
);
1179 namebuf_add_dir (namebuf_t buf
, const char *name
)
1181 static char dirsep
[] = { DIRECTORY_SEPARATOR
, 0 };
1182 if (!ISSLASH (buf
->buffer
[buf
->dir_length
- 1]))
1184 namebuf_name (buf
, dirsep
);
1187 namebuf_name (buf
, name
);
1188 buf
->dir_length
+= strlen (name
);
1192 namebuf_finish (namebuf_t buf
)
1194 char *res
= buf
->buffer
;
1196 if (ISSLASH (buf
->buffer
[buf
->dir_length
- 1]))
1197 buf
->buffer
[buf
->dir_length
] = 0;
1202 /* Return the filenames in directory NAME, relative to the chdir_fd.
1203 If the directory does not exist, report error if MUST_EXIST is
1206 Return NULL on errors.
1209 tar_savedir (const char *name
, int must_exist
)
1213 int fd
= openat (chdir_fd
, name
, open_read_flags
| O_DIRECTORY
);
1216 if (!must_exist
&& errno
== ENOENT
)
1220 else if (! ((dir
= fdopendir (fd
))
1221 && (ret
= streamsavedir (dir
))))
1222 savedir_error (name
);
1224 if (dir
? closedir (dir
) != 0 : 0 <= fd
&& close (fd
) != 0)
1225 savedir_error (name
);