void do_show_super_stats(int argc, char *argv[])
{
dgrp_t i;
FILE *out;
struct ext2_group_desc *gdp;
int c, header_only = 0;
int numdirs = 0;
const char *usage = "Usage: show_super [-h]";
reset_getopt();
while ((c = getopt (argc, argv, "h")) != EOF) {
switch (c) {
case 'h':
header_only++;
break;
default:
com_err(argv[0], 0, usage);
return;
}
}
if (optind != argc) {
com_err(argv[0], 0, usage);
return;
}
if (check_fs_open(argv[0]))
return;
out = open_pager();
list_super2(current_fs->super, out);
for (i=0; i < current_fs->group_desc_count; i++)
numdirs += current_fs->group_desc[i].bg_used_dirs_count;
fprintf(out, "Directories: %d\n", numdirs);
if (header_only) {
close_pager(out);
return;
}
gdp = ¤t_fs->group_desc[0];
for (i = 0; i < current_fs->group_desc_count; i++, gdp++)
fprintf(out, " Group %2d: block bitmap at %d, "
"inode bitmap at %d, "
"inode table at %d\n"
" %d free %s, "
"%d free %s, "
"%d used %s\n",
i, gdp->bg_block_bitmap,
gdp->bg_inode_bitmap, gdp->bg_inode_table,
gdp->bg_free_blocks_count,
gdp->bg_free_blocks_count != 1 ? "blocks" : "block",
gdp->bg_free_inodes_count,
gdp->bg_free_inodes_count != 1 ? "inodes" : "inode",
gdp->bg_used_dirs_count,
gdp->bg_used_dirs_count != 1 ? "directories"
: "directory");
close_pager(out);
}
static void print_possible_fields(struct field_set_info *fields)
{
struct field_set_info *ss;
const char *type, *cmd;
FILE *f;
char name[40], idx[40];
if (fields == super_fields) {
type = "Superblock";
cmd = "set_super_value";
} else if (fields == inode_fields) {
type = "Inode";
cmd = "set_inode";
} else {
type = "Block group descriptor";
cmd = "set_block_group";
}
f = open_pager();
fprintf(f, "%s fields supported by the %s command:\n", type, cmd);
for (ss = fields ; ss->name ; ss++) {
type = "unknown";
if (ss->func == parse_string)
type = "string";
else if (ss->func == parse_int)
type = "integer";
else if (ss->func == parse_uint)
type = "unsigned integer";
else if (ss->func == parse_uuid)
type = "UUID";
else if (ss->func == parse_hashalg)
type = "hash algorithm";
else if (ss->func == parse_time)
type = "date/time";
else if (ss->func == parse_bmap)
type = "set physical->logical block map";
else if (ss->func == parse_gd_csum)
type = "unsigned integer OR \"calc\"";
strcpy(name, ss->name);
if (ss->flags & FLAG_ARRAY) {
if (ss->max_idx > 0)
sprintf(idx, "[%d]", ss->max_idx);
else
strcpy(idx, "[]");
strcat(name, idx);
}
if (ss->ptr2)
strcat(name, "[_hi|_lo]");
fprintf(f, "\t%-25s\t%s\n", name, type);
}
close_pager(f);
}
void control_reader(const char *path)
{
unsigned char buf[MAX_PACKET_SIZE];
uint16_t index, opcode, pktlen;
struct timeval tv;
if (btsnoop_open(path) < 0)
return;
open_pager();
while (1) {
if (btsnoop_read(&tv, &index, &opcode, buf, &pktlen) < 0)
break;
packet_monitor(&tv, index, opcode, buf, pktlen);
}
close_pager();
btsnoop_close();
}
void control_reader(const char *path, bool pager)
{
unsigned char buf[BTSNOOP_MAX_PACKET_SIZE];
uint16_t pktlen;
uint32_t format;
struct timeval tv;
btsnoop_file = btsnoop_open(path, BTSNOOP_FLAG_PKLG_SUPPORT);
if (!btsnoop_file)
return;
format = btsnoop_get_format(btsnoop_file);
switch (format) {
case BTSNOOP_FORMAT_HCI:
case BTSNOOP_FORMAT_UART:
case BTSNOOP_FORMAT_SIMULATOR:
packet_del_filter(PACKET_FILTER_SHOW_INDEX);
break;
case BTSNOOP_FORMAT_MONITOR:
packet_add_filter(PACKET_FILTER_SHOW_INDEX);
break;
}
if (pager)
open_pager();
switch (format) {
case BTSNOOP_FORMAT_HCI:
case BTSNOOP_FORMAT_UART:
case BTSNOOP_FORMAT_MONITOR:
while (1) {
uint16_t index, opcode;
if (!btsnoop_read_hci(btsnoop_file, &tv, &index,
&opcode, buf, &pktlen))
break;
if (opcode == 0xffff)
continue;
packet_monitor(&tv, NULL, index, opcode, buf, pktlen);
ellisys_inject_hci(&tv, index, opcode, buf, pktlen);
}
break;
case BTSNOOP_FORMAT_SIMULATOR:
while (1) {
uint16_t frequency;
if (!btsnoop_read_phy(btsnoop_file, &tv, &frequency,
buf, &pktlen))
break;
packet_simulator(&tv, frequency, buf, pktlen);
}
break;
}
if (pager)
close_pager();
btsnoop_unref(btsnoop_file);
}
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);
}
void do_show_super_stats(int argc, char *argv[])
{
dgrp_t i;
FILE *out;
struct ext2_group_desc *gdp;
int c, header_only = 0;
int numdirs = 0, first, gdt_csum;
reset_getopt();
while ((c = getopt (argc, argv, "h")) != EOF) {
switch (c) {
case 'h':
header_only++;
break;
default:
goto print_usage;
}
}
if (optind != argc) {
goto print_usage;
}
if (check_fs_open(argv[0]))
return;
out = open_pager();
list_super2(current_fs->super, out);
for (i=0; i < current_fs->group_desc_count; i++)
numdirs += current_fs->group_desc[i].bg_used_dirs_count;
fprintf(out, "Directories: %d\n", numdirs);
if (header_only) {
close_pager(out);
return;
}
gdt_csum = EXT2_HAS_RO_COMPAT_FEATURE(current_fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
gdp = ¤t_fs->group_desc[0];
for (i = 0; i < current_fs->group_desc_count; i++, gdp++) {
fprintf(out, " Group %2d: block bitmap at %u, "
"inode bitmap at %u, "
"inode table at %u\n"
" %d free %s, "
"%d free %s, "
"%d used %s%s",
i, gdp->bg_block_bitmap,
gdp->bg_inode_bitmap, gdp->bg_inode_table,
gdp->bg_free_blocks_count,
gdp->bg_free_blocks_count != 1 ? "blocks" : "block",
gdp->bg_free_inodes_count,
gdp->bg_free_inodes_count != 1 ? "inodes" : "inode",
gdp->bg_used_dirs_count,
gdp->bg_used_dirs_count != 1 ? "directories"
: "directory", gdt_csum ? ", " : "\n");
if (gdt_csum)
fprintf(out, "%d unused %s\n",
gdp->bg_itable_unused,
gdp->bg_itable_unused != 1 ? "inodes":"inode");
first = 1;
print_bg_opts(gdp, EXT2_BG_INODE_UNINIT, "Inode not init",
&first, out);
print_bg_opts(gdp, EXT2_BG_BLOCK_UNINIT, "Block not init",
&first, out);
if (gdt_csum) {
fprintf(out, "%sChecksum 0x%04x",
first ? " [":", ", gdp->bg_checksum);
first = 0;
}
if (!first)
fputs("]\n", out);
}
close_pager(out);
return;
print_usage:
fprintf(stderr, "%s: Usage: show_super [-h]\n", argv[0]);
}
void do_htree_dump(int argc, char *argv[])
{
ext2_ino_t ino;
struct ext2_inode inode;
blk64_t blk;
char *buf = NULL;
struct ext2_dx_root_info *rootnode;
struct ext2_dx_entry *ent;
errcode_t errcode;
if (check_fs_open(argv[0]))
return;
pager = open_pager();
if (common_inode_args_process(argc, argv, &ino, 0))
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_bmap2(current_fs, ino, &inode, buf, 0, 0, 0, &blk);
if (errcode) {
com_err("do_htree_block", errcode,
"while mapping logical block 0\n");
goto errout;
}
errcode = io_channel_read_blk64(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);
htree_dump_int_node(current_fs, ino, &inode, rootnode, ent,
buf + current_fs->blocksize,
rootnode->indirect_levels);
errout:
free(buf);
close_pager(pager);
}
/**
* Open the stream within a Redir structure.
*
* @param rd Redir structure to be opened.
* @param charset The charset to be used. Only has an effect if the stream
* to be opened is to an output pager.
* @return True for success, false for failure.
*/
int
open_stream(struct Redir *rd, CorpusCharset charset)
{
int i;
assert(rd);
if (rd->name) {
i = 0;
while (rd->name[i] == ' ')
i++;
if ((rd->name[i] == '|') &&
(rd->name[i+1] != '\0')) {
if (insecure) {
/* set stream to NULL to force return value of 0 */
rd->stream = NULL;
rd->is_pipe = False;
rd->is_paging = False;
}
else {
/* we send the output to a pipe */
rd->is_pipe = True;
rd->is_paging = False;
rd->stream = popen(rd->name+i+1, rd->mode);
}
}
else {
/* normal output to file */
rd->is_pipe = False;
rd->is_paging = False;
rd->stream = open_file(rd->name, rd->mode);
}
}
else { /* i.e. if rd->name is NULL */
if (pager && paging && isatty(fileno(NULL))) {
if (insecure) {
cqpmessage(Error, "Insecure mode, paging not allowed.\n");
/* ... and default back to bare stdout */
rd->stream = NULL;
rd->is_paging = False;
rd->is_pipe = False;
}
else if ((rd->stream = open_pager(pager, charset)) == NULL) {
cqpmessage(Warning, "Could not start pager '%s', trying fallback '%s'.\n", pager, CQP_FALLBACK_PAGER);
if ((rd->stream = open_pager(CQP_FALLBACK_PAGER, charset)) == NULL) {
cqpmessage(Warning, "Could not start fallback pager '%s'. Paging disabled.\n", CQP_FALLBACK_PAGER);
set_integer_option_value("Paging", 0);
rd->is_pipe = False;
rd->is_paging = False;
rd->stream = NULL;
}
else {
rd->is_pipe = 1;
rd->is_paging = True;
set_string_option_value("Pager", cl_strdup(CQP_FALLBACK_PAGER));
}
}
else {
rd->is_pipe = 1;
rd->is_paging = True;
}
}
else {
rd->stream = NULL;
rd->is_paging = False;
rd->is_pipe = False;
}
}
return (rd->stream == NULL ? 0 : 1);
}