bool getopt_cvrf(int argc, char **argv, struct oscap_action *action) {
action->doctype = OSCAP_DOCUMENT_CVRF_FEED;
action->cvrf_action = malloc(sizeof(struct cvrf_action));
struct cvrf_action *cvrf_action = action->cvrf_action;
static const struct option long_options[] = {
{"index", 0, NULL, CVRF_OPT_INDEX},
{"results", 1, NULL, CVRF_OPT_RESULT_FILE},
{"output", 1, NULL, CVRF_OPT_OUTPUT_FILE},
{0, 0, 0, 0}
};
int c;
while ((c = getopt_long(argc, argv, "+", long_options, NULL)) != -1) {
switch (c) {
case CVRF_OPT_INDEX:
cvrf_action->index = 1;
break;
case CVRF_OPT_RESULT_FILE:
cvrf_action->f_results = optarg;
break;
case CVRF_OPT_OUTPUT_FILE:
cvrf_action->f_output = optarg;
break;
default:
return oscap_module_usage(action->module, stderr, NULL);
}
}
if (optind >= argc)
return oscap_module_usage(action->module, stderr, "CVRF file needs to be specified!\n");
cvrf_action->f_cvrf = argv[optind];
return true;
}
bool getopt_oval_validate(int argc, char **argv, struct oscap_action *action)
{
/* we assume 0 is unknown */
action->doctype = 0;
/* Command-options */
struct option long_options[] = {
// flags
{ "definitions", no_argument, &action->doctype, OSCAP_DOCUMENT_OVAL_DEFINITIONS },
{ "variables", no_argument, &action->doctype, OSCAP_DOCUMENT_OVAL_VARIABLES },
{ "syschar", no_argument, &action->doctype, OSCAP_DOCUMENT_OVAL_SYSCHAR },
{ "results", no_argument, &action->doctype, OSCAP_DOCUMENT_OVAL_RESULTS },
{ "directives", no_argument, &action->doctype, OSCAP_DOCUMENT_OVAL_DIRECTIVES },
// force schematron validation
{ "schematron", no_argument, &action->schematron, 1 },
// end
{ 0, 0, 0, 0 }
};
int c;
while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
switch (c) {
case 0: break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
/* we should have OVAL content here */
if (optind >= argc)
return oscap_module_usage(action->module, stderr, "OVAL file needs to be specified!");
action->f_oval = argv[optind];
return true;
}
bool getopt_oval_report(int argc, char **argv, struct oscap_action *action)
{
action->doctype = OSCAP_DOCUMENT_OVAL_DEFINITIONS;
/* Command-options */
struct option long_options[] = {
{ "output", required_argument, NULL, OVAL_OPT_OUTPUT },
{ 0, 0, 0, 0 }
};
/*
* it is not nice that we use action->f_results for output and
* action->f_oval as input here.
*/
int c;
while ((c = getopt_long(argc, argv, "o:", long_options, NULL)) != -1) {
switch (c) {
case OVAL_OPT_OUTPUT: action->f_results = optarg; break;
case 0: break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
/* We should have oval results file here */
if (optind >= argc)
return oscap_module_usage(action->module, stderr, "Definitions file is not specified!");
action->f_oval = argv[optind];
return true;
}
bool getopt_oval_collect(int argc, char **argv, struct oscap_action *action)
{
action->doctype = OSCAP_DOCUMENT_OVAL_DEFINITIONS;
/* Command-options */
struct option long_options[] = {
{ "id", required_argument, NULL, OVAL_OPT_ID },
{ "variables", required_argument, NULL, OVAL_OPT_VARIABLES },
{ "syschar", required_argument, NULL, OVAL_OPT_SYSCHAR },
{ "skip-valid", no_argument, &action->validate, 0 },
{ 0, 0, 0, 0 }
};
int c;
while ((c = getopt_long(argc, argv, "o:", long_options, NULL)) != -1) {
switch (c) {
case OVAL_OPT_ID: action->id = optarg; break;
case OVAL_OPT_VARIABLES: action->f_variables = optarg; break;
case OVAL_OPT_SYSCHAR: action->f_syschar = optarg; break;
case 0: break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
/* We should have Definitions file here */
if (optind >= argc)
return oscap_module_usage(action->module, stderr, "Definitions file is not specified!");
action->f_oval = argv[optind];
return true;
}
bool getopt_oval_eval(int argc, char **argv, struct oscap_action *action)
{
action->doctype = OSCAP_DOCUMENT_OVAL_DEFINITIONS;
action->probe_root = NULL;
/* Command-options */
struct option long_options[] = {
{ "results", required_argument, NULL, OVAL_OPT_RESULT_FILE },
{ "report", required_argument, NULL, OVAL_OPT_REPORT_FILE },
{ "id", required_argument, NULL, OVAL_OPT_ID },
{ "variables", required_argument, NULL, OVAL_OPT_VARIABLES },
{ "directives", required_argument, NULL, OVAL_OPT_DIRECTIVES },
{ "without-syschar", no_argument, &action->without_sys_chars, 1},
{ "datastream-id",required_argument, NULL, OVAL_OPT_DATASTREAM_ID},
{ "oval-id", required_argument, NULL, OVAL_OPT_OVAL_ID},
{ "skip-valid", no_argument, &action->validate, 0 },
{ "probe-root", required_argument, NULL, OVAL_OPT_PROBE_ROOT},
{ "verbose", required_argument, NULL, OVAL_OPT_VERBOSE },
{ "verbose-log-file", required_argument, NULL, OVAL_OPT_VERBOSE_LOG_FILE },
{ "fetch-remote-resources", no_argument, &action->remote_resources, 1},
{ 0, 0, 0, 0 }
};
int c;
while ((c = getopt_long(argc, argv, "o:", long_options, NULL)) != -1) {
switch (c) {
case OVAL_OPT_RESULT_FILE: action->f_results = optarg; break;
case OVAL_OPT_REPORT_FILE: action->f_report = optarg; break;
case OVAL_OPT_ID: action->id = optarg; break;
case OVAL_OPT_VARIABLES: action->f_variables = optarg; break;
case OVAL_OPT_DIRECTIVES: action->f_directives = optarg; break;
case OVAL_OPT_DATASTREAM_ID: action->f_datastream_id = optarg; break;
case OVAL_OPT_OVAL_ID: action->f_oval_id = optarg; break;
case OVAL_OPT_PROBE_ROOT: action->probe_root = optarg; break;
case OVAL_OPT_VERBOSE:
action->verbosity_level = optarg;
break;
case OVAL_OPT_VERBOSE_LOG_FILE:
action->f_verbose_log = optarg;
break;
case 0: break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
if (!check_verbose_options(action)) {
return false;
}
/* We should have Definitions file here */
if (optind >= argc)
return oscap_module_usage(action->module, stderr, "Definitions file is not specified!");
action->f_oval = argv[optind];
return true;
}
bool getopt_oval_analyse(int argc, char **argv, struct oscap_action *action)
{
action->doctype = OSCAP_DOCUMENT_OVAL_DEFINITIONS;
/* Command-options */
struct option long_options[] = {
{ "results", required_argument, NULL, OVAL_OPT_RESULT_FILE },
{ "variables", required_argument, NULL, OVAL_OPT_VARIABLES },
{ "directives", required_argument, NULL, OVAL_OPT_DIRECTIVES },
{ "skip-valid", no_argument, &action->validate, 0 },
{ "verbose", required_argument, NULL, OVAL_OPT_VERBOSE },
{ "verbose-log-file", required_argument, NULL, OVAL_OPT_VERBOSE_LOG_FILE },
{ 0, 0, 0, 0 }
};
int c;
while ((c = getopt_long(argc, argv, "o:", long_options, NULL)) != -1) {
switch (c) {
case OVAL_OPT_RESULT_FILE: action->f_results = optarg; break;
case OVAL_OPT_VARIABLES: action->f_variables = optarg; break;
case OVAL_OPT_DIRECTIVES: action->f_directives = optarg; break;
case OVAL_OPT_VERBOSE:
action->verbosity_level = optarg;
break;
case OVAL_OPT_VERBOSE_LOG_FILE:
action->f_verbose_log = optarg;
break;
case 0: break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
if (!check_verbose_options(action)) {
return false;
}
/* We should have Definitions file here */
if (optind >= argc)
return oscap_module_usage(action->module, stderr, "Definitions file is not specified!");
action->f_oval = argv[optind];
if (action->module == &OVAL_ANALYSE) {
/* We should have System Characteristics file here */
if ((optind+1) > argc)
return oscap_module_usage(action->module, stderr, "System characteristics file is not specified");
action->f_syschar = argv[optind + 1];
if (action->f_results == NULL) {
return oscap_module_usage(action->module, stderr, "OVAL Results file is not specified(--results parameter)");
}
}
return true;
}
bool getopt_oval_list_probes(int argc, char **argv, struct oscap_action *action)
{
#define PROBE_LIST_STATIC 0
#define PROBE_LIST_DYNAMIC 1
int list_type = PROBE_LIST_DYNAMIC;
action->doctype = OSCAP_DOCUMENT_OVAL_DEFINITIONS;
action->verbosity = 0;
/* Command-options */
struct option long_options[] = {
// flags
{ "static", no_argument, &list_type, PROBE_LIST_STATIC },
{ "dynamic", no_argument, &list_type, PROBE_LIST_DYNAMIC },
{ "verbose", no_argument, &action->verbosity, 10},
// end
{ 0, 0, 0, 0 }
};
int c;
while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
switch (c) {
case 0: break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
action->list_dynamic = list_type == PROBE_LIST_DYNAMIC ? true : false;
return true;
}
bool check_verbose_options(struct oscap_action *action)
{
if (action->verbosity_level == NULL && action->f_verbose_log != NULL) {
oscap_module_usage(action->module, stderr, "Verbosity level is not specified!");
return false;
}
if (action->verbosity_level != NULL && action->f_verbose_log == NULL) {
oscap_module_usage(action->module, stderr, "Log file is not specified!");
return false;
}
if (action->verbosity_level != NULL && oscap_verbosity_level_from_cstr(action->verbosity_level) == -1) {
oscap_module_usage(action->module, stderr, "Inavlid verbosity level!");
return false;
}
return true;
}
int oscap_module_process(struct oscap_module *module, int argc, char **argv)
{
assert(module != NULL);
assert(argv != NULL);
int ret = OSCAP_OK;
struct oscap_action action;
oscap_action_init(&action);
optind = 0;
while (module) {
check_module(module);
++optind; // skip current module key index
action.module = module; // update current module
getopt_parse_env(module, &argc, &argv);
switch (oscap_parse_common_opts(argc, argv)) {
case OPT_HELP: oscap_module_print_help(module, stdout); goto cleanup;
case OPT_LISTMODS: oscap_print_submodules(module, stdout, "\n", false); goto cleanup;
case OPT_LISTALLMODS: oscap_print_submodules(module, stdout, "\n", true); goto cleanup;
case OPT_MODTREE: oscap_module_tree(module, stdout, 0); goto cleanup;
default: break;
}
if (module->opt_parser) {
if (!module->opt_parser(argc, argv, &action)) {
ret = OSCAP_BADARGS;
goto cleanup;
}
module = action.module; // module might have changed
}
if (module->func) {
ret = oscap_module_call(&action);
goto cleanup;
}
else if (module->submodules) {
struct oscap_module *old_mod = module;
module = oscap_module_find(module->submodules, argv[optind]);
if (module == NULL) {
if (argv[optind] != NULL)
fprintf(stderr, "No such module: %s\n", argv[optind]);
else oscap_module_usage(old_mod, stderr, NULL);
ret = OSCAP_BADMODULE;
}
}
else {
fprintf(stderr, "Module %s does not do anything\n", module->name);
ret = OSCAP_UNIMPL_MOD;
goto cleanup;
}
}
cleanup:
oscap_action_release(&action);
return ret;
}
bool getopt_cvss(int argc, char **argv, struct oscap_action *action)
{
if (optind < argc) action->cvss_vector = argv[optind];
if ((action->module == &CVSS_SCORE_MODULE) && action->cvss_vector == NULL)
return oscap_module_usage(action->module, stderr, "CVSS vector not supplied");
return true;
}
bool getopt_info(int argc, char **argv, struct oscap_action *action)
{
if( argc != 3) {
oscap_module_usage(action->module, stderr, "Wrong number of parameters.\n");
return false;
}
action->file = argv[2];
return true;
}
bool getopt_generate(int argc, char **argv, struct oscap_action *action)
{
static const struct option long_options[] = {
{"profile", 1, 0, 3},
{0, 0, 0, 0}
};
int c;
while ((c = getopt_long(argc, argv, "+", long_options, NULL)) != -1) {
switch (c) {
case 3: action->profile = optarg; break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
return true;
}
bool getopt_root(int argc, char **argv, struct oscap_action *action)
{
while (1) {
static struct option long_options[] = {
{"quiet", 0, 0, 'q'},
{"version", 0, 0, 'V'},
{0, 0, 0, 0}
};
int c = getopt_long(argc, argv, "+qV", long_options, NULL);
if (c == -1) break;
switch (c) {
case 'q':
printf("Warning: '-q' is obsoleted option, please use '#oscap ... >/dev/null 2>&1' instead\n");
break;
case 'V': action->module = &OSCAP_VERSION_MODULE; break;
case '?': return oscap_module_usage(action->module, stderr, NULL);
}
}
return true;
}
bool getopt_xccdf(int argc, char **argv, struct oscap_action *action)
{
assert(action != NULL);
action->doctype = OSCAP_DOCUMENT_XCCDF;
/* Command-options */
const struct option long_options[] = {
// options
{"output", required_argument, NULL, XCCDF_OPT_OUTPUT},
{"results", required_argument, NULL, XCCDF_OPT_RESULT_FILE},
{"results-arf", required_argument, NULL, XCCDF_OPT_RESULT_FILE_ARF},
{"datastream-id", required_argument, NULL, XCCDF_OPT_DATASTREAM_ID},
{"xccdf-id", required_argument, NULL, XCCDF_OPT_XCCDF_ID},
{"benchmark-id", required_argument, NULL, XCCDF_OPT_BENCHMARK_ID},
{"profile", required_argument, NULL, XCCDF_OPT_PROFILE},
{"result-id", required_argument, NULL, XCCDF_OPT_RESULT_ID},
{"report", required_argument, NULL, XCCDF_OPT_REPORT_FILE},
{"show", required_argument, NULL, XCCDF_OPT_SHOW},
{"template", required_argument, NULL, XCCDF_OPT_TEMPLATE},
{"oval-template", required_argument, NULL, XCCDF_OPT_OVAL_TEMPLATE},
{"stylesheet", required_argument, NULL, XCCDF_OPT_STYLESHEET_FILE},
{"tailoring-file", required_argument, NULL, XCCDF_OPT_TAILORING_FILE},
{"tailoring-id", required_argument, NULL, XCCDF_OPT_TAILORING_ID},
{"cpe", required_argument, NULL, XCCDF_OPT_CPE},
{"cpe-dict", required_argument, NULL, XCCDF_OPT_CPE_DICT}, // DEPRECATED!
{"sce-template", required_argument, NULL, XCCDF_OPT_SCE_TEMPLATE},
// flags
{"force", no_argument, &action->force, 1},
{"oval-results", no_argument, &action->oval_results, 1},
{"sce-results", no_argument, &action->check_engine_results, 1},
{"check-engine-results", no_argument, &action->check_engine_results, 1},
{"skip-valid", no_argument, &action->validate, 0},
{"fetch-remote-resources", no_argument, &action->remote_resources, 1},
{"progress", no_argument, &action->progress, 1},
{"remediate", no_argument, &action->remediate, 1},
{"hide-profile-info", no_argument, &action->hide_profile_info, 1},
{"export-variables", no_argument, &action->export_variables, 1},
{"schematron", no_argument, &action->schematron, 1},
// end
{0, 0, 0, 0}
};
int c;
while ((c = getopt_long(argc, argv, "o:i:", long_options, NULL)) != -1) {
switch (c) {
case XCCDF_OPT_OUTPUT:
case XCCDF_OPT_RESULT_FILE: action->f_results = optarg; break;
case XCCDF_OPT_RESULT_FILE_ARF: action->f_results_arf = optarg; break;
case XCCDF_OPT_DATASTREAM_ID: action->f_datastream_id = optarg; break;
case XCCDF_OPT_XCCDF_ID: action->f_xccdf_id = optarg; break;
case XCCDF_OPT_BENCHMARK_ID: action->f_benchmark_id = optarg; break;
case XCCDF_OPT_PROFILE: action->profile = optarg; break;
case XCCDF_OPT_RESULT_ID: action->id = optarg; break;
case XCCDF_OPT_REPORT_FILE: action->f_report = optarg; break;
case XCCDF_OPT_SHOW: action->show = optarg; break;
case XCCDF_OPT_TEMPLATE: action->tmpl = optarg; break;
case XCCDF_OPT_OVAL_TEMPLATE: action->oval_template = optarg; break;
/* we use realpath to get an absolute path to given XSLT to prevent openscap from looking
into /usr/share/openscap/xsl instead of CWD */
case XCCDF_OPT_STYLESHEET_FILE: realpath(optarg, custom_stylesheet_path); action->stylesheet = custom_stylesheet_path; break;
case XCCDF_OPT_TAILORING_FILE: action->tailoring_file = optarg; break;
case XCCDF_OPT_TAILORING_ID: action->tailoring_id = optarg; break;
case XCCDF_OPT_CPE: action->cpe = optarg; break;
case XCCDF_OPT_CPE_DICT:
{
fprintf(stdout, "Warning: --cpe-dict is a deprecated option. Please use --cpe instead!\n\n");
action->cpe = optarg; break;
}
case XCCDF_OPT_SCE_TEMPLATE: action->sce_template = optarg; break;
case 0: break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
if (action->module == &XCCDF_EVAL) {
/* We should have XCCDF file here */
if (optind >= argc) {
/* TODO */
return oscap_module_usage(action->module, stderr, "XCCDF file need to be specified!");
}
action->f_xccdf = argv[optind];
if (argc > (optind+1)) {
action->f_ovals = malloc((argc-(optind+1)+1) * sizeof(char *));
int i = 1;
while (argc > (optind+i)) {
action->f_ovals[i-1] = argv[optind + i];
i++;
}
action->f_ovals[i-1] = NULL;
} else {
action->f_ovals = NULL;
}
} else if (action->module == &XCCDF_GEN_CUSTOM) {
if (!action->stylesheet) {
return oscap_module_usage(action->module, stderr, "XSLT Stylesheet needs to be specified!");
}
if (optind >= argc)
return oscap_module_usage(action->module, stderr, "XCCDF file needs to be specified!");
action->f_xccdf = argv[optind];
} else {
if (optind >= argc)
return oscap_module_usage(action->module, stderr, "XCCDF file needs to be specified!");
action->f_xccdf = argv[optind];
}
return true;
}
bool getopt_ds(int argc, char **argv, struct oscap_action *action) {
action->doctype = OSCAP_DOCUMENT_SDS;
/* Command-options */
const struct option long_options[] = {
// options
{"skip-valid", no_argument, &action->validate, 0},
{"datastream-id", required_argument, NULL, DS_OPT_DATASTREAM_ID},
{"xccdf-id", required_argument, NULL, DS_OPT_XCCDF_ID},
{"report-id", required_argument, NULL, DS_OPT_REPORT_ID},
{"fetch-remote-resources", no_argument, &action->remote_resources, 1},
// end
{0, 0, 0, 0}
};
int c;
while ((c = getopt_long(argc, argv, "o:i:", long_options, NULL)) != -1) {
switch (c) {
case DS_OPT_DATASTREAM_ID: action->f_datastream_id = optarg; break;
case DS_OPT_XCCDF_ID: action->f_xccdf_id = optarg; break;
case DS_OPT_REPORT_ID: action->f_report_id = optarg; break;
case 0: break;
default: return oscap_module_usage(action->module, stderr, NULL);
}
}
if (action->module == &DS_SDS_SPLIT_MODULE) {
if (optind + 2 != argc) {
oscap_module_usage(action->module, stderr, "Wrong number of parameters.\n");
return false;
}
action->ds_action = malloc(sizeof(struct ds_action));
action->ds_action->file = argv[optind];
action->ds_action->target = argv[optind + 1];
}
else if (action->module == &DS_SDS_COMPOSE_MODULE) {
if(optind + 2 != argc) {
oscap_module_usage(action->module, stderr, "Wrong number of parameters.\n");
return false;
}
action->ds_action = malloc(sizeof(struct ds_action));
action->ds_action->file = argv[optind];
action->ds_action->target = argv[optind + 1];
}
else if (action->module == &DS_SDS_ADD_MODULE) {
if (optind + 2 != argc) {
oscap_module_usage(action->module, stderr, "Wrong number of parameters.\n");
return false;
}
action->ds_action = malloc(sizeof(struct ds_action));
action->ds_action->file = argv[optind];
action->ds_action->target = argv[optind + 1];
}
else if( (action->module == &DS_SDS_VALIDATE_MODULE) ) {
if( argc != 4 ) {
oscap_module_usage(action->module, stderr, "Wrong number of parameters.\n");
return false;
}
action->ds_action = malloc(sizeof(struct ds_action));
action->ds_action->file = argv[3];
}
else if (action->module == &DS_RDS_SPLIT_MODULE) {
if (optind + 2 != argc) {
oscap_module_usage(action->module, stderr, "Wrong number of parameters.\n");
return false;
}
action->ds_action = malloc(sizeof(struct ds_action));
action->ds_action->file = argv[optind];
action->ds_action->target = argv[optind + 1];
}
else if( (action->module == &DS_RDS_CREATE_MODULE) ) {
if(argc - optind < 3 ) {
oscap_module_usage(action->module, stderr, "Wrong number of parameters.\n");
return false;
}
action->ds_action = malloc(sizeof(struct ds_action));
action->ds_action->file = argv[optind];
action->ds_action->target = argv[optind + 1];
action->ds_action->xccdf_result = argv[optind + 2];
action->ds_action->oval_results = &argv[optind + 3];
action->ds_action->oval_result_count = argc - optind - 3;
}
else if( (action->module == &DS_RDS_VALIDATE_MODULE) ) {
if( argc != 4 ) {
oscap_module_usage(action->module, stderr, "Wrong number of parameters.\n");
return false;
}
action->ds_action = malloc(sizeof(struct ds_action));
action->ds_action->file = argv[3];
}
return true;
}
