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;
}
