1 /* Miscellaneous functions, not really specific to GNU tar.
3 Copyright 1988, 1992, 1994-1997, 1999-2001, 2003-2007, 2009-2010,
4 2012-2014, 2016 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
32 static void namebuf_add_dir (namebuf_t, char const *);
33 static char *namebuf_finish (namebuf_t);
34 static const char *tar_getcdpath (int);
37 /* Handling strings. */
39 /* Assign STRING to a copy of VALUE if not zero, or to zero. If
40 STRING was nonzero, it is freed first. */
42 assign_string (char **string, const char *value)
45 *string = value ? xstrdup (value) : 0;
49 /* This function is currently unused; perhaps it should be removed? */
51 /* Allocate a copy of the string quoted as in C, and returns that. If
52 the string does not have to be quoted, it returns a null pointer.
53 The allocated copy should normally be freed with free() after the
54 caller is done with it.
56 This is used in one context only: generating the directory file in
57 incremental dumps. The quoted string is not intended for human
58 consumption; it is intended only for unquote_string. The quoting
59 is locale-independent, so that users needn't worry about locale
60 when reading directory files. This means that we can't use
61 quotearg, as quotearg is locale-dependent and is meant for human
64 quote_copy_string (const char *string)
66 const char *source = string;
67 char *destination = 0;
73 int character = *source++;
80 size_t length = (source - string) - 1;
83 buffer = xmalloc (length + 2 + 2 * strlen (source) + 1);
84 memcpy (buffer, string, length);
85 destination = buffer + length;
87 *destination++ = '\\';
88 *destination++ = character == '\\' ? '\\' : 'n';
93 *destination++ = character;
106 /* Takes a quoted C string (like those produced by quote_copy_string)
107 and turns it back into the un-quoted original. This is done in
108 place. Returns 0 only if the string was not properly quoted, but
109 completes the unquoting anyway.
111 This is used for reading the saved directory file in incremental
112 dumps. It is used for decoding old 'N' records (demangling names).
113 But also, it is used for decoding file arguments, would they come
114 from the shell or a -T file, and for decoding the --exclude
117 unquote_string (char *string)
120 char *source = string;
121 char *destination = string;
123 /* Escape sequences other than \\ and \n are no longer generated by
124 quote_copy_string, but accept them for backwards compatibility,
125 and also because unquote_string is used for purposes other than
126 parsing the output of quote_copy_string. */
133 *destination++ = '\\';
138 *destination++ = '\a';
143 *destination++ = '\b';
148 *destination++ = '\f';
153 *destination++ = '\n';
158 *destination++ = '\r';
163 *destination++ = '\t';
168 *destination++ = '\v';
173 *destination++ = 0177;
186 int value = *source++ - '0';
188 if (*source < '0' || *source > '7')
190 *destination++ = value;
193 value = value * 8 + *source++ - '0';
194 if (*source < '0' || *source > '7')
196 *destination++ = value;
199 value = value * 8 + *source++ - '0';
200 *destination++ = value;
206 *destination++ = '\\';
208 *destination++ = *source++;
211 else if (source != destination)
212 *destination++ = *source++;
214 source++, destination++;
216 if (source != destination)
221 /* Zap trailing slashes. */
223 zap_slashes (char *name)
227 if (!name || *name == 0)
229 q = name + strlen (name) - 1;
230 while (q > name && ISSLASH (*q))
235 /* Normalize FILE_NAME by removing redundant slashes and "."
236 components, including redundant trailing slashes.
237 Leave ".." alone, as it may be significant in the presence
238 of symlinks and on platforms where "/.." != "/".
240 Destructive version: modifies its argument. */
242 normalize_filename_x (char *file_name)
244 char *name = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
249 /* Don't squeeze leading "//" to "/", on hosts where they're distinct. */
250 name += (DOUBLE_SLASH_IS_DISTINCT_ROOT
251 && ISSLASH (*name) && ISSLASH (name[1]) && ! ISSLASH (name[2]));
253 /* Omit redundant leading "." components. */
254 for (q = p = name; (*p = *q) == '.' && ISSLASH (q[1]); p += !*q)
255 for (q += 2; ISSLASH (*q); q++)
258 /* Copy components from Q to P, omitting redundant slashes and
259 internal "." components. */
260 while ((*p++ = c = *q++) != '\0')
262 while (ISSLASH (q[*q == '.']))
263 q += (*q == '.') + 1;
265 /* Omit redundant trailing "." component and slash. */
268 p -= p[-2] == '.' && ISSLASH (p[-3]);
269 p -= 2 < p - name && ISSLASH (p[-2]);
274 /* Normalize NAME by removing redundant slashes and "." components,
275 including redundant trailing slashes.
277 Return a normalized newly-allocated copy. */
280 normalize_filename (int cdidx, const char *name)
284 if (IS_RELATIVE_FILE_NAME (name))
286 /* Set COPY to the absolute path for this name.
288 FIXME: There should be no need to get the absolute file name.
289 tar_getcdpath does not return a true "canonical" path, so
290 this following approach may lead to situations where the same
291 file or directory is processed twice under different absolute
292 paths without that duplication being detected. Perhaps we
293 should use dev+ino pairs instead of names? (See listed03.at for
294 a related test case.) */
295 const char *cdpath = tar_getcdpath (cdidx);
300 call_arg_fatal ("getcwd", ".");
301 copylen = strlen (cdpath);
302 need_separator = ! (DOUBLE_SLASH_IS_DISTINCT_ROOT
303 && copylen == 2 && ISSLASH (cdpath[1]));
304 copy = xmalloc (copylen + need_separator + strlen (name) + 1);
305 strcpy (copy, cdpath);
306 copy[copylen] = DIRECTORY_SEPARATOR;
307 strcpy (copy + copylen + need_separator, name);
311 copy = xstrdup (name);
312 normalize_filename_x (copy);
318 replace_prefix (char **pname, const char *samp, size_t slen,
319 const char *repl, size_t rlen)
322 size_t nlen = strlen (name);
323 if (nlen > slen && memcmp (name, samp, slen) == 0 && ISSLASH (name[slen]))
327 name = xrealloc (name, nlen - slen + rlen + 1);
330 memmove (name + rlen, name + slen, nlen - slen + 1);
331 memcpy (name, repl, rlen);
336 /* Handling numbers. */
338 /* Convert VALUE, which is converted from a system integer type whose
339 minimum value is MINVAL and maximum MINVAL, to an decimal
340 integer string. Use the storage in BUF and return a pointer to the
341 converted string. If VALUE is converted from a negative integer in
342 the range MINVAL .. -1, represent it with a string representation
343 of the negative integer, using leading '-'. */
344 #if ! (INTMAX_MAX <= UINTMAX_MAX / 2)
345 # error "sysinttostr: uintmax_t cannot represent all intmax_t values"
348 sysinttostr (uintmax_t value, intmax_t minval, uintmax_t maxval,
349 char buf[SYSINT_BUFSIZE])
352 return umaxtostr (value, buf);
355 intmax_t i = value - minval;
356 return imaxtostr (i + minval, buf);
360 /* Convert a prefix of the string ARG to a system integer type whose
361 minimum value is MINVAL and maximum MAXVAL. If MINVAL is negative,
362 negative integers MINVAL .. -1 are assumed to be represented using
363 leading '-' in the usual way. If the represented value exceeds
364 INTMAX_MAX, return a negative integer V such that (uintmax_t) V
365 yields the represented value. If ARGLIM is nonnull, store into
366 *ARGLIM a pointer to the first character after the prefix.
368 This is the inverse of sysinttostr.
370 On a normal return, set errno = 0.
371 On conversion error, return 0 and set errno = EINVAL.
372 On overflow, return an extreme value and set errno = ERANGE. */
373 #if ! (INTMAX_MAX <= UINTMAX_MAX)
374 # error "strtosysint: nonnegative intmax_t does not fit in uintmax_t"
377 strtosysint (char const *arg, char **arglim, intmax_t minval, uintmax_t maxval)
380 if (maxval <= INTMAX_MAX)
382 if (ISDIGIT (arg[*arg == '-']))
384 intmax_t i = strtoimax (arg, arglim, 10);
385 intmax_t imaxval = maxval;
386 if (minval <= i && i <= imaxval)
389 return i < minval ? minval : maxval;
396 uintmax_t i = strtoumax (arg, arglim, 10);
398 return represent_uintmax (i);
408 /* Output fraction and trailing digits appropriate for a nanoseconds
409 count equal to NS, but don't output unnecessary '.' or trailing
413 code_ns_fraction (int ns, char *p)
432 p[--i] = '0' + ns % 10;
441 code_timespec (struct timespec t, char sbuf[TIMESPEC_STRSIZE_BOUND])
446 bool negative = s < 0;
448 /* ignore invalid values of ns */
449 if (BILLION <= ns || ns < 0)
452 if (negative && ns != 0)
458 np = umaxtostr (negative ? - (uintmax_t) s : (uintmax_t) s, sbuf + 1);
461 code_ns_fraction (ns, sbuf + UINTMAX_STRSIZE_BOUND);
466 decode_timespec (char const *arg, char **arg_lim, bool parse_fraction)
468 time_t s = TYPE_MINIMUM (time_t);
471 bool negative = *arg == '-';
474 if (! ISDIGIT (arg[negative]))
482 intmax_t i = strtoimax (arg, arg_lim, 10);
483 if (TYPE_SIGNED (time_t) ? TYPE_MINIMUM (time_t) <= i : 0 <= i)
490 uintmax_t i = strtoumax (arg, arg_lim, 10);
491 if (i <= TYPE_MAXIMUM (time_t))
500 if (parse_fraction && *p == '.')
503 bool trailing_nonzero = false;
505 while (ISDIGIT (*++p))
506 if (digits < LOG10_BILLION)
507 digits++, ns = 10 * ns + (*p - '0');
509 trailing_nonzero |= *p != '0';
511 while (digits < LOG10_BILLION)
516 /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
517 I.e., truncate time stamps towards minus infinity while
518 converting them to internal form. */
519 ns += trailing_nonzero;
522 if (s == TYPE_MINIMUM (time_t))
537 *arg_lim = (char *) p;
545 /* Saved names in case backup needs to be undone. */
546 static char *before_backup_name;
547 static char *after_backup_name;
549 /* Return 1 if FILE_NAME is obviously "." or "/". */
551 must_be_dot_or_slash (char const *file_name)
553 file_name += FILE_SYSTEM_PREFIX_LEN (file_name);
555 if (ISSLASH (file_name[0]))
558 if (ISSLASH (file_name[1]))
560 else if (file_name[1] == '.'
561 && ISSLASH (file_name[2 + (file_name[2] == '.')]))
562 file_name += 2 + (file_name[2] == '.');
564 return ! file_name[1];
568 while (file_name[0] == '.' && ISSLASH (file_name[1]))
571 while (ISSLASH (*file_name))
575 return ! file_name[0] || (file_name[0] == '.' && ! file_name[1]);
579 /* Some implementations of rmdir let you remove '.' or '/'.
580 Report an error with errno set to zero for obvious cases of this;
581 otherwise call rmdir. */
583 safer_rmdir (const char *file_name)
585 if (must_be_dot_or_slash (file_name))
591 if (unlinkat (chdir_fd, file_name, AT_REMOVEDIR) == 0)
593 remove_delayed_set_stat (file_name);
599 /* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory,
600 then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
601 recursively; otherwise, remove it only if it is empty. If FILE_NAME is
602 a directory that cannot be removed (e.g., because it is nonempty)
603 and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
604 Return 0 on error, with errno set; if FILE_NAME is obviously the working
605 directory return zero with errno set to zero. */
607 remove_any_file (const char *file_name, enum remove_option option)
609 /* Try unlink first if we cannot unlink directories, as this saves
610 us a system call in the common case where we're removing a
612 bool try_unlink_first = cannot_unlink_dir ();
614 if (try_unlink_first)
616 if (unlinkat (chdir_fd, file_name, 0) == 0)
619 /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
620 directory without appropriate privileges, but many Linux
621 kernels return the more-sensible EISDIR. */
622 if (errno != EPERM && errno != EISDIR)
626 if (safer_rmdir (file_name) == 0)
632 return !try_unlink_first && unlinkat (chdir_fd, file_name, 0) == 0;
636 #if defined ENOTEMPTY && ENOTEMPTY != EEXIST
641 case ORDINARY_REMOVE_OPTION:
644 case WANT_DIRECTORY_REMOVE_OPTION:
647 case RECURSIVE_REMOVE_OPTION:
649 char *directory = tar_savedir (file_name, 0);
656 for (entry = directory;
657 (entrylen = strlen (entry)) != 0;
658 entry += entrylen + 1)
660 char *file_name_buffer = make_file_name (file_name, entry);
661 int r = remove_any_file (file_name_buffer,
662 RECURSIVE_REMOVE_OPTION);
664 free (file_name_buffer);
675 return safer_rmdir (file_name) == 0;
684 /* Check if FILE_NAME already exists and make a backup of it right now.
685 Return success (nonzero) only if the backup is either unneeded, or
686 successful. For now, directories are considered to never need
687 backup. If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
688 so, we do not have to backup block or character devices, nor remote
691 maybe_backup_file (const char *file_name, bool this_is_the_archive)
693 struct stat file_stat;
695 assign_string (&before_backup_name, file_name);
697 /* A run situation may exist between Emacs or other GNU programs trying to
698 make a backup for the same file simultaneously. If theoretically
699 possible, real problems are unlikely. Doing any better would require a
700 convention, GNU-wide, for all programs doing backups. */
702 assign_string (&after_backup_name, 0);
704 /* Check if we really need to backup the file. */
706 if (this_is_the_archive && _remdev (file_name))
709 if (deref_stat (file_name, &file_stat) != 0)
714 stat_error (file_name);
718 if (S_ISDIR (file_stat.st_mode))
721 if (this_is_the_archive
722 && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
725 after_backup_name = find_backup_file_name (file_name, backup_type);
726 if (! after_backup_name)
729 if (renameat (chdir_fd, before_backup_name, chdir_fd, after_backup_name)
733 fprintf (stdlis, _("Renaming %s to %s\n"),
734 quote_n (0, before_backup_name),
735 quote_n (1, after_backup_name));
740 /* The backup operation failed. */
742 ERROR ((0, e, _("%s: Cannot rename to %s"),
743 quotearg_colon (before_backup_name),
744 quote_n (1, after_backup_name)));
745 assign_string (&after_backup_name, 0);
750 /* Try to restore the recently backed up file to its original name.
751 This is usually only needed after a failed extraction. */
753 undo_last_backup (void)
755 if (after_backup_name)
757 if (renameat (chdir_fd, after_backup_name, chdir_fd, before_backup_name)
761 ERROR ((0, e, _("%s: Cannot rename to %s"),
762 quotearg_colon (after_backup_name),
763 quote_n (1, before_backup_name)));
766 fprintf (stdlis, _("Renaming %s back to %s\n"),
767 quote_n (0, after_backup_name),
768 quote_n (1, before_backup_name));
769 assign_string (&after_backup_name, 0);
773 /* Apply either stat or lstat to (NAME, BUF), depending on the
774 presence of the --dereference option. NAME is relative to the
775 most-recent argument to chdir_do. */
777 deref_stat (char const *name, struct stat *buf)
779 return fstatat (chdir_fd, name, buf, fstatat_flags);
782 /* Read from FD into the buffer BUF with COUNT bytes. Attempt to fill
783 BUF. Wait until input is available; this matters because files are
784 opened O_NONBLOCK for security reasons, and on some file systems
785 this can cause read to fail with errno == EAGAIN. Return the
786 actual number of bytes read, zero for EOF, or
787 SAFE_READ_ERROR upon error. */
789 blocking_read (int fd, void *buf, size_t count)
791 size_t bytes = safe_read (fd, buf, count);
793 #if defined F_SETFL && O_NONBLOCK
794 if (bytes == SAFE_READ_ERROR && errno == EAGAIN)
796 int flags = fcntl (fd, F_GETFL);
797 if (0 <= flags && flags & O_NONBLOCK
798 && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
799 bytes = safe_read (fd, buf, count);
806 /* Write to FD from the buffer BUF with COUNT bytes. Do a full write.
807 Wait until an output buffer is available; this matters because
808 files are opened O_NONBLOCK for security reasons, and on some file
809 systems this can cause write to fail with errno == EAGAIN. Return
810 the actual number of bytes written, setting errno if that is less
813 blocking_write (int fd, void const *buf, size_t count)
815 size_t bytes = full_write (fd, buf, count);
817 #if defined F_SETFL && O_NONBLOCK
818 if (bytes < count && errno == EAGAIN)
820 int flags = fcntl (fd, F_GETFL);
821 if (0 <= flags && flags & O_NONBLOCK
822 && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
824 char const *buffer = buf;
825 bytes += full_write (fd, buffer + bytes, count - bytes);
833 /* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's)
834 access time to ATIME. */
836 set_file_atime (int fd, int parentfd, char const *file, struct timespec atime)
838 struct timespec ts[2];
840 ts[1].tv_nsec = UTIME_OMIT;
841 return fdutimensat (fd, parentfd, file, ts, fstatat_flags);
844 /* A description of a working directory. */
847 /* The directory's name. */
849 /* "Absolute" path representing this directory; in the contrast to
850 the real absolute pathname, it can contain /../ components (see
851 normalize_filename_x for the reason of it). It is NULL if the
852 absolute path could not be determined. */
854 /* If nonzero, the file descriptor of the directory, or AT_FDCWD if
855 the working directory. If zero, the directory needs to be opened
860 /* A vector of chdir targets. wd[0] is the initial working directory. */
861 static struct wd *wd;
863 /* The number of working directories in the vector. */
864 static size_t wd_count;
866 /* The allocated size of the vector. */
867 static size_t wd_alloc;
869 /* The maximum number of chdir targets with open directories.
870 Don't make it too large, as many operating systems have a small
871 limit on the number of open file descriptors. Also, the current
872 implementation does not scale well. */
873 enum { CHDIR_CACHE_SIZE = 16 };
875 /* Indexes into WD of chdir targets with open file descriptors, sorted
876 most-recently used first. Zero indexes are unused. */
877 static int wdcache[CHDIR_CACHE_SIZE];
879 /* Number of nonzero entries in WDCACHE. */
880 static size_t wdcache_count;
890 /* DIR is the operand of a -C option; add it to vector of chdir targets,
891 and return the index of its location. */
893 chdir_arg (char const *dir)
897 if (wd_count == wd_alloc)
901 wd = x2nrealloc (wd, &wd_alloc, sizeof *wd);
905 wd[wd_count].name = ".";
906 wd[wd_count].abspath = xgetcwd ();
907 wd[wd_count].fd = AT_FDCWD;
912 /* Optimize the common special case of the working directory,
913 or the working directory as a prefix. */
916 while (dir[0] == '.' && ISSLASH (dir[1]))
917 for (dir += 2; ISSLASH (*dir); dir++)
919 if (! dir[dir[0] == '.'])
924 /* If the given name is absolute, use it to represent this directory;
925 otherwise, construct a name based on the previous -C option. */
926 if (IS_ABSOLUTE_FILE_NAME (dir))
927 absdir = xstrdup (dir);
928 else if (wd[wd_count - 1].abspath)
930 namebuf_t nbuf = namebuf_create (wd[wd_count - 1].abspath);
931 namebuf_add_dir (nbuf, dir);
932 absdir = namebuf_finish (nbuf);
937 wd[wd_count].name = dir;
938 wd[wd_count].abspath = absdir;
943 /* Index of current directory. */
946 /* Value suitable for use as the first argument to openat, and in
947 similar locations for fstatat, etc. This is an open file
948 descriptor, or AT_FDCWD if the working directory is current. It is
949 valid until the next invocation of chdir_do. */
950 int chdir_fd = AT_FDCWD;
952 /* Change to directory I, in a virtual way. This does not actually
953 invoke chdir; it merely sets chdir_fd to an int suitable as the
954 first argument for openat, etc. If I is 0, change to the initial
955 working directory; otherwise, I must be a value returned by
960 if (chdir_current != i)
962 struct wd *curr = &wd[i];
967 if (! IS_ABSOLUTE_FILE_NAME (curr->name))
969 fd = openat (chdir_fd, curr->name,
970 open_searchdir_flags & ~ O_NOFOLLOW);
972 open_fatal (curr->name);
976 /* Add I to the cache, tossing out the lowest-ranking entry if the
978 if (wdcache_count < CHDIR_CACHE_SIZE)
979 wdcache[wdcache_count++] = i;
982 struct wd *stale = &wd[wdcache[CHDIR_CACHE_SIZE - 1]];
983 if (close (stale->fd) != 0)
984 close_diag (stale->name);
986 wdcache[CHDIR_CACHE_SIZE - 1] = i;
992 /* Move the i value to the front of the cache. This is
993 O(CHDIR_CACHE_SIZE), but the cache is small. */
995 int prev = wdcache[0];
996 for (ci = 1; prev != i; ci++)
998 int cur = wdcache[ci];
1015 return wd[chdir_current].name;
1018 /* Return the absolute path that represents the working
1019 directory referenced by IDX.
1021 If wd is empty, then there were no -C options given, and
1022 chdir_args() has never been called, so we simply return the
1023 process's actual cwd. (Note that in this case IDX is ignored,
1024 since it should always be 0.) */
1026 tar_getcdpath (int idx)
1035 return wd[idx].abspath;
1039 close_diag (char const *name)
1041 if (ignore_failed_read_option)
1048 open_diag (char const *name)
1050 if (ignore_failed_read_option)
1057 read_diag_details (char const *name, off_t offset, size_t size)
1059 if (ignore_failed_read_option)
1060 read_warn_details (name, offset, size);
1062 read_error_details (name, offset, size);
1066 readlink_diag (char const *name)
1068 if (ignore_failed_read_option)
1069 readlink_warn (name);
1071 readlink_error (name);
1075 savedir_diag (char const *name)
1077 if (ignore_failed_read_option)
1078 savedir_warn (name);
1080 savedir_error (name);
1084 seek_diag_details (char const *name, off_t offset)
1086 if (ignore_failed_read_option)
1087 seek_warn_details (name, offset);
1089 seek_error_details (name, offset);
1093 stat_diag (char const *name)
1095 if (ignore_failed_read_option)
1102 file_removed_diag (const char *name, bool top_level,
1103 void (*diagfn) (char const *name))
1105 if (!top_level && errno == ENOENT)
1107 WARNOPT (WARN_FILE_REMOVED,
1108 (0, 0, _("%s: File removed before we read it"),
1109 quotearg_colon (name)));
1110 set_exit_status (TAREXIT_DIFFERS);
1116 /* Fork, aborting if unsuccessful. */
1121 if (p == (pid_t) -1)
1122 call_arg_fatal ("fork", _("child process"));
1126 /* Create a pipe, aborting if unsuccessful. */
1131 call_arg_fatal ("pipe", _("interprocess channel"));
1134 /* Return PTR, aligned upward to the next multiple of ALIGNMENT.
1135 ALIGNMENT must be nonzero. The caller must arrange for ((char *)
1136 PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable
1139 static inline void *
1140 ptr_align (void *ptr, size_t alignment)
1143 char *p1 = p0 + alignment - 1;
1144 return p1 - (size_t) p1 % alignment;
1147 /* Return the address of a page-aligned buffer of at least SIZE bytes.
1148 The caller should free *PTR when done with the buffer. */
1151 page_aligned_alloc (void **ptr, size_t size)
1153 size_t alignment = getpagesize ();
1154 size_t size1 = size + alignment;
1157 *ptr = xmalloc (size1);
1158 return ptr_align (*ptr, alignment);
1165 char *buffer; /* directory, '/', and directory member */
1166 size_t buffer_size; /* allocated size of name_buffer */
1167 size_t dir_length; /* length of directory part in buffer */
1171 namebuf_create (const char *dir)
1173 namebuf_t buf = xmalloc (sizeof (*buf));
1174 buf->buffer_size = strlen (dir) + 2;
1175 buf->buffer = xmalloc (buf->buffer_size);
1176 strcpy (buf->buffer, dir);
1177 buf->dir_length = strlen (buf->buffer);
1178 if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
1179 buf->buffer[buf->dir_length++] = DIRECTORY_SEPARATOR;
1184 namebuf_free (namebuf_t buf)
1191 namebuf_name (namebuf_t buf, const char *name)
1193 size_t len = strlen (name);
1194 while (buf->dir_length + len + 1 >= buf->buffer_size)
1195 buf->buffer = x2realloc (buf->buffer, &buf->buffer_size);
1196 strcpy (buf->buffer + buf->dir_length, name);
1201 namebuf_add_dir (namebuf_t buf, const char *name)
1203 static char dirsep[] = { DIRECTORY_SEPARATOR, 0 };
1204 if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
1206 namebuf_name (buf, dirsep);
1209 namebuf_name (buf, name);
1210 buf->dir_length += strlen (name);
1214 namebuf_finish (namebuf_t buf)
1216 char *res = buf->buffer;
1218 if (ISSLASH (buf->buffer[buf->dir_length - 1]))
1219 buf->buffer[buf->dir_length] = 0;
1224 /* Return the filenames in directory NAME, relative to the chdir_fd.
1225 If the directory does not exist, report error if MUST_EXIST is
1228 Return NULL on errors.
1231 tar_savedir (const char *name, int must_exist)
1235 int fd = openat (chdir_fd, name, open_read_flags | O_DIRECTORY);
1238 if (!must_exist && errno == ENOENT)
1242 else if (! ((dir = fdopendir (fd))
1243 && (ret = streamsavedir (dir, savedir_sort_order))))
1244 savedir_error (name);
1246 if (dir ? closedir (dir) != 0 : 0 <= fd && close (fd) != 0)
1247 savedir_error (name);