char *
get_directory_contents (char *path, dev_t device)
{
struct accumulator *accumulator;
/* Recursively scan the given PATH. */
{
DIR *dirp = opendir (path); /* for scanning directory */
struct dirent *entry; /* directory entry being scanned */
char *name_buffer; /* directory, `/', and directory member */
size_t name_buffer_size; /* allocated size of name_buffer, minus 2 */
size_t name_length; /* used length in name_buffer */
struct directory *directory; /* for checking if already already seen */
bool all_children;
if (dirp == NULL)
{
ERROR ((0, errno, _("Cannot open directory %s"), path));
return NULL;
}
errno = 0; /* FIXME: errno should be read-only */
name_buffer_size = strlen (path) + NAME_FIELD_SIZE;
name_buffer = xmalloc (name_buffer_size + 2);
strcpy (name_buffer, path);
if (path[strlen (path) - 1] != '/')
strcat (name_buffer, "/");
name_length = strlen (name_buffer);
directory = find_directory (path);
all_children = directory ? directory->all_new : false;
accumulator = new_accumulator ();
while (entry = readdir (dirp), entry)
{
struct stat stat_info;
/* Skip `.' and `..'. */
if (is_dot_or_dotdot (entry->d_name))
continue;
if (NAMLEN (entry) + name_length >= name_buffer_size)
{
while (NAMLEN (entry) + name_length >= name_buffer_size)
name_buffer_size += NAME_FIELD_SIZE;
name_buffer = (char *)
xrealloc (name_buffer, name_buffer_size + 2);
}
strcpy (name_buffer + name_length, entry->d_name);
if (dereference_option
#ifdef AIX
? statx (name_buffer, &stat_info, STATSIZE, STX_HIDDEN)
: statx (name_buffer, &stat_info, STATSIZE, STX_HIDDEN | STX_LINK)
#else
? stat (name_buffer, &stat_info)
: lstat (name_buffer, &stat_info)
#endif
)
{
ERROR ((0, errno, _("Cannot stat %s"), name_buffer));
continue;
}
if ((one_file_system_option && device != stat_info.st_dev)
|| (exclude_option && check_exclude (name_buffer)))
add_to_accumulator (accumulator, "N", (size_t) 1);
#ifdef AIX
else if (S_ISHIDDEN (stat_info.st_mode))
{
add_to_accumulator (accumulator, "D", (size_t) 1);
strcat (entry->d_name, "A");
entry->d_namlen++;
}
#endif
else if (S_ISDIR (stat_info.st_mode))
{
if (directory = find_directory (name_buffer), directory)
{
/* The same file can have two different devices if an NFS
directory is mounted in multiple locations, which is
relatively common when automounting. For avoiding
spurious incremental redumping of directories, we have to
plainly consider all NFS devices as equal, relying on the
i-node only to establish differences.
Devices having the high bit set usually are NFS devices. */
/* FIXME: Göran Uddeborg <*****@*****.**> says, on
1996-09-20, that SunOS 5/Solaris 2 uses unsigned long for
the device number type. */
if ((((short) directory->device_number >= 0
|| (short) stat_info.st_dev >= 0)
&& directory->device_number != stat_info.st_dev)
|| directory->inode_number != stat_info.st_ino)
{
if (verbose_option)
WARN ((0, 0, _("Directory %s has been renamed"),
name_buffer));
directory->all_new = true;
directory->device_number = stat_info.st_dev;
directory->inode_number = stat_info.st_ino;
}
directory->dir_text = "";
}
else
{
if (verbose_option)
WARN ((0, 0, _("Directory %s is new"), name_buffer));
note_directory (name_buffer,
stat_info.st_dev, stat_info.st_ino, "");
directory = find_directory (name_buffer);
directory->all_new = true;
}
if (all_children && directory)
directory->all_new = true;
add_to_accumulator (accumulator, "D", (size_t) 1);
}
else
if (all_children || FILE_IS_NEW_ENOUGH (&stat_info))
add_to_accumulator (accumulator, "Y", (size_t) 1);
else
add_to_accumulator (accumulator, "N", (size_t) 1);
add_to_accumulator (accumulator, entry->d_name, NAMLEN (entry) + 1);
}
add_to_accumulator (accumulator, "\000\000", (size_t) 2);
free (name_buffer);
closedir (dirp);
}
/* Sort the contents of the directory, now that we have it all. */
{
char *pointer = get_accumulator (accumulator);
size_t counter;
char *cursor;
char *buffer;
char **array;
char **array_cursor;
counter = 0;
for (cursor = pointer; *cursor; cursor += strlen (cursor) + 1)
counter++;
if (counter == 0)
{
delete_accumulator (accumulator);
return NULL;
}
array = (char **) xmalloc (sizeof (char *) * (counter + 1));
array_cursor = array;
for (cursor = pointer; *cursor; cursor += strlen (cursor) + 1)
*array_cursor++ = cursor;
*array_cursor = NULL;
qsort ((voidstar) array, counter, sizeof (char *), compare_dirents);
buffer = (char *) xmalloc ((size_t) (cursor - pointer + 2));
cursor = buffer;
for (array_cursor = array; *array_cursor; array_cursor++)
{
char *string = *array_cursor;
while ((*cursor++ = *string++))
continue;
}
*cursor = '\0';
delete_accumulator (accumulator);
free (array);
return buffer;
}
}
void
read_and (void (*do_something) ())
{
enum read_header status = HEADER_STILL_UNREAD;
enum read_header prev_status;
char save_typeflag;
name_gather ();
open_archive (ACCESS_READ);
while (1)
{
prev_status = status;
status = read_header ();
switch (status)
{
case HEADER_STILL_UNREAD:
abort ();
case HEADER_SUCCESS:
/* Valid header. We should decode next field (mode) first.
Ensure incoming names are null terminated. */
/* FIXME: This is a quick kludge before 1.12 goes out. */
current_stat.st_mtime
= from_oct (1 + 12, current_header->header.mtime);
if (!name_match (current_file_name)
|| current_stat.st_mtime < newer_mtime_option
|| (exclude_option && check_exclude (current_file_name)))
{
int isextended = 0;
if (current_header->header.typeflag == GNUTYPE_VOLHDR
|| current_header->header.typeflag == GNUTYPE_MULTIVOL
|| current_header->header.typeflag == GNUTYPE_NAMES)
{
(*do_something) ();
continue;
}
if (show_omitted_dirs_option
&& current_header->header.typeflag == DIRTYPE)
WARN ((0, 0, _("Omitting %s"), current_file_name));
/* Skip past it in the archive. */
if (current_header->oldgnu_header.isextended)
isextended = 1;
save_typeflag = current_header->header.typeflag;
set_next_block_after (current_header);
if (isextended)
{
#if 0
union block *exhdr;
while (1)
{
exhdr = find_next_block ();
if (!exhdr->sparse_header.isextended)
{
set_next_block_after (exhdr);
break;
}
}
set_next_block_after (exhdr);
#endif
skip_extended_headers ();
}
/* Skip to the next header on the archive. */
if (save_typeflag != DIRTYPE)
skip_file ((long long) current_stat.st_size);
continue;
}
(*do_something) ();
continue;
case HEADER_ZERO_BLOCK:
if (block_number_option)
fprintf (stdlis, _("block %10ld: ** Block of NULs **\n"),
current_block_ordinal ());
set_next_block_after (current_header);
status = prev_status;
if (ignore_zeros_option)
continue;
break;
case HEADER_END_OF_FILE:
if (block_number_option)
fprintf (stdlis, _("block %10ld: ** End of File **\n"),
current_block_ordinal ());
break;
case HEADER_FAILURE:
/* If the previous header was good, tell them that we are
skipping bad ones. */
set_next_block_after (current_header);
switch (prev_status)
{
case HEADER_STILL_UNREAD:
WARN ((0, 0, _("Could not extract file(s); file might not be a tar archive")));
/* Fall through. */
case HEADER_ZERO_BLOCK:
case HEADER_SUCCESS:
WARN ((0, 0, _("Skipping to next file header")));
break;
case HEADER_END_OF_FILE:
case HEADER_FAILURE:
/* We are in the middle of a cascade of errors. */
break;
}
continue;
}
break;
}
apply_delayed_set_stat ();
close_archive ();
names_notfound (); /* print names not found */
}