static void
init_routing_switch_options( routing_switch_options *options, int *argc, char **argv[] ) {
assert( options != NULL );
assert( argc != NULL );
assert( *argc >= 0 );
assert( argv != NULL );
// set default values
options->idle_timeout = FLOW_TIMER;
int argc_tmp = *argc;
char *new_argv[ *argc ];
for ( int i = 0; i <= *argc; ++i ) {
new_argv[ i ] = ( *argv )[ i ];
}
int c;
uint32_t idle_timeout;
while ( ( c = getopt_long( *argc, *argv, short_options, long_options, NULL ) ) != -1 ) {
switch ( c ) {
case 'i':
idle_timeout = ( uint32_t ) atoi( optarg );
if ( idle_timeout == 0 || idle_timeout > UINT16_MAX ) {
printf( "Invalid idle_timeout value\n" );
usage();
finalize_topology_service_interface_options();
exit( EXIT_SUCCESS );
return;
}
options->idle_timeout = ( uint16_t ) idle_timeout;
break;
default:
continue;
}
if ( optarg == 0 || strchr( new_argv[ optind - 1 ], '=' ) != NULL ) {
argc_tmp -= 1;
new_argv[ optind - 1 ] = NULL;
}
else {
argc_tmp -= 2;
new_argv[ optind - 1 ] = NULL;
new_argv[ optind - 2 ] = NULL;
}
}
for ( int i = 0, j = 0; i < *argc; ++i ) {
if ( new_argv[ i ] != NULL ) {
( *argv )[ j ] = new_argv[ i ];
j++;
}
}
( *argv )[ *argc ] = NULL;
*argc = argc_tmp;
reset_getopt();
}
int input_init(input_parameter *param, int plugin_no)
{
int i;
if(pthread_mutex_init(&controls_mutex, NULL) != 0) {
IPRINT("could not initialize mutex variable\n");
exit(EXIT_FAILURE);
}
param->argv[0] = INPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
init_mjpg_proxy( &proxy );
reset_getopt();
if (parse_cmd_line(&proxy, param->argc, param->argv))
return 1;
pglobal = param->global;
IPRINT("host.............: %s\n", proxy.hostname);
IPRINT("port.............: %s\n", proxy.port);
return 0;
}
void do_open_filesys(int argc, char **argv)
{
int c, err;
int catastrophic = 0;
blk_t superblock = 0;
blk_t blocksize = 0;
int open_flags = EXT2_FLAG_SOFTSUPP_FEATURES;
char *data_filename = 0;
reset_getopt();
while ((c = getopt (argc, argv, "iwfecb:s:d:")) != EOF) {
switch (c) {
case 'i':
open_flags |= EXT2_FLAG_IMAGE_FILE;
break;
case 'w':
open_flags |= EXT2_FLAG_RW;
break;
case 'f':
open_flags |= EXT2_FLAG_FORCE;
break;
case 'e':
open_flags |= EXT2_FLAG_EXCLUSIVE;
break;
case 'c':
catastrophic = 1;
break;
case 'd':
data_filename = optarg;
break;
case 'b':
blocksize = parse_ulong(optarg, argv[0],
"block size", &err);
if (err)
return;
break;
case 's':
superblock = parse_ulong(optarg, argv[0],
"superblock number", &err);
if (err)
return;
break;
default:
goto print_usage;
}
}
if (optind != argc-1) {
goto print_usage;
}
if (check_fs_not_open(argv[0]))
return;
open_filesystem(argv[optind], open_flags,
superblock, blocksize, catastrophic,
data_filename);
return;
print_usage:
fprintf(stderr, "%s: Usage: open [-s superblock] [-b blocksize] "
"[-c] [-w] <device>\n", argv[0]);
}
/*
* This function prints the hash of a given file.
*/
void do_dx_hash(int argc, char *argv[])
{
ext2_dirhash_t hash, minor_hash;
errcode_t err;
int c;
int hash_version = 0;
__u32 hash_seed[4];
hash_seed[0] = hash_seed[1] = hash_seed[2] = hash_seed[3] = 0;
reset_getopt();
while ((c = getopt (argc, argv, "h:")) != EOF) {
switch (c) {
case 'h':
hash_version = atoi(optarg);
break;
default:
goto print_usage;
}
}
if (optind != argc-1) {
print_usage:
com_err(argv[0], 0, "usage: dx_hash filename");
return;
}
err = ext2fs_dirhash(hash_version, argv[optind], strlen(argv[optind]),
hash_seed, &hash, &minor_hash);
if (err) {
com_err(argv[0], err, "while caclulating hash");
return;
}
printf("Hash of %s is 0x%0x (minor 0x%0x)\n", argv[optind],
hash, minor_hash);
}
/**
* Execute command
*
* @v command Command name
* @v argv Argument list
* @ret rc Return status code
*
* Execute the named command. Unlike a traditional POSIX execv(),
* this function returns the exit status of the command.
*/
int execv ( const char *command, char * const argv[] ) {
struct command *cmd;
int argc;
/* Count number of arguments */
for ( argc = 0 ; argv[argc] ; argc++ ) {}
/* An empty command is deemed to do nothing, successfully */
if ( command == NULL )
return 0;
/* Sanity checks */
if ( argc == 0 ) {
DBG ( "%s: empty argument list\n", command );
return -EINVAL;
}
/* Reset getopt() library ready for use by the command. This
* is an artefact of the POSIX getopt() API within the context
* of Etherboot; see the documentation for reset_getopt() for
* details.
*/
reset_getopt();
/* Hand off to command implementation */
for_each_table_entry ( cmd, COMMANDS ) {
if ( strcmp ( command, cmd->name ) == 0 )
return cmd->exec ( argc, ( char ** ) argv );
}
printf ( "%s: command not found\n", command );
return -ENOEXEC;
}
/******************************************************************************
Description.: this function is called first, in order to initialize
this plugin and pass a parameter string
Input Value.: parameters
Return Value: 0 if everything is OK, non-zero otherwise
******************************************************************************/
int output_init(output_parameter *param, int id)
{
int i;
delay = 0;
pglobal = param->global;
pglobal->out[id].name = (char *) malloc((1+strlen(OUTPUT_PLUGIN_NAME))*sizeof(char));
sprintf(pglobal->out[id].name, "%s", OUTPUT_PLUGIN_NAME);
DBG("OUT plugin %d name: %s\n", id, pglobal->out[id].name);
param->argv[0] = OUTPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] = {
{"h", no_argument, 0, 0
},
{"help", no_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?') {
help();
return 1;
}
switch(option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
}
}
if(!(input_number < pglobal->incnt)) {
OPRINT("ERROR: the %d input_plugin number is too much only %d plugins loaded\n", input_number, param->global->incnt);
return 1;
}
OPRINT("Starting OpenCV.....\n");
OPRINT("input plugin.....: %d: %s\n", input_number, pglobal->in[input_number].plugin);
param->global->out[id].parametercount = 0;
return 0;
}
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);
}
void do_open_filesys(int argc, char **argv)
{
const char *usage = "Usage: open [-s superblock] [-b blocksize] [-c] [-w] <device>";
int c, err;
int catastrophic = 0;
blk_t superblock = 0;
blk_t blocksize = 0;
int open_flags = 0;
char *data_filename = 0;
reset_getopt();
while ((c = getopt (argc, argv, "iwfcb:s:d:")) != EOF) {
switch (c) {
case 'i':
open_flags |= EXT2_FLAG_IMAGE_FILE;
break;
case 'w':
open_flags |= EXT2_FLAG_RW;
break;
case 'f':
open_flags |= EXT2_FLAG_FORCE;
break;
case 'c':
catastrophic = 1;
break;
case 'd':
data_filename = optarg;
break;
case 'b':
blocksize = parse_ulong(optarg, argv[0],
"block size", &err);
if (err)
return;
break;
case 's':
superblock = parse_ulong(optarg, argv[0],
"superblock number", &err);
if (err)
return;
break;
default:
com_err(argv[0], 0, usage);
return;
}
}
if (optind != argc-1) {
com_err(argv[0], 0, usage);
return;
}
if (check_fs_not_open(argv[0]))
return;
open_filesystem(argv[optind], open_flags,
superblock, blocksize, catastrophic,
data_filename);
}
/******************************************************************************
Description.: this function is called first, in order to initialise
this plugin and pass a parameter string
Input Value.: parameters
Return Value: 0 if everything is ok, non-zero otherwise
******************************************************************************/
int output_init(output_parameter *param)
{
int i;
param->argv[0] = OUTPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] = {
{"h", no_argument, 0, 0},
{"help", no_argument, 0, 0},
{"i", no_argument, 0, 0},
{"input", no_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?') {
help();
return 1;
}
switch(option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
case 2:
case 3:
DBG("case 2,3\n");
plugin_number = atoi(optarg);
break;
}
}
pglobal = param->global;
return 0;
}
void do_dump(int argc, char **argv)
{
ext2_ino_t inode;
int fd;
int c;
int preserve = 0;
char *in_fn, *out_fn;
reset_getopt();
while ((c = getopt (argc, argv, "p")) != EOF) {
switch (c) {
case 'p':
preserve++;
break;
default:
print_usage:
com_err(argv[0], 0, "Usage: dump_inode [-p] "
"<file> <output_file>");
return;
}
}
if (optind != argc-2)
goto print_usage;
if (check_fs_open(argv[0]))
return;
in_fn = argv[optind];
out_fn = argv[optind+1];
inode = string_to_inode(in_fn);
if (!inode)
return;
fd = open(out_fn, O_CREAT | O_WRONLY | O_TRUNC | O_LARGEFILE, 0666);
if (fd < 0) {
com_err(argv[0], errno, "while opening %s for dump_inode",
out_fn);
return;
}
dump_file(argv[0], inode, fd, preserve, out_fn);
if (close(fd) != 0) {
com_err(argv[0], errno, "while closing %s for dump_inode",
out_fn);
return;
}
return;
}
void
option_parser( int *argc, char **argv[] ) {
int c;
int argc_tmp = *argc;
char *new_argv[ *argc ];
for ( int i = 0; i <= *argc; ++i ) {
new_argv[ i ] = ( *argv )[ i ];
}
while ( ( c = getopt_long( *argc, *argv, short_options, long_options, NULL ) ) != -1 ) {
switch ( c ) {
case 't':
xfree( options.name );
options.name = xstrdup( optarg );
break;
default:
finalize_topology_service_interface_options();
exit( EXIT_SUCCESS );
return;
}
if ( optarg == 0 || strchr( new_argv[ optind - 1 ], '=' ) != NULL ) {
argc_tmp -= 1;
new_argv[ optind - 1 ] = NULL;
}
else {
argc_tmp -= 2;
new_argv[ optind - 1 ] = NULL;
new_argv[ optind - 2 ] = NULL;
}
}
for ( int i = 0, j = 0; i < *argc; ++i ) {
if ( new_argv[ i ] != NULL ) {
( *argv )[ j ] = new_argv[ i ];
j++;
}
}
( *argv )[ *argc ] = NULL;
*argc = argc_tmp;
reset_getopt();
debug( "topology_service_interface_name=`%s'", options.name );
}
/*
* The 'GO' command may be followed by options that apply to the batch.
* If they don't appear to be right, assume the letters "go" are part of the
* SQL, not a batch separator.
*/
static int
get_opt_flags(char *s, int *opt_flags)
{
char **argv;
int argc;
int opt;
/* make sure we have enough elements */
assert(s && opt_flags);
argv = (char **) calloc(strlen(s) + 2, sizeof(char*));
if (!argv)
return 0;
/* parse the command line and assign to argv */
for (argc=0; (argv[argc] = strtok(s, " ")) != NULL; argc++)
s = NULL;
*opt_flags = 0;
reset_getopt();
opterr = 0; /* suppress error messages */
while ((opt = getopt(argc, argv, "fhLqtv")) != -1) {
switch (opt) {
case 'f':
*opt_flags |= OPT_NOFOOTER;
break;
case 'h':
*opt_flags |= OPT_NOHEADER;
break;
case 't':
*opt_flags |= OPT_TIMER;
break;
case 'v':
*opt_flags |= OPT_VERSION;
break;
case 'q':
*opt_flags |= OPT_QUIET;
break;
default:
fprintf(stderr, "Warning: invalid option '%s' found: \"go\" treated as simple SQL\n", argv[optind-1]);
free(argv);
return 0;
}
}
free(argv);
return 1;
}
void do_dx_hash(int argc, char *argv[])
{
ext2_dirhash_t hash, minor_hash;
errcode_t err;
int c;
int hash_version = 0;
__u32 hash_seed[4];
hash_seed[0] = hash_seed[1] = hash_seed[2] = hash_seed[3] = 0;
reset_getopt();
while ((c = getopt (argc, argv, "h:s:")) != EOF) {
switch (c) {
case 'h':
hash_version = e2p_string2hash(optarg);
if (hash_version < 0)
hash_version = atoi(optarg);
break;
case 's':
if (uuid_parse(optarg, (unsigned char *) hash_seed)) {
fprintf(stderr, "Invalid UUID format: %s\n",
optarg);
return;
}
break;
default:
goto print_usage;
}
}
if (optind != argc-1) {
print_usage:
com_err(argv[0], 0, "usage: dx_hash [-h hash_alg] "
"[-s hash_seed] filename");
return;
}
err = ext2fs_dirhash(hash_version, argv[optind], strlen(argv[optind]),
hash_seed, &hash, &minor_hash);
if (err) {
com_err(argv[0], err, "while caclulating hash");
return;
}
printf("Hash of %s is 0x%0x (minor 0x%0x)\n", argv[optind],
hash, minor_hash);
}
void setup_cmd(int argc, char **argv)
{
int c, err;
unsigned int blocks = 128;
unsigned int inodes = 0;
unsigned int type = EXT2FS_BMAP64_BITARRAY;
int flags = EXT2_FLAG_64BITS;
if (test_fs)
ext2fs_close_free(&test_fs);
reset_getopt();
while ((c = getopt(argc, argv, "b:i:lt:")) != EOF) {
switch (c) {
case 'b':
blocks = parse_ulong(optarg, argv[0],
"number of blocks", &err);
if (err)
return;
break;
case 'i':
inodes = parse_ulong(optarg, argv[0],
"number of blocks", &err);
if (err)
return;
break;
case 'l': /* Legacy bitmaps */
flags = 0;
break;
case 't':
type = parse_ulong(optarg, argv[0],
"bitmap backend type", &err);
if (err)
return;
break;
default:
fprintf(stderr, "%s: usage: setup [-b blocks] "
"[-i inodes] [-t type]\n", argv[0]);
return;
}
}
setup_filesystem(argv[0], blocks, inodes, type, flags);
}
/******************************************************************************
Description.: this function is called first, in order to initialize
this plugin and pass a parameter string
Input Value.: parameters
Return Value: 0 if everything is OK, non-zero otherwise
******************************************************************************/
int output_init(output_parameter *param, int id)
{
int i;
pglobal = param->global;
pglobal->out[id].name = malloc((1+strlen(OUTPUT_PLUGIN_NAME))*sizeof(char));
sprintf(pglobal->out[id].name, "%s", OUTPUT_PLUGIN_NAME);
DBG("OUT plugin %d name: %s\n", id, pglobal->out[id].name);
param->argv[0] = OUTPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] = {
{"h", no_argument, 0, 0
},
{"help", no_argument, 0, 0},
{"f", required_argument, 0, 0},
{"folder", required_argument, 0, 0},
{"s", required_argument, 0, 0},
{"size", required_argument, 0, 0},
{"e", required_argument, 0, 0},
{"exceed", required_argument, 0, 0},
{"i", required_argument, 0, 0},
{"input", required_argument, 0, 0},
{"m", required_argument, 0, 0},
{"mjpeg", required_argument, 0, 0},
{"a", required_argument, 0, 0},
{"address", required_argument, 0, 0},
{"b", required_argument, 0, 0},
{"buffer_size", required_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?') {
help();
return 1;
}
switch(option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
/* f, folder */
case 2:
case 3:
DBG("case 2,3\n");
folder = malloc(strlen(optarg) + 1);
strcpy(folder, optarg);
if(folder[strlen(folder)-1] == '/')
folder[strlen(folder)-1] = '\0';
break;
/* s, size */
case 4:
case 5:
DBG("case 4,5\n");
ringbuffer_size = atoi(optarg);
break;
/* e, exceed */
case 6:
case 7:
DBG("case 6,7\n");
ringbuffer_exceed = atoi(optarg);
break;
/* i, input*/
case 8:
case 9:
DBG("case 8,9\n");
input_number = atoi(optarg);
break;
/* m mjpeg */
case 10:
case 11:
DBG("case 10,11\n");
mjpgFileName = strdup(optarg);
break;
/* a address */
case 12:
case 13:
DBG("case 12,13\n");
zmqAddress = strdup(optarg);
break;
/* buffer_size */
case 14:
case 15:
DBG("case 14,15\n");
zmqBufferSize = atoi(optarg);
break;
}
}
if(!(input_number < pglobal->incnt)) {
OPRINT("ERROR: the %d input_plugin number is too much only %d plugins loaded\n", input_number, param->global->incnt);
return 1;
}
OPRINT("output folder.....: %s\n", folder);
OPRINT("input plugin.....: %d: %s\n", input_number, pglobal->in[input_number].plugin);
if (mjpgFileName == NULL) {
if(ringbuffer_size > 0) {
OPRINT("ringbuffer size...: %d to %d\n", ringbuffer_size, ringbuffer_size + ringbuffer_exceed);
} else {
OPRINT("ringbuffer size...: %s\n", "no ringbuffer");
}
} else {
char *fnBuffer = malloc(strlen(mjpgFileName) + strlen(folder) + 3);
sprintf(fnBuffer, "%s/%s", folder, mjpgFileName);
OPRINT("output file.......: %s\n", fnBuffer);
if((fd = open(fnBuffer, O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0) {
OPRINT("could not open the file %s\n", fnBuffer);
free(fnBuffer);
return 1;
}
free(fnBuffer);
}
param->global->out[id].parametercount = 2;
param->global->out[id].out_parameters = (control*) calloc(2, sizeof(control));
control take_ctrl;
take_ctrl.group = IN_CMD_GENERIC;
take_ctrl.menuitems = NULL;
take_ctrl.value = 1;
take_ctrl.class_id = 0;
take_ctrl.ctrl.id = OUT_FILE_CMD_TAKE;
take_ctrl.ctrl.type = V4L2_CTRL_TYPE_BUTTON;
strcpy((char*) take_ctrl.ctrl.name, "Take snapshot");
take_ctrl.ctrl.minimum = 0;
take_ctrl.ctrl.maximum = 1;
take_ctrl.ctrl.step = 1;
take_ctrl.ctrl.default_value = 0;
param->global->out[id].out_parameters[0] = take_ctrl;
control filename_ctrl;
filename_ctrl.group = IN_CMD_GENERIC;
filename_ctrl.menuitems = NULL;
filename_ctrl.value = 1;
filename_ctrl.class_id = 0;
filename_ctrl.ctrl.id = OUT_FILE_CMD_FILENAME;
filename_ctrl.ctrl.type = V4L2_CTRL_TYPE_STRING;
strcpy((char*) filename_ctrl.ctrl.name, "Filename");
filename_ctrl.ctrl.minimum = 0;
filename_ctrl.ctrl.maximum = 32;
filename_ctrl.ctrl.step = 1;
filename_ctrl.ctrl.default_value = 0;
param->global->out[id].out_parameters[1] = filename_ctrl;
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);
}
/******************************************************************************
Description.: parse input parameters
Input Value.: param contains the command line string and a pointer to globals
Return Value: 0 if everything is ok
******************************************************************************/
int input_init(input_parameter *param, int plugin_no)
{
int i;
pics = &picture_lookup[1];
if(pthread_mutex_init(&controls_mutex, NULL) != 0) {
IPRINT("could not initialize mutex variable\n");
exit(EXIT_FAILURE);
}
param->argv[0] = INPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] = {
{"h", no_argument, 0, 0
},
{"help", no_argument, 0, 0},
{"d", required_argument, 0, 0},
{"delay", required_argument, 0, 0},
{"r", required_argument, 0, 0},
{"resolution", required_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?') {
help();
return 1;
}
switch(option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
/* d, delay */
case 2:
case 3:
DBG("case 2,3\n");
delay = atoi(optarg);
break;
/* r, resolution */
case 4:
case 5:
DBG("case 4,5\n");
for(i = 0; i < LENGTH_OF(picture_lookup); i++) {
if(strcmp(picture_lookup[i].resolution, optarg) == 0) {
pics = &picture_lookup[i];
break;
}
}
break;
default:
DBG("default case\n");
help();
return 1;
}
}
pglobal = param->global;
IPRINT("delay.............: %i\n", delay);
IPRINT("resolution........: %s\n", pics->resolution);
return 0;
}
/******************************************************************************
Description.: This function ializes the plugin. It parses the commandline-
parameter and stores the default and parsed values in the
appropriate variables.
Input Value.: param contains among others the command-line string
Return Value: 0 if everything is fine
1 if "--help" was triggered, in this case the calling programm
should stop running and leave.
******************************************************************************/
int input_init(input_parameter *param, int id)
{
char *dev = "/dev/video0", *s;
int width = 640, height = 480, fps = 5, format = V4L2_PIX_FMT_MJPEG, i;
/* initialize the mutes variable */
if(pthread_mutex_init(&cams[id].controls_mutex, NULL) != 0) {
IPRINT("could not initialize mutex variable\n");
exit(EXIT_FAILURE);
}
param->argv[0] = INPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
/* parse the parameters */
reset_getopt();
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] = {
{"h", no_argument, 0, 0
},
{"help", no_argument, 0, 0},
{"d", required_argument, 0, 0},
{"device", required_argument, 0, 0},
{"r", required_argument, 0, 0},
{"resolution", required_argument, 0, 0},
{"f", required_argument, 0, 0},
{"fps", required_argument, 0, 0},
{"y", no_argument, 0, 0},
{"yuv", no_argument, 0, 0},
{"q", required_argument, 0, 0},
{"quality", required_argument, 0, 0},
{"m", required_argument, 0, 0},
{"minimum_size", required_argument, 0, 0},
{"n", no_argument, 0, 0},
{"no_dynctrl", no_argument, 0, 0},
{"l", required_argument, 0, 0},
{"led", required_argument, 0, 0},
{"s", no_argument, 0, 0},
{"stop", no_argument, 0, 0},
{0, 0, 0, 0}
};
/* parsing all parameters according to the list above is sufficent */
c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?') {
help();
return 1;
}
/* dispatch the given options */
switch(option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
/* d, device */
case 2:
case 3:
DBG("case 2,3\n");
dev = strdup(optarg);
break;
/* r, resolution */
case 4:
case 5:
DBG("case 4,5\n");
width = -1;
height = -1;
/* try to find the resolution in lookup table "resolutions" */
for(i = 0; i < LENGTH_OF(resolutions); i++) {
if(strcmp(resolutions[i].string, optarg) == 0) {
width = resolutions[i].width;
height = resolutions[i].height;
}
}
/* done if width and height were set */
if(width != -1 && height != -1)
break;
/* parse value as decimal value */
width = strtol(optarg, &s, 10);
height = strtol(s + 1, NULL, 10);
break;
/* f, fps */
case 6:
case 7:
DBG("case 6,7\n");
fps = atoi(optarg);
break;
/* y, yuv */
case 8:
case 9:
DBG("case 8,9\n");
format = V4L2_PIX_FMT_YUYV;
break;
/* q, quality */
case 10:
case 11:
DBG("case 10,11\n");
format = V4L2_PIX_FMT_YUYV;
gquality = MIN(MAX(atoi(optarg), 0), 100);
break;
/* m, minimum_size */
case 12:
case 13:
DBG("case 12,13\n");
minimum_size = MAX(atoi(optarg), 0);
break;
/* n, no_dynctrl */
case 14:
case 15:
DBG("case 14,15\n");
dynctrls = 0;
break;
/* l, led */
case 16:
case 17:/*
DBG("case 16,17\n");
if ( strcmp("on", optarg) == 0 ) {
led = IN_CMD_LED_ON;
} else if ( strcmp("off", optarg) == 0 ) {
led = IN_CMD_LED_OFF;
} else if ( strcmp("auto", optarg) == 0 ) {
led = IN_CMD_LED_AUTO;
} else if ( strcmp("blink", optarg) == 0 ) {
led = IN_CMD_LED_BLINK;
}*/
break;
/* s, stop */
case 18:
case 19:
DBG("case 18,19\n");
stop_camera = 1;
break;
default:
DBG("default case\n");
help();
return 1;
}
}
DBG("input id: %d\n", id);
cams[id].id = id;
cams[id].pglobal = param->global;
/* allocate webcam datastructure */
cams[id].videoIn = malloc(sizeof(struct vdIn));
if(cams[id].videoIn == NULL) {
IPRINT("not enough memory for videoIn\n");
exit(EXIT_FAILURE);
}
memset(cams[id].videoIn, 0, sizeof(struct vdIn));
/* display the parsed values */
IPRINT("Using V4L2 device.: %s\n", dev);
IPRINT("Desired Resolution: %i x %i\n", width, height);
IPRINT("Frames Per Second.: %i\n", fps);
IPRINT("Format............: %s\n", (format == V4L2_PIX_FMT_YUYV) ? "YUV" : "MJPEG");
if(format == V4L2_PIX_FMT_YUYV)
IPRINT("JPEG Quality......: %d\n", gquality);
IPRINT("Stop camera feat..: %d\n", stop_camera);
DBG("vdIn pn: %d\n", id);
/* open video device and prepare data structure */
if(init_videoIn(cams[id].videoIn, dev, width, height, fps, format, 1, cams[id].pglobal, id) < 0) {
IPRINT("init_VideoIn failed\n");
closelog();
exit(EXIT_FAILURE);
}
/*
* recent linux-uvc driver (revision > ~#125) requires to use dynctrls
* for pan/tilt/focus/...
* dynctrls must get initialized
*/
if(dynctrls)
initDynCtrls(cams[id].videoIn->fd);
enumerateControls(cams[id].videoIn, cams[id].pglobal, id); // enumerate V4L2 controls after UVC extended mapping
return 0;
}
static void
init_switch_options( switch_options *options, int *argc, char **argv[] ) {
assert( options != NULL );
assert( argc != NULL );
assert( *argc >= 0 );
assert( argv != NULL );
// set default values
options->idle_timeout = FLOW_TIMER;
options->handle_arp_with_packetout = false;
memset( options->slice_db_file, '\0', sizeof( options->slice_db_file ) );
memset( options->filter_db_file, '\0', sizeof( options->filter_db_file ) );
options->mode = 0;
int argc_tmp = *argc;
char *new_argv[ *argc ];
for ( int i = 0; i <= *argc; ++i ) {
new_argv[ i ] = ( *argv )[ i ];
}
int c;
uint32_t idle_timeout;
while ( ( c = getopt_long( *argc, *argv, short_options, long_options, NULL ) ) != -1 ) {
switch ( c ) {
case 'i':
idle_timeout = ( uint32_t ) atoi( optarg );
if ( idle_timeout == 0 || idle_timeout > UINT16_MAX ) {
printf( "Invalid idle_timeout value.\n" );
usage();
finalize_topology_service_interface_options();
exit( EXIT_SUCCESS );
return;
}
options->idle_timeout = ( uint16_t ) idle_timeout;
break;
case 'A':
options->handle_arp_with_packetout = true;
break;
case 's':
if ( optarg != NULL ) {
if ( realpath( optarg, options->slice_db_file ) == NULL ) {
memset( options->slice_db_file, '\0', sizeof( options->slice_db_file ) );
}
}
break;
case 'a':
if ( optarg != NULL ) {
if ( realpath( optarg, options->filter_db_file ) == NULL ) {
memset( options->filter_db_file, '\0', sizeof( options->filter_db_file ) );
}
}
break;
case 'm':
options->mode |= LOOSE_MAC_BASED_SLICING;
break;
case 'r':
options->mode |= RESTRICT_HOSTS_ON_PORT;
break;
default:
continue;
}
if ( optarg == 0 || strchr( new_argv[ optind - 1 ], '=' ) != NULL ) {
argc_tmp -= 1;
new_argv[ optind - 1 ] = NULL;
}
else {
argc_tmp -= 2;
new_argv[ optind - 1 ] = NULL;
new_argv[ optind - 2 ] = NULL;
}
}
if ( strlen( options->filter_db_file ) == 0 ) {
printf( "--filter_db option is mandatory.\n" );
usage();
exit( EXIT_FAILURE );
}
if ( strlen( options->slice_db_file ) == 0 ) {
printf( "--slice_db option is mandatory.\n" );
usage();
exit( EXIT_FAILURE );
}
for ( int i = 0, j = 0; i < *argc; ++i ) {
if ( new_argv[ i ] != NULL ) {
( *argv )[ j ] = new_argv[ i ];
j++;
}
}
( *argv )[ *argc ] = NULL;
*argc = argc_tmp;
reset_getopt();
}
void do_logdump(int argc, char **argv)
{
int c;
int retval;
char *out_fn;
FILE *out_file;
char *inode_spec = NULL;
char *journal_fn = NULL;
int journal_fd = 0;
int use_sb = 0;
ext2_ino_t journal_inum;
struct ext2_inode journal_inode;
ext2_file_t journal_file;
char *tmp;
struct journal_source journal_source;
struct ext2_super_block *es = NULL;
journal_source.where = 0;
journal_source.fd = 0;
journal_source.file = 0;
dump_all = 0;
dump_contents = 0;
dump_descriptors = 1;
block_to_dump = ANY_BLOCK;
bitmap_to_dump = -1;
inode_block_to_dump = ANY_BLOCK;
inode_to_dump = -1;
reset_getopt();
while ((c = getopt (argc, argv, "ab:ci:f:s")) != EOF) {
switch (c) {
case 'a':
dump_all++;
break;
case 'b':
block_to_dump = strtoul(optarg, &tmp, 0);
if (*tmp) {
com_err(argv[0], 0,
"Bad block number - %s", optarg);
return;
}
dump_descriptors = 0;
break;
case 'c':
dump_contents++;
break;
case 'f':
journal_fn = optarg;
break;
case 'i':
inode_spec = optarg;
dump_descriptors = 0;
break;
case 's':
use_sb++;
break;
default:
goto print_usage;
}
}
if (optind != argc && optind != argc-1) {
goto print_usage;
}
if (current_fs)
es = current_fs->super;
if (inode_spec) {
int inode_group, group_offset, inodes_per_block;
if (check_fs_open(argv[0]))
return;
inode_to_dump = string_to_inode(inode_spec);
if (!inode_to_dump)
return;
inode_group = ((inode_to_dump - 1)
/ es->s_inodes_per_group);
group_offset = ((inode_to_dump - 1)
% es->s_inodes_per_group);
inodes_per_block = (current_fs->blocksize
/ sizeof(struct ext2_inode));
inode_block_to_dump =
current_fs->group_desc[inode_group].bg_inode_table +
(group_offset / inodes_per_block);
inode_offset_to_dump = ((group_offset % inodes_per_block)
* sizeof(struct ext2_inode));
printf("Inode %u is at group %u, block %u, offset %u\n",
inode_to_dump, inode_group,
inode_block_to_dump, inode_offset_to_dump);
}
if (optind == argc) {
out_file = stdout;
} else {
out_fn = argv[optind];
out_file = fopen(out_fn, "w");
if (!out_file < 0) {
com_err(argv[0], errno, "while opening %s for logdump",
out_fn);
return;
}
}
if (block_to_dump != ANY_BLOCK && current_fs != NULL) {
group_to_dump = ((block_to_dump -
es->s_first_data_block)
/ es->s_blocks_per_group);
bitmap_to_dump = current_fs->group_desc[group_to_dump].bg_block_bitmap;
}
if (!journal_fn && check_fs_open(argv[0]))
return;
if (journal_fn) {
/* Set up to read journal from a regular file somewhere */
journal_fd = open(journal_fn, O_RDONLY, 0);
if (journal_fd < 0) {
com_err(argv[0], errno, "while opening %s for logdump",
journal_fn);
return;
}
journal_source.where = JOURNAL_IS_EXTERNAL;
journal_source.fd = journal_fd;
} else if ((journal_inum = es->s_journal_inum)) {
if (use_sb) {
if (es->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS) {
com_err(argv[0], 0,
"no journal backup in super block\n");
return;
}
memset(&journal_inode, 0, sizeof(struct ext2_inode));
memcpy(&journal_inode.i_block[0], es->s_jnl_blocks,
EXT2_N_BLOCKS*4);
journal_inode.i_size = es->s_jnl_blocks[16];
journal_inode.i_links_count = 1;
journal_inode.i_mode = LINUX_S_IFREG | 0600;
} else {
if (debugfs_read_inode(journal_inum, &journal_inode,
argv[0]))
return;
}
retval = ext2fs_file_open2(current_fs, journal_inum,
&journal_inode, 0, &journal_file);
if (retval) {
com_err(argv[0], retval, "while opening ext2 file");
return;
}
journal_source.where = JOURNAL_IS_INTERNAL;
journal_source.file = journal_file;
} else {
char uuid[37];
uuid_unparse(es->s_journal_uuid, uuid);
journal_fn = blkid_get_devname(NULL, "UUID", uuid);
if (!journal_fn)
journal_fn = blkid_devno_to_devname(es->s_journal_dev);
if (!journal_fn) {
com_err(argv[0], 0, "filesystem has no journal");
return;
}
journal_fd = open(journal_fn, O_RDONLY, 0);
if (journal_fd < 0) {
com_err(argv[0], errno, "while opening %s for logdump",
journal_fn);
free(journal_fn);
return;
}
fprintf(out_file, "Using external journal found at %s\n",
journal_fn);
free(journal_fn);
journal_source.where = JOURNAL_IS_EXTERNAL;
journal_source.fd = journal_fd;
}
dump_journal(argv[0], out_file, &journal_source);
if (journal_source.where == JOURNAL_IS_INTERNAL)
ext2fs_file_close(journal_file);
else
close(journal_fd);
if (out_file != stdout)
fclose(out_file);
return;
print_usage:
fprintf(stderr, "%s: Usage: logdump [-ac] [-b<block>] [-i<inode>]\n\t"
"[-f<journal_file>] [output_file]\n", argv[0]);
}
static void
parse_argv( int *argc, char ***argv ) {
assert( argc != NULL );
assert( argv != NULL );
int argc_tmp = *argc;
char *new_argv[ *argc ];
run_as_daemon = false;
controller.ip = 0x7f000001;
controller.port = 6633;
for ( int i = 0; i < *argc; ++i ) {
new_argv[ i ] = ( *argv )[ i ];
}
for ( ;; ) {
opterr = 0;
int c = getopt_long( *argc, *argv, short_options, long_options, NULL );
if ( c == -1 ) {
break;
}
switch ( c ) {
case 'i':
if ( optarg != NULL ) {
string_to_datapath_id( optarg, &datapath_id );
}
break;
case 'c':
if ( optarg != NULL ) {
struct in_addr addr;
inet_aton( optarg, &addr );
controller.ip = ntohl( addr.s_addr );
}
break;
case 'p':
if ( optarg != NULL && atoi( optarg ) <= UINT16_MAX ) {
controller.port = ( uint16_t ) atoi( optarg );
}
break;
case 'd':
run_as_daemon = true;
break;
case 'l':
set_logging_level( optarg );
break;
case 'h':
usage();
exit( EXIT_SUCCESS );
break;
default:
continue;
}
if ( optarg == NULL || strchr( new_argv[ optind - 1 ], '=' ) != NULL ) {
argc_tmp -= 1;
new_argv[ optind - 1 ] = NULL;
}
else {
argc_tmp -= 2;
new_argv[ optind - 1 ] = NULL;
new_argv[ optind - 2 ] = NULL;
}
}
for ( int i = 0, j = 0; i < *argc; ++i ) {
if ( new_argv[ i ] != NULL ) {
( *argv )[ j ] = new_argv[ i ];
j++;
}
}
if ( argc_tmp < *argc ) {
( *argv )[ argc_tmp ] = NULL;
}
*argc = argc_tmp;
reset_getopt();
}
/*** plugin interface functions ***/
int input_init(input_parameter *param, int id)
{
int i;
init_defaults();
plugin_number = id;
param->argv[0] = INPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] = {
{"h", no_argument, 0, 0},
{"help", no_argument, 0, 0},
{"d", required_argument, 0, 0},
{"delay", required_argument, 0, 0},
{"n", required_argument, 0, 0},
{"name", required_argument, 0, 0},
{"dl", required_argument, 0, 0},
{"delim", required_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?') {
help();
return 1;
}
switch(option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
/* d, delay */
case 2:
case 3:
DBG("case 2,3\n");
delay = atoi(optarg);
break;
/* n, name */
case 4:
case 5:
DBG("case 4,5\n");
fifoname = strdup(optarg);
break;
/* dl, delim */
case 6:
case 7:
DBG("case 6,7\n");
frame_delim = strdup(optarg);
frame_delim_size = strlen(frame_delim);
break;
default:
DBG("default case\n");
help();
return 1;
}
}
pglobal = param->global;
//TODO: WARNING ABOUT DEFAULTS
IPRINT("forced delay......: %i\n", delay);
IPRINT("frame delimeter...: %s\n", frame_delim);
IPRINT("fifoname is.......: %s\n", fifoname);
param->global->in[id].name = malloc((strlen(INPUT_PLUGIN_NAME) + 1) * sizeof(char));
sprintf(param->global->in[id].name, INPUT_PLUGIN_NAME);
return 0;
}
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_get_xattr(int argc, char **argv)
{
ext2_ino_t ino;
struct ext2_xattr_handle *h;
FILE *fp = NULL;
char *buf = NULL;
size_t buflen;
int i;
int print_flags = 0;
unsigned int handle_flags = 0;
errcode_t err;
reset_getopt();
while ((i = getopt(argc, argv, "Cf:rxV")) != -1) {
switch (i) {
case 'f':
if (fp)
fclose(fp);
fp = fopen(optarg, "w");
if (fp == NULL) {
perror(optarg);
return;
}
break;
case 'r':
handle_flags |= XATTR_HANDLE_FLAG_RAW;
break;
case 'x':
print_flags |= PRINT_XATTR_HEX;
break;
case 'V':
print_flags |= PRINT_XATTR_RAW|
PRINT_XATTR_NOQUOTES;
break;
case 'C':
print_flags |= PRINT_XATTR_C;
break;
default:
goto usage;
}
}
if (optind != argc - 2) {
usage:
printf("%s: Usage: %s [-f outfile]|[-xVC] [-r] <file> <attr>\n",
argv[0], argv[0]);
goto out2;
}
if (check_fs_open(argv[0]))
goto out2;
ino = string_to_inode(argv[optind]);
if (!ino)
goto out2;
err = ext2fs_xattrs_open(current_fs, ino, &h);
if (err)
goto out2;
err = ext2fs_xattrs_flags(h, &handle_flags, NULL);
if (err)
goto out;
err = ext2fs_xattrs_read(h);
if (err)
goto out;
err = ext2fs_xattr_get(h, argv[optind + 1], (void **)&buf, &buflen);
if (err)
goto out;
if (fp) {
fwrite(buf, buflen, 1, fp);
} else {
if (print_flags & PRINT_XATTR_RAW) {
if (print_flags & (PRINT_XATTR_HEX|PRINT_XATTR_C))
print_flags &= ~PRINT_XATTR_RAW;
print_xattr_string(stdout, buf, buflen, print_flags);
} else {
print_xattr(stdout, argv[optind + 1],
buf, buflen, print_flags);
}
printf("\n");
}
ext2fs_free_mem(&buf);
out:
ext2fs_xattrs_close(&h);
if (err)
com_err(argv[0], err, "while getting extended attribute");
out2:
if (fp)
fclose(fp);
}
/******************************************************************************
Description.: This function initializes the plugin. It parses the commandline-
parameter and stores the default and parsed values in the
appropriate variables.
Input Value.: param contains among others the command-line string
Return Value: 0 if everything is fine
1 if "--help" was triggered, in this case the calling programm
should stop running and leave.
******************************************************************************/
int input_init(input_parameter *param) {
char *argv[MAX_ARGUMENTS]={NULL}, *dev = "/dev/video0", *s;
int argc=1, width=640, height=480, fps=5, format=V4L2_PIX_FMT_MJPEG, i;
in_cmd_type led = IN_CMD_LED_AUTO;
/* initialize the mutes variable */
if( pthread_mutex_init(&controls_mutex, NULL) != 0 ) {
IPRINT("could not initialize mutex variable\n");
exit(EXIT_FAILURE);
}
/* convert the single parameter-string to an array of strings */
argv[0] = INPUT_PLUGIN_NAME;
if ( param->parameter_string != NULL && strlen(param->parameter_string) != 0 ) {
char *arg=NULL, *saveptr=NULL, *token=NULL;
arg=(char *)strdup(param->parameter_string);
if ( strchr(arg, ' ') != NULL ) {
token=strtok_r(arg, " ", &saveptr);
if ( token != NULL ) {
argv[argc] = strdup(token);
argc++;
while ( (token=strtok_r(NULL, " ", &saveptr)) != NULL ) {
argv[argc] = strdup(token);
argc++;
if (argc >= MAX_ARGUMENTS) {
IPRINT("ERROR: too many arguments to input plugin\n");
return 1;
}
}
}
}
}
/* show all parameters for DBG purposes */
for (i=0; i<argc; i++) {
DBG("argv[%d]=%s\n", i, argv[i]);
}
/* parse the parameters */
reset_getopt();
while(1) {
int option_index = 0, c=0;
static struct option long_options[] = \
{
{"h", no_argument, 0, 0},
{"help", no_argument, 0, 0},
{"d", required_argument, 0, 0},
{"device", required_argument, 0, 0},
{"r", required_argument, 0, 0},
{"resolution", required_argument, 0, 0},
{"f", required_argument, 0, 0},
{"fps", required_argument, 0, 0},
{"y", no_argument, 0, 0},
{"yuv", no_argument, 0, 0},
{"q", required_argument, 0, 0},
{"quality", required_argument, 0, 0},
{"m", required_argument, 0, 0},
{"minimum_size", required_argument, 0, 0},
{"n", no_argument, 0, 0},
{"no_dynctrl", no_argument, 0, 0},
{"l", required_argument, 0, 0},
{"led", required_argument, 0, 0},
{0, 0, 0, 0}
};
/* parsing all parameters according to the list above is sufficent */
c = getopt_long_only(argc, argv, "", long_options, &option_index);
/* no more options to parse */
if (c == -1) break;
/* unrecognized option */
if (c == '?'){
help();
return 1;
}
/* dispatch the given options */
switch (option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
/* d, device */
case 2:
case 3:
DBG("case 2,3\n");
dev = strdup(optarg);
break;
/* r, resolution */
case 4:
case 5:
DBG("case 4,5\n");
width = -1;
height = -1;
/* try to find the resolution in lookup table "resolutions" */
for ( i=0; i < LENGTH_OF(resolutions); i++ ) {
if ( strcmp(resolutions[i].string, optarg) == 0 ) {
width = resolutions[i].width;
height = resolutions[i].height;
}
}
/* done if width and height were set */
if(width != -1 && height != -1)
break;
/* parse value as decimal value */
width = strtol(optarg, &s, 10);
height = strtol(s+1, NULL, 10);
break;
/* f, fps */
case 6:
case 7:
DBG("case 6,7\n");
fps=atoi(optarg);
break;
/* y, yuv */
case 8:
case 9:
DBG("case 8,9\n");
format = V4L2_PIX_FMT_YUYV;
break;
/* q, quality */
case 10:
case 11:
DBG("case 10,11\n");
format = V4L2_PIX_FMT_YUYV;
gquality = MIN(MAX(atoi(optarg), 0), 100);
break;
/* m, minimum_size */
case 12:
case 13:
DBG("case 12,13\n");
minimum_size = MAX(atoi(optarg), 0);
break;
/* n, no_dynctrl */
case 14:
case 15:
DBG("case 14,15\n");
dynctrls = 0;
break;
/* l, led */
case 16:
case 17:
DBG("case 16,17\n");
if ( strcmp("on", optarg) == 0 ) {
led = IN_CMD_LED_ON;
} else if ( strcmp("off", optarg) == 0 ) {
led = IN_CMD_LED_OFF;
} else if ( strcmp("auto", optarg) == 0 ) {
led = IN_CMD_LED_AUTO;
} else if ( strcmp("blink", optarg) == 0 ) {
led = IN_CMD_LED_BLINK;
}
break;
default:
DBG("default case\n");
help();
return 1;
}
}
/* keep a pointer to the global variables */
pglobal = param->global;
/* allocate webcam datastructure */
videoIn = malloc(sizeof(struct vdIn));
if ( videoIn == NULL ) {
IPRINT("not enough memory for videoIn\n");
exit(EXIT_FAILURE);
}
memset(videoIn, 0, sizeof(struct vdIn));
/* display the parsed values */
IPRINT("Using V4L2 device.: %s\n", dev);
IPRINT("Desired Resolution: %i x %i\n", width, height);
IPRINT("Frames Per Second.: %i\n", fps);
IPRINT("Format............: %s\n", (format==V4L2_PIX_FMT_YUYV)?"YUV":"MJPEG");
if ( format == V4L2_PIX_FMT_YUYV )
IPRINT("JPEG Quality......: %d\n", gquality);
/* open video device and prepare data structure */
if (init_videoIn(videoIn, dev, width, height, fps, format, 1) < 0) {
IPRINT("init_VideoIn failed\n");
closelog();
exit(EXIT_FAILURE);
}
/*
* recent linux-uvc driver (revision > ~#125) requires to use dynctrls
* for pan/tilt/focus/...
* dynctrls must get initialized
*/
if (dynctrls)
initDynCtrls(videoIn->fd);
/*
* switch the LED according to the command line parameters (if any)
*/
input_cmd(led, 0);
return 0;
}
void do_set_xattr(int argc, char **argv)
{
ext2_ino_t ino;
struct ext2_xattr_handle *h;
FILE *fp = NULL;
char *buf = NULL;
size_t buflen;
unsigned int handle_flags = 0;
int i;
errcode_t err;
reset_getopt();
while ((i = getopt(argc, argv, "f:r")) != -1) {
switch (i) {
case 'f':
if (fp)
fclose(fp);
fp = fopen(optarg, "r");
if (fp == NULL) {
perror(optarg);
return;
}
break;
case 'r':
handle_flags |= XATTR_HANDLE_FLAG_RAW;
break;
default:
goto print_usage;
}
}
if (!(fp && optind == argc - 2) && !(!fp && optind == argc - 3)) {
print_usage:
printf("Usage:\t%s [-r] <file> <attr> <value>\n", argv[0]);
printf("\t%s -f <value_file> [-r] <file> <attr>\n", argv[0]);
goto out2;
}
if (check_fs_open(argv[0]))
goto out2;
if (check_fs_read_write(argv[0]))
goto out2;
if (check_fs_bitmaps(argv[0]))
goto out2;
ino = string_to_inode(argv[optind]);
if (!ino)
goto out2;
err = ext2fs_xattrs_open(current_fs, ino, &h);
if (err)
goto out2;
err = ext2fs_xattrs_flags(h, &handle_flags, NULL);
if (err)
goto out;
err = ext2fs_xattrs_read(h);
if (err)
goto out;
if (fp) {
err = ext2fs_get_mem(current_fs->blocksize, &buf);
if (err)
goto out;
buflen = fread(buf, 1, current_fs->blocksize, fp);
} else {
buf = argv[optind + 2];
buflen = parse_c_string(buf);
}
err = ext2fs_xattr_set(h, argv[optind + 1], buf, buflen);
out:
ext2fs_xattrs_close(&h);
if (err)
com_err(argv[0], err, "while setting extended attribute");
out2:
if (fp) {
fclose(fp);
ext2fs_free_mem(&buf);
}
}
/******************************************************************************
Description.: this function is called first, in order to initialise
this plugin and pass a parameter string
Input Value.: parameters
Return Value: 0 if everything is ok, non-zero otherwise
******************************************************************************/
int output_init(output_parameter *param) {
char *argv[MAX_ARGUMENTS]={NULL};
int argc=1, i;
delay = 10000;
/* convert the single parameter-string to an array of strings */
argv[0] = OUTPUT_PLUGIN_NAME;
if ( param->parameter_string != NULL && strlen(param->parameter_string) != 0 ) {
char *arg=NULL, *saveptr=NULL, *token=NULL;
arg=(char *)strdup(param->parameter_string);
if ( strchr(arg, ' ') != NULL ) {
token=strtok_r(arg, " ", &saveptr);
if ( token != NULL ) {
argv[argc] = strdup(token);
argc++;
while ( (token=strtok_r(NULL, " ", &saveptr)) != NULL ) {
argv[argc] = strdup(token);
argc++;
if (argc >= MAX_ARGUMENTS) {
OPRINT("ERROR: too many arguments to output plugin\n");
return 1;
}
}
}
}
}
/* show all parameters for DBG purposes */
for (i=0; i<argc; i++) {
DBG("argv[%d]=%s\n", i, argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c=0;
static struct option long_options[] = \
{
{"h", no_argument, 0, 0},
{"help", no_argument, 0, 0},
{"d", required_argument, 0, 0},
{"delay", required_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(argc, argv, "", long_options, &option_index);
/* no more options to parse */
if (c == -1) break;
/* unrecognized option */
if (c == '?'){
help();
return 1;
}
switch (option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
/* d, delay */
case 2:
case 3:
DBG("case 2,3\n");
delay = atoi(optarg);
break;
}
}
pglobal = param->global;
OPRINT("delay.............: %d\n", delay);
return 0;
}
/******************************************************************************
Description.: this function is called first, in order to initialise
this plugin and pass a parameter string
Input Value.: parameters
Return Value: 0 if everything is ok, non-zero otherwise
******************************************************************************/
int output_init(output_parameter *param)
{
int i;
param->argv[0] = OUTPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] = {
{"h", no_argument, 0, 0
},
{"help", no_argument, 0, 0},
{"p", required_argument, 0, 0},
{"port", required_argument, 0, 0},
{"i", required_argument, 0, 0},
{"input", required_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?') {
help();
return 1;
}
switch(option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
case 2:
case 3:
DBG("case 2,3\n");
port = atoi(optarg);
break;
/* i, input */
case 4:
case 5:
DBG("case 4,5\n");
input_number = atoi(optarg);
break;
}
}
pglobal = param->global;
if(!(input_number < pglobal->incnt)) {
OPRINT("ERROR: the %d input_plugin number is too much only %d plugins loaded\n", input_number, pglobal->incnt);
return 1;
}
OPRINT("input plugin.....: %d: %s\n", input_number, pglobal->in[input_number].plugin);
OPRINT("UDP port..........: %s\n", "disabled");
return 0;
}
/******************************************************************************
Description.: parse input parameters
Input Value.: param contains the command line string and a pointer to globals
Return Value: 0 if everything is ok
******************************************************************************/
int input_init(input_parameter *param) {
char *argv[MAX_ARGUMENTS]={NULL};
int argc=1, i;
pics = &picture_lookup[1];
if( pthread_mutex_init(&controls_mutex, NULL) != 0 ) {
IPRINT("could not initialize mutex variable\n");
exit(EXIT_FAILURE);
}
/* convert the single parameter-string to an array of strings */
argv[0] = INPUT_PLUGIN_NAME;
if ( param->parameter_string != NULL && strlen(param->parameter_string) != 0 ) {
char *arg=NULL, *saveptr=NULL, *token=NULL;
arg=(char *)strdup(param->parameter_string);
if ( strchr(arg, ' ') != NULL ) {
token=strtok_r(arg, " ", &saveptr);
if ( token != NULL ) {
argv[argc] = strdup(token);
argc++;
while ( (token=strtok_r(NULL, " ", &saveptr)) != NULL ) {
argv[argc] = strdup(token);
argc++;
if (argc >= MAX_ARGUMENTS) {
IPRINT("ERROR: too many arguments to input plugin\n");
return 1;
}
}
}
}
}
/* show all parameters for DBG purposes */
for (i=0; i<argc; i++) {
DBG("argv[%d]=%s\n", i, argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c=0;
static struct option long_options[] = \
{
{"h", no_argument, 0, 0},
{"help", no_argument, 0, 0},
{"d", required_argument, 0, 0},
{"delay", required_argument, 0, 0},
{"r", required_argument, 0, 0},
{"resolution", required_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(argc, argv, "", long_options, &option_index);
/* no more options to parse */
if (c == -1) break;
/* unrecognized option */
if (c == '?'){
help();
return 1;
}
switch (option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
/* d, delay */
case 2:
case 3:
DBG("case 2,3\n");
delay = atoi(optarg);
break;
/* r, resolution */
case 4:
case 5:
DBG("case 4,5\n");
for ( i=0; i < LENGTH_OF(picture_lookup); i++ ) {
if ( strcmp(picture_lookup[i].resolution, optarg) == 0 ) {
pics = &picture_lookup[i];
break;
}
}
break;
default:
DBG("default case\n");
help();
return 1;
}
}
pglobal = param->global;
IPRINT("delay.............: %i\n", delay);
IPRINT("resolution........: %s\n", pics->resolution);
return 0;
}
/******************************************************************************
Description.: Initialize this plugin.
parse configuration parameters,
store the parsed values in global variables
Input Value.: All parameters to work with.
Among many other variables the "param->id" is quite important -
it is used to distinguish between several server instances
Return Value: 0 if everything is OK, other values signal an error
******************************************************************************/
int output_init(output_parameter *param, int id)
{
int i;
int port;
char *credentials, *www_folder;
char nocommands;
DBG("output #%02d\n", param->id);
port = htons(8080);
credentials = NULL;
www_folder = NULL;
nocommands = 0;
param->argv[0] = OUTPUT_PLUGIN_NAME;
/* show all parameters for DBG purposes */
for(i = 0; i < param->argc; i++) {
DBG("argv[%d]=%s\n", i, param->argv[i]);
}
reset_getopt();
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] = {
{"h", no_argument, 0, 0
},
{"help", no_argument, 0, 0},
{"p", required_argument, 0, 0},
{"port", required_argument, 0, 0},
{"c", required_argument, 0, 0},
{"credentials", required_argument, 0, 0},
{"w", required_argument, 0, 0},
{"www", required_argument, 0, 0},
{"n", no_argument, 0, 0},
{"nocommands", no_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?') {
help();
return 1;
}
switch(option_index) {
/* h, help */
case 0:
case 1:
DBG("case 0,1\n");
help();
return 1;
break;
/* p, port */
case 2:
case 3:
DBG("case 2,3\n");
port = htons(atoi(optarg));
break;
/* c, credentials */
case 4:
case 5:
DBG("case 4,5\n");
credentials = strdup(optarg);
break;
/* w, www */
case 6:
case 7:
DBG("case 6,7\n");
www_folder = malloc(strlen(optarg) + 2);
strcpy(www_folder, optarg);
if(optarg[strlen(optarg)-1] != '/')
strcat(www_folder, "/");
break;
/* n, nocommands */
case 8:
case 9:
DBG("case 8,9\n");
nocommands = 1;
break;
}
}
servers[param->id].id = param->id;
servers[param->id].pglobal = param->global;
servers[param->id].conf.port = port;
servers[param->id].conf.credentials = credentials;
servers[param->id].conf.www_folder = www_folder;
servers[param->id].conf.nocommands = nocommands;
OPRINT("www-folder-path...: %s\n", (www_folder == NULL) ? "disabled" : www_folder);
OPRINT("HTTP TCP port.....: %d\n", ntohs(port));
OPRINT("username:password.: %s\n", (credentials == NULL) ? "disabled" : credentials);
OPRINT("commands..........: %s\n", (nocommands) ? "disabled" : "enabled");
return 0;
}
