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 path for this name.
284 FIXME: There should be no need to get the absolute file name.
285 tar_getcdpath does not return a true "canonical" path, so
286 this following approach may lead to situations where the same
287 file or directory is processed twice under different absolute
288 paths without that duplication being detected. Perhaps we
289 should use dev+ino pairs instead of names? */
290 const char *cdpath = tar_getcdpath (cdidx);
294 copylen = strlen (cdpath);
295 need_separator = ! (DOUBLE_SLASH_IS_DISTINCT_ROOT
296 && copylen == 2 && ISSLASH (cdpath[1]));
297 copy = xmalloc (copylen + need_separator + strlen (name) + 1);
298 strcpy (copy, cdpath);
299 copy[copylen] = DIRECTORY_SEPARATOR;
300 strcpy (copy + copylen + need_separator, name);
304 copy = xstrdup (name);
305 normalize_filename_x (copy);
311 replace_prefix (char **pname, const char *samp, size_t slen,
312 const char *repl, size_t rlen)
315 size_t nlen = strlen (name);
316 if (nlen > slen && memcmp (name, samp, slen) == 0 && ISSLASH (name[slen]))
320 name = xrealloc (name, nlen - slen + rlen + 1);
323 memmove (name + rlen, name + slen, nlen - slen + 1);
324 memcpy (name, repl, rlen);
329 /* Handling numbers. */
331 /* Convert VALUE, which is converted from a system integer type whose
332 minimum value is MINVAL and maximum MINVAL, to an decimal
333 integer string. Use the storage in BUF and return a pointer to the
334 converted string. If VALUE is converted from a negative integer in
335 the range MINVAL .. -1, represent it with a string representation
336 of the negative integer, using leading '-'. */
337 #if ! (INTMAX_MAX <= UINTMAX_MAX / 2)
338 # error "sysinttostr: uintmax_t cannot represent all intmax_t values"
341 sysinttostr (uintmax_t value, intmax_t minval, uintmax_t maxval,
342 char buf[SYSINT_BUFSIZE])
345 return umaxtostr (value, buf);
348 intmax_t i = value - minval;
349 return imaxtostr (i + minval, buf);
353 /* Convert a prefix of the string ARG to a system integer type whose
354 minimum value is MINVAL and maximum MAXVAL. If MINVAL is negative,
355 negative integers MINVAL .. -1 are assumed to be represented using
356 leading '-' in the usual way. If the represented value exceeds
357 INTMAX_MAX, return a negative integer V such that (uintmax_t) V
358 yields the represented value. If ARGLIM is nonnull, store into
359 *ARGLIM a pointer to the first character after the prefix.
361 This is the inverse of sysinttostr.
363 On a normal return, set errno = 0.
364 On conversion error, return 0 and set errno = EINVAL.
365 On overflow, return an extreme value and set errno = ERANGE. */
366 #if ! (INTMAX_MAX <= UINTMAX_MAX)
367 # error "strtosysint: nonnegative intmax_t does not fit in uintmax_t"
370 strtosysint (char const *arg, char **arglim, intmax_t minval, uintmax_t maxval)
373 if (maxval <= INTMAX_MAX)
375 if (ISDIGIT (arg[*arg == '-']))
377 intmax_t i = strtoimax (arg, arglim, 10);
378 intmax_t imaxval = maxval;
379 if (minval <= i && i <= imaxval)
382 return i < minval ? minval : maxval;
389 uintmax_t i = strtoumax (arg, arglim, 10);
391 return represent_uintmax (i);
401 /* Output fraction and trailing digits appropriate for a nanoseconds
402 count equal to NS, but don't output unnecessary '.' or trailing
406 code_ns_fraction (int ns, char *p)
425 p[--i] = '0' + ns % 10;
434 code_timespec (struct timespec t, char sbuf[TIMESPEC_STRSIZE_BOUND])
439 bool negative = s < 0;
441 /* ignore invalid values of ns */
442 if (BILLION <= ns || ns < 0)
445 if (negative && ns != 0)
451 np = umaxtostr (negative ? - (uintmax_t) s : (uintmax_t) s, sbuf + 1);
454 code_ns_fraction (ns, sbuf + UINTMAX_STRSIZE_BOUND);
459 decode_timespec (char const *arg, char **arg_lim, bool parse_fraction)
461 time_t s = TYPE_MINIMUM (time_t);
464 bool negative = *arg == '-';
467 if (! ISDIGIT (arg[negative]))
475 intmax_t i = strtoimax (arg, arg_lim, 10);
476 if (TYPE_SIGNED (time_t) ? TYPE_MINIMUM (time_t) <= i : 0 <= i)
483 uintmax_t i = strtoumax (arg, arg_lim, 10);
484 if (i <= TYPE_MAXIMUM (time_t))
493 if (parse_fraction && *p == '.')
496 bool trailing_nonzero = false;
498 while (ISDIGIT (*++p))
499 if (digits < LOG10_BILLION)
500 digits++, ns = 10 * ns + (*p - '0');
502 trailing_nonzero |= *p != '0';
504 while (digits < LOG10_BILLION)
509 /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
510 I.e., truncate time stamps towards minus infinity while
511 converting them to internal form. */
512 ns += trailing_nonzero;
515 if (s == TYPE_MINIMUM (time_t))
530 *arg_lim = (char *) p;
538 /* Saved names in case backup needs to be undone. */
539 static char *before_backup_name;
540 static char *after_backup_name;
542 /* Return 1 if FILE_NAME is obviously "." or "/". */
544 must_be_dot_or_slash (char const *file_name)
546 file_name += FILE_SYSTEM_PREFIX_LEN (file_name);
548 if (ISSLASH (file_name[0]))
551 if (ISSLASH (file_name[1]))
553 else if (file_name[1] == '.'
554 && ISSLASH (file_name[2 + (file_name[2] == '.')]))
555 file_name += 2 + (file_name[2] == '.');
557 return ! file_name[1];
561 while (file_name[0] == '.' && ISSLASH (file_name[1]))
564 while (ISSLASH (*file_name))
568 return ! file_name[0] || (file_name[0] == '.' && ! file_name[1]);
572 /* Some implementations of rmdir let you remove '.' or '/'.
573 Report an error with errno set to zero for obvious cases of this;
574 otherwise call rmdir. */
576 safer_rmdir (const char *file_name)
578 if (must_be_dot_or_slash (file_name))
584 return unlinkat (chdir_fd, file_name, AT_REMOVEDIR);
587 /* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory,
588 then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
589 recursively; otherwise, remove it only if it is empty. If FILE_NAME is
590 a directory that cannot be removed (e.g., because it is nonempty)
591 and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
592 Return 0 on error, with errno set; if FILE_NAME is obviously the working
593 directory return zero with errno set to zero. */
595 remove_any_file (const char *file_name, enum remove_option option)
597 /* Try unlink first if we cannot unlink directories, as this saves
598 us a system call in the common case where we're removing a
600 bool try_unlink_first = cannot_unlink_dir ();
602 if (try_unlink_first)
604 if (unlinkat (chdir_fd, file_name, 0) == 0)
607 /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
608 directory without appropriate privileges, but many Linux
609 kernels return the more-sensible EISDIR. */
610 if (errno != EPERM && errno != EISDIR)
614 if (safer_rmdir (file_name) == 0)
620 return !try_unlink_first && unlinkat (chdir_fd, file_name, 0) == 0;
624 #if defined ENOTEMPTY && ENOTEMPTY != EEXIST
629 case ORDINARY_REMOVE_OPTION:
632 case WANT_DIRECTORY_REMOVE_OPTION:
635 case RECURSIVE_REMOVE_OPTION:
637 char *directory = tar_savedir (file_name, 0);
644 for (entry = directory;
645 (entrylen = strlen (entry)) != 0;
646 entry += entrylen + 1)
648 char *file_name_buffer = new_name (file_name, entry);
649 int r = remove_any_file (file_name_buffer,
650 RECURSIVE_REMOVE_OPTION);
652 free (file_name_buffer);
663 return safer_rmdir (file_name) == 0;
672 /* Check if FILE_NAME already exists and make a backup of it right now.
673 Return success (nonzero) only if the backup is either unneeded, or
674 successful. For now, directories are considered to never need
675 backup. If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
676 so, we do not have to backup block or character devices, nor remote
679 maybe_backup_file (const char *file_name, bool this_is_the_archive)
681 struct stat file_stat;
683 assign_string (&before_backup_name, file_name);
685 /* A run situation may exist between Emacs or other GNU programs trying to
686 make a backup for the same file simultaneously. If theoretically
687 possible, real problems are unlikely. Doing any better would require a
688 convention, GNU-wide, for all programs doing backups. */
690 assign_string (&after_backup_name, 0);
692 /* Check if we really need to backup the file. */
694 if (this_is_the_archive && _remdev (file_name))
697 if (deref_stat (file_name, &file_stat) != 0)
702 stat_error (file_name);
706 if (S_ISDIR (file_stat.st_mode))
709 if (this_is_the_archive
710 && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
713 after_backup_name = find_backup_file_name (file_name, backup_type);
714 if (! after_backup_name)
717 if (renameat (chdir_fd, before_backup_name, chdir_fd, after_backup_name)
721 fprintf (stdlis, _("Renaming %s to %s\n"),
722 quote_n (0, before_backup_name),
723 quote_n (1, after_backup_name));
728 /* The backup operation failed. */
730 ERROR ((0, e, _("%s: Cannot rename to %s"),
731 quotearg_colon (before_backup_name),
732 quote_n (1, after_backup_name)));
733 assign_string (&after_backup_name, 0);
738 /* Try to restore the recently backed up file to its original name.
739 This is usually only needed after a failed extraction. */
741 undo_last_backup (void)
743 if (after_backup_name)
745 if (renameat (chdir_fd, after_backup_name, chdir_fd, before_backup_name)
749 ERROR ((0, e, _("%s: Cannot rename to %s"),
750 quotearg_colon (after_backup_name),
751 quote_n (1, before_backup_name)));
754 fprintf (stdlis, _("Renaming %s back to %s\n"),
755 quote_n (0, after_backup_name),
756 quote_n (1, before_backup_name));
757 assign_string (&after_backup_name, 0);
761 /* Apply either stat or lstat to (NAME, BUF), depending on the
762 presence of the --dereference option. NAME is relative to the
763 most-recent argument to chdir_do. */
765 deref_stat (char const *name, struct stat *buf)
767 return fstatat (chdir_fd, name, buf, fstatat_flags);
770 /* Read from FD into the buffer BUF with COUNT bytes. Attempt to fill
771 BUF. Wait until input is available; this matters because files are
772 opened O_NONBLOCK for security reasons, and on some file systems
773 this can cause read to fail with errno == EAGAIN. Return the
774 actual number of bytes read, zero for EOF, or
775 SAFE_READ_ERROR upon error. */
777 blocking_read (int fd, void *buf, size_t count)
779 size_t bytes = safe_read (fd, buf, count);
781 #if defined F_SETFL && O_NONBLOCK
782 if (bytes == SAFE_READ_ERROR && errno == EAGAIN)
784 int flags = fcntl (fd, F_GETFL);
785 if (0 <= flags && flags & O_NONBLOCK
786 && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
787 bytes = safe_read (fd, buf, count);
794 /* Write to FD from the buffer BUF with COUNT bytes. Do a full write.
795 Wait until an output buffer is available; this matters because
796 files are opened O_NONBLOCK for security reasons, and on some file
797 systems this can cause write to fail with errno == EAGAIN. Return
798 the actual number of bytes written, setting errno if that is less
801 blocking_write (int fd, void const *buf, size_t count)
803 size_t bytes = full_write (fd, buf, count);
805 #if defined F_SETFL && O_NONBLOCK
806 if (bytes < count && errno == EAGAIN)
808 int flags = fcntl (fd, F_GETFL);
809 if (0 <= flags && flags & O_NONBLOCK
810 && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
812 char const *buffer = buf;
813 bytes += full_write (fd, buffer + bytes, count - bytes);
821 /* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's)
822 access time to ATIME. */
824 set_file_atime (int fd, int parentfd, char const *file, struct timespec atime)
826 struct timespec ts[2];
828 ts[1].tv_nsec = UTIME_OMIT;
829 return fdutimensat (fd, parentfd, file, ts, fstatat_flags);
832 /* A description of a working directory. */
835 /* The directory's name. */
837 /* "absolute" path representing this directory; in the contrast to
838 the real absolute pathname, it can contain /../ components (see
839 normalize_filename_x for the reason of it). */
841 /* If nonzero, the file descriptor of the directory, or AT_FDCWD if
842 the working directory. If zero, the directory needs to be opened
847 /* A vector of chdir targets. wd[0] is the initial working directory. */
848 static struct wd *wd;
850 /* The number of working directories in the vector. */
851 static size_t wd_count;
853 /* The allocated size of the vector. */
854 static size_t wd_alloc;
856 /* The maximum number of chdir targets with open directories.
857 Don't make it too large, as many operating systems have a small
858 limit on the number of open file descriptors. Also, the current
859 implementation does not scale well. */
860 enum { CHDIR_CACHE_SIZE = 16 };
862 /* Indexes into WD of chdir targets with open file descriptors, sorted
863 most-recently used first. Zero indexes are unused. */
864 static int wdcache[CHDIR_CACHE_SIZE];
866 /* Number of nonzero entries in WDCACHE. */
867 static size_t wdcache_count;
877 /* DIR is the operand of a -C option; add it to vector of chdir targets,
878 and return the index of its location. */
880 chdir_arg (char const *dir)
882 if (wd_count == wd_alloc)
887 wd = xmalloc (sizeof *wd * wd_alloc);
890 wd = x2nrealloc (wd, &wd_alloc, sizeof *wd);
894 wd[wd_count].name = ".";
895 wd[wd_count].abspath = xgetcwd ();
896 wd[wd_count].fd = AT_FDCWD;
901 /* Optimize the common special case of the working directory,
902 or the working directory as a prefix. */
905 while (dir[0] == '.' && ISSLASH (dir[1]))
906 for (dir += 2; ISSLASH (*dir); dir++)
908 if (! dir[dir[0] == '.'])
912 wd[wd_count].name = dir;
913 /* if the given name is an absolute path, then use that path
914 to represent this working directory; otherwise, construct
915 a path based on the previous -C option's absolute path */
916 if (IS_ABSOLUTE_FILE_NAME (wd[wd_count].name))
917 wd[wd_count].abspath = xstrdup (wd[wd_count].name);
920 namebuf_t nbuf = namebuf_create (wd[wd_count - 1].abspath);
921 namebuf_add_dir (nbuf, wd[wd_count].name);
922 wd[wd_count].abspath = namebuf_finish (nbuf);
928 /* Index of current directory. */
931 /* Value suitable for use as the first argument to openat, and in
932 similar locations for fstatat, etc. This is an open file
933 descriptor, or AT_FDCWD if the working directory is current. It is
934 valid until the next invocation of chdir_do. */
935 int chdir_fd = AT_FDCWD;
937 /* Change to directory I, in a virtual way. This does not actually
938 invoke chdir; it merely sets chdir_fd to an int suitable as the
939 first argument for openat, etc. If I is 0, change to the initial
940 working directory; otherwise, I must be a value returned by
945 if (chdir_current != i)
947 struct wd *curr = &wd[i];
952 if (! IS_ABSOLUTE_FILE_NAME (curr->name))
954 fd = openat (chdir_fd, curr->name,
955 open_searchdir_flags & ~ O_NOFOLLOW);
957 open_fatal (curr->name);
961 /* Add I to the cache, tossing out the lowest-ranking entry if the
963 if (wdcache_count < CHDIR_CACHE_SIZE)
964 wdcache[wdcache_count++] = i;
967 struct wd *stale = &wd[wdcache[CHDIR_CACHE_SIZE - 1]];
968 if (close (stale->fd) != 0)
969 close_diag (stale->name);
971 wdcache[CHDIR_CACHE_SIZE - 1] = i;
977 /* Move the i value to the front of the cache. This is
978 O(CHDIR_CACHE_SIZE), but the cache is small. */
980 int prev = wdcache[0];
981 for (ci = 1; prev != i; ci++)
983 int cur = wdcache[ci];
1000 return wd[chdir_current].name;
1003 /* Return the absolute path that represents the working
1004 directory referenced by IDX.
1006 If wd is empty, then there were no -C options given, and
1007 chdir_args() has never been called, so we simply return the
1008 process's actual cwd. (Note that in this case IDX is ignored,
1009 since it should always be 0.) */
1011 tar_getcdpath (int idx)
1020 return wd[idx].abspath;
1024 close_diag (char const *name)
1026 if (ignore_failed_read_option)
1033 open_diag (char const *name)
1035 if (ignore_failed_read_option)
1042 read_diag_details (char const *name, off_t offset, size_t size)
1044 if (ignore_failed_read_option)
1045 read_warn_details (name, offset, size);
1047 read_error_details (name, offset, size);
1051 readlink_diag (char const *name)
1053 if (ignore_failed_read_option)
1054 readlink_warn (name);
1056 readlink_error (name);
1060 savedir_diag (char const *name)
1062 if (ignore_failed_read_option)
1063 savedir_warn (name);
1065 savedir_error (name);
1069 seek_diag_details (char const *name, off_t offset)
1071 if (ignore_failed_read_option)
1072 seek_warn_details (name, offset);
1074 seek_error_details (name, offset);
1078 stat_diag (char const *name)
1080 if (ignore_failed_read_option)
1087 file_removed_diag (const char *name, bool top_level,
1088 void (*diagfn) (char const *name))
1090 if (!top_level && errno == ENOENT)
1092 WARNOPT (WARN_FILE_REMOVED,
1093 (0, 0, _("%s: File removed before we read it"),
1094 quotearg_colon (name)));
1095 set_exit_status (TAREXIT_DIFFERS);
1102 write_fatal_details (char const *name, ssize_t status, size_t size)
1104 write_error_details (name, status, size);
1108 /* Fork, aborting if unsuccessful. */
1113 if (p == (pid_t) -1)
1114 call_arg_fatal ("fork", _("child process"));
1118 /* Create a pipe, aborting if unsuccessful. */
1123 call_arg_fatal ("pipe", _("interprocess channel"));
1126 /* Return PTR, aligned upward to the next multiple of ALIGNMENT.
1127 ALIGNMENT must be nonzero. The caller must arrange for ((char *)
1128 PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable
1131 static inline void *
1132 ptr_align (void *ptr, size_t alignment)
1135 char *p1 = p0 + alignment - 1;
1136 return p1 - (size_t) p1 % alignment;
1139 /* Return the address of a page-aligned buffer of at least SIZE bytes.
1140 The caller should free *PTR when done with the buffer. */
1143 page_aligned_alloc (void **ptr, size_t size)
1145 size_t alignment = getpagesize ();
1146 size_t size1 = size + alignment;
1149 *ptr = xmalloc (size1);
1150 return ptr_align (*ptr, alignment);
1157 char *buffer; /* directory, '/', and directory member */
1158 size_t buffer_size; /* allocated size of name_buffer */
1159 size_t dir_length; /* length of directory part in buffer */
1163 namebuf_create (const char *dir)
1165 namebuf_t buf = xmalloc (sizeof (*buf));
1166 buf->buffer_size = strlen (dir) + 2;
1167 buf->buffer = xmalloc (buf->buffer_size);
1168 strcpy (buf->buffer, dir);
1169 buf->dir_length = strlen (buf->buffer);
1170 if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
1171 buf->buffer[buf->dir_length++] = DIRECTORY_SEPARATOR;
1176 namebuf_free (namebuf_t buf)
1183 namebuf_name (namebuf_t buf, const char *name)
1185 size_t len = strlen (name);
1186 while (buf->dir_length + len + 1 >= buf->buffer_size)
1187 buf->buffer = x2realloc (buf->buffer, &buf->buffer_size);
1188 strcpy (buf->buffer + buf->dir_length, name);
1193 namebuf_add_dir (namebuf_t buf, const char *name)
1195 static char dirsep[] = { DIRECTORY_SEPARATOR, 0 };
1196 if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
1198 namebuf_name (buf, dirsep);
1201 namebuf_name (buf, name);
1202 buf->dir_length += strlen (name);
1206 namebuf_finish (namebuf_t buf)
1208 char *res = buf->buffer;
1210 if (ISSLASH (buf->buffer[buf->dir_length - 1]))
1211 buf->buffer[buf->dir_length] = 0;
1216 /* Return the filenames in directory NAME, relative to the chdir_fd.
1217 If the directory does not exist, report error if MUST_EXIST is
1220 Return NULL on errors.
1223 tar_savedir (const char *name, int must_exist)
1227 int fd = openat (chdir_fd, name, open_read_flags | O_DIRECTORY);
1230 if (!must_exist && errno == ENOENT)
1234 else if (! ((dir = fdopendir (fd))
1235 && (ret = streamsavedir (dir))))
1236 savedir_error (name);
1238 if (dir ? closedir (dir) != 0 : 0 <= fd && close (fd) != 0)
1239 savedir_error (name);