/*
* This routine is called when an inode is not connected to the
* directory tree.
*
* This subroutine returns 1 then the caller shouldn't bother with the
* rest of the pass 4 tests.
*/
static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i,
struct ext2_inode *inode)
{
ext2_filsys fs = ctx->fs;
struct problem_context pctx;
__u32 eamagic = 0;
int extra_size = 0;
if (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE) {
e2fsck_read_inode_full(ctx, i, inode,EXT2_INODE_SIZE(fs->super),
"pass4: disconnect_inode");
extra_size = ((struct ext2_inode_large *)inode)->i_extra_isize;
} else {
e2fsck_read_inode(ctx, i, inode, "pass4: disconnect_inode");
}
clear_problem_context(&pctx);
pctx.ino = i;
pctx.inode = inode;
if (EXT2_INODE_SIZE(fs->super) -EXT2_GOOD_OLD_INODE_SIZE -extra_size >0)
eamagic = *(__u32 *)(((char *)inode) +EXT2_GOOD_OLD_INODE_SIZE +
extra_size);
/*
* Offer to delete any zero-length files that does not have
* blocks. If there is an EA block, it might have useful
* information, so we won't prompt to delete it, but let it be
* reconnected to lost+found.
*/
if (!inode->i_blocks && eamagic != EXT2_EXT_ATTR_MAGIC &&
(LINUX_S_ISREG(inode->i_mode) || LINUX_S_ISDIR(inode->i_mode))) {
if (fix_problem(ctx, PR_4_ZERO_LEN_INODE, &pctx)) {
e2fsck_clear_inode(ctx, i, inode, 0,
"disconnect_inode");
/*
* Fix up the bitmaps...
*/
e2fsck_read_bitmaps(ctx);
ext2fs_inode_alloc_stats2(fs, i, -1,
LINUX_S_ISDIR(inode->i_mode));
return 0;
}
}
/*
* Prompt to reconnect.
*/
if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) {
if (e2fsck_reconnect_file(ctx, i))
ext2fs_unmark_valid(fs);
} else {
/*
* If we don't attach the inode, then skip the
* i_links_test since there's no point in trying to
* force i_links_count to zero.
*/
ext2fs_unmark_valid(fs);
return 1;
}
return 0;
}
static int ext2_file_type(unsigned int mode)
{
if (LINUX_S_ISREG(mode))
return EXT2_FT_REG_FILE;
if (LINUX_S_ISDIR(mode))
return EXT2_FT_DIR;
if (LINUX_S_ISCHR(mode))
return EXT2_FT_CHRDEV;
if (LINUX_S_ISBLK(mode))
return EXT2_FT_BLKDEV;
if (LINUX_S_ISLNK(mode))
return EXT2_FT_SYMLINK;
if (LINUX_S_ISFIFO(mode))
return EXT2_FT_FIFO;
if (LINUX_S_ISSOCK(mode))
return EXT2_FT_SOCK;
return 0;
}
/*
* This fuction deallocates an inode
*/
static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf)
{
ext2_filsys fs = ctx->fs;
struct ext2_inode inode;
struct problem_context pctx;
__u32 count;
struct del_block del_block;
e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
e2fsck_clear_inode(ctx, ino, &inode, 0, "deallocate_inode");
clear_problem_context(&pctx);
pctx.ino = ino;
/*
* Fix up the bitmaps...
*/
e2fsck_read_bitmaps(ctx);
ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
if (ext2fs_file_acl_block(fs, &inode) &&
(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
pctx.errcode = ext2fs_adjust_ea_refcount3(fs,
ext2fs_file_acl_block(fs, &inode),
block_buf, -1, &count, ino);
if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
pctx.errcode = 0;
count = 1;
}
if (pctx.errcode) {
pctx.blk = ext2fs_file_acl_block(fs, &inode);
fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
if (count == 0) {
ext2fs_unmark_block_bitmap2(ctx->block_found_map,
ext2fs_file_acl_block(fs, &inode));
ext2fs_block_alloc_stats2(fs,
ext2fs_file_acl_block(fs, &inode), -1);
}
ext2fs_file_acl_block_set(fs, &inode, 0);
}
if (!ext2fs_inode_has_valid_blocks2(fs, &inode))
return;
if (LINUX_S_ISREG(inode.i_mode) && EXT2_I_SIZE(&inode) >= 0x80000000UL)
ctx->large_files--;
del_block.ctx = ctx;
del_block.num = 0;
pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, block_buf,
deallocate_inode_block,
&del_block);
if (pctx.errcode) {
fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
}
static int block_map_looks_insane(ext2_filsys fs,
struct ext2_inode_large *inode)
{
unsigned int i, bad;
/* We're only interested in block mapped files, dirs, and symlinks */
if ((inode->i_flags & EXT4_INLINE_DATA_FL) ||
(inode->i_flags & EXT4_EXTENTS_FL))
return 0;
if (!LINUX_S_ISREG(inode->i_mode) &&
!LINUX_S_ISLNK(inode->i_mode) &&
!LINUX_S_ISDIR(inode->i_mode))
return 0;
if (LINUX_S_ISLNK(inode->i_mode) &&
EXT2_I_SIZE(inode) <= sizeof(inode->i_block))
return 0;
/* Unused inodes probably aren't insane */
if (inode->i_links_count == 0)
return 0;
/* See if more than half the block maps are insane */
for (i = 0, bad = 0; i < EXT2_N_BLOCKS; i++)
if (inode->i_block[i] != 0 &&
(inode->i_block[i] < fs->super->s_first_data_block ||
inode->i_block[i] >= ext2fs_blocks_count(fs->super)))
bad++;
return bad > EXT2_N_BLOCKS / 2;
}
/*
* This function returns 1 if the inode's block entries actually
* contain block entries.
*/
int ext2fs_inode_has_valid_blocks(struct ext2_inode *inode)
{
/*
* Only directories, regular files, and some symbolic links
* have valid block entries.
*/
if (!LINUX_S_ISDIR(inode->i_mode) && !LINUX_S_ISREG(inode->i_mode) &&
!LINUX_S_ISLNK(inode->i_mode))
return 0;
/*
* If the symbolic link is a "fast symlink", then the symlink
* target is stored in the block entries.
*/
if (LINUX_S_ISLNK (inode->i_mode)) {
if (inode->i_file_acl == 0) {
/* With no EA block, we can rely on i_blocks */
if (inode->i_blocks == 0)
return 0;
} else {
/* With an EA block, life gets more tricky */
if (inode->i_size >= EXT2_N_BLOCKS*4)
return 1; /* definitely using i_block[] */
if (inode->i_size > 4 && inode->i_block[1] == 0)
return 1; /* definitely using i_block[] */
return 0; /* Probably a fast symlink */
}
}
return 1;
}
/*
* This routine is called when an inode is not connected to the
* directory tree.
*
* This subroutine returns 1 then the caller shouldn't bother with the
* rest of the pass 4 tests.
*/
static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i)
{
ext2_filsys fs = ctx->fs;
struct ext2_inode inode;
struct problem_context pctx;
e2fsck_read_inode(ctx, i, &inode, "pass4: disconnect_inode");
clear_problem_context(&pctx);
pctx.ino = i;
pctx.inode = &inode;
/*
* Offer to delete any zero-length files that does not have
* blocks. If there is an EA block, it might have useful
* information, so we won't prompt to delete it, but let it be
* reconnected to lost+found.
*/
if (!inode.i_blocks && (LINUX_S_ISREG(inode.i_mode) ||
LINUX_S_ISDIR(inode.i_mode))) {
if (fix_problem(ctx, PR_4_ZERO_LEN_INODE, &pctx)) {
ext2fs_icount_store(ctx->inode_link_info, i, 0);
inode.i_links_count = 0;
inode.i_dtime = ctx->now;
e2fsck_write_inode(ctx, i, &inode,
"disconnect_inode");
/*
* Fix up the bitmaps...
*/
e2fsck_read_bitmaps(ctx);
ext2fs_unmark_inode_bitmap(ctx->inode_used_map, i);
ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, i);
ext2fs_inode_alloc_stats2(fs, i, -1,
LINUX_S_ISDIR(inode.i_mode));
return 0;
}
}
/*
* Prompt to reconnect.
*/
if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) {
if (e2fsck_reconnect_file(ctx, i))
ext2fs_unmark_valid(fs);
} else {
/*
* If we don't attach the inode, then skip the
* i_links_test since there's no point in trying to
* force i_links_count to zero.
*/
ext2fs_unmark_valid(fs);
return 1;
}
return 0;
}
static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf)
{
ext2_filsys fs = ctx->fs;
struct ext2_inode inode;
struct problem_context pctx;
__u32 count;
e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
e2fsck_clear_inode(ctx, ino, &inode, 0, "deallocate_inode");
clear_problem_context(&pctx);
pctx.ino = ino;
e2fsck_read_bitmaps(ctx);
ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
if (inode.i_file_acl &&
(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl,
block_buf, -1, &count);
if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
pctx.errcode = 0;
count = 1;
}
if (pctx.errcode) {
pctx.blk = inode.i_file_acl;
fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
if (count == 0) {
ext2fs_unmark_block_bitmap(ctx->block_found_map,
inode.i_file_acl);
ext2fs_block_alloc_stats(fs, inode.i_file_acl, -1);
}
inode.i_file_acl = 0;
}
if (!ext2fs_inode_has_valid_blocks(&inode))
return;
if (LINUX_S_ISREG(inode.i_mode) &&
(inode.i_size_high || inode.i_size & 0x80000000UL))
ctx->large_files--;
pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf,
deallocate_inode_block, ctx);
if (pctx.errcode) {
fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
}
static void rdump_inode(ext2_ino_t ino, struct ext2_inode *inode,
const char *name, const char *dumproot)
{
char *fullname;
/* There are more efficient ways to do this, but this method
* requires only minimal debugging. */
fullname = malloc(strlen(dumproot) + strlen(name) + 2);
if (!fullname) {
com_err("rdump", errno, "while allocating memory");
return;
}
sprintf(fullname, "%s/%s", dumproot, name);
if (LINUX_S_ISLNK(inode->i_mode))
rdump_symlink(ino, inode, fullname);
else if (LINUX_S_ISREG(inode->i_mode)) {
int fd;
fd = open(fullname, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, S_IRWXU);
if (fd == -1) {
com_err("rdump", errno, "while opening %s", fullname);
goto errout;
}
dump_file("rdump", ino, fd, 1, fullname);
if (close(fd) != 0) {
com_err("rdump", errno, "while closing %s", fullname);
goto errout;
}
}
else if (LINUX_S_ISDIR(inode->i_mode) && strcmp(name, ".") && strcmp(name, "..")) {
errcode_t retval;
/* Create the directory with 0700 permissions, because we
* expect to have to create entries it. Then fix its perms
* once we've done the traversal. */
if (name[0] && mkdir(fullname, S_IRWXU) == -1) {
com_err("rdump", errno, "while making directory %s", fullname);
goto errout;
}
retval = ext2fs_dir_iterate(current_fs, ino, 0, 0,
rdump_dirent, (void *) fullname);
if (retval)
com_err("rdump", retval, "while dumping %s", fullname);
fix_perms("rdump", inode, -1, fullname);
}
/* else do nothing (don't dump device files, sockets, fifos, etc.) */
errout:
free(fullname);
}
extern int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir,
ext2_ino_t ino, char *buf)
{
ext2_filsys fs = ctx->fs;
struct ext2_inode inode;
int inode_modified = 0;
int not_fixed = 0;
unsigned char *frag, *fsize;
struct problem_context pctx;
int problem = 0;
e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode");
clear_problem_context(&pctx);
pctx.ino = ino;
pctx.dir = dir;
pctx.inode = &inode;
if (ext2fs_file_acl_block(fs, &inode) &&
!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
if (fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) {
ext2fs_file_acl_block_set(fs, &inode, 0);
inode_modified++;
} else
not_fixed++;
}
if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) &&
!LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) &&
!LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) &&
!(LINUX_S_ISSOCK(inode.i_mode)))
problem = PR_2_BAD_MODE;
else if (LINUX_S_ISCHR(inode.i_mode)
&& !e2fsck_pass1_check_device_inode(fs, &inode))
problem = PR_2_BAD_CHAR_DEV;
else if (LINUX_S_ISBLK(inode.i_mode)
&& !e2fsck_pass1_check_device_inode(fs, &inode))
problem = PR_2_BAD_BLOCK_DEV;
else if (LINUX_S_ISFIFO(inode.i_mode)
&& !e2fsck_pass1_check_device_inode(fs, &inode))
problem = PR_2_BAD_FIFO;
else if (LINUX_S_ISSOCK(inode.i_mode)
&& !e2fsck_pass1_check_device_inode(fs, &inode))
problem = PR_2_BAD_SOCKET;
else if (LINUX_S_ISLNK(inode.i_mode)
&& !e2fsck_pass1_check_symlink(fs, ino, &inode, buf)) {
problem = PR_2_INVALID_SYMLINK;
}
if (problem) {
if (fix_problem(ctx, problem, &pctx)) {
deallocate_inode(ctx, ino, 0);
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
return 0;
return 1;
} else
not_fixed++;
problem = 0;
}
if (inode.i_faddr) {
if (fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) {
inode.i_faddr = 0;
inode_modified++;
} else
not_fixed++;
}
switch (fs->super->s_creator_os) {
case EXT2_OS_HURD:
frag = &inode.osd2.hurd2.h_i_frag;
fsize = &inode.osd2.hurd2.h_i_fsize;
break;
default:
frag = fsize = 0;
}
if (frag && *frag) {
pctx.num = *frag;
if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) {
*frag = 0;
inode_modified++;
} else
not_fixed++;
pctx.num = 0;
}
if (fsize && *fsize) {
pctx.num = *fsize;
if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) {
*fsize = 0;
inode_modified++;
} else
not_fixed++;
pctx.num = 0;
}
if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
!(fs->super->s_feature_ro_compat &
EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
(inode.osd2.linux2.l_i_blocks_hi != 0)) {
pctx.num = inode.osd2.linux2.l_i_blocks_hi;
if (fix_problem(ctx, PR_2_BLOCKS_HI_ZERO, &pctx)) {
inode.osd2.linux2.l_i_blocks_hi = 0;
inode_modified++;
}
}
if (!(fs->super->s_feature_incompat &
EXT4_FEATURE_INCOMPAT_64BIT) &&
inode.osd2.linux2.l_i_file_acl_high != 0) {
pctx.num = inode.osd2.linux2.l_i_file_acl_high;
if (fix_problem(ctx, PR_2_I_FILE_ACL_HI_ZERO, &pctx)) {
inode.osd2.linux2.l_i_file_acl_high = 0;
inode_modified++;
} else
not_fixed++;
}
if (ext2fs_file_acl_block(fs, &inode) &&
((ext2fs_file_acl_block(fs, &inode) < fs->super->s_first_data_block) ||
(ext2fs_file_acl_block(fs, &inode) >= ext2fs_blocks_count(fs->super)))) {
if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
ext2fs_file_acl_block_set(fs, &inode, 0);
inode_modified++;
} else
not_fixed++;
}
if (inode.i_dir_acl &&
LINUX_S_ISDIR(inode.i_mode)) {
if (fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) {
inode.i_dir_acl = 0;
inode_modified++;
} else
not_fixed++;
}
if (inode_modified)
e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode");
if (!not_fixed && ctx->inode_bad_map)
ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino);
return 0;
}
void addFilespec(FILE *fd, int squash_uids, int squash_perms)
{
unsigned long rmode, mode, uid, gid, major, minor, i;
unsigned long start, increment, count, octmode, decmode;
char *c, *dir, *name, *dname = NULL, *path = NULL, *path2 = NULL, *line = NULL;
char type;
size_t len;
int argv, i2, overWrite = 0, lineno = 0;
__u16 inodeType;
while ( getline(&line, &len, fd) >= 0 ) {
rmode = mode = uid = gid = major = minor = start = count = overWrite = 0;
increment = 1;
lineno++;
if (( c = strchr(line, '#'))) *c = 0;
if ( path ) {
free( path ); path = NULL;
}
if ( path2 ) {
free( path2 ); path2 = NULL;
}
argv = sscanf(line, "%" SCANF_PREFIX "s %c %ld %lu %lu %lu %lu %lu %lu %lu",
SCANF_STRING(path), &type, &rmode, &uid, &gid, &major, &minor,
&start, &increment, &count);
if ( argv < 3 ) {
if ( argv > 0 )
log_warning("device table[%d]: bad format for entry '%s' [skip]", lineno, path);
continue;
}
i2 = 0;
octmode = rmode;
decmode = 0;
while ( octmode != 0 ) {
decmode = decmode + (octmode % 10) * pow(8, i2++);
octmode = octmode / 10;
}
if ( squash_uids ) uid = gid = 0;
mode = decmode;
path2 = strdup( path );
name = basename( path );
dir = dirname( path2 );
if (( !strcmp(name, ".")) || ( !strcmp(name, "..")) || ( !strcmp(name, "/"))) {
log_warning("device table[%d]: [skip]", lineno);
continue;
}
log_action(ACT_CHDIR, dir, NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir(dir)) {
log_warning("device table[%d]: target directory '%s' for entry '%s' does not exist [skip]", lineno, dir, name);
log_action(ACT_CHDIR, "/", NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir("/"))
log_error("[Filesystem error] cannot chdir to root");
continue;
}
if (( type != 'd' ) && ( type != 'f' ) && ( type != 'p' ) && ( type != 'c' ) && ( type != 'b' ) && ( type != 's')) {
log_warning("device table[%d]: bad type '%c' for entry '%s' [skip]", lineno, type, name);
continue;
}
if (squash_perms) {
mode &= ~( LINUX_S_IRWXG | LINUX_S_IRWXO );
rmode &= ~( LINUX_S_IRWXG | LINUX_S_IRWXO);
}
if ( count > 0 ) {
if ( dname ) {
free( dname );
dname = NULL;
}
unsigned len;
len = strlen(name) + 10;
dname = malloc(len + 1);
for ( i = start; i < count; i++ ) {
snprintf(dname, len, "%s%lu", name, i);
if (( overWrite = name_to_inode(dname)))
inodeType = inode_mode(dname);
if (( type == 'd' ) && ( overWrite ) && ( !LINUX_S_ISDIR(inodeType)))
log_error("[Remote fs mismatch] %s/%s exists but isn't a directory when it should be.", log_cwd(), dname);
else if (( type != 'd' ) && ( overWrite )) {
if ( LINUX_S_ISDIR(inodeType))
log_error("[Remote fs mismatch] %s/%s exists but is a directory when it shouldn't be.", log_cwd(), dname);
if ((!LINUX_S_ISREG(inodeType)) && (!LINUX_S_ISLNK(inodeType)) &&
(!LINUX_S_ISBLK(inodeType)) && (!LINUX_S_ISCHR(inodeType)) &&
(!LINUX_S_ISFIFO(inodeType)) && (!LINUX_S_ISSOCK(inodeType)))
log_error("[Remote fs mismatch] Existing file %s/%s has unknown/unsupported type [0x%x].", log_cwd(), dname, inodeType);
}
switch ( type ) {
case 'd':
mode |= LINUX_S_IFDIR;
log_action(ACT_MKDIR, dname, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !overWrite )
if ( !do_mkdir(dname))
log_error("[Filesystem error] cannot mkdir %s/%s", log_cwd(), dname);
break;
case 'c':
case 'b':
if ( type == 'c' )
mode |= LINUX_S_IFCHR;
else
mode |= LINUX_S_IFBLK;
if ( overWrite ) {
log_action(ACT_RM, dname, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(dname))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), dname);
}
log_action(ACT_MKNOD, dname, NULL, 0, 0, 0, type, major, minor + ((i * increment) - start), overWrite);
if ( !do_mknod(dname, type, major, minor + ((i * increment) - start)))
log_error("[Filesystem error] cannot mknod %s/%s", log_cwd(), dname);
break;
case 's':
case 'p':
if ( type == 's' )
mode |= LINUX_S_IFSOCK;
else mode |= LINUX_S_IFIFO;
if ( overWrite ) {
log_action(ACT_RM, dname, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(dname))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), dname);
}
log_action(ACT_MKNOD, dname, NULL, 0, 0, 0, type, 0, 0, overWrite);
if ( !do_mknod(dname, type, 0, 0))
log_error("[Filesystem error] cannot mknod %s/%s", log_cwd(), dname);
break;
}
log_action(ACT_CHMOD, dname, NULL, rmode, 0, 0, 0, 0, 0, 0);
if ( !do_chmod(dname, rmode))
log_error("[Filesystem error] cannot chmod %s/%s", log_cwd(), dname);
log_action(ACT_CHOWN, dname, NULL, 0, uid, gid, 0, 0, 0, 0);
if ( !do_chown(dname, uid, gid))
log_error("[Filesystem error] cannot chown %s/%s", log_cwd(), dname);
}
log_action(ACT_CHDIR, "/", NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir("/"))
log_error("[Filesystem error] cannot chdir to root");
free(dname);
dname = NULL;
} else {
if (( overWrite = name_to_inode(name)))
inodeType = inode_mode(name);
if (( type == 'd' ) && ( overWrite ) && ( !LINUX_S_ISDIR(inodeType)))
log_error("[Remote fs mismatch] %s/%s exists but isn't a directory when it should be.", log_cwd(), dname);
else if ( type != 'd' ) {
if (( overWrite ) && ( LINUX_S_ISDIR(inodeType)))
log_error("[Remote fs mismatch] %s/%s exists but is a directory when it shouldn't be.", log_cwd(), dname);
if (( overWrite ) && (!LINUX_S_ISREG(inodeType)) && (!LINUX_S_ISLNK(inodeType)) &&
(!LINUX_S_ISBLK(inodeType)) && (!LINUX_S_ISCHR(inodeType)) &&
(!LINUX_S_ISFIFO(inodeType)) && (!LINUX_S_ISSOCK(inodeType)))
log_error("[Remote fs mismatch] Existing file %s/%s has unknown/unsupported type [0x%x].", log_cwd(), dname, inodeType);
}
switch ( type ) {
case 'd':
mode |= LINUX_S_IFDIR;
log_action(ACT_MKDIR, name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !overWrite )
if ( !do_mkdir(name))
log_error("[Filesystem error] cannot mkdir %s/%s", log_cwd(), name);
break;
case 'c':
case 'b':
if ( type == 'c' )
mode |= LINUX_S_IFCHR;
else
mode |= LINUX_S_IFBLK;
if ( overWrite ) {
log_action(ACT_RM, name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), name);
}
log_action(ACT_MKNOD, name, NULL, 0, 0, 0, type, major, minor, overWrite);
if ( !do_mknod(name, type, major, minor))
log_error("[Filesystem error] cannot mknod %s/%s", log_cwd(), name);
break;
case 's':
case 'p':
if ( type == 's' )
mode |= LINUX_S_IFSOCK;
else mode |= LINUX_S_IFIFO;
if ( overWrite ) {
log_action(ACT_RM, name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), name);
}
log_action(ACT_MKNOD, name, NULL, 0, 0, 0, type, 0, 0, overWrite);
if ( !do_mknod(name, type, 0, 0))
log_error("[Filesystem error] cannot mknod %s/%s", log_cwd(), name);
break;
}
log_action(ACT_CHMOD, name, NULL, rmode, 0, 0, 0, 0, 0, 0);
if ( !do_chmod(name, rmode))
log_error("[Filesystem error] cannot chmod %s/%s", log_cwd(), name);
log_action(ACT_CHOWN, name, NULL, 0, uid, gid, 0, 0, 0, 0);
if ( !do_chown(name, uid, gid))
log_error("[Filesystem error] cannot chown %s/%s", log_cwd(), name);
log_action(ACT_CHDIR, "/", NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir("/"))
log_error("[Filesystem error] cannot chdir to root");
}
}
if ( line ) {
free( line ); line = NULL;
}
if ( path ) {
free( path ); path = NULL;
}
if ( path2 ) {
free( path2 ); path2 = NULL;
}
}
void search_journal_lost_inode(char* des_dir, __u32 t_after, __u32 t_before, int flag){
struct ext2_inode *p_inode;
struct ext2_inode inode;
int i;
char *pathname = NULL;
char *i_pathname = NULL;
char *buf= NULL;
unsigned char *tmp_buf = NULL;
__u32 blocksize, inodesize;
__u32 inode_per_block;
ext2_ino_t inode_max, inode_nr;
pathname = malloc(26);
blocksize = current_fs->blocksize;
inodesize = current_fs->super->s_inode_size;
inode_max = current_fs->super->s_inodes_count;
inode_per_block = blocksize / inodesize;
inode_nr = inode_max ;
buf = malloc(blocksize);
if (! (flag & 0x01) ){
tmp_buf = malloc (12 * blocksize);
if (!tmp_buf)
goto errout;
cookie = magic_open(MAGIC_MIME | MAGIC_NO_CHECK_COMPRESS | MAGIC_NO_CHECK_ELF | MAGIC_CONTINUE);
if ((! cookie) || magic_load(cookie, NULL)){
fprintf(stderr,"ERROR: can't find libmagic\n");
goto errout;
}
}
while ( get_pool_block(buf) ){
for (i=0 ;i < inode_per_block; i++){
inode_nr++;
p_inode = (struct ext2_inode*) (buf + (i * inodesize));
memset(&inode, 0, sizeof(struct ext2_inode));
#ifdef WORDS_BIGENDIAN
ext2fs_swap_inode(current_fs, &inode, p_inode, 0);
#else
memcpy(&inode, p_inode,128);
#endif
if((inode.i_dtime) || (!inode.i_size) || (!inode.i_blocks) || (!LINUX_S_ISREG(inode.i_mode)))
continue;
if (check_file_stat(&inode)){
i_pathname = identify_filename(i_pathname, tmp_buf, &inode, inode_nr);
sprintf(pathname,"<%lu>",(long unsigned int)inode_nr);
recover_file(des_dir,"MAGIC-2", ((i_pathname)?i_pathname : pathname), &inode, inode_nr, 1);
}
if(i_pathname){
free(i_pathname);
i_pathname = NULL;
}
}
}
errout:
if (pathname)
free(pathname);
if(buf) {
free(buf);
buf = NULL;
}
if (tmp_buf){
free(tmp_buf);
tmp_buf = NULL;
}
if (cookie){
magic_close(cookie);
cookie = 0;
}
return;
}
static int fat_unformat_aux(struct ph_param *params, const struct ph_options *options, const uint64_t start_offset, alloc_data_t *list_search_space)
{
int ind_stop=0;
uint64_t offset;
uint64_t offset_end;
unsigned char *buffer_start;
unsigned char *buffer;
time_t start_time;
time_t previous_time;
const unsigned int blocksize=params->blocksize;
const unsigned int read_size=(blocksize>65536?blocksize:65536);
alloc_data_t *current_search_space;
file_recovery_t file_recovery;
disk_t *disk=params->disk;
const partition_t *partition=params->partition;
reset_file_recovery(&file_recovery);
file_recovery.blocksize=blocksize;
buffer_start=(unsigned char *)MALLOC(READ_SIZE);
buffer=buffer_start;
start_time=time(NULL);
previous_time=start_time;
current_search_space=td_list_entry(list_search_space->list.prev, alloc_data_t, list);
if(current_search_space==list_search_space)
{
free(buffer_start);
return 0;
}
offset_end=current_search_space->end;
current_search_space=td_list_entry(list_search_space->list.next, alloc_data_t, list);
offset=set_search_start(params, ¤t_search_space, list_search_space);
if(options->verbose>0)
info_list_search_space(list_search_space, current_search_space, disk->sector_size, 0, options->verbose);
disk->pread(disk, buffer, READ_SIZE, offset);
for(;offset < offset_end; offset+=blocksize)
{
if(memcmp(buffer, ". ", 8+3)==0 &&
memcmp(&buffer[0x20], ".. ", 8+3)==0)
{
file_data_t *dir_list;
dir_list=dir_fat_aux(buffer,read_size,0,0);
if(dir_list!=NULL)
{
const file_data_t *current_file;
log_info("Sector %llu\n", (long long unsigned)offset/disk->sector_size);
dir_aff_log(NULL, dir_list);
del_search_space(list_search_space, offset, offset + blocksize -1);
current_file=dir_list;
while(current_file!=NULL)
{
if(strcmp(current_file->name,".")==0 &&
LINUX_S_ISDIR(current_file->stat.st_mode)!=0 &&
current_file!=dir_list)
current_file=NULL;
else if(current_file->stat.st_ino>2 &&
LINUX_S_ISREG(current_file->stat.st_mode)!=0)
{
const uint64_t file_start=start_offset + (uint64_t)(current_file->stat.st_ino - 2) * blocksize;
#ifdef DJGPP
const uint64_t file_end=file_start+(current_file->file_size+blocksize-1)/blocksize*blocksize - 1;
#else
const uint64_t file_end=file_start+(current_file->stat.st_size+blocksize-1)/blocksize*blocksize - 1;
#endif
if(file_end < partition->part_offset + partition->part_size)
{
if(fat_copy_file(disk, partition, blocksize, start_offset, params->recup_dir, params->dir_num, current_file)==0)
{
params->file_nbr++;
del_search_space(list_search_space, file_start, file_end);
}
current_file=current_file->next;
}
else
current_file=NULL;
}
else
current_file=current_file->next;
}
delete_list_file(dir_list);
}
}
buffer+=blocksize;
if(buffer+read_size>buffer_start+READ_SIZE)
{
buffer=buffer_start;
if(options->verbose>1)
{
log_verbose("Reading sector %10llu/%llu\n",
(unsigned long long)((offset-partition->part_offset)/disk->sector_size),
(unsigned long long)((partition->part_size-1)/disk->sector_size));
}
if(disk->pread(disk, buffer, READ_SIZE, offset) != READ_SIZE)
{
#ifdef HAVE_NCURSES
wmove(stdscr,11,0);
wclrtoeol(stdscr);
wprintw(stdscr,"Error reading sector %10lu\n",
(unsigned long)((offset-partition->part_offset)/disk->sector_size));
#endif
}
#ifdef HAVE_NCURSES
{
time_t current_time;
current_time=time(NULL);
if(current_time>previous_time)
{
const time_t elapsed_time=current_time - params->real_start_time;
previous_time=current_time;
wmove(stdscr,9,0);
wclrtoeol(stdscr);
log_info("Reading sector %10llu/%llu, %u files found\n",
(unsigned long long)((offset-partition->part_offset)/disk->sector_size),
(unsigned long long)(partition->part_size/disk->sector_size), params->file_nbr);
wprintw(stdscr,"Reading sector %10llu/%llu, %u files found\n",
(unsigned long long)((offset-partition->part_offset)/disk->sector_size),
(unsigned long long)(partition->part_size/disk->sector_size), params->file_nbr);
wmove(stdscr,10,0);
wclrtoeol(stdscr);
wprintw(stdscr,"Elapsed time %uh%02um%02us",
(unsigned)(elapsed_time/60/60),
(unsigned)(elapsed_time/60%60),
(unsigned)(elapsed_time%60));
if(offset-partition->part_offset!=0)
{
wprintw(stdscr," - Estimated time to completion %uh%02um%02u\n",
(unsigned)((partition->part_offset+partition->part_size-1-offset)*elapsed_time/(offset-partition->part_offset)/3600),
(unsigned)(((partition->part_offset+partition->part_size-1-offset)*elapsed_time/(offset-partition->part_offset)/60)%60),
(unsigned)((partition->part_offset+partition->part_size-1-offset)*elapsed_time/(offset-partition->part_offset))%60);
}
wrefresh(stdscr);
if(check_enter_key_or_s(stdscr))
{
log_info("PhotoRec has been stopped\n");
params->offset=offset;
offset = offset_end;
ind_stop=1;
}
}
}
#endif
}
}
free(buffer_start);
return ind_stop;
}
static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
{
struct process_block_struct pb;
struct ext2_super_block *sb = ctx->fs->super;
struct ext2_super_block jsuper;
struct problem_context pctx;
struct buffer_head *bh;
struct inode *j_inode = NULL;
struct kdev_s *dev_fs = NULL, *dev_journal;
const char *journal_name = 0;
journal_t *journal = NULL;
errcode_t retval = 0;
io_manager io_ptr = 0;
unsigned long long start = 0;
int ext_journal = 0;
int tried_backup_jnl = 0;
clear_problem_context(&pctx);
journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal");
if (!journal) {
return EXT2_ET_NO_MEMORY;
}
dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev");
if (!dev_fs) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
dev_journal = dev_fs+1;
dev_fs->k_ctx = dev_journal->k_ctx = ctx;
dev_fs->k_dev = K_DEV_FS;
dev_journal->k_dev = K_DEV_JOURNAL;
journal->j_dev = dev_journal;
journal->j_fs_dev = dev_fs;
journal->j_inode = NULL;
journal->j_blocksize = ctx->fs->blocksize;
if (uuid_is_null(sb->s_journal_uuid)) {
if (!sb->s_journal_inum) {
retval = EXT2_ET_BAD_INODE_NUM;
goto errout;
}
j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode),
"journal inode");
if (!j_inode) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
j_inode->i_ctx = ctx;
j_inode->i_ino = sb->s_journal_inum;
if ((retval = ext2fs_read_inode(ctx->fs,
sb->s_journal_inum,
&j_inode->i_ext2))) {
try_backup_journal:
if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
tried_backup_jnl)
goto errout;
memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks,
EXT2_N_BLOCKS*4);
j_inode->i_ext2.i_size_high = sb->s_jnl_blocks[15];
j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
j_inode->i_ext2.i_links_count = 1;
j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
e2fsck_use_inode_shortcuts(ctx, 1);
ctx->stashed_ino = j_inode->i_ino;
ctx->stashed_inode = &j_inode->i_ext2;
tried_backup_jnl++;
}
if (!j_inode->i_ext2.i_links_count ||
!LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
retval = EXT2_ET_NO_JOURNAL;
goto try_backup_journal;
}
if (EXT2_I_SIZE(&j_inode->i_ext2) / journal->j_blocksize <
JFS_MIN_JOURNAL_BLOCKS) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
pb.last_block = -1;
retval = ext2fs_block_iterate3(ctx->fs, j_inode->i_ino,
BLOCK_FLAG_HOLE, 0,
process_journal_block, &pb);
if ((pb.last_block + 1) * ctx->fs->blocksize <
(int) EXT2_I_SIZE(&j_inode->i_ext2)) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
if (tried_backup_jnl && !(ctx->options & E2F_OPT_READONLY)) {
retval = ext2fs_write_inode(ctx->fs, sb->s_journal_inum,
&j_inode->i_ext2);
if (retval)
goto errout;
}
journal->j_maxlen = EXT2_I_SIZE(&j_inode->i_ext2) /
journal->j_blocksize;
#ifdef USE_INODE_IO
retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum,
&j_inode->i_ext2,
&journal_name);
if (retval)
goto errout;
io_ptr = inode_io_manager;
#else
journal->j_inode = j_inode;
ctx->journal_io = ctx->fs->io;
if ((retval = (errcode_t) journal_bmap(journal, 0, &start)) != 0)
goto errout;
#endif
} else {
ext_journal = 1;
if (!ctx->journal_name) {
char uuid[37];
uuid_unparse(sb->s_journal_uuid, uuid);
ctx->journal_name = blkid_get_devname(ctx->blkid,
"UUID", uuid);
if (!ctx->journal_name)
ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
}
journal_name = ctx->journal_name;
if (!journal_name) {
fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx);
retval = EXT2_ET_LOAD_EXT_JOURNAL;
goto errout;
}
jfs_debug(1, "Using journal file %s\n", journal_name);
io_ptr = unix_io_manager;
}
#if 0
test_io_backing_manager = io_ptr;
io_ptr = test_io_manager;
#endif
#ifndef USE_INODE_IO
if (ext_journal)
#endif
{
int flags = IO_FLAG_RW;
if (!(ctx->mount_flags & EXT2_MF_ISROOT &&
ctx->mount_flags & EXT2_MF_READONLY))
flags |= IO_FLAG_EXCLUSIVE;
if ((ctx->mount_flags & EXT2_MF_READONLY) &&
(ctx->options & E2F_OPT_FORCE))
flags &= ~IO_FLAG_EXCLUSIVE;
retval = io_ptr->open(journal_name, flags,
&ctx->journal_io);
}
if (retval)
goto errout;
io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize);
if (ext_journal) {
blk64_t maxlen;
start = ext2fs_journal_sb_start(ctx->fs->blocksize) - 1;
bh = getblk(dev_journal, start, ctx->fs->blocksize);
if (!bh) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
ll_rw_block(READ, 1, &bh);
if ((retval = bh->b_err) != 0) {
brelse(bh);
goto errout;
}
memcpy(&jsuper, start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET,
sizeof(jsuper));
#ifdef WORDS_BIGENDIAN
if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
ext2fs_swap_super(&jsuper);
#endif
if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
!(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx);
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
/* Make sure the journal UUID is correct */
if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid,
sizeof(jsuper.s_uuid))) {
fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx);
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
/* Check the superblock checksum */
if (jsuper.s_feature_ro_compat &
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
struct struct_ext2_filsys fsx;
struct ext2_super_block superx;
void *p;
p = start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET;
memcpy(&fsx, ctx->fs, sizeof(fsx));
memcpy(&superx, ctx->fs->super, sizeof(superx));
fsx.super = &superx;
fsx.super->s_feature_ro_compat |=
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM;
if (!ext2fs_superblock_csum_verify(&fsx, p) &&
fix_problem(ctx, PR_0_EXT_JOURNAL_SUPER_CSUM_INVALID,
&pctx)) {
ext2fs_superblock_csum_set(&fsx, p);
mark_buffer_dirty(bh);
}
}
brelse(bh);
maxlen = ext2fs_blocks_count(&jsuper);
journal->j_maxlen = (maxlen < 1ULL << 32) ? maxlen : (1ULL << 32) - 1;
start++;
}
if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
journal->j_sb_buffer = bh;
journal->j_superblock = (journal_superblock_t *)bh->b_data;
#ifdef USE_INODE_IO
if (j_inode)
ext2fs_free_mem(&j_inode);
#endif
*ret_journal = journal;
e2fsck_use_inode_shortcuts(ctx, 0);
return 0;
errout:
e2fsck_use_inode_shortcuts(ctx, 0);
if (dev_fs)
ext2fs_free_mem(&dev_fs);
if (j_inode)
ext2fs_free_mem(&j_inode);
if (journal)
ext2fs_free_mem(&journal);
return retval;
}
int
fstat(int fd, struct stat *st)
{
int ret;
struct linux_stat lst;
struct ifreq ifr;
ret = syscall(SYS_fstat, fd, &lst);
if (ret == -1) {
errno = EBADF;
return -1;
}
st->st_size = lst.st_size;
switch (lst.st_mode & LINUX_S_IFMT) {
case LINUX_S_IFSOCK:
__platform_socket_fd = fd;
/* currently no support for raw socket networking */
lst.st_mode = 0;
break;
case LINUX_S_IFBLK:
syscall(SYS_ioctl, fd, BLKGETSIZE64, &st->st_size);
break;
case LINUX_S_IFCHR:
/* macvtap has a dynamic major number, so hard to test */
if (lst.st_rdev != makedev(10, 200) && major(lst.st_rdev) < 128)
break;
ret = syscall(SYS_ioctl, fd, TUNGETIFF, &ifr);
if (ret == 0) {
/* we do not yet support macvtap offload facilities */
if (ifr.ifr_flags & IFF_VNET_HDR) {
ifr.ifr_flags &= ~IFF_VNET_HDR;
syscall(SYS_ioctl, fd, TUNSETIFF, &ifr);
}
/* use sock type to tell config we are network */
lst.st_mode = LINUX_S_IFSOCK;
/* find mac address */
ret = syscall(SYS_ioctl, fd, SIOCGIFHWADDR, &ifr);
if (ret == -1 && __platform_socket_fd != -1)
ret = syscall(SYS_ioctl, __platform_socket_fd, SIOCGIFHWADDR, &ifr);
if (ret == 0) {
memcpy(st->st_hwaddr, ifr.ifr_addr.sa_data, 6);
}
__platform_pollfd[__platform_npoll].fd = fd;
__platform_pollfd[__platform_npoll].events = POLLIN | POLLPRI;
__platform_npoll++;
}
break;
}
st->st_mode = (LINUX_S_ISDIR (lst.st_mode) ? S_IFDIR : 0) |
(LINUX_S_ISCHR (lst.st_mode) ? S_IFCHR : 0) |
(LINUX_S_ISBLK (lst.st_mode) ? S_IFBLK : 0) |
(LINUX_S_ISREG (lst.st_mode) ? S_IFREG : 0) |
(LINUX_S_ISFIFO(lst.st_mode) ? S_IFIFO : 0) |
(LINUX_S_ISLNK (lst.st_mode) ? S_IFLNK : 0) |
(LINUX_S_ISSOCK(lst.st_mode) ? S_IFSOCK : 0);
/* if we are passed in /dev/urandom use as a random source */
if (LINUX_S_ISCHR(lst.st_mode) && lst.st_rdev == makedev(1, 9))
__platform_random_fd = fd;
return 0;
}
static errcode_t ext2fs_get_journal(ext2_filsys fs, journal_t **ret_journal)
{
struct process_block_struct pb;
struct ext2_super_block *sb = fs->super;
struct ext2_super_block jsuper;
struct buffer_head *bh;
struct inode *j_inode = NULL;
struct kdev_s *dev_fs = NULL, *dev_journal;
const char *journal_name = 0;
journal_t *journal = NULL;
errcode_t retval = 0;
io_manager io_ptr = 0;
unsigned long long start = 0;
int ext_journal = 0;
int tried_backup_jnl = 0;
retval = ext2fs_get_memzero(sizeof(journal_t), &journal);
if (retval)
return retval;
retval = ext2fs_get_memzero(2 * sizeof(struct kdev_s), &dev_fs);
if (retval)
goto errout;
dev_journal = dev_fs+1;
dev_fs->k_fs = dev_journal->k_fs = fs;
dev_fs->k_dev = K_DEV_FS;
dev_journal->k_dev = K_DEV_JOURNAL;
journal->j_dev = dev_journal;
journal->j_fs_dev = dev_fs;
journal->j_inode = NULL;
journal->j_blocksize = fs->blocksize;
if (uuid_is_null(sb->s_journal_uuid)) {
if (!sb->s_journal_inum) {
retval = EXT2_ET_BAD_INODE_NUM;
goto errout;
}
retval = ext2fs_get_memzero(sizeof(*j_inode), &j_inode);
if (retval)
goto errout;
j_inode->i_fs = fs;
j_inode->i_ino = sb->s_journal_inum;
retval = ext2fs_read_inode(fs, sb->s_journal_inum,
&j_inode->i_ext2);
if (retval) {
try_backup_journal:
if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
tried_backup_jnl)
goto errout;
memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks,
EXT2_N_BLOCKS*4);
j_inode->i_ext2.i_size_high = sb->s_jnl_blocks[15];
j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
j_inode->i_ext2.i_links_count = 1;
j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
tried_backup_jnl++;
}
if (!j_inode->i_ext2.i_links_count ||
!LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
retval = EXT2_ET_NO_JOURNAL;
goto try_backup_journal;
}
if (EXT2_I_SIZE(&j_inode->i_ext2) / journal->j_blocksize <
JFS_MIN_JOURNAL_BLOCKS) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
pb.last_block = -1;
retval = ext2fs_block_iterate3(fs, j_inode->i_ino,
BLOCK_FLAG_HOLE, 0,
process_journal_block, &pb);
if ((pb.last_block + 1) * fs->blocksize <
(int) EXT2_I_SIZE(&j_inode->i_ext2)) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
if (tried_backup_jnl && (fs->flags & EXT2_FLAG_RW)) {
retval = ext2fs_write_inode(fs, sb->s_journal_inum,
&j_inode->i_ext2);
if (retval)
goto errout;
}
journal->j_maxlen = EXT2_I_SIZE(&j_inode->i_ext2) /
journal->j_blocksize;
#ifdef USE_INODE_IO
retval = ext2fs_inode_io_intern2(fs, sb->s_journal_inum,
&j_inode->i_ext2,
&journal_name);
if (retval)
goto errout;
io_ptr = inode_io_manager;
#else
journal->j_inode = j_inode;
fs->journal_io = fs->io;
retval = (errcode_t)journal_bmap(journal, 0, &start);
if (retval)
goto errout;
#endif
} else {
ext_journal = 1;
if (!fs->journal_name) {
char uuid[37];
blkid_cache blkid;
blkid_get_cache(&blkid, NULL);
uuid_unparse(sb->s_journal_uuid, uuid);
fs->journal_name = blkid_get_devname(blkid,
"UUID", uuid);
if (!fs->journal_name)
fs->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
blkid_put_cache(blkid);
}
journal_name = fs->journal_name;
if (!journal_name) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
goto errout;
}
jfs_debug(1, "Using journal file %s\n", journal_name);
io_ptr = unix_io_manager;
}
#if 0
test_io_backing_manager = io_ptr;
io_ptr = test_io_manager;
#endif
#ifndef USE_INODE_IO
if (ext_journal)
#endif
{
retval = io_ptr->open(journal_name, fs->flags & EXT2_FLAG_RW,
&fs->journal_io);
}
if (retval)
goto errout;
io_channel_set_blksize(fs->journal_io, fs->blocksize);
if (ext_journal) {
blk64_t maxlen;
start = ext2fs_journal_sb_start(fs->blocksize) - 1;
bh = getblk(dev_journal, start, fs->blocksize);
if (!bh) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
ll_rw_block(READ, 1, &bh);
retval = bh->b_err;
if (retval) {
brelse(bh);
goto errout;
}
memcpy(&jsuper, start ? bh->b_data :
bh->b_data + SUPERBLOCK_OFFSET,
sizeof(jsuper));
#ifdef WORDS_BIGENDIAN
if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
ext2fs_swap_super(&jsuper);
#endif
if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
!ext2fs_has_feature_journal_dev(&jsuper)) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
/* Make sure the journal UUID is correct */
if (memcmp(jsuper.s_uuid, fs->super->s_journal_uuid,
sizeof(jsuper.s_uuid))) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
/* Check the superblock checksum */
if (ext2fs_has_feature_metadata_csum(&jsuper)) {
struct struct_ext2_filsys fsx;
struct ext2_super_block superx;
void *p;
p = start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET;
memcpy(&fsx, fs, sizeof(fsx));
memcpy(&superx, fs->super, sizeof(superx));
fsx.super = &superx;
ext2fs_set_feature_metadata_csum(fsx.super);
if (!ext2fs_superblock_csum_verify(&fsx, p)) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
}
brelse(bh);
maxlen = ext2fs_blocks_count(&jsuper);
journal->j_maxlen = (maxlen < 1ULL << 32) ? maxlen :
(1ULL << 32) - 1;
start++;
}
bh = getblk(dev_journal, start, journal->j_blocksize);
if (!bh) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
journal->j_sb_buffer = bh;
journal->j_superblock = (journal_superblock_t *)bh->b_data;
#ifdef USE_INODE_IO
if (j_inode)
ext2fs_free_mem(&j_inode);
#endif
*ret_journal = journal;
return 0;
errout:
if (dev_fs)
ext2fs_free_mem(&dev_fs);
if (j_inode)
ext2fs_free_mem(&j_inode);
if (journal)
ext2fs_free_mem(&journal);
return retval;
}
extern int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir,
ext2_ino_t ino)
{
ext2_filsys fs = ctx->fs;
struct ext2_inode inode;
int inode_modified = 0;
unsigned char *frag, *fsize;
struct problem_context pctx;
int problem = 0;
e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode");
clear_problem_context(&pctx);
pctx.ino = ino;
pctx.dir = dir;
pctx.inode = &inode;
if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) &&
!LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) &&
!LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) &&
!(LINUX_S_ISSOCK(inode.i_mode)))
problem = PR_2_BAD_MODE;
else if (LINUX_S_ISCHR(inode.i_mode)
&& !e2fsck_pass1_check_device_inode(&inode))
problem = PR_2_BAD_CHAR_DEV;
else if (LINUX_S_ISBLK(inode.i_mode)
&& !e2fsck_pass1_check_device_inode(&inode))
problem = PR_2_BAD_BLOCK_DEV;
else if (LINUX_S_ISFIFO(inode.i_mode)
&& !e2fsck_pass1_check_device_inode(&inode))
problem = PR_2_BAD_FIFO;
else if (LINUX_S_ISSOCK(inode.i_mode)
&& !e2fsck_pass1_check_device_inode(&inode))
problem = PR_2_BAD_SOCKET;
else if (LINUX_S_ISLNK(inode.i_mode)
&& !e2fsck_pass1_check_symlink(fs, &inode)) {
problem = PR_2_SYMLINK_SIZE;
}
if (problem) {
if (fix_problem(ctx, problem, &pctx)) {
deallocate_inode(ctx, ino, 0);
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
return 0;
return 1;
}
problem = 0;
}
if (inode.i_faddr &&
fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) {
inode.i_faddr = 0;
inode_modified++;
}
switch (fs->super->s_creator_os) {
case EXT2_OS_LINUX:
frag = &inode.osd2.linux2.l_i_frag;
fsize = &inode.osd2.linux2.l_i_fsize;
break;
case EXT2_OS_HURD:
frag = &inode.osd2.hurd2.h_i_frag;
fsize = &inode.osd2.hurd2.h_i_fsize;
break;
case EXT2_OS_MASIX:
frag = &inode.osd2.masix2.m_i_frag;
fsize = &inode.osd2.masix2.m_i_fsize;
break;
default:
frag = fsize = 0;
}
if (frag && *frag) {
pctx.num = *frag;
if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) {
*frag = 0;
inode_modified++;
}
pctx.num = 0;
}
if (fsize && *fsize) {
pctx.num = *fsize;
if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) {
*fsize = 0;
inode_modified++;
}
pctx.num = 0;
}
if (inode.i_file_acl &&
!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) &&
fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) {
inode.i_file_acl = 0;
inode_modified++;
}
if (inode.i_file_acl &&
((inode.i_file_acl < fs->super->s_first_data_block) ||
(inode.i_file_acl >= fs->super->s_blocks_count)) &&
fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
inode.i_file_acl = 0;
inode_modified++;
}
if (inode.i_dir_acl &&
LINUX_S_ISDIR(inode.i_mode) &&
fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) {
inode.i_dir_acl = 0;
inode_modified++;
}
if (inode_modified)
e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode");
return 0;
}
/*
* This function expands '%IX' expressions
*/
static _INLINE_ void expand_inode_expression(char ch,
struct problem_context *ctx)
{
struct ext2_inode *inode;
struct ext2_inode_large *large_inode;
const char * time_str;
time_t t;
int do_gmt = -1;
if (!ctx || !ctx->inode)
goto no_inode;
inode = ctx->inode;
large_inode = (struct ext2_inode_large *) inode;
switch (ch) {
case 's':
if (LINUX_S_ISDIR(inode->i_mode))
printf("%u", inode->i_size);
else {
#ifdef EXT2_NO_64_TYPE
if (inode->i_size_high)
printf("0x%x%08x", inode->i_size_high,
inode->i_size);
else
printf("%u", inode->i_size);
#else
printf("%llu", inode->i_size |
((long long)inode->i_size_high << 32));
#endif
}
break;
case 'S':
printf("%u", large_inode->i_extra_isize);
break;
case 'b':
printf("%u", inode->i_blocks);
break;
case 'l':
printf("%d", inode->i_links_count);
break;
case 'm':
printf("0%o", inode->i_mode);
break;
case 'M':
/* The diet libc doesn't respect the TZ environemnt variable */
if (do_gmt == -1) {
time_str = getenv("TZ");
if (!time_str)
time_str = "";
do_gmt = !strcmp(time_str, "GMT");
}
t = inode->i_mtime;
time_str = asctime(do_gmt ? gmtime(&t) : localtime(&t));
printf("%.24s", time_str);
break;
case 'F':
printf("%u", inode->i_faddr);
break;
case 'f':
printf("%u", inode->i_file_acl);
break;
case 'd':
printf("%u", (LINUX_S_ISDIR(inode->i_mode) ?
inode->i_dir_acl : 0));
break;
case 'u':
printf("%d", inode_uid(*inode));
break;
case 'g':
printf("%d", inode_gid(*inode));
break;
case 't':
if (LINUX_S_ISREG(inode->i_mode))
printf(_("regular file"));
else if (LINUX_S_ISDIR(inode->i_mode))
printf(_("directory"));
else if (LINUX_S_ISCHR(inode->i_mode))
printf(_("character device"));
else if (LINUX_S_ISBLK(inode->i_mode))
printf(_("block device"));
else if (LINUX_S_ISFIFO(inode->i_mode))
printf(_("named pipe"));
else if (LINUX_S_ISLNK(inode->i_mode))
printf(_("symbolic link"));
else if (LINUX_S_ISSOCK(inode->i_mode))
printf(_("socket"));
else
printf(_("unknown file type with mode 0%o"),
inode->i_mode);
break;
default:
no_inode:
printf("%%I%c", ch);
break;
}
}
/*
* This function expands '%IX' expressions
*/
static _INLINE_ void expand_inode_expression(FILE *f, ext2_filsys fs, char ch,
struct problem_context *ctx)
{
struct ext2_inode *inode;
struct ext2_inode_large *large_inode;
if (!ctx || !ctx->inode)
goto no_inode;
inode = ctx->inode;
large_inode = (struct ext2_inode_large *) inode;
switch (ch) {
case 's':
if (LINUX_S_ISDIR(inode->i_mode))
fprintf(f, "%u", inode->i_size);
else {
#ifdef EXT2_NO_64_TYPE
if (inode->i_size_high)
fprintf(f, "0x%x%08x", inode->i_size_high,
inode->i_size);
else
fprintf(f, "%u", inode->i_size);
#else
fprintf(f, "%llu", EXT2_I_SIZE(inode));
#endif
}
break;
case 'S':
fprintf(f, "%u", large_inode->i_extra_isize);
break;
case 'b':
if (ext2fs_has_feature_huge_file(fs->super))
fprintf(f, "%llu", inode->i_blocks +
(((long long) inode->osd2.linux2.l_i_blocks_hi)
<< 32));
else
fprintf(f, "%u", inode->i_blocks);
break;
case 'l':
fprintf(f, "%d", inode->i_links_count);
break;
case 'm':
fprintf(f, "0%o", inode->i_mode);
break;
case 'M':
print_time(f, inode->i_mtime);
break;
case 'F':
fprintf(f, "%u", inode->i_faddr);
break;
case 'f':
fprintf(f, "%llu", ext2fs_file_acl_block(fs, inode));
break;
case 'd':
fprintf(f, "%u", (LINUX_S_ISDIR(inode->i_mode) ?
inode->i_dir_acl : 0));
break;
case 'u':
fprintf(f, "%d", inode_uid(*inode));
break;
case 'g':
fprintf(f, "%d", inode_gid(*inode));
break;
case 't':
if (LINUX_S_ISREG(inode->i_mode))
fputs(_("regular file"), f);
else if (LINUX_S_ISDIR(inode->i_mode))
fputs(_("directory"), f);
else if (LINUX_S_ISCHR(inode->i_mode))
fputs(_("character device"), f);
else if (LINUX_S_ISBLK(inode->i_mode))
fputs(_("block device"), f);
else if (LINUX_S_ISFIFO(inode->i_mode))
fputs(_("named pipe"), f);
else if (LINUX_S_ISLNK(inode->i_mode))
fputs(_("symbolic link"), f);
else if (LINUX_S_ISSOCK(inode->i_mode))
fputs(_("socket"), f);
else
fprintf(f, _("unknown file type with mode 0%o"),
inode->i_mode);
break;
default:
no_inode:
fprintf(f, "%%I%c", ch);
break;
}
}
static long int dir_aff_ncurses(disk_t *disk, const partition_t *partition, dir_data_t *dir_data, file_data_t*dir_list, const unsigned long int inode, const unsigned int depth)
{
/* Return value
* -1: quit
* 1: back
* other: new inode
* */
int quit=0;
WINDOW *window=(WINDOW*)dir_data->display;
do
{
int offset=0;
int pos_num=0;
file_data_t *pos=dir_list;
int old_LINES=LINES;
unsigned int status=FILE_STATUS_MARKED;
aff_copy(window);
wmove(window,3,0);
aff_part(window, AFF_PART_ORDER|AFF_PART_STATUS, disk, partition);
wmove(window,4,0);
wprintw(window,"Directory %s\n",dir_data->current_directory);
do
{
int i;
int car;
const file_data_t *current_file;
for(i=0,current_file=dir_list;(current_file!=NULL) && (i<offset);current_file=current_file->next,i++);
for(i=offset;(current_file!=NULL) &&((i-offset)<INTER_DIR);i++,current_file=current_file->next)
{
char str[11];
char datestr[80];
wmove(window, 6+i-offset, 0);
wclrtoeol(window); /* before addstr for BSD compatibility */
if(current_file==pos)
{
wattrset(window, A_REVERSE);
waddstr(window, ">");
}
else
waddstr(window, " ");
if((current_file->status&FILE_STATUS_DELETED)!=0 && has_colors())
wbkgdset(window,' ' | COLOR_PAIR(1));
else if((current_file->status&FILE_STATUS_MARKED)!=0 && has_colors())
wbkgdset(window,' ' | COLOR_PAIR(2));
if(current_file->td_mtime!=0)
{
struct tm *tm_p;
tm_p = localtime(¤t_file->td_mtime);
snprintf(datestr, sizeof(datestr),"%2d-%s-%4d %02d:%02d",
tm_p->tm_mday, monstr[tm_p->tm_mon],
1900 + tm_p->tm_year, tm_p->tm_hour,
tm_p->tm_min);
/* May have to use %d instead of %e */
} else {
strncpy(datestr, " ",sizeof(datestr));
}
mode_string(current_file->st_mode, str);
wprintw(window, "%s %5u %5u ",
str, (unsigned int)current_file->st_uid, (unsigned int)current_file->st_gid);
wprintw(window, "%9llu", (long long unsigned int)current_file->st_size);
/* screen may overlap due to long filename */
wprintw(window, " %s %s", datestr, current_file->name);
if(((current_file->status&FILE_STATUS_DELETED)!=0 ||
(current_file->status&FILE_STATUS_MARKED)!=0) && has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
if(current_file==pos)
wattroff(window, A_REVERSE);
}
wmove(window, 6-1, 51);
wclrtoeol(window);
if(offset>0)
wprintw(window, "Previous");
/* Clear the last line, useful if overlapping */
wmove(window,6+i-offset,0);
wclrtoeol(window);
wmove(window, 6+INTER_DIR, 51);
wclrtoeol(window);
if(current_file!=NULL)
wprintw(window, "Next");
if(dir_list==NULL)
{
wmove(window,6,0);
wprintw(window,"No file found, filesystem may be damaged.");
}
/* Redraw the bottom of the screen everytime because very long filenames may have corrupt it*/
mvwaddstr(window,LINES-3,0,"Use ");
if(depth>0)
{
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(0));
waddstr(window, "Left");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
waddstr(window," arrow to go back, ");
}
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(0));
waddstr(window,"Right");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
waddstr(window," to change directory");
if((dir_data->capabilities&CAPA_LIST_DELETED)!=0)
{
waddstr(window,", ");
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(0));
waddstr(window,"h");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
if((dir_data->param&FLAG_LIST_DELETED)==0)
waddstr(window," to unhide deleted files");
else
waddstr(window," to hide deleted files");
}
wmove(window,LINES-2,4);
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(0));
waddstr(window,"q");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
waddstr(window," to quit");
if(dir_data->copy_file!=NULL)
{
waddstr(window,", ");
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(0));
waddstr(window,":");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
waddstr(window," to select the current file, ");
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(0));
waddstr(window,"a");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
if((status&FILE_STATUS_MARKED)==FILE_STATUS_MARKED)
waddstr(window," to select all files ");
else
waddstr(window," to deselect all files");
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(0));
mvwaddstr(window,LINES-1,4,"C");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
waddstr(window," to copy the selected files, ");
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(0));
waddstr(window,"c");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
waddstr(window," to copy the current file");
}
wrefresh(window);
/* Using gnome terminal under FC3, TERM=xterm, the screen is not always correct */
wredrawln(window,0,getmaxy(window)); /* redrawwin def is boggus in pdcur24 */
car=wgetch(window);
wmove(window,5,0);
wclrtoeol(window);
switch(car)
{
case key_ESC:
case 'q':
case 'M':
quit=1;
break;
case '-':
case KEY_LEFT:
case '4':
if(depth>0)
return 1;
break;
case 'h':
if((dir_data->capabilities&CAPA_LIST_DELETED)!=0)
dir_data->param^=FLAG_LIST_DELETED;
return inode;
}
if(dir_list!=NULL)
{
switch(car)
{
case KEY_UP:
case '8':
if(pos->prev!=NULL)
{
pos=pos->prev;
pos_num--;
}
break;
case KEY_DOWN:
case '2':
if(pos->next!=NULL)
{
pos=pos->next;
pos_num++;
}
break;
case ':':
if(!(pos->name[0]=='.' && pos->name[1]=='\0') &&
!(pos->name[0]=='.' && pos->name[1]=='.' && pos->name[2]=='\0'))
pos->status^=FILE_STATUS_MARKED;
if(pos->next!=NULL)
{
pos=pos->next;
pos_num++;
}
break;
case 'a':
{
file_data_t *tmp;
for(tmp=dir_list; tmp!=NULL; tmp=tmp->next)
{
if((tmp->name[0]=='.' && tmp->name[1]=='\0') ||
(tmp->name[0]=='.' && tmp->name[1]=='.' && tmp->name[2]=='\0'))
{
tmp->status&=~FILE_STATUS_MARKED;
}
else
{
if((tmp->status & FILE_STATUS_MARKED)!=status)
tmp->status^=FILE_STATUS_MARKED;
}
}
status^=FILE_STATUS_MARKED;
}
break;
case 'p':
case 'P':
case '+':
case ' ':
case KEY_RIGHT:
case '\r':
case '\n':
case '6':
case KEY_ENTER:
#ifdef PADENTER
case PADENTER:
#endif
if((pos!=NULL) && (LINUX_S_ISDIR(pos->st_mode)!=0))
{
unsigned long int new_inode=pos->st_ino;
if((new_inode!=inode) &&(strcmp(pos->name,".")!=0))
{
if(strcmp(pos->name,"..")==0)
return 1;
if(strlen(dir_data->current_directory)+1+strlen(pos->name)+1<=sizeof(dir_data->current_directory))
{
if(strcmp(dir_data->current_directory,"/"))
strcat(dir_data->current_directory,"/");
strcat(dir_data->current_directory,pos->name);
return (long int)new_inode;
}
}
}
break;
case KEY_PPAGE:
for(i=0;(i<INTER_DIR-1)&&(pos->prev!=NULL);i++)
{
pos=pos->prev;
pos_num--;
}
break;
case KEY_NPAGE:
for(i=0;(i<INTER_DIR-1)&&(pos->next!=NULL);i++)
{
pos=pos->next;
pos_num++;
}
break;
case 'c':
if(dir_data->copy_file!=NULL)
{
const unsigned int current_directory_namelength=strlen(dir_data->current_directory);
if(strcmp(pos->name,"..")!=0 &&
current_directory_namelength+1+strlen(pos->name)<sizeof(dir_data->current_directory)-1)
{
if(strcmp(dir_data->current_directory,"/"))
strcat(dir_data->current_directory,"/");
if(strcmp(pos->name,".")!=0)
strcat(dir_data->current_directory,pos->name);
if(dir_data->local_dir==NULL)
{
if(LINUX_S_ISDIR(pos->st_mode)!=0)
dir_data->local_dir=ask_location("Please select a destination where %s and any files below will be copied.",
dir_data->current_directory, NULL);
else
dir_data->local_dir=ask_location("Please select a destination where %s will be copied.",
dir_data->current_directory, NULL);
}
if(dir_data->local_dir!=NULL)
{
int res=-1;
wmove(window,5,0);
wclrtoeol(window);
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(1));
wprintw(window,"Copying, please wait...");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
wrefresh(window);
if(LINUX_S_ISDIR(pos->st_mode)!=0)
{
res=copy_dir(disk, partition, dir_data, pos);
}
else if(LINUX_S_ISREG(pos->st_mode)!=0)
{
res=dir_data->copy_file(disk, partition, dir_data, pos);
}
wmove(window,5,0);
wclrtoeol(window);
if(res < -1)
{
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(1));
wprintw(window,"Copy failed!");
}
else
{
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(2));
if(res < 0)
wprintw(window,"Copy done! (Failed to copy some files)");
else
wprintw(window,"Copy done!");
}
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
}
dir_data->current_directory[current_directory_namelength]='\0';
}
}
break;
case 'C':
if(dir_data->copy_file!=NULL)
{
if(dir_data->local_dir==NULL)
{
dir_data->local_dir=ask_location("Please select a destination where the marked files will be copied.", NULL, NULL);
}
if(dir_data->local_dir!=NULL)
{
file_data_t *tmp;
int copy_bad=0;
int copy_ok=0;
const unsigned int current_directory_namelength=strlen(dir_data->current_directory);
wmove(window,5,0);
wclrtoeol(window);
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(1));
wprintw(window,"Copying, please wait...");
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
wrefresh(window);
for(tmp=dir_list; tmp!=NULL; tmp=tmp->next)
{
if((tmp->status&FILE_STATUS_MARKED)!=0 &&
current_directory_namelength + 1 + strlen(tmp->name) <
sizeof(dir_data->current_directory)-1)
{
if(strcmp(dir_data->current_directory,"/"))
strcat(dir_data->current_directory,"/");
if(strcmp(tmp->name,".")!=0)
strcat(dir_data->current_directory,tmp->name);
if(LINUX_S_ISDIR(tmp->st_mode)!=0)
{
const int res=copy_dir(disk, partition, dir_data, tmp);
if(res >=-1)
{
tmp->status&=~FILE_STATUS_MARKED;
copy_ok=1;
}
else if(res < 0)
copy_bad=1;
}
else if(LINUX_S_ISREG(tmp->st_mode)!=0)
{
if(dir_data->copy_file(disk, partition, dir_data, tmp) == 0)
{
tmp->status&=~FILE_STATUS_MARKED;
copy_ok=1;
}
else
copy_bad=1;
}
}
dir_data->current_directory[current_directory_namelength]='\0';
}
wmove(window,5,0);
wclrtoeol(window);
if(copy_bad > 0 && copy_ok==0)
{
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(1));
wprintw(window,"Copy failed!");
}
else
{
if(has_colors())
wbkgdset(window,' ' | A_BOLD | COLOR_PAIR(2));
if(copy_bad > 0)
wprintw(window,"Copy done! (Failed to copy some files)");
else if(copy_ok == 0)
wprintw(window,"No file selected");
else
wprintw(window,"Copy done!");
}
if(has_colors())
wbkgdset(window,' ' | COLOR_PAIR(0));
}
}
break;
case 'f':
{
const char *needle=ask_string_ncurses("Filename to find ? ");
if(needle!=NULL && needle[0]!='\0')
{
file_data_t *pos_org=pos;
const int pos_num_org=pos_num;
while(strcmp(pos->name, needle)!=0 && pos->next!=NULL)
{
pos=pos->next;
pos_num++;
}
if(strcmp(pos->name, needle)!=0)
{
pos=pos_org;
pos_num=pos_num_org;
}
}
}
break;
}
if(pos_num<offset)
offset=pos_num;
if(pos_num>=offset+INTER_DIR)
offset=pos_num-INTER_DIR+1;
}
} while(quit==0 && old_LINES==LINES);
} while(quit==0);
return -1;
}
void addPath(const char *path, int squash_uids, int squash_perms)
{
size_t len;
char *full_name = NULL, *lnk = NULL;
struct dirent *file = NULL;
DIR *direc = NULL;
struct stat st;
int overWrite;
__u16 inodeType;
direc = opendir(path);
if ( !direc )
log_error("[Local fs opendir] Cannot open directory %s", path);
while (( file = readdir(direc)) != NULL ) {
if (( !strcmp(file->d_name, "." )) || ( !strcmp(file->d_name, ".." )))
continue;
len = strlen(path) + strlen( file->d_name ) + 3;
if ( full_name ) {
free( full_name );
full_name = NULL;
}
full_name = (char*)malloc(len + 2);
if ( !full_name )
log_error("[Local fs stat] Memory allocation error ( full_name --> %s/%s )", path, file->d_name);
memset(full_name, 0, len + 2);
snprintf(full_name, len, "%s/%s", path, file->d_name);
lstat(full_name, &st);
mode_t fmt = st.st_mode & S_IFMT;
if ( squash_uids )
st.st_uid = st.st_gid = 0;
if ( squash_perms )
st.st_mode &= ~( LINUX_S_IRWXG | LINUX_S_IRWXO );
overWrite = name_to_inode( file->d_name );
if ( st.st_nlink > 1 ) {
if (( lnk = linklist_add(st.st_dev, st.st_ino, full_name + modPath_path_len))) {
if ( overWrite ) {
log_action(ACT_RM, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(file->d_name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), file->d_name);
}
log_action(ACT_HARDLINK, file->d_name, lnk, 0, 0, 0, 0, 0, 0, overWrite);
if (!do_hardlink(&st, lnk, file->d_name))
log_error("[Filesystem error] cannot hardlink %s --> %s", file->d_name, lnk);
continue;
}
}
if ( overWrite )
inodeType = inode_mode( file->d_name );
if (( fmt == S_IFDIR ) && ( overWrite ) && ( !LINUX_S_ISDIR(inodeType)))
log_error("[Remote fs mismatch] %s/%s exists but isn't a directory when it should be.", log_cwd(), file->d_name);
else if (( fmt != S_IFDIR) && ( overWrite )) {
if ( LINUX_S_ISDIR(inodeType))
log_error("[Remote fs mismatch] %s/%s exists but is a directory when it shouldn't be.", log_cwd(), file->d_name);
if ((!LINUX_S_ISREG(inodeType)) && (!LINUX_S_ISLNK(inodeType)) &&
(!LINUX_S_ISBLK(inodeType)) && (!LINUX_S_ISCHR(inodeType)) &&
(!LINUX_S_ISFIFO(inodeType)) && (!LINUX_S_ISSOCK(inodeType)))
log_error("[Remote fs mismatch] Existing file %s/%s has unknown/unsupported type [0x%x].", log_cwd(), file->d_name);
}
switch ( fmt ) {
case S_IFDIR: // Directory
log_action(ACT_MKDIR, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !overWrite )
if ( !do_mkdir( &st, file->d_name ))
log_error("[Filesystem error] cannot mkdir %s/%s", log_cwd(), file->d_name);
log_action(ACT_CHMODE, file->d_name, NULL, st.st_mode, 0, 0, 0, 0, 0, overWrite);
if ( !do_chmode(file->d_name, st.st_mode))
log_error("[Filesystem error] Failed to chmode 0x%x for directory %s/%s", st.st_mode, log_cwd(), file->d_name);
log_action(ACT_CHOWN, file->d_name, NULL, 0, st.st_uid, st.st_gid, 0, 0, 0, 0);
if ( !do_chown(file->d_name, st.st_uid, st.st_gid))
log_error("[Filesystem error] Failed to chown %ld, %ld for directory %s/%s", st.st_uid, st.st_gid, log_cwd(), file->d_name);
log_action(ACT_CHDIR, file->d_name, NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir( file->d_name ))
log_error("[Filesystem error] cannot chdir to newly created %s/%s", log_cwd(), file->d_name);
addPath(full_name, squash_uids, squash_perms);
log_action(ACT_CHDIR, "..", NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir(".."))
log_error("[Filesystem error] cannot chdir to parent directory");
break;
case S_IFREG: // Regular file
if ( overWrite ) {
log_action(ACT_RM, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(file->d_name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), file->d_name);
}
log_action(ACT_WRITE, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_write(full_name, file->d_name))
log_error("[Filesystem error] cannot write %s/%s", log_cwd(), file->d_name);
break;
case S_IFLNK: // Symbolic link
lnk = (char*)malloc(MAX_PATHSIZE + 2);
if ( !lnk )
log_error("[symlink] Memory allocation error (lnk)");
int len = readlink(full_name, lnk, MAX_PATHSIZE);
if ( len == -1 ) {
free(lnk);
log_error("[Local filesystem error] Cannot read destination for link %s/%s", log_cwd(), file->d_name);
} else lnk[len] = '\0';
if ( overWrite ) {
log_action(ACT_RM, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(file->d_name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), file->d_name);
}
log_action(ACT_SYMLINK, file->d_name, lnk, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_symlink(&st, lnk, file->d_name))
log_error("[Filesystem error] cannot symlink %s/%s --> %s", log_cwd(), file->d_name, lnk);
free(lnk);
break;
case S_IFBLK: // Block device node
case S_IFCHR: // Character device node
case S_IFSOCK: // socket
case S_IFIFO: // fifo
if ( overWrite ) {
log_action(ACT_RM, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(file->d_name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), file->d_name);
}
char nodetype = ( fmt == S_IFBLK ? 'b' : ( fmt == S_IFCHR ? 'c' : ( fmt == S_IFSOCK ? 's' : 'p' )));
unsigned long major = 0, minor = 0;
if (( nodetype == 'b' ) || ( nodetype == 'c' )) {
major = (long)major(st.st_rdev);
minor = (long)minor(st.st_rdev);
}
log_action(ACT_MKNOD, file->d_name, NULL, 0, 0, 0, nodetype, major, minor, overWrite);
if ( !do_mknod(file->d_name, nodetype, major, minor))
log_error("[Filesystem error] cannot mknod %c %ld,%ld %s/%s", log_cwd(), nodetype, major, minor, log_cwd(), file->d_name);
break;
}
if ( fmt != S_IFDIR ) { // Not dir ?
log_action(ACT_CHMODE, file->d_name, NULL, st.st_mode, 0, 0, 0, 0, 0, overWrite);
if ( !do_chmode(file->d_name, st.st_mode))
log_error("[Filesystem error] Failed to chmode 0x%x for file %s/%s", st.st_mode, log_cwd(), file->d_name);
log_action(ACT_CHOWN, file->d_name, NULL, 0, st.st_uid, st.st_gid, 0, 0, 0, 0);
if ( !do_chown(file->d_name, st.st_uid, st.st_gid))
log_error("[Filesystem error] Failed to chown %ld, %ld for file %s/%s", st.st_uid, st.st_gid, log_cwd(), file->d_name);
}
if ( full_name ) {
free( full_name );
full_name = NULL;
}
}
closedir(direc);
}
static int copy_dir(disk_t *disk, const partition_t *partition, dir_data_t *dir_data, const file_data_t *dir)
{
static unsigned int dir_nbr=0;
static unsigned long int inode_known[MAX_DIR_NBR];
file_data_t *dir_list;
const unsigned int current_directory_namelength=strlen(dir_data->current_directory);
file_data_t *current_file;
char *dir_name;
int copy_bad=0;
int copy_ok=0;
if(dir_data->get_dir==NULL || dir_data->copy_file==NULL)
return -2;
inode_known[dir_nbr++]=dir->st_ino;
dir_name=mkdir_local(dir_data->local_dir, dir_data->current_directory);
dir_list=dir_data->get_dir(disk, partition, dir_data, (const unsigned long int)dir->st_ino);
for(current_file=dir_list;current_file!=NULL;current_file=current_file->next)
{
dir_data->current_directory[current_directory_namelength]='\0';
if(current_directory_namelength+1+strlen(current_file->name)<sizeof(dir_data->current_directory)-1)
{
if(strcmp(dir_data->current_directory,"/"))
strcat(dir_data->current_directory,"/");
strcat(dir_data->current_directory,current_file->name);
if(LINUX_S_ISDIR(current_file->st_mode)!=0)
{
const unsigned long int new_inode=current_file->st_ino;
unsigned int new_inode_ok=1;
unsigned int i;
if(new_inode<2)
new_inode_ok=0;
if(strcmp(current_file->name,"..")==0 || strcmp(current_file->name,".")==0)
new_inode_ok=0;
for(i=0;i<dir_nbr && new_inode_ok!=0;i++)
if(new_inode==inode_known[i]) /* Avoid loop */
new_inode_ok=0;
if(new_inode_ok>0)
{
int tmp;
tmp=copy_dir(disk, partition, dir_data, current_file);
if(tmp>=-1)
copy_ok=1;
if(tmp<0)
copy_bad=1;
}
}
else if(LINUX_S_ISREG(current_file->st_mode)!=0)
{
// log_trace("copy_file %s\n",dir_data->current_directory);
int tmp;
tmp=dir_data->copy_file(disk, partition, dir_data, current_file);
if(tmp==0)
copy_ok=1;
else
copy_bad=1;
}
}
}
dir_data->current_directory[current_directory_namelength]='\0';
delete_list_file(dir_list);
set_date(dir_name, dir->td_atime, dir->td_mtime);
free(dir_name);
dir_nbr--;
return (copy_bad>0?(copy_ok>0?-1:-2):0);
}
static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
{
struct ext2_super_block *sb = ctx->fs->super;
struct ext2_super_block jsuper;
struct problem_context pctx;
struct buffer_head *bh;
struct inode *j_inode = NULL;
struct kdev_s *dev_fs = NULL, *dev_journal;
const char *journal_name = 0;
journal_t *journal = NULL;
errcode_t retval = 0;
io_manager io_ptr = 0;
unsigned long start = 0;
blk_t blk;
int ext_journal = 0;
int tried_backup_jnl = 0;
int i;
clear_problem_context(&pctx);
journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal");
if (!journal) {
return EXT2_ET_NO_MEMORY;
}
dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev");
if (!dev_fs) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
dev_journal = dev_fs+1;
dev_fs->k_ctx = dev_journal->k_ctx = ctx;
dev_fs->k_dev = K_DEV_FS;
dev_journal->k_dev = K_DEV_JOURNAL;
journal->j_dev = dev_journal;
journal->j_fs_dev = dev_fs;
journal->j_inode = NULL;
journal->j_blocksize = ctx->fs->blocksize;
if (uuid_is_null(sb->s_journal_uuid)) {
if (!sb->s_journal_inum)
return EXT2_ET_BAD_INODE_NUM;
j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode),
"journal inode");
if (!j_inode) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
j_inode->i_ctx = ctx;
j_inode->i_ino = sb->s_journal_inum;
if ((retval = ext2fs_read_inode(ctx->fs,
sb->s_journal_inum,
&j_inode->i_ext2))) {
try_backup_journal:
if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
tried_backup_jnl)
goto errout;
memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks,
EXT2_N_BLOCKS*4);
j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
j_inode->i_ext2.i_links_count = 1;
j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
tried_backup_jnl++;
}
if (!j_inode->i_ext2.i_links_count ||
!LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
retval = EXT2_ET_NO_JOURNAL;
goto try_backup_journal;
}
if (j_inode->i_ext2.i_size / journal->j_blocksize <
JFS_MIN_JOURNAL_BLOCKS) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
for (i=0; i < EXT2_N_BLOCKS; i++) {
blk = j_inode->i_ext2.i_block[i];
if (!blk) {
if (i < EXT2_NDIR_BLOCKS) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
continue;
}
if (blk < sb->s_first_data_block ||
blk >= sb->s_blocks_count) {
retval = EXT2_ET_BAD_BLOCK_NUM;
goto try_backup_journal;
}
}
journal->j_maxlen = j_inode->i_ext2.i_size / journal->j_blocksize;
#ifdef USE_INODE_IO
retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum,
&j_inode->i_ext2,
&journal_name);
if (retval)
goto errout;
io_ptr = inode_io_manager;
#else
journal->j_inode = j_inode;
ctx->journal_io = ctx->fs->io;
if ((retval = journal_bmap(journal, 0, &start)) != 0)
goto errout;
#endif
} else {
ext_journal = 1;
if (!ctx->journal_name) {
char uuid[37];
uuid_unparse(sb->s_journal_uuid, uuid);
ctx->journal_name = blkid_get_devname(ctx->blkid,
"UUID", uuid);
if (!ctx->journal_name)
ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
}
journal_name = ctx->journal_name;
if (!journal_name) {
fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx);
return EXT2_ET_LOAD_EXT_JOURNAL;
}
jfs_debug(1, "Using journal file %s\n", journal_name);
io_ptr = unix_io_manager;
}
#if 0
test_io_backing_manager = io_ptr;
io_ptr = test_io_manager;
#endif
#ifndef USE_INODE_IO
if (ext_journal)
#endif
retval = io_ptr->open(journal_name, IO_FLAG_RW,
&ctx->journal_io);
if (retval)
goto errout;
io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize);
if (ext_journal) {
if (ctx->fs->blocksize == 1024)
start = 1;
bh = getblk(dev_journal, start, ctx->fs->blocksize);
if (!bh) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
ll_rw_block(READ, 1, &bh);
if ((retval = bh->b_err) != 0) {
brelse(bh);
goto errout;
}
memcpy(&jsuper, start ? bh->b_data : bh->b_data + 1024,
sizeof(jsuper));
brelse(bh);
#ifdef EXT2FS_ENABLE_SWAPFS
if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
ext2fs_swap_super(&jsuper);
#endif
if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
!(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx);
retval = EXT2_ET_LOAD_EXT_JOURNAL;
goto errout;
}
/* Make sure the journal UUID is correct */
if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid,
sizeof(jsuper.s_uuid))) {
fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx);
retval = EXT2_ET_LOAD_EXT_JOURNAL;
goto errout;
}
journal->j_maxlen = jsuper.s_blocks_count;
start++;
}
if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
journal->j_sb_buffer = bh;
journal->j_superblock = (journal_superblock_t *)bh->b_data;
#ifdef USE_INODE_IO
if (j_inode)
ext2fs_free_mem(&j_inode);
#endif
*ret_journal = journal;
return 0;
errout:
if (dev_fs)
ext2fs_free_mem(&dev_fs);
if (j_inode)
ext2fs_free_mem(&j_inode);
if (journal)
ext2fs_free_mem(&journal);
return retval;
}
/* Copy the native file to the fs */
errcode_t do_write_internal(ext2_filsys fs, ext2_ino_t cwd, const char *src,
const char *dest, ext2_ino_t root)
{
int fd;
struct stat statbuf;
ext2_ino_t newfile;
errcode_t retval;
struct ext2_inode inode;
int bufsize = IO_BUFSIZE;
int make_holes = 0;
fd = ext2fs_open_file(src, O_RDONLY, 0);
if (fd < 0) {
com_err(src, errno, 0);
return errno;
}
if (fstat(fd, &statbuf) < 0) {
com_err(src, errno, 0);
close(fd);
return errno;
}
retval = ext2fs_namei(fs, root, cwd, dest, &newfile);
if (retval == 0) {
close(fd);
return EXT2_ET_FILE_EXISTS;
}
retval = ext2fs_new_inode(fs, cwd, 010755, 0, &newfile);
if (retval) {
com_err(__func__, retval, 0);
close(fd);
return retval;
}
#ifdef DEBUGFS
printf("Allocated inode: %u\n", newfile);
#endif
retval = ext2fs_link(fs, cwd, dest, newfile,
EXT2_FT_REG_FILE);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, cwd);
if (retval) {
com_err(__func__, retval, "while expanding directory");
close(fd);
return retval;
}
retval = ext2fs_link(fs, cwd, dest, newfile,
EXT2_FT_REG_FILE);
}
if (retval) {
com_err(dest, retval, 0);
close(fd);
return errno;
}
if (ext2fs_test_inode_bitmap2(fs->inode_map, newfile))
com_err(__func__, 0, "Warning: inode already set");
ext2fs_inode_alloc_stats2(fs, newfile, +1, 0);
memset(&inode, 0, sizeof(inode));
inode.i_mode = (statbuf.st_mode & ~LINUX_S_IFMT) | LINUX_S_IFREG;
inode.i_atime = inode.i_ctime = inode.i_mtime =
fs->now ? fs->now : time(0);
inode.i_links_count = 1;
retval = ext2fs_inode_size_set(fs, &inode, statbuf.st_size);
if (retval) {
com_err(dest, retval, 0);
close(fd);
return retval;
}
if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT4_FEATURE_INCOMPAT_INLINE_DATA)) {
inode.i_flags |= EXT4_INLINE_DATA_FL;
} else if (fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_EXTENTS) {
int i;
struct ext3_extent_header *eh;
eh = (struct ext3_extent_header *) &inode.i_block[0];
eh->eh_depth = 0;
eh->eh_entries = 0;
eh->eh_magic = ext2fs_cpu_to_le16(EXT3_EXT_MAGIC);
i = (sizeof(inode.i_block) - sizeof(*eh)) /
sizeof(struct ext3_extent);
eh->eh_max = ext2fs_cpu_to_le16(i);
inode.i_flags |= EXT4_EXTENTS_FL;
}
retval = ext2fs_write_new_inode(fs, newfile, &inode);
if (retval) {
com_err(__func__, retval, "while creating inode %u", newfile);
close(fd);
return retval;
}
if (inode.i_flags & EXT4_INLINE_DATA_FL) {
retval = ext2fs_inline_data_init(fs, newfile);
if (retval) {
com_err("copy_file", retval, 0);
close(fd);
return retval;
}
}
if (LINUX_S_ISREG(inode.i_mode)) {
if (statbuf.st_blocks < statbuf.st_size / S_BLKSIZE) {
make_holes = 1;
/*
* Use I/O blocksize as buffer size when
* copying sparse files.
*/
bufsize = statbuf.st_blksize;
}
retval = copy_file(fs, fd, newfile, bufsize, make_holes);
if (retval)
com_err("copy_file", retval, 0);
}
close(fd);
return retval;
}
