static void handle_bad_blocks(ext2_filsys fs, badblocks_list bb_list)
{
dgrp_t i;
blk_t j;
unsigned must_be_good;
blk_t blk;
badblocks_iterate bb_iter;
errcode_t retval;
blk_t group_block;
int group;
int group_bad;
if (!bb_list)
return;
/*
* The primary superblock and group descriptors *must* be
* good; if not, abort.
*/
must_be_good = fs->super->s_first_data_block + 1 + fs->desc_blocks;
for (i = fs->super->s_first_data_block; i <= must_be_good; i++) {
if (ext2fs_badblocks_list_test(bb_list, i)) {
fprintf(stderr, _("Block %d in primary "
"superblock/group descriptor area bad.\n"), i);
fprintf(stderr, _("Blocks %u through %u must be good "
"in order to build a filesystem.\n"),
fs->super->s_first_data_block, must_be_good);
fputs(_("Aborting....\n"), stderr);
exit(1);
}
}
/*
* See if any of the bad blocks are showing up in the backup
* superblocks and/or group descriptors. If so, issue a
* warning and adjust the block counts appropriately.
*/
group_block = fs->super->s_first_data_block +
fs->super->s_blocks_per_group;
for (i = 1; i < fs->group_desc_count; i++) {
group_bad = 0;
for (j=0; j < fs->desc_blocks+1; j++) {
if (ext2fs_badblocks_list_test(bb_list,
group_block + j)) {
if (!group_bad)
fprintf(stderr,
_("Warning: the backup superblock/group descriptors at block %u contain\n"
" bad blocks.\n\n"),
group_block);
group_bad++;
group = ext2fs_group_of_blk(fs, group_block+j);
fs->group_desc[group].bg_free_blocks_count++;
fs->super->s_free_blocks_count++;
}
}
group_block += fs->super->s_blocks_per_group;
}
/*
* Mark all the bad blocks as used...
*/
retval = ext2fs_badblocks_list_iterate_begin(bb_list, &bb_iter);
if (retval) {
com_err("ext2fs_badblocks_list_iterate_begin", retval,
_("while marking bad blocks as used"));
exit(1);
}
while (ext2fs_badblocks_list_iterate(bb_iter, &blk))
ext2fs_mark_block_bitmap(fs->block_map, blk);
ext2fs_badblocks_list_iterate_end(bb_iter);
}
static void print_inline_journal_information(ext2_filsys fs)
{
journal_superblock_t *jsb;
struct ext2_inode inode;
ext2_file_t journal_file;
errcode_t retval;
ino_t ino = fs->super->s_journal_inum;
char buf[1024];
__u32 *mask_ptr, mask, m;
int i, j, size, printed = 0;
if (fs->flags & EXT2_FLAG_IMAGE_FILE)
return;
retval = ext2fs_read_inode(fs, ino, &inode);
if (retval) {
com_err(program_name, retval, "%s",
_("while reading journal inode"));
exit(1);
}
retval = ext2fs_file_open2(fs, ino, &inode, 0, &journal_file);
if (retval) {
com_err(program_name, retval, "%s",
_("while opening journal inode"));
exit(1);
}
retval = ext2fs_file_read(journal_file, buf, sizeof(buf), 0);
if (retval) {
com_err(program_name, retval, "%s",
_("while reading journal super block"));
exit(1);
}
ext2fs_file_close(journal_file);
jsb = (journal_superblock_t *) buf;
if (be32_to_cpu(jsb->s_header.h_magic) != JFS_MAGIC_NUMBER) {
fprintf(stderr, "%s",
_("Journal superblock magic number invalid!\n"));
exit(1);
}
printf("%s", _("Journal features: "));
for (i=0, mask_ptr=&jsb->s_feature_compat; i <3; i++,mask_ptr++) {
mask = be32_to_cpu(*mask_ptr);
for (j=0,m=1; j < 32; j++, m<<=1) {
if (mask & m) {
printf(" %s", e2p_jrnl_feature2string(i, m));
printed++;
}
}
}
if (printed == 0)
printf(" (none)");
printf("\n");
fputs(_("Journal size: "), stdout);
if ((fs->super->s_feature_ro_compat &
EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
(inode.i_flags & EXT4_HUGE_FILE_FL))
size = inode.i_blocks / (fs->blocksize / 1024);
else
size = inode.i_blocks >> 1;
if (size < 8192)
printf("%uk\n", size);
else
printf("%uM\n", size >> 10);
printf(_("Journal length: %u\n"
"Journal sequence: 0x%08x\n"
"Journal start: %u\n"),
(unsigned int)ntohl(jsb->s_maxlen),
(unsigned int)ntohl(jsb->s_sequence),
(unsigned int)ntohl(jsb->s_start));
if (jsb->s_errno != 0)
printf(_("Journal errno: %d\n"),
(int) ntohl(jsb->s_errno));
}
krb5_error_code
get_securid_edata_2(krb5_context context, krb5_db_entry *client,
krb5_keyblock *client_key, krb5_sam_challenge_2 *sc2)
{
krb5_error_code retval;
krb5_data scratch, track_id = empty_data();
char *user = NULL;
char *def_user = "******";
struct securid_track_data sid_track_data;
krb5_data tmp_data;
krb5_sam_challenge_2_body sc2b;
scratch.data = NULL;
retval = krb5_unparse_name(context, client->princ, &user);
if (retval)
goto cleanup;
memset(&sc2b, 0, sizeof(sc2b));
sc2b.magic = KV5M_SAM_CHALLENGE_2;
sc2b.sam_flags = KRB5_SAM_SEND_ENCRYPTED_SAD;
sc2b.sam_type_name.length = 0;
sc2b.sam_challenge_label.length = 0;
sc2b.sam_challenge.length = 0;
sc2b.sam_response_prompt.data = PASSCODE_message;
sc2b.sam_response_prompt.length = strlen(sc2b.sam_response_prompt.data);
sc2b.sam_pk_for_sad.length = 0;
sc2b.sam_type = PA_SAM_TYPE_SECURID;
sid_track_data.state = SECURID_STATE_INITIAL;
sid_track_data.hostid = gethostid();
tmp_data.data = (char *)&sid_track_data;
tmp_data.length = sizeof(sid_track_data);
retval = securid_encrypt_track_data_2(context, client, &tmp_data,
&track_id);
if (retval != 0) {
com_err("krb5kdc", retval, "while encrypting nonce track data");
goto cleanup;
}
sc2b.sam_track_id = track_id;
scratch.data = (char *)&sc2b.sam_nonce;
scratch.length = sizeof(sc2b.sam_nonce);
retval = krb5_c_random_make_octets(context, &scratch);
if (retval) {
com_err("krb5kdc", retval,
"while generating nonce data in get_securid_edata_2 (%s)",
user ? user : def_user);
goto cleanup;
}
/* Get the client's key */
sc2b.sam_etype = client_key->enctype;
retval = sam_make_challenge(context, &sc2b, client_key, sc2);
if (retval) {
com_err("krb5kdc", retval,
"while making SAM_CHALLENGE_2 checksum (%s)",
user ? user : def_user);
}
cleanup:
free(user);
krb5_free_data_contents(context, &track_id);
return retval;
}
int main (int argc, char *argv[])
{
errcode_t retval = 0, retval2 = 0, orig_retval = 0;
int exit_value = FSCK_OK;
ext2_filsys fs = 0;
io_manager io_ptr;
struct ext2_super_block *sb;
const char *lib_ver_date;
int my_ver, lib_ver;
e2fsck_t ctx;
blk_t orig_superblock;
struct problem_context pctx;
int flags, run_result;
int journal_size;
int sysval, sys_page_size = 4096;
__u32 features[3];
char *cp;
clear_problem_context(&pctx);
#ifdef MTRACE
mtrace();
#endif
#ifdef MCHECK
mcheck(0);
#endif
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
#endif
my_ver = ext2fs_parse_version_string(my_ver_string);
lib_ver = ext2fs_get_library_version(0, &lib_ver_date);
if (my_ver > lib_ver) {
fprintf( stderr, _("Error: ext2fs library version "
"out of date!\n"));
show_version_only++;
}
retval = PRS(argc, argv, &ctx);
if (retval) {
com_err("e2fsck", retval,
_("while trying to initialize program"));
exit(FSCK_ERROR);
}
reserve_stdio_fds();
init_resource_track(&ctx->global_rtrack, NULL);
if (!(ctx->options & E2F_OPT_PREEN) || show_version_only)
fprintf(stderr, "e2fsck %s (%s)\n", my_ver_string,
my_ver_date);
if (show_version_only) {
fprintf(stderr, _("\tUsing %s, %s\n"),
error_message(EXT2_ET_BASE), lib_ver_date);
exit(FSCK_OK);
}
check_mount(ctx);
if (!(ctx->options & E2F_OPT_PREEN) &&
!(ctx->options & E2F_OPT_NO) &&
!(ctx->options & E2F_OPT_YES)) {
if (!ctx->interactive)
fatal_error(ctx,
_("need terminal for interactive repairs"));
}
ctx->superblock = ctx->use_superblock;
restart:
#ifdef CONFIG_TESTIO_DEBUG
if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
io_ptr = test_io_manager;
test_io_backing_manager = unix_io_manager;
} else
#endif
io_ptr = unix_io_manager;
flags = EXT2_FLAG_NOFREE_ON_ERROR;
if ((ctx->options & E2F_OPT_READONLY) == 0)
flags |= EXT2_FLAG_RW;
if ((ctx->mount_flags & EXT2_MF_MOUNTED) == 0)
flags |= EXT2_FLAG_EXCLUSIVE;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) &&
!(ctx->flags & E2F_FLAG_SB_SPECIFIED) &&
((retval == EXT2_ET_BAD_MAGIC) ||
(retval == EXT2_ET_CORRUPT_SUPERBLOCK) ||
((retval == 0) && (retval2 = ext2fs_check_desc(fs))))) {
if (retval2 == ENOMEM) {
retval = retval2;
goto failure;
}
if (fs->flags & EXT2_FLAG_NOFREE_ON_ERROR) {
ext2fs_free(fs);
fs = NULL;
}
if (!fs || (fs->group_desc_count > 1)) {
printf(_("%s: %s trying backup blocks...\n"),
ctx->program_name,
retval ? _("Superblock invalid,") :
_("Group descriptors look bad..."));
orig_superblock = ctx->superblock;
get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr);
if (fs)
ext2fs_close(fs);
orig_retval = retval;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
if ((orig_retval == 0) && retval != 0) {
com_err(ctx->program_name, retval,
"when using the backup blocks");
printf(_("%s: going back to original "
"superblock\n"), ctx->program_name);
ctx->superblock = orig_superblock;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
}
}
}
if (((retval == EXT2_ET_UNSUPP_FEATURE) ||
(retval == EXT2_ET_RO_UNSUPP_FEATURE)) &&
fs && fs->super) {
sb = fs->super;
features[0] = (sb->s_feature_compat &
~EXT2_LIB_FEATURE_COMPAT_SUPP);
features[1] = (sb->s_feature_incompat &
~EXT2_LIB_FEATURE_INCOMPAT_SUPP);
features[2] = (sb->s_feature_ro_compat &
~EXT2_LIB_FEATURE_RO_COMPAT_SUPP);
if (features[0] || features[1] || features[2])
goto print_unsupp_features;
}
failure:
if (retval) {
if (orig_retval)
retval = orig_retval;
com_err(ctx->program_name, retval, _("while trying to open %s"),
ctx->filesystem_name);
if (retval == EXT2_ET_REV_TOO_HIGH) {
printf(_("The filesystem revision is apparently "
"too high for this version of e2fsck.\n"
"(Or the filesystem superblock "
"is corrupt)\n\n"));
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
} else if (retval == EXT2_ET_SHORT_READ)
printf(_("Could this be a zero-length partition?\n"));
else if ((retval == EPERM) || (retval == EACCES))
printf(_("You must have %s access to the "
"filesystem or be root\n"),
(ctx->options & E2F_OPT_READONLY) ?
"r/o" : "r/w");
else if (retval == ENXIO)
printf(_("Possibly non-existent or swap device?\n"));
else if (retval == EBUSY)
printf(_("Filesystem mounted or opened exclusively "
"by another program?\n"));
#ifdef EROFS
else if (retval == EROFS)
printf(_("Disk write-protected; use the -n option "
"to do a read-only\n"
"check of the device.\n"));
#endif
else
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
fatal_error(ctx, 0);
}
/*
* We only update the master superblock because (a) paranoia;
* we don't want to corrupt the backup superblocks, and (b) we
* don't need to update the mount count and last checked
* fields in the backup superblock (the kernel doesn't update
* the backup superblocks anyway). With newer versions of the
* library this flag is set by ext2fs_open2(), but we set this
* here just to be sure. (No, we don't support e2fsck running
* with some other libext2fs than the one that it was shipped
* with, but just in case....)
*/
fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
if (!(ctx->flags & E2F_FLAG_GOT_DEVSIZE)) {
__u32 blocksize = EXT2_BLOCK_SIZE(fs->super);
int need_restart = 0;
pctx.errcode = ext2fs_get_device_size2(ctx->filesystem_name,
blocksize,
&ctx->num_blocks);
/*
* The floppy driver refuses to allow anyone else to
* open the device if has been opened with O_EXCL;
* this is unlike other block device drivers in Linux.
* To handle this, we close the filesystem and then
* reopen the filesystem after we get the device size.
*/
if (pctx.errcode == EBUSY) {
ext2fs_close(fs);
need_restart++;
pctx.errcode =
ext2fs_get_device_size2(ctx->filesystem_name,
blocksize,
&ctx->num_blocks);
}
if (pctx.errcode == EXT2_ET_UNIMPLEMENTED)
ctx->num_blocks = 0;
else if (pctx.errcode) {
fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
fatal_error(ctx, 0);
}
ctx->flags |= E2F_FLAG_GOT_DEVSIZE;
if (need_restart)
goto restart;
}
ctx->fs = fs;
fs->priv_data = ctx;
fs->now = ctx->now;
sb = fs->super;
if (sb->s_rev_level > E2FSCK_CURRENT_REV) {
com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH,
_("while trying to open %s"),
ctx->filesystem_name);
get_newer:
fatal_error(ctx, _("Get a newer version of e2fsck!"));
}
/*
* Set the device name, which is used whenever we print error
* or informational messages to the user.
*/
if (ctx->device_name == 0 &&
(sb->s_volume_name[0] != 0)) {
ctx->device_name = string_copy(ctx, sb->s_volume_name,
sizeof(sb->s_volume_name));
}
if (ctx->device_name == 0)
ctx->device_name = string_copy(ctx, ctx->filesystem_name, 0);
for (cp = ctx->device_name; *cp; cp++)
if (isspace(*cp) || *cp == ':')
*cp = '_';
ehandler_init(fs->io);
if ((ctx->mount_flags & EXT2_MF_MOUNTED) &&
!(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER))
goto skip_journal;
/*
* Make sure the ext3 superblock fields are consistent.
*/
retval = e2fsck_check_ext3_journal(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while checking ext3 journal for %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
/*
* Check to see if we need to do ext3-style recovery. If so,
* do it, and then restart the fsck.
*/
if (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) {
if (ctx->options & E2F_OPT_READONLY) {
printf(_("Warning: skipping journal recovery "
"because doing a read-only filesystem "
"check.\n"));
io_channel_flush(ctx->fs->io);
} else {
if (ctx->flags & E2F_FLAG_RESTARTED) {
/*
* Whoops, we attempted to run the
* journal twice. This should never
* happen, unless the hardware or
* device driver is being bogus.
*/
com_err(ctx->program_name, 0,
_("unable to set superblock flags on %s\n"), ctx->device_name);
fatal_error(ctx, 0);
}
retval = e2fsck_run_ext3_journal(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while recovering ext3 journal of %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
ext2fs_close(ctx->fs);
ctx->fs = 0;
ctx->flags |= E2F_FLAG_RESTARTED;
goto restart;
}
}
skip_journal:
/*
* Check for compatibility with the feature sets. We need to
* be more stringent than ext2fs_open().
*/
features[0] = sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP;
features[1] = sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP;
features[2] = (sb->s_feature_ro_compat &
~EXT2_LIB_FEATURE_RO_COMPAT_SUPP);
print_unsupp_features:
if (features[0] || features[1] || features[2]) {
int i, j;
__u32 *mask = features, m;
fprintf(stderr, _("%s has unsupported feature(s):"),
ctx->filesystem_name);
for (i=0; i <3; i++,mask++) {
for (j=0,m=1; j < 32; j++, m<<=1) {
if (*mask & m)
fprintf(stderr, " %s",
e2p_feature2string(i, m));
}
}
putc('\n', stderr);
goto get_newer;
}
#ifdef ENABLE_COMPRESSION
if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)
com_err(ctx->program_name, 0,
_("Warning: compression support is experimental.\n"));
#endif
#ifndef ENABLE_HTREE
if (sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) {
com_err(ctx->program_name, 0,
_("E2fsck not compiled with HTREE support,\n\t"
"but filesystem %s has HTREE directories.\n"),
ctx->device_name);
goto get_newer;
}
#endif
/*
* If the user specified a specific superblock, presumably the
* master superblock has been trashed. So we mark the
* superblock as dirty, so it can be written out.
*/
if (ctx->superblock &&
!(ctx->options & E2F_OPT_READONLY))
ext2fs_mark_super_dirty(fs);
/*
* Calculate the number of filesystem blocks per pagesize. If
* fs->blocksize > page_size, set the number of blocks per
* pagesize to 1 to avoid division by zero errors.
*/
#ifdef _SC_PAGESIZE
sysval = sysconf(_SC_PAGESIZE);
if (sysval > 0)
sys_page_size = sysval;
#endif /* _SC_PAGESIZE */
ctx->blocks_per_page = sys_page_size / fs->blocksize;
if (ctx->blocks_per_page == 0)
ctx->blocks_per_page = 1;
if (ctx->superblock)
set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0);
ext2fs_mark_valid(fs);
check_super_block(ctx);
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
check_if_skip(ctx);
check_resize_inode(ctx);
if (bad_blocks_file)
read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks);
else if (cflag)
read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
/*
* Mark the system as valid, 'til proven otherwise
*/
ext2fs_mark_valid(fs);
retval = ext2fs_read_bb_inode(fs, &fs->badblocks);
if (retval) {
com_err(ctx->program_name, retval,
_("while reading bad blocks inode"));
preenhalt(ctx);
printf(_("This doesn't bode well,"
" but we'll try to go on...\n"));
}
/*
* Save the journal size in megabytes.
* Try and use the journal size from the backup else let e2fsck
* find the default journal size.
*/
if (sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS)
journal_size = sb->s_jnl_blocks[16] >> 20;
else
void fail(int conn, int err, char *msg)
{
com_err(whoami, err, "%s", msg);
return;
}
static errcode_t copy_file(ext2_filsys fs, int fd, ext2_ino_t newfile,
int bufsize, int make_holes)
{
ext2_file_t e2_file;
errcode_t retval, close_ret;
int got;
unsigned int written;
char *buf;
char *ptr;
char *zero_buf;
int cmp;
retval = ext2fs_file_open(fs, newfile,
EXT2_FILE_WRITE, &e2_file);
if (retval)
return retval;
retval = ext2fs_get_mem(bufsize, &buf);
if (retval) {
com_err("copy_file", retval, "can't allocate buffer\n");
goto out_close;
}
/* This is used for checking whether the whole block is zero */
retval = ext2fs_get_memzero(bufsize, &zero_buf);
if (retval) {
com_err("copy_file", retval, "can't allocate zero buffer\n");
goto out_free_buf;
}
while (1) {
got = read(fd, buf, bufsize);
if (got == 0)
break;
if (got < 0) {
retval = errno;
goto fail;
}
ptr = buf;
/* Sparse copy */
if (make_holes) {
/* Check whether all is zero */
cmp = memcmp(ptr, zero_buf, got);
if (cmp == 0) {
/* The whole block is zero, make a hole */
retval = ext2fs_file_lseek(e2_file, got,
EXT2_SEEK_CUR,
NULL);
if (retval)
goto fail;
got = 0;
}
}
/* Normal copy */
while (got > 0) {
retval = ext2fs_file_write(e2_file, ptr,
got, &written);
if (retval)
goto fail;
got -= written;
ptr += written;
}
}
fail:
ext2fs_free_mem(&zero_buf);
out_free_buf:
ext2fs_free_mem(&buf);
out_close:
close_ret = ext2fs_file_close(e2_file);
if (retval == 0)
retval = close_ret;
return retval;
}
/* Copy files from source_dir to fs */
static errcode_t __populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
const char *source_dir, ext2_ino_t root,
struct hdlinks_s *hdlinks)
{
const char *name;
DIR *dh;
struct dirent *dent;
struct stat st;
char ln_target[PATH_MAX];
unsigned int save_inode;
ext2_ino_t ino;
errcode_t retval = 0;
int read_cnt;
int hdlink;
if (chdir(source_dir) < 0) {
com_err(__func__, errno,
_("while changing working directory to \"%s\""),
source_dir);
return errno;
}
if (!(dh = opendir("."))) {
com_err(__func__, errno,
_("while opening directory \"%s\""), source_dir);
return errno;
}
while ((dent = readdir(dh))) {
if ((!strcmp(dent->d_name, ".")) ||
(!strcmp(dent->d_name, "..")))
continue;
if (lstat(dent->d_name, &st)) {
com_err(__func__, errno, _("while lstat \"%s\""),
dent->d_name);
goto out;
}
name = dent->d_name;
/* Check for hardlinks */
save_inode = 0;
if (!S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode) &&
st.st_nlink > 1) {
hdlink = is_hardlink(hdlinks, st.st_dev, st.st_ino);
if (hdlink >= 0) {
retval = add_link(fs, parent_ino,
hdlinks->hdl[hdlink].dst_ino,
name);
if (retval) {
com_err(__func__, retval,
"while linking %s", name);
goto out;
}
continue;
} else
save_inode = 1;
}
switch(st.st_mode & S_IFMT) {
case S_IFCHR:
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
retval = do_mknod_internal(fs, parent_ino, name, &st);
if (retval) {
com_err(__func__, retval,
_("while creating special file "
"\"%s\""), name);
goto out;
}
break;
case S_IFLNK:
read_cnt = readlink(name, ln_target,
sizeof(ln_target) - 1);
if (read_cnt == -1) {
com_err(__func__, errno,
_("while trying to readlink \"%s\""),
name);
retval = errno;
goto out;
}
ln_target[read_cnt] = '\0';
retval = do_symlink_internal(fs, parent_ino, name,
ln_target, root);
if (retval) {
com_err(__func__, retval,
_("while writing symlink\"%s\""),
name);
goto out;
}
break;
case S_IFREG:
retval = do_write_internal(fs, parent_ino, name, name,
root);
if (retval) {
com_err(__func__, retval,
_("while writing file \"%s\""), name);
goto out;
}
break;
case S_IFDIR:
retval = do_mkdir_internal(fs, parent_ino, name, &st,
root);
if (retval) {
com_err(__func__, retval,
_("while making dir \"%s\""), name);
goto out;
}
retval = ext2fs_namei(fs, root, parent_ino,
name, &ino);
if (retval) {
com_err(name, retval, 0);
goto out;
}
/* Populate the dir recursively*/
retval = __populate_fs(fs, ino, name, root, hdlinks);
if (retval) {
com_err(__func__, retval,
_("while adding dir \"%s\""), name);
goto out;
}
if (chdir("..")) {
com_err(__func__, errno, _("during cd .."));
retval = errno;
goto out;
}
break;
default:
com_err(__func__, 0,
_("ignoring entry \"%s\""), name);
}
retval = ext2fs_namei(fs, root, parent_ino, name, &ino);
if (retval) {
com_err(name, retval, 0);
goto out;
}
retval = set_inode_extra(fs, parent_ino, ino, &st);
if (retval) {
com_err(__func__, retval,
_("while setting inode for \"%s\""), name);
goto out;
}
retval = set_inode_xattr(fs, ino, name);
if (retval) {
com_err(__func__, retval,
_("while setting xattrs for \"%s\""), name);
goto out;
}
/* Save the hardlink ino */
if (save_inode) {
/*
* Check whether need more memory, and we don't need
* free() since the lifespan will be over after the fs
* populated.
*/
if (hdlinks->count == hdlinks->size) {
void *p = realloc(hdlinks->hdl,
(hdlinks->size + HDLINK_CNT) *
sizeof(struct hdlink_s));
if (p == NULL) {
com_err(name, errno,
_("Not enough memory"));
retval = EXT2_ET_NO_MEMORY;
goto out;
}
hdlinks->hdl = p;
hdlinks->size += HDLINK_CNT;
}
hdlinks->hdl[hdlinks->count].src_dev = st.st_dev;
hdlinks->hdl[hdlinks->count].src_ino = st.st_ino;
hdlinks->hdl[hdlinks->count].dst_ino = ino;
hdlinks->count++;
}
}
out:
closedir(dh);
return retval;
}
static void htree_dump_leaf_node(ext2_filsys fs, ext2_ino_t ino,
struct ext2_inode *inode,
struct ext2_dx_root_info * rootnode,
blk_t blk, char *buf)
{
errcode_t errcode;
struct ext2_dir_entry *dirent;
int thislen, col = 0;
unsigned int offset = 0;
char name[EXT2_NAME_LEN + 1];
char tmp[EXT2_NAME_LEN + 16];
blk_t pblk;
ext2_dirhash_t hash, minor_hash;
int rec_len, hash_alg;
errcode = ext2fs_bmap(fs, ino, inode, buf, 0, blk, &pblk);
if (errcode) {
com_err("htree_dump_leaf_node", errcode,
"while mapping logical block %u\n", blk);
return;
}
printf("Reading directory block %lu, phys %lu\n", blk, pblk);
errcode = ext2fs_read_dir_block2(current_fs, pblk, buf, 0);
if (errcode) {
com_err("htree_dump_leaf_node", errcode,
"while reading block %lu (%lu)\n", blk, pblk);
return;
}
hash_alg = rootnode->hash_version;
if ((hash_alg <= EXT2_HASH_TEA) &&
(fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
hash_alg += 3;
while (offset < fs->blocksize) {
dirent = (struct ext2_dir_entry *) (buf + offset);
rec_len = (dirent->rec_len || fs->blocksize < 65536) ?
dirent->rec_len : 65536;
if (((offset + rec_len) > fs->blocksize) ||
(rec_len < 8) ||
((rec_len % 4) != 0) ||
(((dirent->name_len & 0xFF)+8) > rec_len)) {
fprintf(pager, "Corrupted directory block (%u)!\n", blk);
break;
}
thislen = ((dirent->name_len & 0xFF) < EXT2_NAME_LEN) ?
(dirent->name_len & 0xFF) : EXT2_NAME_LEN;
strncpy(name, dirent->name, thislen);
name[thislen] = '\0';
errcode = ext2fs_dirhash(hash_alg, name,
thislen, fs->super->s_hash_seed,
&hash, &minor_hash);
if (errcode)
com_err("htree_dump_leaf_node", errcode,
"while calculating hash");
sprintf(tmp, "%u 0x%08x-%08x (%d) %s ", dirent->inode,
hash, minor_hash, rec_len, name);
thislen = strlen(tmp);
if (col + thislen > 80) {
fprintf(pager, "\n");
col = 0;
}
fprintf(pager, "%s", tmp);
col += thislen;
offset += rec_len;
}
fprintf(pager, "\n");
}
int main(int argc, char *argv[])
{
errcode_t ret;
int c;
int64_t blkno, count, blksize;
char *filename;
io_channel *channel;
char *blks;
/* Some simple defaults */
blksize = 512;
blkno = 0;
count = 1;
initialize_ocfs_error_table();
while((c = getopt(argc, argv, "b:c:B:")) != EOF) {
switch (c) {
case 'b':
blkno = read_number(optarg);
if (blkno < 0) {
fprintf(stderr,
"Invalid blkno: %s\n",
optarg);
print_usage();
return 1;
}
break;
case 'c':
count = read_number(optarg);
if (!count) {
fprintf(stderr,
"Invalid count: %s\n",
optarg);
print_usage();
return 1;
}
break;
case 'B':
blksize = read_number(optarg);
if (!blksize) {
fprintf(stderr,
"Invalid blksize: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (blksize % OCFS2_MIN_BLOCKSIZE) {
fprintf(stderr, "Invalid blocksize: %"PRId64"\n", blksize);
print_usage();
return 1;
}
if (count < 0) {
if (-count > (int64_t)INT_MAX) {
fprintf(stderr, "Count is too large: %"PRId64"\n",
count);
print_usage();
return 1;
}
count = -count / blksize;
} else {
if ((count * blksize) > INT_MAX) {
fprintf(stderr, "Count is too large: %"PRId64"\n",
count);
print_usage();
return 1;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
ret = io_open(filename, OCFS2_FLAG_RO, &channel);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_malloc_blocks(channel, (int)count, &blks);
if (ret) {
com_err(argv[0], ret,
"while allocating %"PRId64" blocks", count);
goto out_channel;
}
ret = io_read_block(channel, blkno, (int)count, blks);
if (ret) {
com_err(argv[0], ret,
"while reading %"PRId64" blocks at block %"PRId64" (%s)",
count, blkno,
strerror(io_get_error(channel)));
goto out_blocks;
}
for (c = 0; c < count; c++)
dump_block(blkno + c, blksize, blks + (c * blksize));
out_blocks:
ocfs2_free(&blks);
out_channel:
ret = io_close(channel);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno;
int c;
int walk_blocks = 0, walk_extents = 0;
char *filename, *buf, *eb_buf = NULL;
ocfs2_filesys *fs;
struct ocfs2_dinode *di;
struct walk_it wi;
struct walk_block wb;
blkno = OCFS2_SUPER_BLOCK_BLKNO;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "bei:")) != EOF) {
switch (c) {
case 'b':
walk_blocks = 1;
break;
case 'e':
walk_extents = 1;
break;
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
if (!(walk_blocks + walk_extents)) {
fprintf(stderr,
"No operation specified\n");
print_usage();
return 1;
}
ret = ocfs2_open(filename, OCFS2_FLAG_RO, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
com_err(argv[0], ret,
"while allocating inode buffer");
goto out_close;
}
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret) {
com_err(argv[0], ret, "while reading inode %"PRIu64, blkno);
goto out_free;
}
di = (struct ocfs2_dinode *)buf;
fprintf(stdout, "OCFS2 inode %"PRIu64" on \"%s\" has depth %"PRId16"\n",
blkno, filename, di->id2.i_list.l_tree_depth);
if (walk_extents) {
if (di->id2.i_list.l_tree_depth) {
ret = ocfs2_malloc_blocks(fs->fs_io,
di->id2.i_list.l_tree_depth,
&eb_buf);
if (ret) {
com_err(argv[0], ret,
"while allocating eb buffer");
goto out_free;
}
}
wi.di = di;
ret = ocfs2_extent_iterate(fs, blkno, 0,
eb_buf,
walk_extents_func,
&wi);
if (ret) {
com_err(argv[0], ret,
"while walking extents");
goto out_free;
}
}
if (walk_blocks) {
wb.di = di;
wb.run_first_blkno = wb.run_first_bcount =
wb.run_prev_blkno = 0;
wb.last_block = (wb.di->i_size +
(fs->fs_blocksize - 1)) /
fs->fs_blocksize;
ret = ocfs2_block_iterate(fs, blkno, 0,
walk_blocks_func,
&wb);
if (ret) {
com_err(argv[0], ret,
"while walking blocks");
goto out_free;
}
}
out_free:
if (eb_buf)
ocfs2_free(&eb_buf);
ocfs2_free(&buf);
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
void do_htree_dump(int argc, char *argv[])
{
ext2_ino_t ino;
struct ext2_inode inode;
int c;
int long_opt = 0;
blk_t blk;
char *buf = NULL;
struct ext2_dx_root_info *rootnode;
struct ext2_dx_entry *ent;
struct ext2_dx_countlimit *limit;
errcode_t errcode;
if (check_fs_open(argv[0]))
return;
pager = open_pager();
reset_getopt();
while ((c = getopt (argc, argv, "l")) != EOF) {
switch (c) {
case 'l':
long_opt++;
break;
default:
goto print_usage;
}
}
if (argc > optind+1) {
print_usage:
com_err(0, 0, "Usage: htree_dump [-l] file");
goto errout;
}
if (argc == optind)
ino = cwd;
else
ino = string_to_inode(argv[optind]);
if (!ino)
goto errout;
if (debugfs_read_inode(ino, &inode, argv[1]))
goto errout;
if (!LINUX_S_ISDIR(inode.i_mode)) {
com_err(argv[0], 0, "Not a directory");
goto errout;
}
if ((inode.i_flags & EXT2_BTREE_FL) == 0) {
com_err(argv[0], 0, "Not a hash-indexed directory");
goto errout;
}
buf = malloc(2*current_fs->blocksize);
if (!buf) {
com_err(argv[0], 0, "Couldn't allocate htree buffer");
goto errout;
}
errcode = ext2fs_bmap(current_fs, ino, &inode, buf, 0, 0, &blk);
if (errcode) {
com_err("do_htree_block", errcode,
"while mapping logical block 0\n");
goto errout;
}
errcode = io_channel_read_blk(current_fs->io, blk,
1, buf);
if (errcode) {
com_err(argv[0], errcode, "Error reading root node");
goto errout;
}
rootnode = (struct ext2_dx_root_info *) (buf + 24);
fprintf(pager, "Root node dump:\n");
fprintf(pager, "\t Reserved zero: %u\n", rootnode->reserved_zero);
fprintf(pager, "\t Hash Version: %d\n", rootnode->hash_version);
fprintf(pager, "\t Info length: %d\n", rootnode->info_length);
fprintf(pager, "\t Indirect levels: %d\n", rootnode->indirect_levels);
fprintf(pager, "\t Flags: %d\n", rootnode->unused_flags);
ent = (struct ext2_dx_entry *) (buf + 24 + rootnode->info_length);
limit = (struct ext2_dx_countlimit *) ent;
htree_dump_int_node(current_fs, ino, &inode, rootnode, ent,
buf + current_fs->blocksize,
rootnode->indirect_levels);
errout:
free(buf);
close_pager(pager);
}
errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
blk64_t *new_size, int flags EXT2FS_ATTR((unused)))
{
#ifdef __linux__
struct ext2_new_group_input input;
struct ext4_new_group_input input64;
struct ext2_super_block *sb = fs->super;
unsigned long new_desc_blocks;
ext2_filsys new_fs;
errcode_t retval;
double percent;
dgrp_t i;
blk_t size;
int fd, overhead;
int use_old_ioctl = 1;
printf(_("Filesystem at %s is mounted on %s; "
"on-line resizing required\n"), fs->device_name, mtpt);
if (*new_size < ext2fs_blocks_count(sb)) {
com_err(program_name, 0, _("On-line shrinking not supported"));
exit(1);
}
/*
* If the number of descriptor blocks is going to increase,
* the on-line resizing inode must be present.
*/
new_desc_blocks = ext2fs_div_ceil(
ext2fs_div64_ceil(*new_size -
fs->super->s_first_data_block,
EXT2_BLOCKS_PER_GROUP(fs->super)),
EXT2_DESC_PER_BLOCK(fs->super));
printf("old_desc_blocks = %lu, new_desc_blocks = %lu\n",
fs->desc_blocks, new_desc_blocks);
/*
* Do error checking to make sure the resize will be successful.
*/
if ((access("/sys/fs/ext4/features/meta_bg_resize", R_OK) != 0) ||
getenv("RESIZE2FS_NO_META_BG_RESIZE")) {
if (!EXT2_HAS_COMPAT_FEATURE(fs->super,
EXT2_FEATURE_COMPAT_RESIZE_INODE) &&
(new_desc_blocks != fs->desc_blocks)) {
com_err(program_name, 0,
_("Filesystem does not support online resizing"));
exit(1);
}
if (EXT2_HAS_COMPAT_FEATURE(fs->super,
EXT2_FEATURE_COMPAT_RESIZE_INODE) &&
new_desc_blocks > (fs->desc_blocks +
fs->super->s_reserved_gdt_blocks)) {
com_err(program_name, 0,
_("Not enough reserved gdt blocks for resizing"));
exit(1);
}
if ((ext2fs_blocks_count(sb) > MAX_32_NUM) ||
(*new_size > MAX_32_NUM)) {
com_err(program_name, 0,
_("Kernel does not support resizing a file system this large"));
exit(1);
}
}
fd = open(mtpt, O_RDONLY);
if (fd < 0) {
com_err(program_name, errno,
_("while trying to open mountpoint %s"), mtpt);
exit(1);
}
if (ioctl(fd, EXT4_IOC_RESIZE_FS, new_size)) {
/*
* If kernel does not support EXT4_IOC_RESIZE_FS, use the
* old online resize. Note that the old approach does not
* handle >32 bit file systems
*
* Sigh, if we are running a 32-bit binary on a 64-bit
* kernel (which happens all the time on the MIPS
* architecture in Debian, but can happen on other CPU
* architectures as well) we will get EINVAL returned
* when an ioctl doesn't exist, at least up to Linux
* 3.1. See compat_sys_ioctl() in fs/compat_ioctl.c
* in the kernel sources. This is probably a kernel
* bug, but work around it here.
*/
if ((errno != ENOTTY) && (errno != EINVAL)) {
if (errno == EPERM)
com_err(program_name, 0,
_("Permission denied to resize filesystem"));
else
com_err(program_name, errno,
_("While checking for on-line resizing "
"support"));
exit(1);
}
} else {
close(fd);
return 0;
}
size = ext2fs_blocks_count(sb);
if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
if (errno == EPERM)
com_err(program_name, 0,
_("Permission denied to resize filesystem"));
else if (errno == ENOTTY)
com_err(program_name, 0,
_("Kernel does not support online resizing"));
else
com_err(program_name, errno,
_("While checking for on-line resizing support"));
exit(1);
}
percent = (ext2fs_r_blocks_count(sb) * 100.0) /
ext2fs_blocks_count(sb);
retval = ext2fs_read_bitmaps(fs);
if (retval)
return retval;
retval = ext2fs_dup_handle(fs, &new_fs);
if (retval)
return retval;
/* The current method of adding one block group at a time to a
* mounted filesystem means it is impossible to accomodate the
* flex_bg allocation method of placing the metadata together
* in a single block group. For now we "fix" this issue by
* using the traditional layout for new block groups, where
* each block group is self-contained and contains its own
* bitmap blocks and inode tables. This means we don't get
* the layout advantages of flex_bg in the new block groups,
* but at least it allows on-line resizing to function.
*/
new_fs->super->s_feature_incompat &= ~EXT4_FEATURE_INCOMPAT_FLEX_BG;
retval = adjust_fs_info(new_fs, fs, 0, *new_size);
if (retval)
return retval;
printf(_("Performing an on-line resize of %s to %llu (%dk) blocks.\n"),
fs->device_name, *new_size, fs->blocksize / 1024);
size = fs->group_desc_count * sb->s_blocks_per_group +
sb->s_first_data_block;
if (size > *new_size)
size = *new_size;
if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
com_err(program_name, errno,
_("While trying to extend the last group"));
exit(1);
}
for (i = fs->group_desc_count;
i < new_fs->group_desc_count; i++) {
overhead = (int) (2 + new_fs->inode_blocks_per_group);
if (ext2fs_bg_has_super(new_fs, new_fs->group_desc_count - 1))
overhead += 1 + new_fs->desc_blocks +
new_fs->super->s_reserved_gdt_blocks;
input.group = i;
input.block_bitmap = ext2fs_block_bitmap_loc(new_fs, i);
input.inode_bitmap = ext2fs_inode_bitmap_loc(new_fs, i);
input.inode_table = ext2fs_inode_table_loc(new_fs, i);
input.blocks_count = ext2fs_group_blocks_count(new_fs, i);
input.reserved_blocks = (blk_t) (percent * input.blocks_count
/ 100.0);
#if 0
printf("new block bitmap is at 0x%04x\n", input.block_bitmap);
printf("new inode bitmap is at 0x%04x\n", input.inode_bitmap);
printf("new inode table is at 0x%04x-0x%04x\n",
input.inode_table,
input.inode_table + new_fs->inode_blocks_per_group-1);
printf("new group has %u blocks\n", input.blocks_count);
printf("new group will reserve %d blocks\n",
input.reserved_blocks);
printf("new group has %d free blocks\n",
ext2fs_bg_free_blocks_count(new_fs, i),
printf("new group has %d free inodes (%d blocks)\n",
ext2fs_bg_free_inodes_count(new_fs, i),
new_fs->inode_blocks_per_group);
printf("Adding group #%d\n", input.group);
#endif
if (use_old_ioctl &&
ioctl(fd, EXT2_IOC_GROUP_ADD, &input) == 0)
continue;
else
use_old_ioctl = 0;
input64.group = input.group;
input64.block_bitmap = input.block_bitmap;
input64.inode_bitmap = input.inode_bitmap;
input64.inode_table = input.inode_table;
input64.blocks_count = input.blocks_count;
input64.reserved_blocks = input.reserved_blocks;
input64.unused = input.unused;
if (ioctl(fd, EXT4_IOC_GROUP_ADD, &input64) < 0) {
com_err(program_name, errno,
_("While trying to add group #%d"),
input.group);
exit(1);
}
}
ext2fs_free(new_fs);
close(fd);
return 0;
#else
printf(_("Filesystem at %s is mounted on %s, and on-line resizing is "
"not supported on this system.\n"), fs->device_name, mtpt);
exit(1);
#endif
}
int run_test(int flags, int size, char *dir, struct test_program *prog)
{
errcode_t retval;
ext2_icount_t icount;
struct test_program *pc;
__u16 result;
int problem = 0;
if (dir) {
retval = ext2fs_create_icount_tdb(test_fs, dir,
flags, &icount);
if (retval) {
com_err("run_test", retval,
"while creating icount using tdb");
exit(1);
}
} else {
retval = ext2fs_create_icount2(test_fs, flags, size, 0,
&icount);
if (retval) {
com_err("run_test", retval, "while creating icount");
exit(1);
}
}
for (pc = prog; pc->cmd != EXIT; pc++) {
switch (pc->cmd) {
case FETCH:
printf("icount_fetch(%u) = ", pc->ino);
break;
case STORE:
retval = ext2fs_icount_store(icount, pc->ino, pc->arg);
if (retval) {
com_err("run_test", retval,
"while calling icount_store");
exit(1);
}
printf("icount_store(%u, %u) = ", pc->ino, pc->arg);
break;
case INCREMENT:
retval = ext2fs_icount_increment(icount, pc->ino, 0);
if (retval) {
com_err("run_test", retval,
"while calling icount_increment");
exit(1);
}
printf("icount_increment(%u) = ", pc->ino);
break;
case DECREMENT:
retval = ext2fs_icount_decrement(icount, pc->ino, 0);
if (retval) {
com_err("run_test", retval,
"while calling icount_decrement");
exit(1);
}
printf("icount_decrement(%u) = ", pc->ino);
break;
}
retval = ext2fs_icount_fetch(icount, pc->ino, &result);
if (retval) {
com_err("run_test", retval,
"while calling icount_fetch");
exit(1);
}
printf("%u (%s)\n", result, (result == pc->expected) ?
"OK" : "NOT OK");
if (result != pc->expected)
problem++;
}
printf("icount size is %u\n", ext2fs_get_icount_size(icount));
retval = ext2fs_icount_validate(icount, stdout);
if (retval) {
com_err("run_test", retval, "while calling icount_validate");
exit(1);
}
ext2fs_free_icount(icount);
return problem;
}
static void PRS(int argc, char *argv[])
{
int b, c;
int size;
char *tmp, *tmp2;
int blocksize = 0;
int inode_ratio = 0;
int inode_size = 0;
double reserved_ratio = 5.0;
int sector_size = 0;
int show_version_only = 0;
unsigned long long num_inodes = 0; /* unsigned long long to catch too-large input */
errcode_t retval;
char * oldpath = getenv("PATH");
char * extended_opts = 0;
const char * fs_type = 0;
blk_t dev_size;
#ifdef __linux__
struct utsname ut;
#endif
long sysval;
int s_opt = -1, r_opt = -1;
char *fs_features = 0;
int use_bsize;
char *newpath;
int pathlen = sizeof(PATH_SET) + 1;
if (oldpath)
pathlen += strlen(oldpath);
newpath = malloc(pathlen);
strcpy(newpath, PATH_SET);
/* Update our PATH to include /sbin */
if (oldpath) {
strcat (newpath, ":");
strcat (newpath, oldpath);
}
putenv (newpath);
tmp = getenv("MKE2FS_SYNC");
if (tmp)
sync_kludge = atoi(tmp);
/* Determine the system page size if possible */
#ifdef HAVE_SYSCONF
#if (!defined(_SC_PAGESIZE) && defined(_SC_PAGE_SIZE))
#define _SC_PAGESIZE _SC_PAGE_SIZE
#endif
#ifdef _SC_PAGESIZE
sysval = sysconf(_SC_PAGESIZE);
if (sysval > 0)
sys_page_size = sysval;
#endif /* _SC_PAGESIZE */
#endif /* HAVE_SYSCONF */
if ((tmp = getenv("MKE2FS_CONFIG")) != NULL)
config_fn[0] = tmp;
profile_set_syntax_err_cb(syntax_err_report);
retval = profile_init(config_fn, &profile);
if (retval == ENOENT) {
profile_init(default_files, &profile);
profile_set_default(profile, mke2fs_default_profile);
}
setbuf(stdout, NULL);
setbuf(stderr, NULL);
add_error_table(&et_ext2_error_table);
add_error_table(&et_prof_error_table);
memset(&fs_param, 0, sizeof(struct ext2_super_block));
fs_param.s_rev_level = 1; /* Create revision 1 filesystems now */
#ifdef __linux__
if (uname(&ut)) {
perror("uname");
exit(1);
}
linux_version_code = parse_version_number(ut.release);
if (linux_version_code && linux_version_code < (2*65536 + 2*256))
fs_param.s_rev_level = 0;
#endif
if (argc && *argv) {
program_name = get_progname(*argv);
/* If called as mkfs.ext3, create a journal inode */
if (!strcmp(program_name, "mkfs.ext3"))
journal_size = -1;
}
while ((c = getopt (argc, argv,
"b:cf:g:i:jl:m:no:qr:s:tvE:FI:J:L:M:N:O:R:ST:V")) != EOF) {
switch (c) {
case 'b':
blocksize = strtol(optarg, &tmp, 0);
b = (blocksize > 0) ? blocksize : -blocksize;
if (b < EXT2_MIN_BLOCK_SIZE ||
b > EXT2_MAX_BLOCK_SIZE || *tmp) {
com_err(program_name, 0,
_("invalid block size - %s"), optarg);
exit(1);
}
if (blocksize > 4096)
fprintf(stderr, _("Warning: blocksize %d not "
"usable on most systems.\n"),
blocksize);
if (blocksize > 0)
fs_param.s_log_block_size =
int_log2(blocksize >>
EXT2_MIN_BLOCK_LOG_SIZE);
break;
case 'c': /* Check for bad blocks */
case 't': /* deprecated */
#ifndef NO_CHECK_BB
cflag++;
#else
com_err(program_name, 0, _("check for bad blocks disabled"));
exit(1);
#endif
break;
case 'f':
size = strtoul(optarg, &tmp, 0);
if (size < EXT2_MIN_BLOCK_SIZE ||
size > EXT2_MAX_BLOCK_SIZE || *tmp) {
com_err(program_name, 0,
_("invalid fragment size - %s"),
optarg);
exit(1);
}
fs_param.s_log_frag_size =
int_log2(size >> EXT2_MIN_BLOCK_LOG_SIZE);
fprintf(stderr, _("Warning: fragments not supported. "
"Ignoring -f option\n"));
break;
case 'g':
fs_param.s_blocks_per_group = strtoul(optarg, &tmp, 0);
if (*tmp) {
com_err(program_name, 0,
_("Illegal number for blocks per group"));
exit(1);
}
if ((fs_param.s_blocks_per_group % 8) != 0) {
com_err(program_name, 0,
_("blocks per group must be multiple of 8"));
exit(1);
}
break;
case 'i':
inode_ratio = strtoul(optarg, &tmp, 0);
if (inode_ratio < EXT2_MIN_BLOCK_SIZE ||
inode_ratio > EXT2_MAX_BLOCK_SIZE * 1024 ||
*tmp) {
com_err(program_name, 0,
_("invalid inode ratio %s (min %d/max %d)"),
optarg, EXT2_MIN_BLOCK_SIZE,
EXT2_MAX_BLOCK_SIZE);
exit(1);
}
break;
case 'J':
parse_journal_opts(optarg);
break;
case 'j':
if (!journal_size)
journal_size = -1;
break;
case 'l':
bad_blocks_filename = malloc(strlen(optarg)+1);
if (!bad_blocks_filename) {
com_err(program_name, ENOMEM,
_("in malloc for bad_blocks_filename"));
exit(1);
}
strcpy(bad_blocks_filename, optarg);
break;
case 'm':
reserved_ratio = strtod(optarg, &tmp);
if (reserved_ratio > 50 || *tmp) {
com_err(program_name, 0,
_("invalid reserved blocks percent - %s"),
optarg);
exit(1);
}
break;
case 'n':
noaction++;
break;
case 'o':
creator_os = optarg;
break;
case 'q':
quiet = 1;
break;
case 'r':
r_opt = strtoul(optarg, &tmp, 0);
if (*tmp) {
com_err(program_name, 0,
_("bad revision level - %s"), optarg);
exit(1);
}
fs_param.s_rev_level = r_opt;
break;
case 's': /* deprecated */
s_opt = atoi(optarg);
break;
case 'I':
inode_size = strtoul(optarg, &tmp, 0);
if (*tmp) {
com_err(program_name, 0,
_("invalid inode size - %s"), optarg);
exit(1);
}
break;
case 'v':
verbose = 1;
break;
case 'F':
force++;
break;
case 'L':
volume_label = optarg;
break;
case 'M':
mount_dir = optarg;
break;
case 'N':
num_inodes = strtoul(optarg, &tmp, 0);
if (*tmp) {
com_err(program_name, 0,
_("bad num inodes - %s"), optarg);
exit(1);
}
break;
case 'O':
fs_features = optarg;
break;
case 'E':
case 'R':
extended_opts = optarg;
break;
case 'S':
super_only = 1;
break;
case 'T':
fs_type = optarg;
break;
case 'V':
/* Print version number and exit */
show_version_only++;
break;
default:
usage();
}
}
if ((optind == argc) && !show_version_only)
usage();
device_name = argv[optind++];
if (!quiet || show_version_only)
fprintf (stderr, "mke2fs %s (%s)\n", E2FSPROGS_VERSION,
E2FSPROGS_DATE);
if (show_version_only) {
fprintf(stderr, _("\tUsing %s\n"),
error_message(EXT2_ET_BASE));
exit(0);
}
/*
* If there's no blocksize specified and there is a journal
* device, use it to figure out the blocksize
*/
if (blocksize <= 0 && journal_device) {
ext2_filsys jfs;
io_manager io_ptr;
#ifdef CONFIG_TESTIO_DEBUG
io_ptr = test_io_manager;
test_io_backing_manager = unix_io_manager;
#else
io_ptr = unix_io_manager;
#endif
retval = ext2fs_open(journal_device,
EXT2_FLAG_JOURNAL_DEV_OK, 0,
0, io_ptr, &jfs);
if (retval) {
com_err(program_name, retval,
_("while trying to open journal device %s\n"),
journal_device);
exit(1);
}
if ((blocksize < 0) && (jfs->blocksize < (unsigned) (-blocksize))) {
com_err(program_name, 0,
_("Journal dev blocksize (%d) smaller than "
"minimum blocksize %d\n"), jfs->blocksize,
-blocksize);
exit(1);
}
blocksize = jfs->blocksize;
fs_param.s_log_block_size =
int_log2(blocksize >> EXT2_MIN_BLOCK_LOG_SIZE);
ext2fs_close(jfs);
}
static errcode_t set_inode_xattr(ext2_filsys fs, ext2_ino_t ino, const char *filename)
{
#ifdef HAVE_LLISTXATTR
errcode_t retval, close_retval;
struct ext2_inode inode;
struct ext2_xattr_handle *handle;
ssize_t size, value_size;
char *list;
int i;
size = llistxattr(filename, NULL, 0);
if (size == -1) {
com_err(__func__, errno, "llistxattr failed on %s", filename);
return errno;
} else if (size == 0) {
return 0;
}
retval = ext2fs_xattrs_open(fs, ino, &handle);
if (retval) {
if (retval == EXT2_ET_MISSING_EA_FEATURE)
return 0;
com_err(__func__, retval, "while opening inode %u", ino);
return retval;
}
retval = ext2fs_get_mem(size, &list);
if (retval) {
com_err(__func__, retval, "whilst allocating memory");
goto out;
}
size = llistxattr(filename, list, size);
if (size == -1) {
com_err(__func__, errno, "llistxattr failed on %s", filename);
retval = errno;
goto out;
}
for (i = 0; i < size; i += strlen(&list[i]) + 1) {
const char *name = &list[i];
char *value;
value_size = getxattr(filename, name, NULL, 0);
if (value_size == -1) {
com_err(__func__, errno, "getxattr failed on %s",
filename);
retval = errno;
break;
}
retval = ext2fs_get_mem(value_size, &value);
if (retval) {
com_err(__func__, retval, "whilst allocating memory");
break;
}
value_size = getxattr(filename, name, value, value_size);
if (value_size == -1) {
ext2fs_free_mem(&value);
com_err(__func__, errno, "getxattr failed on %s",
filename);
retval = errno;
break;
}
retval = ext2fs_xattr_set(handle, name, value, value_size);
ext2fs_free_mem(&value);
if (retval) {
com_err(__func__, retval,
"while writing xattr %u", ino);
break;
}
}
out:
ext2fs_free_mem(&list);
close_retval = ext2fs_xattrs_close(&handle);
if (close_retval) {
com_err(__func__, retval, "while closing inode %u", ino);
retval = retval ? retval : close_retval;
}
return retval;
#else /* HAVE_LLISTXATTR */
return 0;
#endif /* HAVE_LLISTXATTR */
}
errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
blk_t *new_size, int flags)
{
struct ext2_new_group_input input;
struct ext2_super_block *sb = fs->super;
ext2_filsys new_fs;
errcode_t retval;
dgrp_t i;
blk_t size;
int fd, r_frac, overhead;
printf(_("Filesystem at %s is mounted on %s; "
"on-line resizing required\n"), fs->device_name, mtpt);
if (*new_size < sb->s_blocks_count) {
printf(_("On-line shrinking from %u to %u not supported.\n"),
sb->s_blocks_count, *new_size);
exit(1);
}
fd = open(mtpt, O_RDONLY);
if (fd < 0) {
com_err(program_name, errno,
_("while trying to open mountpoint %s"), mtpt);
exit(1);
}
size=sb->s_blocks_count;
if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
if (errno == EPERM)
com_err(program_name, 0,
_("Permission denied to resize filesystem"));
else if (errno == ENOTTY)
com_err(program_name, 0,
_("Filesystem does not support online resizing"));
else
com_err(program_name, errno,
_("While checking for on-line resizing support"));
exit(1);
}
r_frac = ((100 * sb->s_r_blocks_count) + sb->s_blocks_count-1) /
sb->s_blocks_count;
retval = ext2fs_read_bitmaps(fs);
if (retval)
return retval;
retval = ext2fs_dup_handle(fs, &new_fs);
if (retval)
return retval;
retval = adjust_fs_info(new_fs, fs, *new_size);
if (retval)
return retval;
printf(_("Performing an on-line resize of %s to %d (%dk) blocks.\n"),
fs->device_name, *new_size, fs->blocksize / 1024);
size = fs->group_desc_count * sb->s_blocks_per_group +
sb->s_first_data_block;
if (size > *new_size)
size = *new_size;
if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
com_err(program_name, errno,
_("While trying to extend the last group"));
exit(1);
}
for (i = fs->group_desc_count;
i < new_fs->group_desc_count; i++) {
overhead = (int) (2 + new_fs->inode_blocks_per_group);
if (ext2fs_bg_has_super(new_fs, new_fs->group_desc_count - 1))
overhead += 1 + new_fs->desc_blocks +
new_fs->super->s_reserved_gdt_blocks;
input.group = i;
input.block_bitmap = new_fs->group_desc[i].bg_block_bitmap;
input.inode_bitmap = new_fs->group_desc[i].bg_inode_bitmap;
input.inode_table = new_fs->group_desc[i].bg_inode_table;
input.blocks_count = sb->s_blocks_per_group;
if (i == new_fs->group_desc_count-1) {
input.blocks_count = new_fs->super->s_blocks_count -
sb->s_first_data_block -
(i * sb->s_blocks_per_group);
}
input.reserved_blocks = input.blocks_count * r_frac / 100;
#if 0
printf("new block bitmap is at 0x%04x\n", input.block_bitmap);
printf("new inode bitmap is at 0x%04x\n", input.inode_bitmap);
printf("new inode table is at 0x%04x-0x%04x\n",
input.inode_table,
input.inode_table + new_fs->inode_blocks_per_group-1);
printf("new group has %d blocks\n", input.blocks_count);
printf("new group will reserve %d blocks\n",
input.reserved_blocks);
printf("new group has %d free blocks\n",
new_fs->group_desc[i].bg_free_blocks_count);
printf("new group has %d free inodes (%d blocks)\n",
new_fs->group_desc[i].bg_free_inodes_count,
new_fs->inode_blocks_per_group);
printf("Adding group #%d\n", input.group);
#endif
if (ioctl(fd, EXT2_IOC_GROUP_ADD, &input) < 0) {
com_err(program_name, errno,
_("While trying to add group #%d"),
input.group);
exit(1);
}
}
ext2fs_free(new_fs);
close(fd);
return 0;
}
/* Make a special files (block and character devices), fifo's, and sockets */
errcode_t do_mknod_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
struct stat *st)
{
ext2_ino_t ino;
errcode_t retval;
struct ext2_inode inode;
unsigned long devmajor, devminor, mode;
int filetype;
switch(st->st_mode & S_IFMT) {
case S_IFCHR:
mode = LINUX_S_IFCHR;
filetype = EXT2_FT_CHRDEV;
break;
case S_IFBLK:
mode = LINUX_S_IFBLK;
filetype = EXT2_FT_BLKDEV;
break;
case S_IFIFO:
mode = LINUX_S_IFIFO;
filetype = EXT2_FT_FIFO;
break;
case S_IFSOCK:
mode = LINUX_S_IFSOCK;
filetype = EXT2_FT_SOCK;
break;
default:
return EXT2_ET_INVALID_ARGUMENT;
}
if (!(fs->flags & EXT2_FLAG_RW)) {
com_err(__func__, 0, "Filesystem opened read/only");
return EROFS;
}
retval = ext2fs_new_inode(fs, cwd, 010755, 0, &ino);
if (retval) {
com_err(__func__, retval, 0);
return retval;
}
#ifdef DEBUGFS
printf("Allocated inode: %u\n", ino);
#endif
retval = ext2fs_link(fs, cwd, name, ino, filetype);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, cwd);
if (retval) {
com_err(__func__, retval, "while expanding directory");
return retval;
}
retval = ext2fs_link(fs, cwd, name, ino, filetype);
}
if (retval) {
com_err(name, retval, 0);
return retval;
}
if (ext2fs_test_inode_bitmap2(fs->inode_map, ino))
com_err(__func__, 0, "Warning: inode already set");
ext2fs_inode_alloc_stats2(fs, ino, +1, 0);
memset(&inode, 0, sizeof(inode));
inode.i_mode = mode;
inode.i_atime = inode.i_ctime = inode.i_mtime =
fs->now ? fs->now : time(0);
if (filetype != S_IFIFO) {
devmajor = major(st->st_rdev);
devminor = minor(st->st_rdev);
if ((devmajor < 256) && (devminor < 256)) {
inode.i_block[0] = devmajor * 256 + devminor;
inode.i_block[1] = 0;
} else {
inode.i_block[0] = 0;
inode.i_block[1] = (devminor & 0xff) | (devmajor << 8) |
((devminor & ~0xff) << 12);
}
}
inode.i_links_count = 1;
retval = ext2fs_write_new_inode(fs, ino, &inode);
if (retval)
com_err(__func__, retval, "while creating inode %u", ino);
return retval;
}
static void test_hmac()
{
krb5_keyblock key;
krb5_data in, out;
char outbuf[20];
char stroutbuf[80];
krb5_error_code err;
unsigned int i, j;
int lose = 0;
struct k5buf buf;
/* RFC 2202 test vector. */
static const struct hmac_test md5tests[] = {
{
16, {
0xb, 0xb, 0xb, 0xb, 0xb, 0xb, 0xb, 0xb,
0xb, 0xb, 0xb, 0xb, 0xb, 0xb, 0xb, 0xb,
},
8, "Hi There",
"0x9294727a3638bb1c13f48ef8158bfc9d"
},
{
4, "Jefe",
28, "what do ya want for nothing?",
"0x750c783e6ab0b503eaa86e310a5db738"
},
{
16, {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
},
50, {
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
},
"0x56be34521d144c88dbb8c733f0e8b3f6"
},
{
25, {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16, 0x17, 0x18, 0x19
},
50, {
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
},
"0x697eaf0aca3a3aea3a75164746ffaa79"
},
{
16, {
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c
},
20, "Test With Truncation",
"0x56461ef2342edc00f9bab995690efd4c"
},
{
80, {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
54, "Test Using Larger Than Block-Size Key - Hash Key First",
"0x6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd"
},
{
80, {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
73,
"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
"0x6f630fad67cda0ee1fb1f562db3aa53e"
},
};
for (i = 0; i < sizeof(md5tests)/sizeof(md5tests[0]); i++) {
key.contents = md5tests[i].key;
key.length = md5tests[i].key_len;
in.data = md5tests[i].data;
in.length = md5tests[i].data_len;
out.data = outbuf;
out.length = 20;
printf("\nTest #%d:\n", i+1);
err = hmac1(&krb5int_hash_md5, &key, &in, &out);
if (err) {
com_err(whoami, err, "computing hmac");
exit(1);
}
k5_buf_init_fixed(&buf, stroutbuf, sizeof(stroutbuf));
k5_buf_add(&buf, "0x");
for (j = 0; j < out.length; j++)
k5_buf_add_fmt(&buf, "%02x", 0xff & outbuf[j]);
if (k5_buf_data(&buf) == NULL)
abort();
if (strcmp(stroutbuf, md5tests[i].hexdigest)) {
printf("*** CHECK FAILED!\n"
"\tReturned: %s.\n"
"\tExpected: %s.\n", stroutbuf, md5tests[i].hexdigest);
lose++;
} else
printf("Matches expected result.\n");
}
/* Do again with SHA-1 tests.... */
if (lose) {
printf("%d failures; exiting.\n", lose);
exit(1);
}
}
/* 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;
}
int main (int argc, char *argv[]) {
const char *me;
krb5_data crealm, srealm, transit;
krb5_error_code r;
int expand_only = 0;
me = strrchr (argv[0], '/');
me = me ? me+1 : argv[0];
while (argc > 3 && argv[1][0] == '-') {
if (!strcmp ("-v", argv[1]))
verbose++, argc--, argv++;
else if (!strcmp ("-x", argv[1]))
expand_only++, argc--, argv++;
else
goto usage;
}
if (argc != 4) {
usage:
printf ("usage: %s [-v] [-x] clientRealm serverRealm transitEncoding\n",
me);
return 1;
}
crealm.data = argv[1];
crealm.length = strlen(argv[1]);
srealm.data = argv[2];
srealm.length = strlen(argv[2]);
transit.data = argv[3];
transit.length = strlen(argv[3]);
if (expand_only) {
printf ("client realm: %s\n", argv[1]);
printf ("server realm: %s\n", argv[2]);
printf ("transit enc.: %s\n", argv[3]);
if (argv[3][0] == 0) {
printf ("no other realms transited\n");
return 0;
}
r = foreach_realm (print_a_realm, NULL, &crealm, &srealm, &transit);
if (r)
printf ("--> returned error %ld\n", (long) r);
return r != 0;
} else {
/* Actually check the values against the supplied krb5.conf file. */
krb5_context ctx;
r = krb5_init_context (&ctx);
if (r) {
com_err (me, r, "initializing krb5 context");
return 1;
}
r = krb5_check_transited_list (ctx, &transit, &crealm, &srealm);
if (r == KRB5KRB_AP_ERR_ILL_CR_TKT) {
printf ("NO\n");
} else if (r == 0) {
printf ("YES\n");
} else {
printf ("kablooey!\n");
com_err (me, r, "checking transited-realm list");
return 1;
}
return 0;
}
}
static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
{
int flush = 0;
int c, fd;
#ifdef MTRACE
extern void *mallwatch;
#endif
e2fsck_t ctx;
errcode_t retval;
#ifdef HAVE_SIGNAL_H
struct sigaction sa;
#endif
char *extended_opts = 0;
char *cp;
int res; /* result of sscanf */
#ifdef CONFIG_JBD_DEBUG
char *jbd_debug;
#endif
retval = e2fsck_allocate_context(&ctx);
if (retval)
return retval;
*ret_ctx = ctx;
setvbuf(stdout, NULL, _IONBF, BUFSIZ);
setvbuf(stderr, NULL, _IONBF, BUFSIZ);
if (isatty(0) && isatty(1)) {
ctx->interactive = 1;
} else {
ctx->start_meta[0] = '\001';
ctx->stop_meta[0] = '\002';
}
memset(bar, '=', sizeof(bar)-1);
memset(spaces, ' ', sizeof(spaces)-1);
add_error_table(&et_ext2_error_table);
add_error_table(&et_prof_error_table);
blkid_get_cache(&ctx->blkid, NULL);
if (argc && *argv)
ctx->program_name = *argv;
else
ctx->program_name = "e2fsck";
while ((c = getopt (argc, argv, "panyrcC:B:dE:fvtFVM:b:I:j:P:l:L:N:SsDk")) != EOF)
switch (c) {
case 'C':
ctx->progress = e2fsck_update_progress;
res = sscanf(optarg, "%d", &ctx->progress_fd);
if (res != 1)
goto sscanf_err;
if (ctx->progress_fd < 0) {
ctx->progress = 0;
ctx->progress_fd = ctx->progress_fd * -1;
}
if (!ctx->progress_fd)
break;
/* Validate the file descriptor to avoid disasters */
fd = dup(ctx->progress_fd);
if (fd < 0) {
fprintf(stderr,
_("Error validating file descriptor %d: %s\n"),
ctx->progress_fd,
error_message(errno));
fatal_error(ctx,
_("Invalid completion information file descriptor"));
} else
close(fd);
break;
case 'D':
ctx->options |= E2F_OPT_COMPRESS_DIRS;
break;
case 'E':
extended_opts = optarg;
break;
case 'p':
case 'a':
if (ctx->options & (E2F_OPT_YES|E2F_OPT_NO)) {
conflict_opt:
fatal_error(ctx,
_("Only one of the options -p/-a, -n or -y may be specified."));
}
ctx->options |= E2F_OPT_PREEN;
break;
case 'n':
if (ctx->options & (E2F_OPT_YES|E2F_OPT_PREEN))
goto conflict_opt;
ctx->options |= E2F_OPT_NO;
break;
case 'y':
if (ctx->options & (E2F_OPT_PREEN|E2F_OPT_NO))
goto conflict_opt;
ctx->options |= E2F_OPT_YES;
break;
case 't':
#ifdef RESOURCE_TRACK
if (ctx->options & E2F_OPT_TIME)
ctx->options |= E2F_OPT_TIME2;
else
ctx->options |= E2F_OPT_TIME;
#else
fprintf(stderr, _("The -t option is not "
"supported on this version of e2fsck.\n"));
#endif
break;
case 'c':
if (cflag++)
ctx->options |= E2F_OPT_WRITECHECK;
ctx->options |= E2F_OPT_CHECKBLOCKS;
break;
case 'r':
/* What we do by default, anyway! */
break;
case 'b':
res = sscanf(optarg, "%u", &ctx->use_superblock);
if (res != 1)
goto sscanf_err;
ctx->flags |= E2F_FLAG_SB_SPECIFIED;
break;
case 'B':
ctx->blocksize = atoi(optarg);
break;
case 'I':
res = sscanf(optarg, "%d", &ctx->inode_buffer_blocks);
if (res != 1)
goto sscanf_err;
break;
case 'j':
ctx->journal_name = string_copy(ctx, optarg, 0);
break;
case 'P':
res = sscanf(optarg, "%d", &ctx->process_inode_size);
if (res != 1)
goto sscanf_err;
break;
case 'L':
replace_bad_blocks++;
case 'l':
bad_blocks_file = string_copy(ctx, optarg, 0);
break;
case 'd':
ctx->options |= E2F_OPT_DEBUG;
break;
case 'f':
ctx->options |= E2F_OPT_FORCE;
break;
case 'F':
flush = 1;
break;
case 'v':
verbose = 1;
break;
case 'V':
show_version_only = 1;
break;
#ifdef MTRACE
case 'M':
mallwatch = (void *) strtol(optarg, NULL, 0);
break;
#endif
case 'N':
ctx->device_name = string_copy(ctx, optarg, 0);
break;
case 'k':
keep_bad_blocks++;
break;
default:
usage(ctx);
}
if (show_version_only)
return 0;
if (optind != argc - 1)
usage(ctx);
if ((ctx->options & E2F_OPT_NO) &&
(ctx->options & E2F_OPT_COMPRESS_DIRS)) {
com_err(ctx->program_name, 0,
_("The -n and -D options are incompatible."));
fatal_error(ctx, 0);
}
if ((ctx->options & E2F_OPT_NO) && cflag) {
com_err(ctx->program_name, 0,
_("The -n and -c options are incompatible."));
fatal_error(ctx, 0);
}
if ((ctx->options & E2F_OPT_NO) && bad_blocks_file) {
com_err(ctx->program_name, 0,
_("The -n and -l/-L options are incompatible."));
fatal_error(ctx, 0);
}
if (ctx->options & E2F_OPT_NO)
ctx->options |= E2F_OPT_READONLY;
ctx->io_options = strchr(argv[optind], '?');
if (ctx->io_options)
*ctx->io_options++ = 0;
ctx->filesystem_name = blkid_get_devname(ctx->blkid, argv[optind], 0);
if (!ctx->filesystem_name) {
com_err(ctx->program_name, 0, _("Unable to resolve '%s'"),
argv[optind]);
fatal_error(ctx, 0);
}
if (extended_opts)
parse_extended_opts(ctx, extended_opts);
if ((cp = getenv("E2FSCK_CONFIG")) != NULL)
config_fn[0] = cp;
profile_set_syntax_err_cb(syntax_err_report);
profile_init(config_fn, &ctx->profile);
if (flush) {
fd = open(ctx->filesystem_name, O_RDONLY, 0);
if (fd < 0) {
com_err("open", errno,
_("while opening %s for flushing"),
ctx->filesystem_name);
fatal_error(ctx, 0);
}
if ((retval = ext2fs_sync_device(fd, 1))) {
com_err("ext2fs_sync_device", retval,
_("while trying to flush %s"),
ctx->filesystem_name);
fatal_error(ctx, 0);
}
close(fd);
}
if (cflag && bad_blocks_file) {
fprintf(stderr, _("The -c and the -l/-L options may "
"not be both used at the same time.\n"));
exit(FSCK_USAGE);
}
#ifdef HAVE_SIGNAL_H
/*
* Set up signal action
*/
memset(&sa, 0, sizeof(struct sigaction));
sa.sa_handler = signal_cancel;
sigaction(SIGINT, &sa, 0);
sigaction(SIGTERM, &sa, 0);
#ifdef SA_RESTART
sa.sa_flags = SA_RESTART;
#endif
e2fsck_global_ctx = ctx;
sa.sa_handler = signal_progress_on;
sigaction(SIGUSR1, &sa, 0);
sa.sa_handler = signal_progress_off;
sigaction(SIGUSR2, &sa, 0);
#endif
/* Update our PATH to include /sbin if we need to run badblocks */
if (cflag) {
char *oldpath = getenv("PATH");
char *newpath;
int len = sizeof(PATH_SET) + 1;
if (oldpath)
len += strlen(oldpath);
newpath = malloc(len);
if (!newpath)
fatal_error(ctx, "Couldn't malloc() newpath");
strcpy(newpath, PATH_SET);
if (oldpath) {
strcat(newpath, ":");
strcat(newpath, oldpath);
}
putenv(newpath);
}
#ifdef CONFIG_JBD_DEBUG
jbd_debug = getenv("E2FSCK_JBD_DEBUG");
if (jbd_debug) {
res = sscanf(jbd_debug, "%d", &journal_enable_debug);
if (res != 1) {
fprintf(stderr,
_("E2FSCK_JBD_DEBUG \"%s\" not an integer\n\n"),
jbd_debug);
exit (1);
}
}
#endif
return 0;
sscanf_err:
fprintf(stderr, _("\nInvalid non-numeric argument to -%c (\"%s\")\n\n"),
c, optarg);
exit (1);
}
int
main(int argc, char *argv[])
{
struct ncp_conn_spec spec;
struct ncp_conn *conn;
char *server = NULL;
char *user_name = NULL;
char *object_name = NULL;
int object_type = NCP_BINDERY_USER;
unsigned char ncp_key[8];
struct ncp_bindery_object user;
unsigned char buf_obj_name[50];
long err;
char *str;
char oldpass[200], newpass1[200], newpass2[200];
int opt;
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
progname = argv[0];
while ((opt = getopt(argc, argv, "h?S:U:O:t:")) != EOF)
{
switch (opt)
{
case 'S':
server = optarg;
break;
case 'U':
user_name = optarg;
break;
case 'O':
object_name = optarg;
break;
case 't':
object_type = atoi(optarg);
break;
case 'h':
case '?':
help();
exit(1);
default:
usage();
exit(1);
}
}
err = ncp_find_conn_spec3(server, user_name, "",
1, getuid(), 0, &spec);
if (err)
{
com_err(argv[0], err, _("trying to find server"));
exit(1);
}
if (!object_name)
{
object_name = spec.user;
} else
{
strcpy(buf_obj_name, object_name);
object_name = buf_obj_name;
str_upper(object_name);
}
spec.login_type = object_type;
printf(_("Changing password for user %s on server %s\n"),
object_name, spec.server);
if (object_name == spec.user)
{
str = getpass(_("Enter old password: "******"Enter password for %s: "), spec.user);
str = getpass(sx);
}
if (strlen(str) >= sizeof(oldpass))
{
printf(_("Password too long\n"));
exit(1);
}
strcpy(oldpass, str);
str = getpass(_("Enter new password: "******"Password too long\n"));
exit(1);
}
strcpy(newpass1, str);
str = getpass(_("Re-Enter new password: "******"Password too long\n"));
exit(1);
}
strcpy(newpass2, str);
str_upper(oldpass);
str_upper(newpass1);
str_upper(newpass2);
if (strcmp(newpass1, newpass2) != 0)
{
printf(_("You mistype the new password, try again\n"));
exit(1);
}
strcpy(spec.password, oldpass);
if ((conn = ncp_open(&spec, &err)) == NULL)
{
com_err(argv[0], err, _("when trying to open connection"));
exit(1);
}
if (object_name != spec.user)
{
if (!(err = ncp_get_bindery_object_id(conn, 1, spec.user,
&user))
&& !(err = ncp_login_user(conn, spec.user, oldpass)))
{
*oldpass = '******';
} else
{
com_err(argv[0], err, _("not own password"));
}
}
if (((err = ncp_get_encryption_key(conn, ncp_key)) != 0)
|| ((err = ncp_get_bindery_object_id(conn, 1, object_name,
&user)) != 0)
|| ((err = ncp_change_login_passwd(conn, &user, ncp_key,
oldpass, newpass1)) != 0))
{
com_err(argv[0], err, _("trying to change password"));
}
ncp_close(conn);
return 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno, result_blkno;
int c, len;
char *filename, *lookup_path, *buf;
char *filebuf;
char *p;
char lookup_name[256];
ocfs2_filesys *fs;
blkno = 0;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "i:")) != EOF) {
switch (c) {
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
optind++;
if (optind >= argc) {
fprintf(stdout, "Missing path to lookup\n");
print_usage();
return 1;
}
lookup_path = argv[optind];
ret = ocfs2_open(filename, OCFS2_FLAG_RO, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
com_err(argv[0], ret,
"while allocating inode buffer");
goto out_close;
}
if (!blkno)
blkno = OCFS2_RAW_SB(fs->fs_super)->s_root_blkno;
for (p = lookup_path; *p == '/'; p++);
lookup_path = p;
for (p = lookup_path; ; p++) {
if (*p && *p != '/')
continue;
memcpy(lookup_name, lookup_path, p - lookup_path);
lookup_name[p - lookup_path] = '\0';
ret = ocfs2_lookup(fs, blkno, lookup_name,
strlen(lookup_name), NULL,
&result_blkno);
if (ret) {
com_err(argv[0], ret,
"while looking up \"%s\" in inode %"PRIu64
" on \"%s\"\n",
lookup_name, blkno, filename);
goto out_free;
}
blkno = result_blkno;
for (; *p == '/'; p++);
lookup_path = p;
if (!*p)
break;
}
if (ocfs2_check_directory(fs, blkno) != OCFS2_ET_NO_DIRECTORY) {
com_err(argv[0], ret, "\"%s\" is not a file", filename);
goto out_free;
}
ret = ocfs2_read_whole_file(fs, blkno, &filebuf, &len);
if (ret) {
com_err(argv[0], ret,
"while reading file \"%s\" -- read %d bytes",
filename, len);
goto out_free_filebuf;
}
if (!len)
fprintf(stderr, "boo!\n");
dump_filebuf(filebuf, len);
out_free_filebuf:
if (len)
ocfs2_free(&filebuf);
out_free:
ocfs2_free(&buf);
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
/*
* Remove an external journal from the filesystem
*/
static void remove_journal_device(ext2_filsys fs)
{
char *journal_path;
ext2_filsys jfs;
char buf[1024];
journal_superblock_t *jsb;
int i, nr_users;
errcode_t retval;
int commit_remove_journal = 0;
io_manager io_ptr;
if (f_flag)
commit_remove_journal = 1; /* force removal even if error */
uuid_unparse(fs->super->s_journal_uuid, buf);
journal_path = blkid_get_devname(NULL, "UUID", buf);
if (!journal_path) {
journal_path =
ext2fs_find_block_device(fs->super->s_journal_dev);
if (!journal_path)
return;
}
#ifdef CONFIG_TESTIO_DEBUG
if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
io_ptr = test_io_manager;
test_io_backing_manager = unix_io_manager;
} else
#endif
io_ptr = unix_io_manager;
retval = ext2fs_open(journal_path, EXT2_FLAG_RW|
EXT2_FLAG_JOURNAL_DEV_OK, 0,
fs->blocksize, io_ptr, &jfs);
if (retval) {
com_err(program_name, retval,
_("while trying to open external journal"));
goto no_valid_journal;
}
if (!(jfs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
fprintf(stderr, _("%s is not a journal device.\n"),
journal_path);
goto no_valid_journal;
}
/* Get the journal superblock */
if ((retval = io_channel_read_blk(jfs->io, 1, -1024, buf))) {
com_err(program_name, retval,
_("while reading journal superblock"));
goto no_valid_journal;
}
jsb = (journal_superblock_t *) buf;
if ((jsb->s_header.h_magic != (unsigned) ntohl(JFS_MAGIC_NUMBER)) ||
(jsb->s_header.h_blocktype != (unsigned) ntohl(JFS_SUPERBLOCK_V2))) {
fputs(_("Journal superblock not found!\n"), stderr);
goto no_valid_journal;
}
/* Find the filesystem UUID */
nr_users = ntohl(jsb->s_nr_users);
for (i = 0; i < nr_users; i++) {
if (memcmp(fs->super->s_uuid,
&jsb->s_users[i*16], 16) == 0)
break;
}
if (i >= nr_users) {
fputs(_("Filesystem's UUID not found on journal device.\n"),
stderr);
commit_remove_journal = 1;
goto no_valid_journal;
}
nr_users--;
for (i = 0; i < nr_users; i++)
memcpy(&jsb->s_users[i*16], &jsb->s_users[(i+1)*16], 16);
jsb->s_nr_users = htonl(nr_users);
/* Write back the journal superblock */
if ((retval = io_channel_write_blk(jfs->io, 1, -1024, buf))) {
com_err(program_name, retval,
"while writing journal superblock.");
goto no_valid_journal;
}
commit_remove_journal = 1;
no_valid_journal:
if (commit_remove_journal == 0) {
fputs(_("Journal NOT removed\n"), stderr);
exit(1);
}
fs->super->s_journal_dev = 0;
uuid_clear(fs->super->s_journal_uuid);
ext2fs_mark_super_dirty(fs);
fputs(_("Journal removed\n"), stdout);
free(journal_path);
}
static void list_desc (ext2_filsys fs)
{
unsigned long i;
blk64_t first_block, last_block;
blk64_t super_blk, old_desc_blk, new_desc_blk;
char *block_bitmap=NULL, *inode_bitmap=NULL;
const char *units = _("blocks");
int inode_blocks_per_group, old_desc_blocks, reserved_gdt;
int block_nbytes, inode_nbytes;
int has_super;
blk64_t blk_itr = EXT2FS_B2C(fs, fs->super->s_first_data_block);
ext2_ino_t ino_itr = 1;
errcode_t retval;
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_BIGALLOC))
units = _("clusters");
block_nbytes = EXT2_CLUSTERS_PER_GROUP(fs->super) / 8;
inode_nbytes = EXT2_INODES_PER_GROUP(fs->super) / 8;
if (fs->block_map)
block_bitmap = malloc(block_nbytes);
if (fs->inode_map)
inode_bitmap = malloc(inode_nbytes);
inode_blocks_per_group = ((fs->super->s_inodes_per_group *
EXT2_INODE_SIZE(fs->super)) +
EXT2_BLOCK_SIZE(fs->super) - 1) /
EXT2_BLOCK_SIZE(fs->super);
reserved_gdt = fs->super->s_reserved_gdt_blocks;
fputc('\n', stdout);
first_block = fs->super->s_first_data_block;
if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG)
old_desc_blocks = fs->super->s_first_meta_bg;
else
old_desc_blocks = fs->desc_blocks;
for (i = 0; i < fs->group_desc_count; i++) {
first_block = ext2fs_group_first_block2(fs, i);
last_block = ext2fs_group_last_block2(fs, i);
ext2fs_super_and_bgd_loc2(fs, i, &super_blk,
&old_desc_blk, &new_desc_blk, 0);
printf (_("Group %lu: (Blocks "), i);
print_range(first_block, last_block);
fputs(")", stdout);
print_bg_opts(fs, i);
if (fs->super->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) {
unsigned csum = ext2fs_bg_checksum(fs, i);
unsigned exp_csum = ext2fs_group_desc_csum(fs, i);
printf(_(" Checksum 0x%04x"), csum);
if (csum != exp_csum)
printf(_(" (EXPECTED 0x%04x)"), exp_csum);
printf(_(", unused inodes %u\n"),
ext2fs_bg_itable_unused(fs, i));
}
has_super = ((i==0) || super_blk);
if (has_super) {
printf (_(" %s superblock at "),
i == 0 ? _("Primary") : _("Backup"));
print_number(super_blk);
}
if (old_desc_blk) {
printf("%s", _(", Group descriptors at "));
print_range(old_desc_blk,
old_desc_blk + old_desc_blocks - 1);
if (reserved_gdt) {
printf("%s", _("\n Reserved GDT blocks at "));
print_range(old_desc_blk + old_desc_blocks,
old_desc_blk + old_desc_blocks +
reserved_gdt - 1);
}
} else if (new_desc_blk) {
fputc(has_super ? ',' : ' ', stdout);
printf("%s", _(" Group descriptor at "));
print_number(new_desc_blk);
has_super++;
}
if (has_super)
fputc('\n', stdout);
fputs(_(" Block bitmap at "), stdout);
print_number(ext2fs_block_bitmap_loc(fs, i));
print_bg_rel_offset(fs, ext2fs_block_bitmap_loc(fs, i), 0,
first_block, last_block);
fputs(_(", Inode bitmap at "), stdout);
print_number(ext2fs_inode_bitmap_loc(fs, i));
print_bg_rel_offset(fs, ext2fs_inode_bitmap_loc(fs, i), 0,
first_block, last_block);
fputs(_("\n Inode table at "), stdout);
print_range(ext2fs_inode_table_loc(fs, i),
ext2fs_inode_table_loc(fs, i) +
inode_blocks_per_group - 1);
print_bg_rel_offset(fs, ext2fs_inode_table_loc(fs, i), 1,
first_block, last_block);
printf (_("\n %u free %s, %u free inodes, "
"%u directories%s"),
ext2fs_bg_free_blocks_count(fs, i), units,
ext2fs_bg_free_inodes_count(fs, i),
ext2fs_bg_used_dirs_count(fs, i),
ext2fs_bg_itable_unused(fs, i) ? "" : "\n");
if (ext2fs_bg_itable_unused(fs, i))
printf (_(", %u unused inodes\n"),
ext2fs_bg_itable_unused(fs, i));
if (block_bitmap) {
fputs(_(" Free blocks: "), stdout);
retval = ext2fs_get_block_bitmap_range2(fs->block_map,
blk_itr, block_nbytes << 3, block_bitmap);
if (retval)
com_err("list_desc", retval,
"while reading block bitmap");
else
print_free(i, block_bitmap,
fs->super->s_clusters_per_group,
fs->super->s_first_data_block,
EXT2FS_CLUSTER_RATIO(fs));
fputc('\n', stdout);
blk_itr += fs->super->s_clusters_per_group;
}
if (inode_bitmap) {
fputs(_(" Free inodes: "), stdout);
retval = ext2fs_get_inode_bitmap_range2(fs->inode_map,
ino_itr, inode_nbytes << 3, inode_bitmap);
if (retval)
com_err("list_desc", retval,
"while reading inode bitmap");
else
print_free(i, inode_bitmap,
fs->super->s_inodes_per_group,
1, 1);
fputc('\n', stdout);
ino_itr += fs->super->s_inodes_per_group;
}
}
if (block_bitmap)
free(block_bitmap);
if (inode_bitmap)
free(inode_bitmap);
}
void client_read(client *cl)
{
int status, pn;
status = mr_cont_receive(cl->con, &cl->req);
if (status == -1)
return;
else if (status != MR_SUCCESS)
{
cl->state = CL_CLOSING;
if (status != MR_NOT_CONNECTED)
com_err(whoami, status, "while reading from socket");
return;
}
pn = cl->req.u.mr_procno;
if (pn < 0 || pn > MR_MAX_PROC)
{
com_err(whoami, 0, "procno out of range");
client_reply(cl, MR_UNKNOWN_PROC);
goto out;
}
log_args(procnames[pn], 2, cl->req.mr_argc, cl->req.mr_argv);
if (dormant == ASLEEP && pn != MR_NOOP && pn != MR_MOTD)
{
client_reply(cl, MR_DOWN);
com_err(whoami, MR_DOWN, "(query refused)");
goto out;
}
/* make sure this gets cleared before every operation */
dbms_errno = 0;
switch (pn)
{
case MR_NOOP:
client_reply(cl, MR_SUCCESS);
break;
case MR_AUTH:
do_auth(cl);
break;
case MR_QUERY:
do_retr(cl);
break;
case MR_ACCESS:
do_access(cl);
break;
case MR_SHUTDOWN:
do_shutdown(cl);
break;
case MR_DO_UPDATE:
client_reply(cl, MR_PERM);
break;
case MR_MOTD:
get_motd(cl);
break;
case MR_PROXY:
do_proxy(cl);
break;
case MR_SETVERSION:
do_version(cl);
break;
case MR_KRB5_AUTH:
do_krb5_auth(cl);
break;
}
out:
mr_destroy_reply(cl->req);
memset(&cl->req, 0, sizeof(mr_params));
}
int main (int argc, char ** argv)
{
errcode_t retval;
ext2_filsys fs;
int print_badblocks = 0;
blk64_t use_superblock = 0;
int use_blocksize = 0;
int image_dump = 0;
int force = 0;
int flags;
int header_only = 0;
int c;
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
set_com_err_gettext(gettext);
#endif
add_error_table(&et_ext2_error_table);
fprintf (stderr, "dumpe2fs %s (%s)\n", E2FSPROGS_VERSION,
E2FSPROGS_DATE);
if (argc && *argv)
program_name = *argv;
while ((c = getopt (argc, argv, "bfhixVo:")) != EOF) {
switch (c) {
case 'b':
print_badblocks++;
break;
case 'f':
force++;
break;
case 'h':
header_only++;
break;
case 'i':
image_dump++;
break;
case 'o':
parse_extended_opts(optarg, &use_superblock,
&use_blocksize);
break;
case 'V':
/* Print version number and exit */
fprintf(stderr, _("\tUsing %s\n"),
error_message(EXT2_ET_BASE));
exit(0);
case 'x':
hex_format++;
break;
default:
usage();
}
}
if (argc - 1 > optind) {
usage();
exit(1);
}
device_name = argv[optind++];
flags = EXT2_FLAG_JOURNAL_DEV_OK | EXT2_FLAG_SOFTSUPP_FEATURES | EXT2_FLAG_64BITS;
if (force)
flags |= EXT2_FLAG_FORCE;
if (image_dump)
flags |= EXT2_FLAG_IMAGE_FILE;
if (use_superblock && !use_blocksize) {
for (use_blocksize = EXT2_MIN_BLOCK_SIZE;
use_blocksize <= EXT2_MAX_BLOCK_SIZE;
use_blocksize *= 2) {
retval = ext2fs_open (device_name, flags,
use_superblock,
use_blocksize, unix_io_manager,
&fs);
if (!retval)
break;
}
} else
retval = ext2fs_open (device_name, flags, use_superblock,
use_blocksize, unix_io_manager, &fs);
if (retval) {
com_err (program_name, retval, _("while trying to open %s"),
device_name);
printf("%s", _("Couldn't find valid filesystem superblock.\n"));
exit (1);
}
fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE;
if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
blocks64 = 1;
if (print_badblocks) {
list_bad_blocks(fs, 1);
} else {
list_super (fs->super);
if (fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
print_journal_information(fs);
ext2fs_close_free(&fs);
exit(0);
}
if ((fs->super->s_feature_compat &
EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
(fs->super->s_journal_inum != 0))
print_inline_journal_information(fs);
list_bad_blocks(fs, 0);
if (header_only) {
ext2fs_close_free(&fs);
exit (0);
}
retval = ext2fs_read_bitmaps (fs);
list_desc (fs);
if (retval) {
printf(_("\n%s: %s: error reading bitmaps: %s\n"),
program_name, device_name,
error_message(retval));
}
}
ext2fs_close_free(&fs);
remove_error_table(&et_ext2_error_table);
exit (0);
}
static void swap_inodes(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
dgrp_t group;
unsigned int i;
ext2_ino_t ino = 1;
char *buf = NULL, *block_buf = NULL;
errcode_t retval;
struct ext2_inode * inode;
e2fsck_use_inode_shortcuts(ctx, 1);
retval = ext2fs_get_array(fs->blocksize, fs->inode_blocks_per_group,
&buf);
if (retval) {
com_err("swap_inodes", retval,
_("while allocating inode buffer"));
ctx->flags |= E2F_FLAG_ABORT;
goto errout;
}
block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4,
"block interate buffer");
for (group = 0; group < fs->group_desc_count; group++) {
retval = io_channel_read_blk(fs->io,
fs->group_desc[group].bg_inode_table,
fs->inode_blocks_per_group, buf);
if (retval) {
com_err("swap_inodes", retval,
_("while reading inode table (group %d)"),
group);
ctx->flags |= E2F_FLAG_ABORT;
goto errout;
}
inode = (struct ext2_inode *) buf;
for (i=0; i < fs->super->s_inodes_per_group;
i++, ino++, inode++) {
ctx->stashed_ino = ino;
ctx->stashed_inode = inode;
if (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)
ext2fs_swap_inode(fs, inode, inode, 0);
/*
* Skip deleted files.
*/
if (inode->i_links_count == 0)
continue;
if (LINUX_S_ISDIR(inode->i_mode) ||
((inode->i_block[EXT2_IND_BLOCK] ||
inode->i_block[EXT2_DIND_BLOCK] ||
inode->i_block[EXT2_TIND_BLOCK]) &&
ext2fs_inode_has_valid_blocks(inode)))
swap_inode_blocks(ctx, ino, block_buf, inode);
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
goto errout;
if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)
ext2fs_swap_inode(fs, inode, inode, 1);
}
retval = io_channel_write_blk(fs->io,
fs->group_desc[group].bg_inode_table,
fs->inode_blocks_per_group, buf);
if (retval) {
com_err("swap_inodes", retval,
_("while writing inode table (group %d)"),
group);
ctx->flags |= E2F_FLAG_ABORT;
goto errout;
}
}
errout:
if (buf)
ext2fs_free_mem(&buf);
if (block_buf)
ext2fs_free_mem(&block_buf);
e2fsck_use_inode_shortcuts(ctx, 0);
ext2fs_flush_icache(fs);
}
krb5_error_code
verify_securid_data_2(krb5_context context, krb5_db_entry *client,
krb5_sam_response_2 *sr2,
krb5_enc_tkt_part *enc_tkt_reply, krb5_pa_data *pa,
krb5_sam_challenge_2 **sc2_out)
{
krb5_error_code retval;
int new_pin = 0;
krb5_key_data *client_key_data = NULL;
krb5_keyblock client_key;
krb5_data scratch;
krb5_enc_sam_response_enc_2 *esre2 = NULL;
struct securid_track_data sid_track_data, *trackp = NULL;
krb5_data tmp_data;
SDI_HANDLE sd_handle = SDI_HANDLE_NONE;
krb5_sam_challenge_2 *sc2p = NULL;
char *cp, *user = NULL;
char *securid_user = NULL;
char passcode[LENPRNST+1];
char max_pin_len, min_pin_len, alpha_pin;
memset(&client_key, 0, sizeof(client_key));
memset(&scratch, 0, sizeof(scratch));
*sc2_out = NULL;
retval = krb5_unparse_name(context, client->princ, &user);
if (retval != 0) {
com_err("krb5kdc", retval,
"while unparsing client name in verify_securid_data_2");
return retval;
}
if ((sr2->sam_enc_nonce_or_sad.ciphertext.data == NULL) ||
(sr2->sam_enc_nonce_or_sad.ciphertext.length <= 0)) {
retval = KRB5KDC_ERR_PREAUTH_FAILED;
k5_setmsg(context, retval,
"No preauth data supplied in verify_securid_data_2 (%s)",
user);
goto cleanup;
}
retval = krb5_dbe_find_enctype(context, client,
sr2->sam_enc_nonce_or_sad.enctype, -1,
sr2->sam_enc_nonce_or_sad.kvno,
&client_key_data);
if (retval) {
com_err("krb5kdc", retval,
"while getting client key in verify_securid_data_2 (%s)",
user);
goto cleanup;
}
retval = krb5_dbe_decrypt_key_data(context, NULL, client_key_data,
&client_key, NULL);
if (retval != 0) {
com_err("krb5kdc", retval,
"while decrypting client key in verify_securid_data_2 (%s)",
user);
goto cleanup;
}
scratch.length = sr2->sam_enc_nonce_or_sad.ciphertext.length;
scratch.data = k5alloc(scratch.length, &retval);
if (retval)
goto cleanup;
retval = krb5_c_decrypt(context, &client_key,
KRB5_KEYUSAGE_PA_SAM_RESPONSE, 0,
&sr2->sam_enc_nonce_or_sad, &scratch);
if (retval) {
com_err("krb5kdc", retval,
"while decrypting SAD in verify_securid_data_2 (%s)", user);
goto cleanup;
}
retval = decode_krb5_enc_sam_response_enc_2(&scratch, &esre2);
if (retval) {
com_err("krb5kdc", retval,
"while decoding SAD in verify_securid_data_2 (%s)", user);
esre2 = NULL;
goto cleanup;
}
if (sr2->sam_nonce != esre2->sam_nonce) {
com_err("krb5kdc", KRB5KDC_ERR_PREAUTH_FAILED,
"while checking nonce in verify_securid_data_2 (%s)", user);
retval = KRB5KDC_ERR_PREAUTH_FAILED;
goto cleanup;
}
if (esre2->sam_sad.length == 0 || esre2->sam_sad.data == NULL) {
com_err("krb5kdc", KRB5KDC_ERR_PREAUTH_FAILED,
"No SecurID passcode in verify_securid_data_2 (%s)", user);
retval = KRB5KDC_ERR_PREAUTH_FAILED;
goto cleanup;
}
/* Copy out SAD to null-terminated buffer */
memset(passcode, 0, sizeof(passcode));
if (esre2->sam_sad.length > (sizeof(passcode) - 1)) {
retval = KRB5KDC_ERR_PREAUTH_FAILED;
com_err("krb5kdc", retval,
"SecurID passcode/PIN too long (%d bytes) in "
"verify_securid_data_2 (%s)",
esre2->sam_sad.length, user);
goto cleanup;
}
if (esre2->sam_sad.length > 0)
memcpy(passcode, esre2->sam_sad.data, esre2->sam_sad.length);
securid_user = strdup(user);
if (!securid_user) {
retval = ENOMEM;
com_err("krb5kdc", ENOMEM,
"while copying user name in verify_securid_data_2 (%s)", user);
goto cleanup;
}
cp = strchr(securid_user, '@');
if (cp != NULL)
*cp = '\0';
/* Check for any track_id data that may have state from a previous attempt
* at SecurID authentication. */
if (sr2->sam_track_id.data && (sr2->sam_track_id.length > 0)) {
krb5_data track_id_data;
memset(&track_id_data, 0, sizeof(track_id_data));
retval = securid_decrypt_track_data_2(context, client,
&sr2->sam_track_id,
&track_id_data);
if (retval) {
com_err("krb5kdc", retval,
"while decrypting SecurID trackID in "
"verify_securid_data_2 (%s)", user);
goto cleanup;
}
if (track_id_data.length < sizeof (struct securid_track_data)) {
retval = KRB5KDC_ERR_PREAUTH_FAILED;
com_err("krb5kdc", retval, "Length of track data incorrect");
goto cleanup;
}
trackp = (struct securid_track_data *)track_id_data.data;
if(trackp->hostid != gethostid()) {
krb5_klog_syslog(LOG_INFO, "Unexpected challenge response");
retval = KRB5KDC_ERR_DISCARD;
goto cleanup;
}
switch(trackp->state) {
case SECURID_STATE_INITIAL:
goto initial;
break;
case SECURID_STATE_NEW_PIN_AGAIN:
{
int pin1_len, pin2_len;
trackp->handle = ntohl(trackp->handle);
pin2_len = strlen(passcode);
pin1_len = strlen(trackp->passcode);
if ((pin1_len != pin2_len) ||
(memcmp(passcode, trackp->passcode, pin1_len) != 0)) {
retval = KRB5KDC_ERR_PREAUTH_FAILED;
krb5_klog_syslog(LOG_INFO, "New SecurID PIN Failed for user "
"%s: PIN mis-match", user);
break;
}
retval = SD_Pin(trackp->handle, passcode);
SD_Close(trackp->handle);
if (retval == ACM_NEW_PIN_ACCEPTED) {
enc_tkt_reply->flags|= TKT_FLG_HW_AUTH;
enc_tkt_reply->flags|= TKT_FLG_PRE_AUTH;
krb5_klog_syslog(LOG_INFO, "SecurID PIN Accepted for %s in "
"verify_securid_data_2",
securid_user);
retval = 0;
} else {
retval = KRB5KDC_ERR_PREAUTH_FAILED;
krb5_klog_syslog(LOG_INFO,
"SecurID PIN Failed for user %s (AceServer "
"returns %d) in verify_securid_data_2",
user, retval);
}
break;
}
case SECURID_STATE_NEW_PIN: {
krb5_sam_challenge_2_body sc2b;
sc2p = k5alloc(sizeof *sc2p, &retval);
if (retval)
goto cleanup;
memset(sc2p, 0, sizeof(*sc2p));
memset(&sc2b, 0, sizeof(sc2b));
sc2b.sam_type = PA_SAM_TYPE_SECURID;
sc2b.sam_response_prompt.data = NEW_PIN_AGAIN_message;
sc2b.sam_response_prompt.length =
strlen(sc2b.sam_response_prompt.data);
sc2b.sam_flags = KRB5_SAM_SEND_ENCRYPTED_SAD;
sc2b.sam_etype = client_key.enctype;
tmp_data.data = (char *)&sc2b.sam_nonce;
tmp_data.length = sizeof(sc2b.sam_nonce);
if ((retval = krb5_c_random_make_octets(context, &tmp_data))) {
com_err("krb5kdc", retval,
"while making nonce for SecurID new "
"PIN2 SAM_CHALLENGE_2 (%s)", user);
goto cleanup;
}
sid_track_data.state = SECURID_STATE_NEW_PIN_AGAIN;
sid_track_data.handle = trackp->handle;
sid_track_data.hostid = gethostid();
/* Should we complain if sizes don't work ?? */
memcpy(sid_track_data.passcode, passcode,
sizeof(sid_track_data.passcode));
tmp_data.data = (char *)&sid_track_data;
tmp_data.length = sizeof(sid_track_data);
if ((retval = securid_encrypt_track_data_2(context, client,
&tmp_data,
&sc2b.sam_track_id))) {
com_err("krb5kdc", retval,
"while encrypting NEW PIN2 SecurID "
"track data for SAM_CHALLENGE_2 (%s)",
securid_user);
goto cleanup;
}
retval = sam_make_challenge(context, &sc2b, &client_key, sc2p);
if (retval) {
com_err("krb5kdc", retval,
"while making cksum for "
"SAM_CHALLENGE_2 (new PIN2) (%s)", securid_user);
goto cleanup;
}
krb5_klog_syslog(LOG_INFO,
"Requesting verification of new PIN for user %s",
securid_user);
*sc2_out = sc2p;
sc2p = NULL;
/*sc2_out may be set even on error path*/
retval = KRB5KDC_ERR_PREAUTH_REQUIRED;
goto cleanup;
}
case SECURID_STATE_NEXT_CODE:
trackp->handle = ntohl(trackp->handle);
retval = SD_Next(trackp->handle, passcode);
SD_Close(trackp->handle);
if (retval == ACM_OK) {
enc_tkt_reply->flags |= TKT_FLG_HW_AUTH | TKT_FLG_PRE_AUTH;
krb5_klog_syslog(LOG_INFO, "Next SecurID Code Accepted for "
"user %s", securid_user);
retval = 0;
} else {
krb5_klog_syslog(LOG_INFO, "Next SecurID Code Failed for user "
"%s (AceServer returns %d) in "
"verify_securid_data_2", user, retval);
retval = KRB5KDC_ERR_PREAUTH_FAILED;
}
break;
}
} else { /* No track data, this is first of N attempts */
initial:
retval = SD_Init(&sd_handle);
if (retval) {
com_err("krb5kdc", KRB5KDC_ERR_PREAUTH_FAILED,
"SD_Init() returns error %d in verify_securid_data_2 (%s)",
retval, securid_user);
retval = KRB5KDC_ERR_PREAUTH_FAILED;
goto cleanup;
}
retval = SD_Lock(sd_handle, securid_user);
if (retval != ACM_OK) {
SD_Close(sd_handle);
retval = KRB5KDC_ERR_PREAUTH_FAILED;
krb5_klog_syslog(LOG_INFO,
"SD_Lock() failed (AceServer returns %d) for %s",
retval, securid_user);
goto cleanup;
}
retval = SD_Check(sd_handle, passcode, securid_user);
switch (retval) {
case ACM_OK:
SD_Close(sd_handle);
enc_tkt_reply->flags|= TKT_FLG_HW_AUTH;
enc_tkt_reply->flags|= TKT_FLG_PRE_AUTH;
krb5_klog_syslog(LOG_INFO, "SecurID passcode accepted for user %s",
user);
retval = 0;
break;
case ACM_ACCESS_DENIED:
SD_Close(sd_handle);
retval = KRB5KDC_ERR_PREAUTH_FAILED;
krb5_klog_syslog(LOG_INFO, "AceServer returns Access Denied for "
"user %s (SAM2)", user);
goto cleanup;
case ACM_NEW_PIN_REQUIRED:
new_pin = 1;
/*fall through*/
case ACM_NEXT_CODE_REQUIRED: {
krb5_sam_challenge_2_body sc2b;
sc2p = k5alloc(sizeof *sc2p, &retval);
if (retval)
goto cleanup;
memset(sc2p, 0, sizeof(*sc2p));
memset(&sc2b, 0, sizeof(sc2b));
sc2b.sam_type = PA_SAM_TYPE_SECURID;
sc2b.sam_response_prompt.data = NEXT_PASSCODE_message;
sc2b.sam_response_prompt.length =
strlen(sc2b.sam_response_prompt.data);
sc2b.sam_flags = KRB5_SAM_SEND_ENCRYPTED_SAD;
sc2b.sam_etype = client_key.enctype;
if (new_pin) {
if ((AceGetMaxPinLen(sd_handle, &max_pin_len) == ACE_SUCCESS)
&& (AceGetMinPinLen(sd_handle,
&min_pin_len) == ACE_SUCCESS)
&& (AceGetAlphanumeric(sd_handle,
&alpha_pin) == ACE_SUCCESS)) {
sprintf(PIN_message,
"New PIN must contain %d to %d %sdigits",
min_pin_len, max_pin_len,
(alpha_pin == 0) ? "" : "alphanumeric ");
sc2b.sam_challenge_label.data = PIN_message;
sc2b.sam_challenge_label.length =
strlen(sc2b.sam_challenge_label.data);
} else {
sc2b.sam_challenge_label.length = 0;
}
}
tmp_data.data = (char *)&sc2b.sam_nonce;
tmp_data.length = sizeof(sc2b.sam_nonce);
if ((retval = krb5_c_random_make_octets(context, &tmp_data))) {
com_err("krb5kdc", retval,
"while making nonce for SecurID SAM_CHALLENGE_2 (%s)",
user);
goto cleanup;
}
if (new_pin)
sid_track_data.state = SECURID_STATE_NEW_PIN;
else
sid_track_data.state = SECURID_STATE_NEXT_CODE;
sid_track_data.handle = htonl(sd_handle);
sid_track_data.hostid = gethostid();
tmp_data.data = (char *)&sid_track_data;
tmp_data.length = sizeof(sid_track_data);
retval = securid_encrypt_track_data_2(context, client, &tmp_data,
&sc2b.sam_track_id);
if (retval) {
com_err("krb5kdc", retval,
"while encrypting SecurID track "
"data for SAM_CHALLENGE_2 (%s)",
securid_user);
goto cleanup;
}
retval = sam_make_challenge(context, &sc2b, &client_key, sc2p);
if (retval) {
com_err("krb5kdc", retval,
"while making cksum for SAM_CHALLENGE_2 (%s)",
securid_user);
}
if (new_pin)
krb5_klog_syslog(LOG_INFO, "New SecurID PIN required for "
"user %s", securid_user);
else
krb5_klog_syslog(LOG_INFO, "Next SecurID passcode required "
"for user %s", securid_user);
*sc2_out = sc2p;
sc2p = NULL;
retval = KRB5KDC_ERR_PREAUTH_REQUIRED;
/*sc2_out is permitted as an output on error path*/
goto cleanup;
}
default:
com_err("krb5kdc", KRB5KDC_ERR_PREAUTH_FAILED,
"AceServer returns unknown error code %d "
"in verify_securid_data_2\n", retval);
retval = KRB5KDC_ERR_PREAUTH_FAILED;
goto cleanup;
}
} /* no track_id data */
cleanup:
krb5_free_keyblock_contents(context, &client_key);
free(scratch.data);
krb5_free_enc_sam_response_enc_2(context, esre2);
free(user);
free(securid_user);
free(trackp);
krb5_free_sam_challenge_2(context, sc2p);
return retval;
}
static void do_v5_kvno (int count, char *names[],
char * ccachestr, char *etypestr, char *keytab_name,
char *sname, int canon, int unknown)
{
krb5_error_code ret;
int i, errors;
krb5_enctype etype;
krb5_ccache ccache;
krb5_principal me;
krb5_creds in_creds, *out_creds;
krb5_ticket *ticket;
char *princ;
krb5_keytab keytab = NULL;
ret = krb5_init_context(&context);
if (ret) {
com_err(prog, ret, "while initializing krb5 library");
exit(1);
}
if (etypestr) {
ret = krb5_string_to_enctype(etypestr, &etype);
if (ret) {
com_err(prog, ret, "while converting etype");
exit(1);
}
} else {
etype = 0;
}
if (ccachestr)
ret = krb5_cc_resolve(context, ccachestr, &ccache);
else
ret = krb5_cc_default(context, &ccache);
if (ret) {
com_err(prog, ret, "while opening ccache");
exit(1);
}
if (keytab_name) {
ret = krb5_kt_resolve(context, keytab_name, &keytab);
if (ret) {
com_err(prog, ret, "resolving keytab %s", keytab_name);
exit(1);
}
}
ret = krb5_cc_get_principal(context, ccache, &me);
if (ret) {
com_err(prog, ret, "while getting client principal name");
exit(1);
}
errors = 0;
for (i = 0; i < count; i++) {
memset(&in_creds, 0, sizeof(in_creds));
in_creds.client = me;
if (sname != NULL) {
ret = krb5_sname_to_principal(context, names[i],
sname, KRB5_NT_SRV_HST,
&in_creds.server);
} else {
ret = krb5_parse_name(context, names[i], &in_creds.server);
}
if (ret) {
if (!quiet)
com_err(prog, ret, "while parsing principal name %s", names[i]);
errors++;
continue;
}
if (unknown == 1) {
krb5_princ_type(context, in_creds.server) = KRB5_NT_UNKNOWN;
}
ret = krb5_unparse_name(context, in_creds.server, &princ);
if (ret) {
com_err(prog, ret,
"while formatting parsed principal name for '%s'",
names[i]);
errors++;
continue;
}
in_creds.keyblock.enctype = etype;
ret = krb5_get_credentials(context, canon ? KRB5_GC_CANONICALIZE : 0,
ccache, &in_creds, &out_creds);
krb5_free_principal(context, in_creds.server);
if (ret) {
com_err(prog, ret, "while getting credentials for %s", princ);
krb5_free_unparsed_name(context, princ);
errors++;
continue;
}
/* we need a native ticket */
ret = krb5_decode_ticket(&out_creds->ticket, &ticket);
if (ret) {
com_err(prog, ret, "while decoding ticket for %s", princ);
krb5_free_creds(context, out_creds);
krb5_free_unparsed_name(context, princ);
errors++;
continue;
}
if (keytab) {
ret = krb5_server_decrypt_ticket_keytab(context, keytab, ticket);
if (ret) {
if (!quiet)
printf("%s: kvno = %d, keytab entry invalid", princ, ticket->enc_part.kvno);
com_err(prog, ret, "while decrypting ticket for %s", princ);
krb5_free_ticket(context, ticket);
krb5_free_creds(context, out_creds);
krb5_free_unparsed_name(context, princ);
errors++;
continue;
}
if (!quiet)
printf("%s: kvno = %d, keytab entry valid\n", princ, ticket->enc_part.kvno);
} else {
if (!quiet)
printf("%s: kvno = %d\n", princ, ticket->enc_part.kvno);
}
krb5_free_creds(context, out_creds);
krb5_free_unparsed_name(context, princ);
}
if (keytab)
krb5_kt_close(context, keytab);
krb5_free_principal(context, me);
krb5_cc_close(context, ccache);
krb5_free_context(context);
if (errors)
exit(1);
exit(0);
}
