static char *parse_text_element(xmlTextReaderPtr reader, char *name) { char *string = NULL; __attribute__nonnull__(reader); __attribute__nonnull__(name); // parse string element attributes here (like xml:lang) while (xmlTextReaderNextNode(reader)) { if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT && !xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST name)) { return string; } switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_TEXT: string = (char *)xmlTextReaderValue(reader); break; default: oscap_seterr(OSCAP_EFAMILY_OSCAP, "Unknown XML element in platform"); break; } } return string; }
/* Private exporting functions cpe_*<structure>*_export( xmlTextWriterPtr ) * More info in representive header file. * returns the type of <structure> */ void cpe_lang_model_export_xml(const struct cpe_lang_model *spec, const char *file) { __attribute__nonnull__(spec); __attribute__nonnull__(file); // TODO: ad macro to check return value from xmlTextWriter* functions xmlTextWriterPtr writer; writer = xmlNewTextWriterFilename(file, 0); if (writer == NULL) { oscap_setxmlerr(xmlGetLastError()); return; } // Set properties of writer TODO: make public function to edit this ?? xmlTextWriterSetIndent(writer, 1); xmlTextWriterSetIndentString(writer, BAD_CAST " "); xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL); cpe_lang_export(spec, writer); xmlTextWriterEndDocument(writer); xmlFreeTextWriter(writer); if (xmlGetLastError() != NULL) oscap_setxmlerr(xmlGetLastError()); }
void cpe_lang_export(const struct cpe_lang_model *spec, xmlTextWriterPtr writer) { __attribute__nonnull__(spec); __attribute__nonnull__(writer); xmlTextWriterStartElementNS(writer, NULL, TAG_PLATFORM_SPEC_STR, BAD_CAST XMLNS_CPE2L); OSCAP_FOREACH(cpe_platform, p, cpe_lang_model_get_platforms(spec), // dump its contents to XML tree cpe_platform_export(p, writer);)
struct oval_string_iterator *oval_definition_model_get_definitions_dependent_on_variable(struct oval_definition_model *model, struct oval_variable *variable) { __attribute__nonnull__(model); __attribute__nonnull__(variable); if (model->vardef_map == NULL) model->vardef_map = oval_definition_model_build_vardef_mapping(model); struct oval_string_map *def_list = (struct oval_string_map *) oval_string_map_get_value(model->vardef_map, oval_variable_get_id(variable)); return (struct oval_string_iterator *) (def_list != NULL ? oval_string_map_keys(def_list) : oval_collection_iterator_new()); }
static int cpe_ext_deprecation_export(const struct cpe_ext_deprecation *deprecation, xmlTextWriterPtr writer) { __attribute__nonnull__(writer); __attribute__nonnull__(deprecation); xmlTextWriterStartElementNS(writer, NULL, BAD_CAST TAG_CPE_EXT_DEPRECATION_STR, BAD_CAST XMLNS_CPE2D3_EXTENSION); if (deprecation->date != NULL) { xmlTextWriterWriteAttribute(writer, BAD_CAST ATTR_DATE_STR, BAD_CAST deprecation->date); } OSCAP_FOREACH(cpe_ext_deprecatedby, d, oscap_iterator_new(deprecation->deprecatedbys), cpe_ext_deprecatedby_export(d, writer););
struct oval_message_iterator *oval_result_definition_get_messages(const struct oval_result_definition *definition) { __attribute__nonnull__(definition); return (struct oval_message_iterator *) oval_collection_iterator(definition->messages); }
struct oval_result_test *oval_result_test_clone (struct oval_result_system *new_system, struct oval_result_test *old_test) { __attribute__nonnull__(old_test); const char *testid = oval_result_test_get_id(old_test); struct oval_result_test *new_test = oval_result_test_new(new_system, (char *) testid); struct oval_result_item_iterator *old_items = oval_result_test_get_items(old_test); while (oval_result_item_iterator_has_more(old_items)) { struct oval_result_item *old_item = oval_result_item_iterator_next(old_items); struct oval_result_item *new_item = oval_result_item_clone(new_system, old_item); oval_result_test_add_item(new_test, new_item); } oval_result_item_iterator_free(old_items); struct oval_variable_binding_iterator *old_bindings = oval_result_test_get_bindings(old_test); while (oval_variable_binding_iterator_has_more(old_bindings)) { struct oval_variable_binding *old_binding = oval_variable_binding_iterator_next(old_bindings); struct oval_variable_binding *new_binding = oval_variable_binding_clone(old_binding, NULL); oval_result_test_add_binding(new_test, new_binding); } oval_variable_binding_iterator_free(old_bindings); struct oval_message_iterator *old_messages = oval_result_test_get_messages(old_test); while (oval_message_iterator_has_more(old_messages)) { struct oval_message *old_message = oval_message_iterator_next(old_messages); struct oval_message *new_message = oval_message_clone(old_message); oval_result_test_add_message(new_test, new_message); } oval_message_iterator_free(old_messages); oval_result_test_set_instance(new_test, oval_result_test_get_instance(old_test)); oval_result_test_set_result(new_test, old_test->result); return new_test; }
void oval_string_map_put(struct oval_string_map *map, const char *key, void *item) { __attribute__nonnull__(map); char *temp = (char *)oscap_alloc((strlen(key) + 1) * sizeof(char) + 1); char *usekey = strcpy(temp, key); /* SEARCH FOR INSERTION POINT */ struct _oval_string_map_entry *insert_before = map->entries, *insert_after = NULL, *insertion; if (insert_before == NULL) { map->entries = insertion = _oval_string_map_entry_new(NULL, NULL); } else { int compare; while (insert_before != NULL && ((compare = strcmp(usekey, insert_before->key)) < 0)) { insert_after = insert_before; insert_before = insert_after->next; } if (insert_before == NULL) { insertion = _oval_string_map_entry_new(insert_after, NULL); } else if (compare == 0) { insertion = insert_before; } else { insertion = _oval_string_map_entry_new(insert_after, insert_before); if (insert_after == NULL) map->entries = insertion; } } if (insertion == NULL) { free(temp); return; } insertion->key = usekey; insertion->item = item; }
void oval_sysent_set_name(struct oval_sysent *sysent, char *name) { __attribute__nonnull__(sysent); if (sysent->name != NULL) oscap_free(sysent->name); sysent->name = name; }
struct oval_test *oval_test_new(struct oval_definition_model *model, const char *id) { __attribute__nonnull__(model); oval_test_t *test; test = (oval_test_t *) oscap_alloc(sizeof(oval_test_t)); if (test == NULL) return NULL; test->deprecated = 0; test->version = 0; test->check = OVAL_CHECK_UNKNOWN; test->existence = OVAL_EXISTENCE_UNKNOWN; test->state_operator = OVAL_OPERATOR_AND; test->subtype = OVAL_SUBTYPE_UNKNOWN; test->comment = NULL; test->id = oscap_strdup(id); test->object = NULL; test->states = oval_collection_new(); test->notes = oval_collection_new(); test->model = model; oval_definition_model_add_test(model, test); return test; }
struct cpe_lang_model *cpe_lang_model_parse(xmlTextReaderPtr reader) { struct cpe_lang_model *ret = NULL; struct cpe_platform *platform = NULL; __attribute__nonnull__(reader); if (!xmlStrcmp(xmlTextReaderConstLocalName(reader), TAG_PLATFORM_SPEC_STR) && xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) { ret = cpe_lang_model_new(); if (ret == NULL) return NULL; // skip nodes until new element xmlTextReaderNextElementWE(reader, TAG_PLATFORM_SPEC_STR); while (xmlStrcmp(xmlTextReaderConstLocalName(reader), TAG_PLATFORM_STR) == 0) { platform = cpe_platform_parse(reader); if (platform) cpe_lang_model_add_platform(ret, platform); xmlTextReaderNextElementWE(reader, TAG_PLATFORM_SPEC_STR); } } return ret; }
const struct cpe_testexpr *cpe_testexpr_get_next(const struct cpe_testexpr *expr) { __attribute__nonnull__(expr); return ++(expr); }
struct oval_string_iterator *oval_affected_get_platforms(struct oval_affected *affected) { __attribute__nonnull__(affected); return (struct oval_string_iterator *) oval_collection_iterator(affected->platforms); }
struct oval_iterator *oval_collection_iterator(struct oval_collection *collection) { __attribute__nonnull__(collection); struct oval_iterator *iterator = (struct oval_iterator *)oscap_alloc(sizeof(oval_iterator_t)); if (iterator == NULL) return NULL; if ((iterator_count++) < 0) { _debugStack[iterator_count - 1] = iterator; oscap_dlprintf(DBG_W, "iterator_count: %d.\n", iterator_count); } iterator->item_iterator_frame = NULL; struct _oval_collection_item_frame *collection_frame = collection->item_collection_frame; while (collection_frame != NULL) { struct _oval_collection_item_frame *iterator_frame = (struct _oval_collection_item_frame *)oscap_alloc(sizeof(_oval_collection_item_frame_t)); if (iterator_frame == NULL) return NULL; iterator_frame->next = iterator->item_iterator_frame; iterator_frame->item = collection_frame->item; iterator->item_iterator_frame = iterator_frame; collection_frame = collection_frame->next; } return iterator; }
void oval_result_definition_set_instance(struct oval_result_definition *definition, int instance) { __attribute__nonnull__(definition); definition->instance = instance; // When a new variable_instance is set, we usually want to reset the hint definition->variable_instance_hint = instance; }
struct oval_entity *oval_state_content_get_entity(struct oval_state_content *content) { __attribute__nonnull__(content); return content->entity; }
static struct cpe_ext_deprecatedby *cpe_ext_deprecatedby_parse(xmlTextReaderPtr reader) { __attribute__nonnull__(reader); if (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATEDBY_STR) != 0 || xmlTextReaderNodeType(reader) != 1) { oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' node when expecting: '%s'!", xmlTextReaderConstLocalName(reader), TAG_CPE_EXT_DEPRECATEDBY_STR); } const xmlChar* nsuri = xmlTextReaderConstNamespaceUri(reader); if (nsuri && xmlStrcmp(nsuri, BAD_CAST XMLNS_CPE2D3_EXTENSION) != 0) { oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' namespace when expecting: '%s'!", nsuri, XMLNS_CPE2D3_EXTENSION); return NULL; } struct cpe_ext_deprecatedby *deprecatedby = cpe_ext_deprecatedby_new(); deprecatedby->name = (char *) xmlTextReaderGetAttribute(reader, BAD_CAST ATTR_NAME_STR); const char *type = (const char *) xmlTextReaderGetAttribute(reader, BAD_CAST ATTR_TYPE_STR); if (type == NULL) { oscap_seterr(OSCAP_EFAMILY_OSCAP, "Compulsory attribute '%s' missing at '%s' element.", ATTR_TYPE_STR, TAG_CPE_EXT_DEPRECATEDBY_STR); cpe_ext_deprecatedby_free(deprecatedby); return NULL; } deprecatedby->type = oscap_string_to_enum(CPE_EXT_DEPRECATION_MAP, type); return deprecatedby; }
int oval_definition_model_merge(struct oval_definition_model *model, const char *file) { __attribute__nonnull__(model); int ret; xmlTextReader *reader = xmlNewTextReaderFilename(file); if (reader == NULL) { oscap_seterr(OSCAP_EFAMILY_GLIBC, "%s '%s'", strerror(errno), file); return -1; } /* setup context */ struct oval_parser_context context; context.reader = reader; context.definition_model = model; context.user_data = NULL; xmlTextReaderSetErrorHandler(reader, &libxml_error_handler, &context); /* jump into oval_definitions */ while (xmlTextReaderRead(reader) == 1 && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT) ; /* start parsing */ ret = oval_definition_model_parse(reader, &context); xmlFreeTextReader(reader); return ret; }
void oval_definition_model_free(struct oval_definition_model *model) { __attribute__nonnull__(model); oval_string_map_free(model->definition_map, (oscap_destruct_func) oval_definition_free); oval_string_map_free(model->object_map, (oscap_destruct_func) oval_object_free); oval_string_map_free(model->state_map, (oscap_destruct_func) oval_state_free); oval_string_map_free(model->test_map, (oscap_destruct_func) oval_test_free); oval_string_map_free(model->variable_map, (oscap_destruct_func) oval_variable_free); if (model->vardef_map != NULL) oval_string_map_free(model->vardef_map, (oscap_destruct_func) oval_string_map_free0); if (model->bound_variable_models) oval_collection_free_items(model->bound_variable_models, (oscap_destruct_func) oval_variable_model_free); if (model->schema != NULL) oscap_free(model->schema); model->definition_map = NULL; model->object_map = NULL; model->state_map = NULL; model->test_map = NULL; model->variable_map = NULL; model->schema = NULL; oval_generator_free(model->generator); oscap_free(model); }
char *oval_message_get_text(struct oval_message *message) { __attribute__nonnull__(message); return message->text; }
void oval_behavior_set_keyval(struct oval_behavior *behavior, const char *key, const char *value) { __attribute__nonnull__(behavior); behavior->key = oscap_strdup(key); behavior->value = oscap_strdup(value); }
oval_message_level_t oval_message_get_level(struct oval_message * message) { __attribute__nonnull__(message); return message->level; }
void oval_test_set_comment(struct oval_test *test, char *comm) { __attribute__nonnull__(test); if (test->comment != NULL) oscap_free(test->comment); test->comment = oscap_strdup(comm); }
void oval_message_set_text(struct oval_message *message, char *text) { __attribute__nonnull__(message); if (message->text != NULL) oscap_free(message->text); message->text = (text == NULL) ? NULL : oscap_strdup(text); }
void oval_sysent_set_value(struct oval_sysent *sysent, char *value) { __attribute__nonnull__(sysent); if (sysent->value != NULL) oscap_free(sysent->value); sysent->value = oscap_strdup(value); }
void oval_state_content_set_entity(struct oval_state_content *content, struct oval_entity *entity) { __attribute__nonnull__(content); if (content->entity) oval_entity_free(content->entity); content->entity = entity; }
struct oval_result_item_iterator *oval_result_test_get_items(struct oval_result_test *rtest) { __attribute__nonnull__(rtest); return (struct oval_result_item_iterator *) oval_collection_iterator(rtest->items); }
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; }
/* this function will gather all the necessary ingredients and call 'evaluate_items' when it finds them */ static oval_result_t _oval_result_test_result(struct oval_result_test *rtest, void **args) { __attribute__nonnull__(rtest); /* is the test already evaluated? */ if (rtest->result != OVAL_RESULT_NOT_EVALUATED) { dI("Found result from previous evaluation: %d, returning without further processing.\n", rtest->result); return (rtest->result); } /* get syschar of rtest */ struct oval_test *test = oval_result_test_get_test(rtest); struct oval_object * object = oval_test_get_object(test); char * object_id = oval_object_get_id(object); struct oval_result_system *sys = oval_result_test_get_system(rtest); struct oval_syschar_model *syschar_model = oval_result_system_get_syschar_model(sys); struct oval_syschar * syschar = oval_syschar_model_get_syschar(syschar_model, object_id); if (syschar == NULL) { dW("No syschar for object: %s\n", object_id); return OVAL_RESULT_UNKNOWN; } /* evaluate items */ oval_result_t result = _oval_result_test_evaluate_items(test, syschar, args); return result; }
struct oval_value *oval_value_clone(struct oval_value *old_value) { __attribute__nonnull__(old_value); struct oval_value *new_value = oval_value_new(old_value->datatype, old_value->text); return new_value; }