//typedef void (*oval_entity_consumer)(struct oval_entity_node*, void*);
int oval_entity_parse_tag(xmlTextReaderPtr reader,
struct oval_parser_context *context, oscap_consumer_func consumer, void *user)
{
__attribute__nonnull__(context);
struct oval_entity *entity = oval_entity_new(context->definition_model);
int return_code = 0;
oval_datatype_t datatype = oval_datatype_parse(reader, "datatype", OVAL_DATATYPE_STRING);
oval_operation_t operation = oval_operation_parse(reader, "operation", OVAL_OPERATION_EQUALS);
int mask = oval_parser_boolean_attribute(reader, "mask", 0);
char *nil_attr = (char *) xmlTextReaderGetAttributeNs(reader, BAD_CAST "nil", OSCAP_XMLNS_XSI);
int xsi_nil = oscap_streq(nil_attr, "true") != 0;
xmlFree(nil_attr);
oval_entity_type_t type = OVAL_ENTITY_TYPE_UNKNOWN;
//The value of the type field vs. the complexity of extracting type is arguable
char *varref = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "var_ref");
struct oval_value *value = NULL;
struct oval_variable *variable;
char *name = (char *)xmlTextReaderLocalName(reader);
oval_entity_varref_type_t varref_type;
if (strcmp(name, "var_ref") == 0) { //special case for <var_ref>
if (varref == NULL) {
struct oval_definition_model *model = context->definition_model;
varref_type = OVAL_ENTITY_VARREF_ELEMENT;
struct oval_consume_varref_context ctx = {.model = model, .variable = &variable, .value = &value};
return_code = oscap_parser_text_value(reader, &oval_consume_varref, &ctx);
} else {
varref_type = OVAL_ENTITY_VARREF_ATTRIBUTE;
struct oval_definition_model *model = context->definition_model;
oval_schema_version_t version = oval_definition_model_get_core_schema_version(model);
if (oval_schema_version_cmp(version, OVAL_SCHEMA_VERSION(5.6)) > 0) {
oscap_seterr(OSCAP_EFAMILY_OVAL, "The var_ref attribute for the var_ref entity "
"of a variable_object is prohibited since OVAL 5.6. Use plain "
"var_ref instead.");
}
variable = oval_definition_model_get_variable(model, varref);
if (variable == NULL) {
oscap_seterr(OSCAP_EFAMILY_OVAL,
"Could not found variable '%s' referenced by var_ref element.", varref);
return_code = 1;
} else {
oscap_free(varref);
varref = NULL;
value = NULL;
}
}
} else if (varref == NULL) {
int oval_value_parse_tag(xmlTextReaderPtr reader,
struct oval_parser_context *context, oval_value_consumer consumer, void *user)
{
int return_code;
oval_datatype_t datatype = oval_datatype_parse(reader, "datatype", OVAL_DATATYPE_STRING);
char *text = NULL;
int isNil = oval_parser_boolean_attribute(reader, "xsi:nil", 0);
if (isNil) {
return_code = 0;
} else {
return_code = oscap_parser_text_value(reader, &oval_value_parse_tag_consume_text, &text);
}
struct oval_value *value = oval_value_new(datatype, text ? text : "");
oscap_free(text);
(*consumer) (value, user);
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;
}
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;
}
