static int _oval_test_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, void *user) { struct oval_test *test = (struct oval_test *)user; char *tagname = (char *)xmlTextReaderLocalName(reader); int return_code = 0; if ((strcmp(tagname, "notes") == 0)) { return_code = oval_parser_parse_tag(reader, context, &_oval_test_parse_notes, test); } else if ((strcmp(tagname, "object") == 0)) { char *object_ref = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "object_ref"); if (object_ref != NULL) { struct oval_definition_model *model = context->definition_model; struct oval_object *object = oval_definition_model_get_new_object(model, object_ref); oscap_free(object_ref); object_ref = NULL; oval_test_set_object(test, object); } } else if ((strcmp(tagname, "state") == 0)) { char *state_ref = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "state_ref"); if (state_ref != NULL) { struct oval_definition_model *model = context->definition_model; struct oval_state *state = oval_definition_model_get_new_state(model, state_ref); oval_test_add_state(test, state); oscap_free(state_ref); state_ref = NULL; } } else { oscap_dlprintf(DBG_W, "Skipping tag <%s>.\n", tagname); return_code = oval_parser_skip_tag(reader, context); } oscap_free(tagname); return return_code; }
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_affected_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, oval_affected_consumer consumer, void *user) { __attribute__nonnull__(context); struct oval_affected *affected = oval_affected_new(context->definition_model); char *family = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "family"); oval_affected_set_family(affected, _odafamily(family)); oscap_free(family); (*consumer) (affected, user); return oval_parser_parse_tag(reader, context, &_oval_affected_parse_tag, affected); }
int oval_result_definition_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_definition *ddef; struct oval_result_definition *definition; xmlChar *definition_id = xmlTextReaderGetAttribute(reader, BAD_CAST "definition_id"); xmlChar *definition_version = xmlTextReaderGetAttribute(reader, BAD_CAST "version"); int resvsn = atoi((char *)definition_version); oval_result_t result = oval_result_parse(reader, "result", OVAL_ENUMERATION_INVALID); int instance = oval_parser_int_attribute(reader, "variable_instance", 1); dmod = context->definition_model; ddef = oval_definition_model_get_new_definition(dmod, (char *) definition_id); definition = oval_result_system_get_new_definition(sys, ddef, instance); if (definition == NULL) return -1; int defvsn = oval_definition_get_version(definition->definition); if (defvsn && resvsn != defvsn) { dW("Definition versions don't match: definition id: %s, ovaldef vsn: %d, resdef vsn: %d.", definition_id, defvsn, resvsn); } oval_definition_set_version(definition->definition, resvsn); // The following _set_instance() might be overabundant, since it should be already set // by oval_result_system_get_new_definition() Let's see if the assert agrees over time: assert(oval_result_definition_get_instance(definition) == instance); oval_result_definition_set_instance(definition, instance); if ((int)result != OVAL_ENUMERATION_INVALID) { oval_result_definition_set_result(definition, result); } else { dW("Can't resolve result attribute, definition id: %s.", definition_id); oval_result_definition_set_result(definition, OVAL_RESULT_UNKNOWN); } return_code = oval_parser_parse_tag(reader, context, oval_result_definition_parse, definition); oscap_free(definition_id); oscap_free(definition_version); return return_code; }
int oval_sysent_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, oval_sysent_consumer consumer, void *user) { int ret, mask; char *tagname; struct oval_sysent *sysent; oval_datatype_t datatype; oval_syschar_status_t status; __attribute__nonnull__(context); tagname = (char *) xmlTextReaderLocalName(reader); if (!strcmp("#text", tagname)) { xmlFree(tagname); return 0; } sysent = oval_sysent_new(context->syschar_model); oval_sysent_set_name(sysent, tagname); mask = oval_parser_boolean_attribute(reader, "mask", 0); oval_sysent_set_mask(sysent, mask); datatype = oval_datatype_parse(reader, "datatype", OVAL_DATATYPE_STRING); oval_sysent_set_datatype(sysent, datatype); status = oval_syschar_status_parse(reader, "status", SYSCHAR_STATUS_EXISTS); oval_sysent_set_status(sysent, status); if (datatype == OVAL_DATATYPE_RECORD) ret = oval_parser_parse_tag(reader, context, &_oval_sysent_parse_record_field, sysent); else ret = oval_parser_text_value(reader, context, &oval_sysent_value_consumer_, sysent); if (ret == 0) (*consumer) (sysent, user); return ret; }