vasilito
068a1ca63e
Bootloader fork rebase:
- Base changed from 0.1.0 pre-patched archive to upstream 1.0.0 tag (c7eeb9f)
- Applied 0001-redbear-local-forks.patch (Cargo.toml crate path redirects)
- Applied fix-uefi-alloc-panic.patch equivalents (4 panic!() -> graceful
error handling in src/main.rs)
- Applied P5-live-preload-cap-1gib.patch (1 GiB cap on live image preload)
- Skipped: P0 GPT partition scan (requires new module + integration),
P1 timeout/default-resolution, P2 live preload guard (subsumed by
panic fixes + cap), P3 live image safe read, P4 large ISO boot,
redox.patch — to be applied in dedicated rebase session.
firmware-loader/Cargo.toml: version 0.1.0 -> 0.3.0 (sync with other
Red Bear custom crates which are at 0.3.0).
fork-upstream-map.toml: bootloader back from PENDING_REBASE to 1.0.0
since the partial rebase matches upstream 1.0.0 content.
fork-upstream-map.toml: base restored to 'main' tracked (was correctly
tracked by build-redbear.sh).
377 lines
11 KiB
C
377 lines
11 KiB
C
/* Read, sort and compare two directories. Used for GNU DIFF.
|
|
|
|
Copyright (C) 1988-1989, 1992-1995, 1998, 2001-2002, 2004, 2006-2007,
|
|
2009-2013, 2015-2025 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU DIFF.
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "diff.h"
|
|
|
|
#include <diagnose.h>
|
|
#include <dirname.h>
|
|
#include <error.h>
|
|
#include <exclude.h>
|
|
#include <filenamecat.h>
|
|
#include <mcel.h>
|
|
#include <quote.h>
|
|
#include <setjmp.h>
|
|
#include <xalloc.h>
|
|
|
|
#ifndef HAVE_STRUCT_DIRENT_D_TYPE
|
|
# define HAVE_STRUCT_DIRENT_D_TYPE false
|
|
#endif
|
|
|
|
/* A sorted vector of file names obtained by reading a directory.
|
|
If HAVE_STRUCT_DIRENT_D_TYPE, each name is preceded by a byte
|
|
giving the file type as an enum detype value. */
|
|
|
|
struct dirdata
|
|
{
|
|
idx_t nnames; /* Number of names. */
|
|
char const **names; /* Sorted names of files in dir, followed by 0. */
|
|
char *data; /* Allocated storage for file names. */
|
|
};
|
|
|
|
/* Whether file names in directories should be compared with
|
|
locale-specific sorting. */
|
|
static bool locale_specific_sorting;
|
|
|
|
/* Where to go if locale-specific sorting fails. */
|
|
static jmp_buf failed_locale_specific_sorting;
|
|
|
|
static int compare_names (char const *, char const *);
|
|
static bool dir_loop (struct comparison const *, int);
|
|
|
|
|
|
/* Given the parent directory PARENTDIRFD (negative for current dir),
|
|
read the directory named by DIR and store into DIRDATA a sorted
|
|
vector of filenames for its contents.
|
|
Use DIR's basename if PARENTDIRFD is nonnegative, for efficiency.
|
|
If DIR->desc == NONEXISTENT, this directory is known to be
|
|
nonexistent so set DIRDATA to an empty vector;
|
|
otherwise, update DIR->desc and DIR->dirstream as needed.
|
|
If STARTFILE, ignore directory entries less than STARTFILE, and if
|
|
STARTFILE_ONLY, also ignore directory entries greater than STARTFILE.
|
|
Return true if successful, false (setting errno) otherwise. */
|
|
|
|
static bool
|
|
dir_read (int parentdirfd, struct file_data *dir, struct dirdata *dirdata,
|
|
char const *startfile, bool startfile_only)
|
|
{
|
|
/* Number of files in directory. */
|
|
idx_t nnames = 0;
|
|
|
|
/* Allocated and used storage for file name data. */
|
|
char *data;
|
|
|
|
dirdata->names = nullptr;
|
|
dirdata->data = nullptr;
|
|
|
|
if (dir->desc != NONEXISTENT)
|
|
{
|
|
/* Open the directory and check for errors. */
|
|
int dirfd = dir->desc;
|
|
if (dirfd < 0)
|
|
{
|
|
dirfd = openat (parentdirfd,
|
|
(parentdirfd < 0 ? dir->name
|
|
: last_component (dir->name)),
|
|
(O_RDONLY | O_CLOEXEC | O_DIRECTORY
|
|
| (no_dereference_symlinks ? O_NOFOLLOW : 0)));
|
|
if (dirfd < 0)
|
|
return false;
|
|
dir->desc = dirfd;
|
|
}
|
|
DIR *reading = fdopendir (dirfd);
|
|
if (!reading)
|
|
return false;
|
|
dir->dirstream = reading;
|
|
|
|
/* Initialize the table of filenames. */
|
|
|
|
idx_t data_alloc = 512;
|
|
idx_t data_used = 0;
|
|
dirdata->data = data = ximalloc (data_alloc);
|
|
|
|
/* Read the directory entries, and insert the subfiles
|
|
into the 'data' table. */
|
|
|
|
while (true)
|
|
{
|
|
errno = 0;
|
|
struct dirent *next = readdir (reading);
|
|
if (!next)
|
|
break;
|
|
|
|
char *d_name = next->d_name;
|
|
|
|
/* Ignore "." and "..". */
|
|
if (d_name[0] == '.'
|
|
&& (d_name[1] == 0 || (d_name[1] == '.' && d_name[2] == 0)))
|
|
continue;
|
|
|
|
if (startfile)
|
|
{
|
|
int cmp = compare_names (d_name, startfile);
|
|
if (cmp < 0 || (startfile_only && !!cmp))
|
|
continue;
|
|
}
|
|
|
|
if (excluded_file_name (excluded, d_name))
|
|
continue;
|
|
|
|
idx_t d_size = HAVE_STRUCT_DIRENT_D_TYPE + _D_EXACT_NAMLEN (next) + 1;
|
|
if (data_alloc - data_used < d_size)
|
|
dirdata->data = data
|
|
= xpalloc (data, &data_alloc,
|
|
d_size - (data_alloc - data_used), -1, 1);
|
|
#if HAVE_STRUCT_DIRENT_D_TYPE
|
|
char detype;
|
|
switch (next->d_type)
|
|
{
|
|
case DT_BLK: detype = DE_BLK; break;
|
|
case DT_CHR: detype = DE_CHR; break;
|
|
case DT_DIR: detype = DE_DIR; break;
|
|
case DT_FIFO: detype = DE_FIFO; break;
|
|
case DT_LNK: detype = DE_LNK; break;
|
|
case DT_REG: detype = DE_REG; break;
|
|
case DT_SOCK: detype = DE_SOCK; break;
|
|
# ifdef DT_WHT
|
|
case DT_WHT: detype = DE_WHT; break;
|
|
# endif
|
|
case DT_UNKNOWN: detype = DE_UNKNOWN; break;
|
|
default: detype = DE_OTHER; break;
|
|
}
|
|
data[data_used++] = detype;
|
|
d_size--;
|
|
#endif
|
|
memcpy (data + data_used, d_name, d_size);
|
|
data_used += d_size;
|
|
nnames++;
|
|
}
|
|
|
|
if (errno)
|
|
return false;
|
|
}
|
|
|
|
/* Create the 'names' table from the 'data' table. */
|
|
char const **names = xinmalloc (nnames + 1, sizeof *names);
|
|
dirdata->names = names;
|
|
dirdata->nnames = nnames;
|
|
for (idx_t i = 0; i < nnames; i++)
|
|
{
|
|
data += HAVE_STRUCT_DIRENT_D_TYPE;
|
|
names[i] = data;
|
|
data += strlen (data) + 1;
|
|
}
|
|
names[nnames] = nullptr;
|
|
return true;
|
|
}
|
|
|
|
/* Compare strings in a locale-specific way, returning a value
|
|
compatible with strcmp. */
|
|
|
|
static int
|
|
compare_collated (char const *name1, char const *name2)
|
|
{
|
|
errno = 0;
|
|
int r = strcoll (name1, name2);
|
|
if (errno)
|
|
{
|
|
error (0, errno, _("cannot compare file names %s and %s"),
|
|
quote_n (0, name1), quote_n (1, name2));
|
|
longjmp (failed_locale_specific_sorting, 1);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/* Compare file names, returning a value compatible with strcmp. */
|
|
|
|
static int
|
|
compare_names (char const *name1, char const *name2)
|
|
{
|
|
if (ignore_file_name_case)
|
|
return mbscasecmp (name1, name2); /* Best we can do. */
|
|
|
|
if (locale_specific_sorting)
|
|
{
|
|
int diff = compare_collated (name1, name2);
|
|
if (diff)
|
|
return diff;
|
|
}
|
|
return file_name_cmp (name1, name2);
|
|
}
|
|
|
|
/* Compare names FILE1 and FILE2 when sorting a directory.
|
|
Prefer filtered comparison, breaking ties with file_name_cmp. */
|
|
|
|
static int
|
|
compare_names_for_qsort (void const *file1, void const *file2)
|
|
{
|
|
char const *const *f1 = file1;
|
|
char const *const *f2 = file2;
|
|
return compare_names (*f1, *f2);
|
|
}
|
|
|
|
/* Compare the contents of two directories named in CMP.
|
|
This is a top-level routine; it does everything necessary for diff
|
|
on two directories.
|
|
|
|
If CMP->file[0].desc == NONEXISTENT, directory CMP->file[0] doesn't exist
|
|
and pretend it is empty. Otherwise, update CMP->file[0].desc and
|
|
CMP->file[0].dirstream as needed. Likewise for CMP->file[1].
|
|
|
|
Returns the maximum of all the values returned by compare_files,
|
|
or EXIT_TROUBLE if trouble is encountered in opening files. */
|
|
|
|
int
|
|
diff_dirs (struct comparison *cmp)
|
|
{
|
|
if ((cmp->file[0].desc == NONEXISTENT || dir_loop (cmp, 0))
|
|
&& (cmp->file[1].desc == NONEXISTENT || dir_loop (cmp, 1)))
|
|
{
|
|
error (0, 0, _("%s: recursive directory loop"),
|
|
squote (0, cmp->file[cmp->file[0].desc == NONEXISTENT].name));
|
|
return EXIT_TROUBLE;
|
|
}
|
|
|
|
/* Get contents of both dirs. */
|
|
struct dirdata dirdata[2];
|
|
int val = EXIT_SUCCESS;
|
|
for (int i = 0; i < 2; i++)
|
|
if (! dir_read (cmp->parent->file[i].desc, &cmp->file[i], &dirdata[i],
|
|
cmp->parent == &noparent ? starting_file : nullptr, false))
|
|
{
|
|
perror_with_name (cmp->file[i].name);
|
|
val = EXIT_TROUBLE;
|
|
}
|
|
|
|
if (val == EXIT_SUCCESS)
|
|
{
|
|
/* Use locale-specific sorting if possible, else native byte order. */
|
|
locale_specific_sorting = true;
|
|
if (! ignore_file_name_case)
|
|
if (setjmp (failed_locale_specific_sorting))
|
|
locale_specific_sorting = false;
|
|
|
|
/* Sort the directories. */
|
|
for (int i = 0; i < 2; i++)
|
|
qsort (dirdata[i].names, dirdata[i].nnames, sizeof *dirdata[i].names,
|
|
compare_names_for_qsort);
|
|
|
|
/* Loop while files remain in one or both dirs. */
|
|
char const **n0 = dirdata[0].names;
|
|
char const **n1 = dirdata[1].names;
|
|
while (*n0 || *n1)
|
|
{
|
|
/* Compare next name in dir 0 with next name in dir 1.
|
|
At the end of a dir,
|
|
pretend the "next name" in that dir is very large. */
|
|
int nameorder = !*n0 ? 1 : !*n1 ? -1 : compare_names (*n0, *n1);
|
|
|
|
/* Prefer a file_name_cmp match if available. This algorithm is
|
|
O(N**2), where N is the number of names in a directory
|
|
that compare_names says are all equal, but in practice N
|
|
is so small it's not worth tuning. */
|
|
if (nameorder == 0 && ignore_file_name_case)
|
|
{
|
|
int raw_order = file_name_cmp (*n0, *n1);
|
|
if (raw_order != 0)
|
|
{
|
|
char const **lesser = raw_order < 0 ? n0 : n1;
|
|
char const *greater_name = *(raw_order < 0 ? n1 : n0);
|
|
|
|
for (char const **p = lesser + 1;
|
|
*p && compare_names (*p, greater_name) == 0;
|
|
p++)
|
|
{
|
|
int c = file_name_cmp (*p, greater_name);
|
|
if (0 <= c)
|
|
{
|
|
if (c == 0)
|
|
{
|
|
memmove (lesser + 1, lesser,
|
|
(char *) p - (char *) lesser);
|
|
*lesser = greater_name;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
enum detype detypes[]
|
|
= { HAVE_STRUCT_DIRENT_D_TYPE && *n0 ? (*n0)[-1] : DE_UNKNOWN,
|
|
HAVE_STRUCT_DIRENT_D_TYPE && *n1 ? (*n1)[-1] : DE_UNKNOWN };
|
|
int v1 = compare_files (cmp, detypes,
|
|
0 < nameorder ? nullptr : *n0++,
|
|
nameorder < 0 ? nullptr : *n1++);
|
|
if (val < v1)
|
|
val = v1;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
free (dirdata[i].names);
|
|
free (dirdata[i].data);
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
/* Return nonzero if CMP is looping recursively in argument I. */
|
|
|
|
static bool ATTRIBUTE_PURE
|
|
dir_loop (struct comparison const *cmp, int i)
|
|
{
|
|
for (struct comparison const *p = cmp; (p = p->parent) != &noparent; )
|
|
if (same_file (&p->file[i].stat, &cmp->file[i].stat))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/* Find a matching filename in a directory. */
|
|
|
|
char *
|
|
find_dir_file_pathname (struct file_data *dir, char const *file,
|
|
enum detype *detype)
|
|
{
|
|
char const *match = file;
|
|
|
|
struct dirdata dirdata;
|
|
dirdata.names = nullptr;
|
|
dirdata.data = nullptr;
|
|
|
|
if (ignore_file_name_case && dir_read (AT_FDCWD, dir, &dirdata, file, true))
|
|
for (char const **p = dirdata.names; *p; p++)
|
|
{
|
|
if (file_name_cmp (*p, file) == 0)
|
|
{
|
|
match = *p;
|
|
break;
|
|
}
|
|
if (match == file)
|
|
match = *p;
|
|
}
|
|
|
|
*detype = HAVE_STRUCT_DIRENT_D_TYPE && match != file ? match[-1] : DE_UNKNOWN;
|
|
char *val = file_name_concat (dir->name, match, nullptr);
|
|
free (dirdata.names);
|
|
free (dirdata.data);
|
|
return val;
|
|
}
|