/* Used for sorting the hash entry */
static EXT2_QSORT_TYPE name_cmp(const void *a, const void *b)
{
const struct hash_entry *he_a = (const struct hash_entry *) a;
const struct hash_entry *he_b = (const struct hash_entry *) b;
unsigned int he_a_len, he_b_len;
int ret;
int min_len;
he_a_len = ext2fs_dirent_name_len(he_a->dir);
he_b_len = ext2fs_dirent_name_len(he_b->dir);
min_len = he_a_len;
if (min_len > he_b_len)
min_len = he_b_len;
ret = strncmp(he_a->dir->name, he_b->dir->name, min_len);
if (ret == 0) {
if (he_a_len > he_b_len)
ret = 1;
else if (he_a_len < he_b_len)
ret = -1;
else
ret = he_b->dir->inode - he_a->dir->inode;
}
return ret;
}
static int dict_de_cmp(const void *a, const void *b)
{
const struct ext2_dir_entry *de_a, *de_b;
int a_len, b_len;
de_a = (const struct ext2_dir_entry *) a;
a_len = ext2fs_dirent_name_len(de_a);
de_b = (const struct ext2_dir_entry *) b;
b_len = ext2fs_dirent_name_len(de_b);
if (a_len != b_len)
return (a_len - b_len);
return strncmp(de_a->name, de_b->name, a_len);
}
/*
* Make sure the first entry in the directory is '.', and that the
* directory entry is sane.
*/
static int check_dot(e2fsck_t ctx,
struct ext2_dir_entry *dirent,
ext2_ino_t ino, struct problem_context *pctx)
{
struct ext2_dir_entry *nextdir;
unsigned int rec_len, new_len;
int status = 0;
int created = 0;
problem_t problem = 0;
if (!dirent->inode)
problem = PR_2_MISSING_DOT;
else if ((ext2fs_dirent_name_len(dirent) != 1) ||
(dirent->name[0] != '.'))
problem = PR_2_1ST_NOT_DOT;
else if (dirent->name[1] != '\0')
problem = PR_2_DOT_NULL_TERM;
(void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
if (problem) {
if (fix_problem(ctx, problem, pctx)) {
if (rec_len < 12)
rec_len = dirent->rec_len = 12;
dirent->inode = ino;
ext2fs_dirent_set_name_len(dirent, 1);
ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
dirent->name[0] = '.';
dirent->name[1] = '\0';
status = 1;
created = 1;
}
}
if (dirent->inode != ino) {
if (fix_problem(ctx, PR_2_BAD_INODE_DOT, pctx)) {
dirent->inode = ino;
status = 1;
}
}
if (rec_len > 12) {
new_len = rec_len - 12;
if (new_len > 12) {
if (created ||
fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) {
nextdir = (struct ext2_dir_entry *)
((char *) dirent + 12);
dirent->rec_len = 12;
(void) ext2fs_set_rec_len(ctx->fs, new_len,
nextdir);
nextdir->inode = 0;
ext2fs_dirent_set_name_len(nextdir, 0);
ext2fs_dirent_set_file_type(nextdir,
EXT2_FT_UNKNOWN);
status = 1;
}
}
}
return status;
}
/*
* This function expands '%dX' expressions
*/
static _INLINE_ void expand_dirent_expression(FILE *f, ext2_filsys fs, char ch,
struct problem_context *ctx)
{
struct ext2_dir_entry *dirent;
unsigned int rec_len, len;
if (!ctx || !ctx->dirent)
goto no_dirent;
dirent = ctx->dirent;
switch (ch) {
case 'i':
fprintf(f, "%u", dirent->inode);
break;
case 'n':
len = ext2fs_dirent_name_len(dirent);
if ((ext2fs_get_rec_len(fs, dirent, &rec_len) == 0) &&
(len > rec_len))
len = rec_len;
safe_print(f, dirent->name, len);
break;
case 'r':
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
fprintf(f, "%u", rec_len);
break;
case 'l':
fprintf(f, "%u", ext2fs_dirent_name_len(dirent));
break;
case 't':
fprintf(f, "%u", ext2fs_dirent_file_type(dirent));
break;
default:
no_dirent:
fprintf(f, "%%D%c", ch);
break;
}
}
/*
* Make sure the second entry in the directory is '..', and that the
* directory entry is sane. We do not check the inode number of '..'
* here; this gets done in pass 3.
*/
static int check_dotdot(e2fsck_t ctx,
struct ext2_dir_entry *dirent,
ext2_ino_t ino, struct problem_context *pctx)
{
problem_t problem = 0;
unsigned int rec_len;
if (!dirent->inode)
problem = PR_2_MISSING_DOT_DOT;
else if ((ext2fs_dirent_name_len(dirent) != 2) ||
(dirent->name[0] != '.') ||
(dirent->name[1] != '.'))
problem = PR_2_2ND_NOT_DOT_DOT;
else if (dirent->name[2] != '\0')
problem = PR_2_DOT_DOT_NULL_TERM;
(void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
if (problem) {
if (fix_problem(ctx, problem, pctx)) {
if (rec_len < 12)
dirent->rec_len = 12;
/*
* Note: we don't have the parent inode just
* yet, so we will fill it in with the root
* inode. This will get fixed in pass 3.
*/
dirent->inode = EXT2_ROOT_INO;
ext2fs_dirent_set_name_len(dirent, 2);
ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
dirent->name[0] = '.';
dirent->name[1] = '.';
dirent->name[2] = '\0';
return 1;
}
return 0;
}
if (e2fsck_dir_info_set_dotdot(ctx, ino, dirent->inode)) {
fix_problem(ctx, PR_2_NO_DIRINFO, pctx);
return -1;
}
return 0;
}
/*
* Check to make sure a directory entry doesn't contain any illegal
* characters.
*/
static int check_name(e2fsck_t ctx,
struct ext2_dir_entry *dirent,
ext2_ino_t dir_ino EXT2FS_ATTR((unused)),
struct problem_context *pctx)
{
int i;
int fixup = -1;
int ret = 0;
for ( i = 0; i < ext2fs_dirent_name_len(dirent); i++) {
if (dirent->name[i] == '/' || dirent->name[i] == '\0') {
if (fixup < 0) {
fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx);
}
if (fixup) {
dirent->name[i] = '.';
ret = 1;
}
}
}
return ret;
}
static int print_filename(FILE *f, struct ext2_dir_entry *dirent, int options)
{
unsigned char ch;
const char *cp = dirent->name;
int len = ext2fs_dirent_name_len(dirent);
int retlen = 0;
if ((options & ENCRYPT_OPT) && !(options & RAW_OPT)) {
if (f)
return fprintf(f, "<encrypted (%d)>", len);
else {
char tmp[1];
return snprintf(tmp, sizeof(tmp),
"<encrypted (%d)>", len);
}
}
while (len--) {
ch = *cp++;
if (ch > 128) {
if (f)
fputs("M-", f);
ch -= 128;
retlen += 2;
}
if ((ch < 32) || (ch == 0x7f)) {
if (f)
fputc('^', f);
ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
retlen++;
}
if (f)
fputc(ch, f);
retlen++;
}
return retlen;
}
char *buf EXT2FS_ATTR((unused)),
void *private)
{
struct ext2_inode inode;
ext2_ino_t ino;
struct tm *tm_p;
time_t modtime;
char tmp[EXT2_NAME_LEN + 16];
char datestr[80];
char lbr, rbr;
int thislen;
int options;
struct list_dir_struct *ls = (struct list_dir_struct *) private;
struct ext2_dir_entry_tail *t = (struct ext2_dir_entry_tail *) dirent;
thislen = ext2fs_dirent_name_len(dirent);
ino = dirent->inode;
options = ls->options;
if (ls->state < 2) {
ls->state++;
options |= RAW_OPT;
}
if (entry == DIRENT_DELETED_FILE) {
lbr = '<';
rbr = '>';
ino = 0;
} else {
lbr = rbr = ' ';
}
if (options & PARSE_OPT) {
static errcode_t copy_dir_entries(e2fsck_t ctx,
struct fill_dir_struct *fd,
struct out_dir *outdir)
{
ext2_filsys fs = ctx->fs;
errcode_t retval;
char *block_start;
struct hash_entry *ent;
struct ext2_dir_entry *dirent;
unsigned int rec_len, prev_rec_len, left, slack, offset;
int i;
ext2_dirhash_t prev_hash;
int csum_size = 0;
struct ext2_dir_entry_tail *t;
if (ctx->htree_slack_percentage == 255) {
profile_get_uint(ctx->profile, "options",
"indexed_dir_slack_percentage",
0, 20,
&ctx->htree_slack_percentage);
if (ctx->htree_slack_percentage > 100)
ctx->htree_slack_percentage = 20;
}
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
csum_size = sizeof(struct ext2_dir_entry_tail);
outdir->max = 0;
retval = alloc_size_dir(fs, outdir,
(fd->dir_size / fs->blocksize) + 2);
if (retval)
return retval;
outdir->num = fd->compress ? 0 : 1;
offset = 0;
outdir->hashes[0] = 0;
prev_hash = 1;
if ((retval = get_next_block(fs, outdir, &block_start)))
return retval;
dirent = (struct ext2_dir_entry *) block_start;
prev_rec_len = 0;
rec_len = 0;
left = fs->blocksize - csum_size;
slack = fd->compress ? 12 :
((fs->blocksize - csum_size) * ctx->htree_slack_percentage)/100;
if (slack < 12)
slack = 12;
for (i = 0; i < fd->num_array; i++) {
ent = fd->harray + i;
if (ent->dir->inode == 0)
continue;
rec_len = EXT2_DIR_REC_LEN(ext2fs_dirent_name_len(ent->dir));
if (rec_len > left) {
if (left) {
left += prev_rec_len;
retval = ext2fs_set_rec_len(fs, left, dirent);
if (retval)
return retval;
}
if (csum_size) {
t = EXT2_DIRENT_TAIL(block_start,
fs->blocksize);
ext2fs_initialize_dirent_tail(fs, t);
}
if ((retval = get_next_block(fs, outdir,
&block_start)))
return retval;
offset = 0;
}
left = (fs->blocksize - csum_size) - offset;
dirent = (struct ext2_dir_entry *) (block_start + offset);
if (offset == 0) {
if (ent->hash == prev_hash)
outdir->hashes[outdir->num-1] = ent->hash | 1;
else
outdir->hashes[outdir->num-1] = ent->hash;
}
dirent->inode = ent->dir->inode;
ext2fs_dirent_set_name_len(dirent,
ext2fs_dirent_name_len(ent->dir));
ext2fs_dirent_set_file_type(dirent,
ext2fs_dirent_file_type(ent->dir));
retval = ext2fs_set_rec_len(fs, rec_len, dirent);
if (retval)
return retval;
prev_rec_len = rec_len;
memcpy(dirent->name, ent->dir->name,
ext2fs_dirent_name_len(dirent));
offset += rec_len;
left -= rec_len;
if (left < slack) {
prev_rec_len += left;
retval = ext2fs_set_rec_len(fs, prev_rec_len, dirent);
if (retval)
return retval;
offset += left;
left = 0;
}
prev_hash = ent->hash;
}
if (left)
retval = ext2fs_set_rec_len(fs, rec_len + left, dirent);
if (csum_size) {
t = EXT2_DIRENT_TAIL(block_start, fs->blocksize);
ext2fs_initialize_dirent_tail(fs, t);
}
return retval;
}
static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs,
ext2_ino_t ino,
struct fill_dir_struct *fd)
{
struct problem_context pctx;
struct hash_entry *ent, *prev;
int i, j;
int fixed = 0;
char new_name[256];
unsigned int new_len;
int hash_alg;
clear_problem_context(&pctx);
pctx.ino = ino;
hash_alg = fs->super->s_def_hash_version;
if ((hash_alg <= EXT2_HASH_TEA) &&
(fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
hash_alg += 3;
for (i=1; i < fd->num_array; i++) {
ent = fd->harray + i;
prev = ent - 1;
if (!ent->dir->inode ||
(ext2fs_dirent_name_len(ent->dir) !=
ext2fs_dirent_name_len(prev->dir)) ||
strncmp(ent->dir->name, prev->dir->name,
ext2fs_dirent_name_len(ent->dir)))
continue;
pctx.dirent = ent->dir;
if ((ent->dir->inode == prev->dir->inode) &&
fix_problem(ctx, PR_2_DUPLICATE_DIRENT, &pctx)) {
e2fsck_adjust_inode_count(ctx, ent->dir->inode, -1);
ent->dir->inode = 0;
fixed++;
continue;
}
new_len = ext2fs_dirent_name_len(ent->dir);
memcpy(new_name, ent->dir->name, new_len);
mutate_name(new_name, &new_len);
for (j=0; j < fd->num_array; j++) {
if ((i==j) ||
(new_len !=
ext2fs_dirent_name_len(fd->harray[j].dir)) ||
strncmp(new_name, fd->harray[j].dir->name, new_len))
continue;
mutate_name(new_name, &new_len);
j = -1;
}
new_name[new_len] = 0;
pctx.str = new_name;
if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) {
memcpy(ent->dir->name, new_name, new_len);
ext2fs_dirent_set_name_len(ent->dir, new_len);
ext2fs_dirhash(hash_alg, new_name, new_len,
fs->super->s_hash_seed,
&ent->hash, &ent->minor_hash);
fixed++;
}
}
return fixed;
}
static int fill_dir_block(ext2_filsys fs,
blk64_t *block_nr,
e2_blkcnt_t blockcnt,
blk64_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct fill_dir_struct *fd = (struct fill_dir_struct *) priv_data;
struct hash_entry *new_array, *ent;
struct ext2_dir_entry *dirent;
char *dir;
unsigned int offset, dir_offset, rec_len, name_len;
int hash_alg;
if (blockcnt < 0)
return 0;
offset = blockcnt * fs->blocksize;
if (offset + fs->blocksize > fd->inode->i_size) {
fd->err = EXT2_ET_DIR_CORRUPTED;
return BLOCK_ABORT;
}
dir = (fd->buf+offset);
if (*block_nr == 0) {
memset(dir, 0, fs->blocksize);
dirent = (struct ext2_dir_entry *) dir;
(void) ext2fs_set_rec_len(fs, fs->blocksize, dirent);
} else {
int flags = fs->flags;
fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
fd->err = ext2fs_read_dir_block4(fs, *block_nr, dir, 0,
fd->dir);
fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
(fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
if (fd->err)
return BLOCK_ABORT;
}
hash_alg = fs->super->s_def_hash_version;
if ((hash_alg <= EXT2_HASH_TEA) &&
(fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
hash_alg += 3;
/* While the directory block is "hot", index it. */
dir_offset = 0;
while (dir_offset < fs->blocksize) {
dirent = (struct ext2_dir_entry *) (dir + dir_offset);
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
name_len = ext2fs_dirent_name_len(dirent);
if (((dir_offset + rec_len) > fs->blocksize) ||
(rec_len < 8) ||
((rec_len % 4) != 0) ||
(name_len + 8 > rec_len)) {
fd->err = EXT2_ET_DIR_CORRUPTED;
return BLOCK_ABORT;
}
dir_offset += rec_len;
if (dirent->inode == 0)
continue;
if (!fd->compress && (name_len == 1) &&
(dirent->name[0] == '.'))
continue;
if (!fd->compress && (name_len == 2) &&
(dirent->name[0] == '.') && (dirent->name[1] == '.')) {
fd->parent = dirent->inode;
continue;
}
if (fd->num_array >= fd->max_array) {
new_array = realloc(fd->harray,
sizeof(struct hash_entry) * (fd->max_array+500));
if (!new_array) {
fd->err = ENOMEM;
return BLOCK_ABORT;
}
fd->harray = new_array;
fd->max_array += 500;
}
ent = fd->harray + fd->num_array++;
ent->dir = dirent;
fd->dir_size += EXT2_DIR_REC_LEN(name_len);
ent->ino = dirent->inode;
if (fd->compress)
ent->hash = ent->minor_hash = 0;
else {
fd->err = ext2fs_dirhash(hash_alg, dirent->name,
name_len,
fs->super->s_hash_seed,
&ent->hash, &ent->minor_hash);
if (fd->err)
return BLOCK_ABORT;
}
}
return 0;
}
static int link_proc(struct ext2_dir_entry *dirent,
int offset,
int blocksize,
char *buf,
void *priv_data)
{
struct link_struct *ls = (struct link_struct *) priv_data;
struct ext2_dir_entry *next;
unsigned int rec_len, min_rec_len, curr_rec_len;
int ret = 0;
int csum_size = 0;
struct ext2_dir_entry_tail *t;
if (ls->done)
return DIRENT_ABORT;
rec_len = EXT2_DIR_REC_LEN(ls->namelen);
ls->err = ext2fs_get_rec_len(ls->fs, dirent, &curr_rec_len);
if (ls->err)
return DIRENT_ABORT;
if (EXT2_HAS_RO_COMPAT_FEATURE(ls->fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
csum_size = sizeof(struct ext2_dir_entry_tail);
/*
* See if the following directory entry (if any) is unused;
* if so, absorb it into this one.
*/
next = (struct ext2_dir_entry *) (buf + offset + curr_rec_len);
if ((offset + (int) curr_rec_len < blocksize - (8 + csum_size)) &&
(next->inode == 0) &&
(offset + (int) curr_rec_len + (int) next->rec_len <= blocksize)) {
curr_rec_len += next->rec_len;
ls->err = ext2fs_set_rec_len(ls->fs, curr_rec_len, dirent);
if (ls->err)
return DIRENT_ABORT;
ret = DIRENT_CHANGED;
}
/*
* Since ext2fs_link blows away htree data, we need to be
* careful -- if metadata_csum is enabled and we're passed in
* a dirent that contains htree data, we need to create the
* fake entry at the end of the block that hides the checksum.
*/
/* De-convert a dx_node block */
if (csum_size &&
curr_rec_len == ls->fs->blocksize &&
!dirent->inode) {
curr_rec_len -= csum_size;
ls->err = ext2fs_set_rec_len(ls->fs, curr_rec_len, dirent);
if (ls->err)
return DIRENT_ABORT;
t = EXT2_DIRENT_TAIL(buf, ls->fs->blocksize);
ext2fs_initialize_dirent_tail(ls->fs, t);
ret = DIRENT_CHANGED;
}
/* De-convert a dx_root block */
if (csum_size &&
curr_rec_len == ls->fs->blocksize - EXT2_DIR_REC_LEN(1) &&
offset == EXT2_DIR_REC_LEN(1) &&
dirent->name[0] == '.' && dirent->name[1] == '.') {
curr_rec_len -= csum_size;
ls->err = ext2fs_set_rec_len(ls->fs, curr_rec_len, dirent);
if (ls->err)
return DIRENT_ABORT;
t = EXT2_DIRENT_TAIL(buf, ls->fs->blocksize);
ext2fs_initialize_dirent_tail(ls->fs, t);
ret = DIRENT_CHANGED;
}
/*
* If the directory entry is used, see if we can split the
* directory entry to make room for the new name. If so,
* truncate it and return.
*/
if (dirent->inode) {
min_rec_len = EXT2_DIR_REC_LEN(ext2fs_dirent_name_len(dirent));
if (curr_rec_len < (min_rec_len + rec_len))
return ret;
rec_len = curr_rec_len - min_rec_len;
ls->err = ext2fs_set_rec_len(ls->fs, min_rec_len, dirent);
if (ls->err)
return DIRENT_ABORT;
next = (struct ext2_dir_entry *) (buf + offset +
dirent->rec_len);
next->inode = 0;
ext2fs_dirent_set_name_len(next, 0);
ext2fs_dirent_set_file_type(next, 0);
ls->err = ext2fs_set_rec_len(ls->fs, rec_len, next);
if (ls->err)
return DIRENT_ABORT;
return DIRENT_CHANGED;
}
/*
* If we get this far, then the directory entry is not used.
* See if we can fit the request entry in. If so, do it.
*/
if (curr_rec_len < rec_len)
return ret;
dirent->inode = ls->inode;
ext2fs_dirent_set_name_len(dirent, ls->namelen);
strncpy(dirent->name, ls->name, ls->namelen);
if (ls->sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_FILETYPE)
ext2fs_dirent_set_file_type(dirent, ls->flags & 0x7);
ls->done++;
return DIRENT_ABORT|DIRENT_CHANGED;
}
static int check_dir_block(ext2_filsys fs,
struct ext2_db_entry2 *db,
void *priv_data)
{
struct dx_dir_info *dx_dir;
#ifdef ENABLE_HTREE
struct dx_dirblock_info *dx_db = 0;
#endif /* ENABLE_HTREE */
struct ext2_dir_entry *dirent, *prev, dot, dotdot;
ext2_dirhash_t hash;
unsigned int offset = 0;
int dir_modified = 0;
int dot_state;
unsigned int rec_len;
blk64_t block_nr = db->blk;
ext2_ino_t ino = db->ino;
ext2_ino_t subdir_parent;
__u16 links;
struct check_dir_struct *cd;
char *buf;
e2fsck_t ctx;
problem_t problem;
struct ext2_dx_root_info *root;
struct ext2_dx_countlimit *limit;
static dict_t de_dict;
struct problem_context pctx;
int dups_found = 0;
int ret;
int dx_csum_size = 0, de_csum_size = 0;
int failed_csum = 0;
int is_leaf = 1;
size_t inline_data_size = 0;
int filetype = 0;
cd = (struct check_dir_struct *) priv_data;
buf = cd->buf;
ctx = cd->ctx;
if (ctx->flags & E2F_FLAG_SIGNAL_MASK || ctx->flags & E2F_FLAG_RESTART)
return DIRENT_ABORT;
if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max))
return DIRENT_ABORT;
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
dx_csum_size = sizeof(struct ext2_dx_tail);
de_csum_size = sizeof(struct ext2_dir_entry_tail);
}
if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT2_FEATURE_INCOMPAT_FILETYPE))
filetype = EXT2_FT_DIR << 8;
/*
* Make sure the inode is still in use (could have been
* deleted in the duplicate/bad blocks pass.
*/
if (!(ext2fs_test_inode_bitmap2(ctx->inode_used_map, ino)))
return 0;
cd->pctx.ino = ino;
cd->pctx.blk = block_nr;
cd->pctx.blkcount = db->blockcnt;
cd->pctx.ino2 = 0;
cd->pctx.dirent = 0;
cd->pctx.num = 0;
if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT4_FEATURE_INCOMPAT_INLINE_DATA)) {
errcode_t ec;
ec = ext2fs_inline_data_size(fs, ino, &inline_data_size);
if (ec && ec != EXT2_ET_NO_INLINE_DATA)
return DIRENT_ABORT;
}
if (db->blk == 0 && !inline_data_size) {
if (allocate_dir_block(ctx, db, buf, &cd->pctx))
return 0;
block_nr = db->blk;
}
if (db->blockcnt)
dot_state = 2;
else
dot_state = 0;
if (ctx->dirs_to_hash &&
ext2fs_u32_list_test(ctx->dirs_to_hash, ino))
dups_found++;
#if 0
printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr,
db->blockcnt, ino);
#endif
ehandler_operation(_("reading directory block"));
if (inline_data_size)
cd->pctx.errcode = ext2fs_inline_data_get(fs, ino, 0, buf, 0);
else
cd->pctx.errcode = ext2fs_read_dir_block4(fs, block_nr,
buf, 0, ino);
ehandler_operation(0);
if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED)
cd->pctx.errcode = 0; /* We'll handle this ourselves */
else if (cd->pctx.errcode == EXT2_ET_DIR_CSUM_INVALID) {
cd->pctx.errcode = 0; /* We'll handle this ourselves */
failed_csum = 1;
}
if (cd->pctx.errcode) {
char *buf2;
if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) {
ctx->flags |= E2F_FLAG_ABORT;
return DIRENT_ABORT;
}
ext2fs_new_dir_block(fs, db->blockcnt == 0 ? ino : 0,
EXT2_ROOT_INO, &buf2);
memcpy(buf, buf2, fs->blocksize);
ext2fs_free_mem(&buf2);
}
#ifdef ENABLE_HTREE
dx_dir = e2fsck_get_dx_dir_info(ctx, ino);
if (dx_dir && dx_dir->numblocks) {
if (db->blockcnt >= dx_dir->numblocks) {
if (fix_problem(ctx, PR_2_UNEXPECTED_HTREE_BLOCK,
&pctx)) {
clear_htree(ctx, ino);
dx_dir->numblocks = 0;
dx_db = 0;
goto out_htree;
}
fatal_error(ctx, _("Can not continue."));
}
dx_db = &dx_dir->dx_block[db->blockcnt];
dx_db->type = DX_DIRBLOCK_LEAF;
dx_db->phys = block_nr;
dx_db->min_hash = ~0;
dx_db->max_hash = 0;
dirent = (struct ext2_dir_entry *) buf;
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
limit = (struct ext2_dx_countlimit *) (buf+8);
if (db->blockcnt == 0) {
root = (struct ext2_dx_root_info *) (buf + 24);
dx_db->type = DX_DIRBLOCK_ROOT;
dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST;
if ((root->reserved_zero ||
root->info_length < 8 ||
root->indirect_levels > 1) &&
fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) {
clear_htree(ctx, ino);
dx_dir->numblocks = 0;
dx_db = 0;
}
dx_dir->hashversion = root->hash_version;
if ((dx_dir->hashversion <= EXT2_HASH_TEA) &&
(fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
dx_dir->hashversion += 3;
dx_dir->depth = root->indirect_levels + 1;
} else if ((dirent->inode == 0) &&
(rec_len == fs->blocksize) &&
(ext2fs_dirent_name_len(dirent) == 0) &&
(ext2fs_le16_to_cpu(limit->limit) ==
((fs->blocksize - (8 + dx_csum_size)) /
sizeof(struct ext2_dx_entry))))
dx_db->type = DX_DIRBLOCK_NODE;
is_leaf = 0;
}
out_htree:
#endif /* ENABLE_HTREE */
/* Verify checksum. */
if (is_leaf && de_csum_size && !inline_data_size) {
/* No space for csum? Rebuild dirs in pass 3A. */
if (!ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
de_csum_size = 0;
if (e2fsck_dir_will_be_rehashed(ctx, ino))
goto skip_checksum;
if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_MISSING_CSUM,
&cd->pctx))
goto skip_checksum;
e2fsck_rehash_dir_later(ctx, ino);
goto skip_checksum;
}
if (failed_csum) {
char *buf2;
if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_CSUM_INVALID,
&cd->pctx))
goto skip_checksum;
ext2fs_new_dir_block(fs,
db->blockcnt == 0 ? ino : 0,
EXT2_ROOT_INO, &buf2);
memcpy(buf, buf2, fs->blocksize);
ext2fs_free_mem(&buf2);
dir_modified++;
failed_csum = 0;
}
}
/* htree nodes don't use fake dirents to store checksums */
if (!is_leaf)
de_csum_size = 0;
skip_checksum:
dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp);
prev = 0;
do {
dgrp_t group;
ext2_ino_t first_unused_inode;
unsigned int name_len;
problem = 0;
if (!inline_data_size || dot_state > 1) {
dirent = (struct ext2_dir_entry *) (buf + offset);
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
cd->pctx.dirent = dirent;
cd->pctx.num = offset;
if (((offset + rec_len) > fs->blocksize) ||
(rec_len < 12) ||
((rec_len % 4) != 0) ||
((ext2fs_dirent_name_len(dirent) + 8) > rec_len)) {
if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) {
salvage_directory(fs, dirent, prev, &offset);
dir_modified++;
continue;
} else
goto abort_free_dict;
}
} else {
if (dot_state == 0) {
memset(&dot, 0, sizeof(dot));
dirent = ˙
dirent->inode = ino;
dirent->rec_len = EXT2_DIR_REC_LEN(1);
dirent->name_len = 1 | filetype;
dirent->name[0] = '.';
} else if (dot_state == 1) {
memset(&dotdot, 0, sizeof(dotdot));
dirent = &dotdot;
dirent->inode =
((struct ext2_dir_entry *)buf)->inode;
dirent->rec_len = EXT2_DIR_REC_LEN(2);
dirent->name_len = 2 | filetype;
dirent->name[0] = '.';
dirent->name[1] = '.';
} else {
fatal_error(ctx, _("Can not continue."));
}
cd->pctx.dirent = dirent;
cd->pctx.num = offset;
}
if (dot_state == 0) {
if (check_dot(ctx, dirent, ino, &cd->pctx))
dir_modified++;
} else if (dot_state == 1) {
ret = check_dotdot(ctx, dirent, ino, &cd->pctx);
if (ret < 0)
goto abort_free_dict;
if (ret)
dir_modified++;
} else if (dirent->inode == ino) {
problem = PR_2_LINK_DOT;
if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
}
if (!dirent->inode)
goto next;
/*
* Make sure the inode listed is a legal one.
*/
name_len = ext2fs_dirent_name_len(dirent);
if (((dirent->inode != EXT2_ROOT_INO) &&
(dirent->inode < EXT2_FIRST_INODE(fs->super))) ||
(dirent->inode > fs->super->s_inodes_count)) {
problem = PR_2_BAD_INO;
} else if (ctx->inode_bb_map &&
(ext2fs_test_inode_bitmap2(ctx->inode_bb_map,
dirent->inode))) {
/*
* If the inode is in a bad block, offer to
* clear it.
*/
problem = PR_2_BB_INODE;
} else if ((dot_state > 1) && (name_len == 1) &&
(dirent->name[0] == '.')) {
/*
* If there's a '.' entry in anything other
* than the first directory entry, it's a
* duplicate entry that should be removed.
*/
problem = PR_2_DUP_DOT;
} else if ((dot_state > 1) && (name_len == 2) &&
(dirent->name[0] == '.') &&
(dirent->name[1] == '.')) {
/*
* If there's a '..' entry in anything other
* than the second directory entry, it's a
* duplicate entry that should be removed.
*/
problem = PR_2_DUP_DOT_DOT;
} else if ((dot_state > 1) &&
(dirent->inode == EXT2_ROOT_INO)) {
/*
* Don't allow links to the root directory.
* We check this specially to make sure we
* catch this error case even if the root
* directory hasn't been created yet.
*/
problem = PR_2_LINK_ROOT;
} else if ((dot_state > 1) && (name_len == 0)) {
/*
* Don't allow zero-length directory names.
*/
problem = PR_2_NULL_NAME;
}
if (problem) {
if (fix_problem(ctx, problem, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
/*
* If the inode was marked as having bad fields in
* pass1, process it and offer to fix/clear it.
* (We wait until now so that we can display the
* pathname to the user.)
*/
if (ctx->inode_bad_map &&
ext2fs_test_inode_bitmap2(ctx->inode_bad_map,
dirent->inode)) {
if (e2fsck_process_bad_inode(ctx, ino,
dirent->inode,
buf + fs->blocksize)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
return DIRENT_ABORT;
}
group = ext2fs_group_of_ino(fs, dirent->inode);
first_unused_inode = group * fs->super->s_inodes_per_group +
1 + fs->super->s_inodes_per_group -
ext2fs_bg_itable_unused(fs, group);
cd->pctx.group = group;
/*
* Check if the inode was missed out because
* _INODE_UNINIT flag was set or bg_itable_unused was
* incorrect. If so, clear the _INODE_UNINIT flag and
* restart e2fsck. In the future it would be nice if
* we could call a function in pass1.c that checks the
* newly visible inodes.
*/
if (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)) {
pctx.num = dirent->inode;
if (fix_problem(ctx, PR_2_INOREF_BG_INO_UNINIT,
&cd->pctx)){
ext2fs_bg_flags_clear(fs, group,
EXT2_BG_INODE_UNINIT);
ext2fs_mark_super_dirty(fs);
ctx->flags |= E2F_FLAG_RESTART_LATER;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
} else if (dirent->inode >= first_unused_inode) {
pctx.num = dirent->inode;
if (fix_problem(ctx, PR_2_INOREF_IN_UNUSED, &cd->pctx)){
ext2fs_bg_itable_unused_set(fs, group, 0);
ext2fs_mark_super_dirty(fs);
ctx->flags |= E2F_FLAG_RESTART_LATER;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
/*
* Offer to clear unused inodes; if we are going to be
* restarting the scan due to bg_itable_unused being
* wrong, then don't clear any inodes to avoid zapping
* inodes that were skipped during pass1 due to an
* incorrect bg_itable_unused; we'll get any real
* problems after we restart.
*/
if (!(ctx->flags & E2F_FLAG_RESTART_LATER) &&
!(ext2fs_test_inode_bitmap2(ctx->inode_used_map,
dirent->inode)))
problem = PR_2_UNUSED_INODE;
if (problem) {
if (fix_problem(ctx, problem, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
if (check_name(ctx, dirent, ino, &cd->pctx))
dir_modified++;
if (check_filetype(ctx, dirent, ino, &cd->pctx))
dir_modified++;
#ifdef ENABLE_HTREE
if (dx_db) {
ext2fs_dirhash(dx_dir->hashversion, dirent->name,
ext2fs_dirent_name_len(dirent),
fs->super->s_hash_seed, &hash, 0);
if (hash < dx_db->min_hash)
dx_db->min_hash = hash;
if (hash > dx_db->max_hash)
dx_db->max_hash = hash;
}
#endif
/*
* If this is a directory, then mark its parent in its
* dir_info structure. If the parent field is already
* filled in, then this directory has more than one
* hard link. We assume the first link is correct,
* and ask the user if he/she wants to clear this one.
*/
if ((dot_state > 1) &&
(ext2fs_test_inode_bitmap2(ctx->inode_dir_map,
dirent->inode))) {
if (e2fsck_dir_info_get_parent(ctx, dirent->inode,
&subdir_parent)) {
cd->pctx.ino = dirent->inode;
fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
goto abort_free_dict;
}
if (subdir_parent) {
cd->pctx.ino2 = subdir_parent;
if (fix_problem(ctx, PR_2_LINK_DIR,
&cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
cd->pctx.ino2 = 0;
} else {
(void) e2fsck_dir_info_set_parent(ctx,
dirent->inode, ino);
}
}
if (dups_found) {
;
} else if (dict_lookup(&de_dict, dirent)) {
clear_problem_context(&pctx);
pctx.ino = ino;
pctx.dirent = dirent;
fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx);
e2fsck_rehash_dir_later(ctx, ino);
dups_found++;
} else
dict_alloc_insert(&de_dict, dirent, dirent);
ext2fs_icount_increment(ctx->inode_count, dirent->inode,
&links);
if (links > 1)
ctx->fs_links_count++;
ctx->fs_total_count++;
next:
prev = dirent;
if (dir_modified)
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
if (!inline_data_size || dot_state > 1) {
offset += rec_len;
} else {
if (dot_state == 1)
offset = 4;
}
dot_state++;
} while (is_last_entry(fs, inline_data_size, offset, de_csum_size));
#if 0
printf("\n");
#endif
#ifdef ENABLE_HTREE
if (dx_db) {
#ifdef DX_DEBUG
printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n",
db->blockcnt, dx_db->type,
dx_db->min_hash, dx_db->max_hash);
#endif
cd->pctx.dir = cd->pctx.ino;
if ((dx_db->type == DX_DIRBLOCK_ROOT) ||
(dx_db->type == DX_DIRBLOCK_NODE))
parse_int_node(fs, db, cd, dx_dir, buf, failed_csum);
}
#endif /* ENABLE_HTREE */
if (inline_data_size) {
if (offset != inline_data_size) {
cd->pctx.num = rec_len + offset - inline_data_size;
if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
dirent->rec_len = cd->pctx.num;
dir_modified++;
}
}
} else {
if (offset != fs->blocksize - de_csum_size) {
cd->pctx.num = rec_len - (fs->blocksize - de_csum_size) +
offset;
if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
dirent->rec_len = cd->pctx.num;
dir_modified++;
}
}
}
if (dir_modified) {
/* leaf block with no tail? Rehash dirs later. */
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
is_leaf &&
!ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf))
e2fsck_rehash_dir_later(ctx, ino);
write_and_fix:
if (e2fsck_dir_will_be_rehashed(ctx, ino))
ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
if (inline_data_size) {
cd->pctx.errcode =
ext2fs_inline_data_set(fs, ino, 0, buf,
inline_data_size);
} else
cd->pctx.errcode = ext2fs_write_dir_block4(fs, block_nr,
buf, 0, ino);
if (e2fsck_dir_will_be_rehashed(ctx, ino))
ctx->fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
if (cd->pctx.errcode) {
if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK,
&cd->pctx))
goto abort_free_dict;
}
ext2fs_mark_changed(fs);
} else if (is_leaf && failed_csum && !dir_modified) {
/*
* If a leaf node that fails csum makes it this far without
* alteration, ask the user if the checksum should be fixed.
*/
if (fix_problem(ctx, PR_2_LEAF_NODE_ONLY_CSUM_INVALID,
&cd->pctx))
goto write_and_fix;
}
dict_free_nodes(&de_dict);
return 0;
abort_free_dict:
ctx->flags |= E2F_FLAG_ABORT;
dict_free_nodes(&de_dict);
return DIRENT_ABORT;
}
/*
* Given a busted directory, try to salvage it somehow.
*
*/
static void salvage_directory(ext2_filsys fs,
struct ext2_dir_entry *dirent,
struct ext2_dir_entry *prev,
unsigned int *offset)
{
char *cp = (char *) dirent;
int left;
unsigned int rec_len, prev_rec_len;
unsigned int name_len = ext2fs_dirent_name_len(dirent);
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
left = fs->blocksize - *offset - rec_len;
/*
* Special case of directory entry of size 8: copy what's left
* of the directory block up to cover up the invalid hole.
*/
if ((left >= 12) && (rec_len == 8)) {
memmove(cp, cp+8, left);
memset(cp + left, 0, 8);
return;
}
/*
* If the directory entry overruns the end of the directory
* block, and the name is small enough to fit, then adjust the
* record length.
*/
if ((left < 0) &&
((int) rec_len + left > 8) &&
((int) name_len + 8 <= (int) rec_len + left) &&
dirent->inode <= fs->super->s_inodes_count &&
strnlen(dirent->name, name_len) == name_len) {
(void) ext2fs_set_rec_len(fs, (int) rec_len + left, dirent);
return;
}
/*
* If the record length of the directory entry is a multiple
* of four, and not too big, such that it is valid, let the
* previous directory entry absorb the invalid one.
*/
if (prev && rec_len && (rec_len % 4) == 0 &&
(*offset + rec_len <= fs->blocksize)) {
(void) ext2fs_get_rec_len(fs, prev, &prev_rec_len);
prev_rec_len += rec_len;
(void) ext2fs_set_rec_len(fs, prev_rec_len, prev);
*offset += rec_len;
return;
}
/*
* Default salvage method --- kill all of the directory
* entries for the rest of the block. We will either try to
* absorb it into the previous directory entry, or create a
* new empty directory entry the rest of the directory block.
*/
if (prev) {
(void) ext2fs_get_rec_len(fs, prev, &prev_rec_len);
prev_rec_len += fs->blocksize - *offset;
(void) ext2fs_set_rec_len(fs, prev_rec_len, prev);
*offset = fs->blocksize;
} else {
rec_len = fs->blocksize - *offset;
(void) ext2fs_set_rec_len(fs, rec_len, dirent);
ext2fs_dirent_set_name_len(dirent, 0);
ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
dirent->inode = 0;
}
}
