int oval_state_content_parse_tag(xmlTextReaderPtr reader,
struct oval_parser_context *context, oscap_consumer_func consumer, void *user)
{
__attribute__nonnull__(context);
oval_datatype_t ent_datatype;
struct oval_state_content *content = oval_state_content_new(context->definition_model);
int retcode = oval_entity_parse_tag
(reader, context, (oscap_consumer_func) _oval_state_content_entity_consumer, content);
oval_check_t var_check = oval_check_parse(reader, "var_check", OVAL_CHECK_ALL);
oval_check_t ent_check = oval_check_parse(reader, "entity_check", OVAL_CHECK_ALL);
/* "check_existence" is new optional attribute in OVAL 5.11.1
* if this attribute is not present, the default value
* of "at_least_one_exists" is used
*/
oval_existence_t check_existence = oval_existence_parse(reader,
"check_existence", OVAL_AT_LEAST_ONE_EXISTS);
ent_datatype = oval_entity_get_datatype(content->entity);
if (ent_datatype == OVAL_DATATYPE_RECORD) {
retcode = oval_parser_parse_tag(reader, context,
&_oval_state_content_parse_record_field, content);
}
oval_state_content_set_varcheck(content, var_check);
oval_state_content_set_entcheck(content, ent_check);
oval_state_content_set_check_existence(content, check_existence);
(*consumer) (content, user);
return retcode;
}
int oval_result_test_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, void *usr) {
struct oval_result_system *sys = (struct oval_result_system *) usr;
int return_code = 0;
struct oval_definition_model *dmod;
struct oval_test *dtst;
struct oval_result_test *test;
xmlChar *test_id = xmlTextReaderGetAttribute(reader, BAD_CAST "test_id");
dmod = context->definition_model;
dtst = oval_definition_model_get_new_test(dmod, (char *) test_id);
oval_result_t result = oval_result_parse(reader, "result", 0);
int variable_instance = oval_parser_int_attribute(reader, "variable_instance", 1);
test = oval_result_system_get_new_test(sys, dtst, variable_instance);
if (test == NULL)
return -1;
oval_result_test_set_result(test, result);
oval_result_test_set_instance(test, variable_instance);
struct oval_test *ovaltst = oval_result_test_get_test(test);
oval_existence_t check_existence = oval_existence_parse(reader, "check_existence", OVAL_AT_LEAST_ONE_EXISTS);
oval_existence_t tst_check_existence = oval_test_get_existence(ovaltst);
if (tst_check_existence == OVAL_EXISTENCE_UNKNOWN) {
oval_test_set_existence(ovaltst, check_existence);
} else if (tst_check_existence != check_existence) {
oscap_dlprintf(DBG_W, "@check_existence does not match, test_id: %s.\n", test_id);
}
oval_check_t check = oval_check_parse(reader, "check", OVAL_CHECK_UNKNOWN);
oval_check_t tst_check = oval_test_get_check(ovaltst);
if (tst_check == OVAL_CHECK_UNKNOWN) {
oval_test_set_check(ovaltst, check);
} else if (tst_check != check) {
oscap_dlprintf(DBG_W, "@check does not match, test_id: %s.\n", test_id);
}
int version = oval_parser_int_attribute(reader, "version", 0);
int tst_version = oval_test_get_version(ovaltst);
if (tst_version == 0) {
oval_test_set_version(ovaltst, version);
} else if (tst_version != version) {
oscap_dlprintf(DBG_W, "@version does not match, test_id: %s.\n", test_id);
}
struct oval_string_map *itemmap = oval_string_map_new();
void *args[] = { sys, test, itemmap };
return_code = oval_parser_parse_tag(reader, context, (oval_xml_tag_parser) _oval_result_test_parse, args);
oval_string_map_free(itemmap, NULL);
test->bindings_initialized = true;
oscap_free(test_id);
return return_code;
}
int oval_test_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, void *usr)
{
int ret = 0;
char *comm = NULL;
char *version = NULL;
struct oval_definition_model *model = context->definition_model;
char *id = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "id");
struct oval_test *test = oval_definition_model_get_new_test(model, id);
oval_subtype_t subtype = oval_subtype_parse(reader);
if ( subtype == OVAL_SUBTYPE_UNKNOWN) {
oscap_seterr(OSCAP_EFAMILY_OVAL, "Unknown test type %s.", id);
ret = -1;
goto cleanup;
}
oval_test_set_subtype(test, subtype);
oval_operator_t ste_operator = oval_operator_parse(reader, "state_operator", OVAL_OPERATOR_AND);
oval_test_set_state_operator(test, ste_operator);
oval_check_t check = oval_check_parse(reader, "check", OVAL_CHECK_UNKNOWN);
if (check == OVAL_CHECK_NONE_EXIST) {
dW("The 'none exist' CheckEnumeration value has been deprecated. "
"Converted to check='none satisfy' and check_existence='none exist'.\n");
oval_test_set_check(test, OVAL_CHECK_NONE_SATISFY);
oval_test_set_existence(test, OVAL_NONE_EXIST);
} else {
oval_existence_t existence;
oval_test_set_check(test, check);
existence = oval_existence_parse(reader, "check_existence", OVAL_AT_LEAST_ONE_EXISTS);
oval_test_set_existence(test, existence);
}
comm = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "comment");
if (comm != NULL) {
oval_test_set_comment(test, comm);
}
int deprecated = oval_parser_boolean_attribute(reader, "deprecated", 0);
oval_test_set_deprecated(test, deprecated);
version = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "version");
oval_test_set_version(test, atoi(version));
ret = oval_parser_parse_tag(reader, context, &_oval_test_parse_tag, test);
cleanup:
oscap_free(version);
oscap_free(comm);
oscap_free(id);
return ret;
}
int oval_record_field_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context,
oscap_consumer_func consumer, void *user,
oval_record_field_type_t record_field_type)
{
int ret = 0, mask;
char *name;
oval_datatype_t datatype;
struct oval_record_field *rf;
rf = oval_record_field_new(record_field_type);
if (rf == NULL)
return -1;
name = (char *) xmlTextReaderGetAttribute(reader, BAD_CAST "name");
datatype = oval_datatype_parse(reader, "datatype", OVAL_DATATYPE_STRING);
mask = oval_parser_boolean_attribute(reader, "mask", 0);
oval_record_field_set_name(rf, name);
xmlFree(name);
oval_record_field_set_datatype(rf, datatype);
oval_record_field_set_mask(rf, mask);
switch (record_field_type) {
case OVAL_RECORD_FIELD_STATE:
{
oval_operation_t opr;
oval_check_t var_check;
oval_check_t ent_check;
char *var_ref;
opr = oval_operation_parse(reader, "operation", OVAL_OPERATION_EQUALS);
oval_record_field_set_operation(rf, opr);
var_check = oval_check_parse(reader, "var_check", OVAL_CHECK_ALL);
oval_record_field_set_var_check(rf, var_check);
ent_check = oval_check_parse(reader, "entity_check", OVAL_CHECK_ALL);
oval_record_field_set_ent_check(rf, ent_check);
var_ref = (char *) xmlTextReaderGetAttribute(reader, BAD_CAST "var_ref");
if (var_ref == NULL) {
ret = oscap_parser_text_value(reader, &_oval_record_field_value_consumer, rf);
} else {
struct oval_definition_model *model;
struct oval_variable *var;
model = context->definition_model;
var = oval_definition_model_get_new_variable(model, var_ref, OVAL_VARIABLE_UNKNOWN);
oval_record_field_set_variable(rf, var);
xmlFree(var_ref);
}
break;
}
case OVAL_RECORD_FIELD_ITEM:
{
oval_syschar_status_t status;
status = oval_syschar_status_parse(reader, "status", SYSCHAR_STATUS_EXISTS);
oval_record_field_set_status(rf, status);
ret = oscap_parser_text_value(reader, &_oval_record_field_value_consumer, rf);
break;
}
default:
dE("Impossible happened.\n");
}
(*consumer) (rf, user);
return ret;
}
