static SEXP_t *oval_probe_cmd_obj_eval(SEXP_t *sexp, void *arg)
{
char *id_str;
struct oval_definition_model *defs;
struct oval_object *obj;
struct oval_syschar *res;
oval_pext_t *pext = (oval_pext_t *) arg;
SEXP_t *ret, *ret_code;
int r;
assume_d (sexp != NULL, NULL);
assume_d (arg != NULL, NULL);
if (!SEXP_stringp(sexp)) {
oscap_dlprintf(DBG_E, "Invalid argument: type=%s.\n", SEXP_strtype(sexp));
return (NULL);
}
id_str = SEXP_string_cstr(sexp);
defs = oval_syschar_model_get_definition_model(*(pext->model));
obj = oval_definition_model_get_object(defs, id_str);
ret = SEXP_list_new (sexp, NULL);
oscap_dlprintf(DBG_I, "Get_object: %s.\n", id_str);
if (obj == NULL) {
oscap_dlprintf(DBG_E, "Can't find obj: id=%s.\n", id_str);
oscap_free(id_str);
SEXP_free(ret);
return (NULL);
}
oscap_clearerr();
r = oval_probe_query_object(pext->sess_ptr, obj, OVAL_PDFLAG_NOREPLY|OVAL_PDFLAG_SLAVE, &res);
if (r < 0)
ret_code = SEXP_number_newu((unsigned int) SYSCHAR_FLAG_COMPLETE);
else
ret_code = SEXP_number_newu((unsigned int) oval_syschar_get_flag(res));
SEXP_list_add(ret, ret_code);
SEXP_free(ret_code);
if (oscap_err()) {
oscap_dlprintf(DBG_E, "Failed: id: %s, err: %d, %s.\n",
id_str, oscap_err_family(), oscap_err_desc());
oscap_clearerr();
oscap_free(id_str);
SEXP_free(ret);
return (NULL);
}
oscap_free(id_str);
return (ret);
}
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;
}
static SEXP_t *oval_probe_cmd_ste_fetch(SEXP_t *sexp, void *arg)
{
SEXP_t *id, *ste_list, *ste_sexp;
char *id_str;
struct oval_state *ste;
struct oval_definition_model *definition_model;
oval_pext_t *pext = (oval_pext_t *)arg;
int ret;
assume_d (sexp != NULL, NULL);
assume_d (arg != NULL, NULL);
ste_list = SEXP_list_new(NULL);
SEXP_list_foreach(id, sexp) {
if (SEXP_stringp(id)) {
id_str = SEXP_string_cstr(id);
definition_model = oval_syschar_model_get_definition_model(*(pext->model));
ste = oval_definition_model_get_state(definition_model, id_str);
if (ste == NULL) {
oscap_dlprintf(DBG_E, "Can't find ste: id: %s.\n", id_str);
SEXP_list_free(ste_list);
oscap_free(id_str);
SEXP_free(id);
return (NULL);
}
ret = oval_state_to_sexp(pext->sess_ptr, ste, &ste_sexp);
if (ret !=0) {
oscap_dlprintf(DBG_E, "Failed to convert OVAL state to SEXP, id: %s.\n",
id_str);
SEXP_list_free(ste_list);
oscap_free(id_str);
SEXP_free(id);
return (NULL);
}
SEXP_list_add(ste_list, ste_sexp);
SEXP_free(ste_sexp);
oscap_free(id_str);
}
}
return (ste_list);
}
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;
}
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;
}
struct oval_definition_model * oval_definition_model_import(const char *file)
{
struct oval_definition_model *model = oval_definition_model_new();
int ret = oval_definition_model_merge(model,file);
if (ret == -1 ) {
oscap_dlprintf(DBG_E, "Failed to merge the definition model from: %s.\n", file);
oval_definition_model_free(model);
model = NULL;
}
return model;
}
static int oval_probe_cmd_init(oval_pext_t *pext)
{
assume_d (pext != NULL, -1);
if (SEAP_cmd_register(pext->pdtbl->ctx, PROBECMD_OBJ_EVAL, SEAP_CMDREG_USEARG,
&oval_probe_cmd_obj_eval, (void *)pext) != 0)
{
oscap_dlprintf(DBG_E, "Can't register command: %s: errno=%u, %s.\n", "obj_eval", errno, strerror(errno));
return (-1);
}
if (SEAP_cmd_register(pext->pdtbl->ctx, PROBECMD_STE_FETCH, SEAP_CMDREG_USEARG,
&oval_probe_cmd_ste_fetch, (void *)pext) != 0) {
oscap_dlprintf(DBG_E, "Can't register command: %s: errno=%u, %s.\n", "ste_fetch", errno, strerror(errno));
/* FIXME: unregister the first command */
return (-1);
}
return (0);
}
struct oval_iterator *oval_collection_iterator_new()
{
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;
return iterator;
}
int oscap_xml_save_filename(const char *filename, xmlDocPtr doc)
{
xmlOutputBufferPtr buff;
int xmlCode;
if (strcmp(filename, "-") == 0) {
xmlCode = xmlSaveFormatFileEnc(filename, doc, "UTF-8", 1);
}
else {
int fd = open(filename, O_CREAT|O_TRUNC|O_WRONLY,
S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
if (fd < 0) {
oscap_seterr(OSCAP_EFAMILY_GLIBC, "%s '%s'", strerror(errno), filename);
xmlFreeDoc(doc);
return -1;
}
buff = xmlOutputBufferCreateFd(fd, NULL);
if (buff == NULL) {
close(fd);
oscap_setxmlerr(xmlGetLastError());
oscap_dlprintf(DBG_W, "xmlOutputBufferCreateFile() failed.\n");
xmlFreeDoc(doc);
return -1;
}
xmlCode = xmlSaveFormatFileTo(buff, doc, "UTF-8", 1);
close(fd);
}
if (xmlCode <= 0) {
oscap_setxmlerr(xmlGetLastError());
oscap_dlprintf(DBG_W, "No bytes exported: xmlCode: %d.\n", xmlCode);
}
return (xmlCode >= 1) ? 1 : -1;
}
void oval_collection_iterator_free(struct oval_iterator *iterator)
{
if (iterator) { //NOOP if iterator is NULL
if ((--iterator_count) < 0) {
oscap_dlprintf(DBG_W, "iterator_count: %d.\n", iterator_count);
if (iterator != _debugStack[iterator_count]) {
debug = false;
}
}
while (iterator->item_iterator_frame) {
struct _oval_collection_item_frame *oc_this;
oc_this = iterator->item_iterator_frame;
iterator->item_iterator_frame = oc_this->next;
oc_this->item = NULL;
oc_this->next = NULL;
oscap_free(oc_this);
}
iterator->item_iterator_frame = NULL;
oscap_free(iterator);
}
}
char *oval_glob_to_regex (const char *glob, int noescape)
{
struct oscap_string *regex;
char * result;
char c;
int i = 0;
int left_bracket = -1;
int state = START;
regex = oscap_string_new();
if (regex == NULL) {
return NULL;
}
oscap_string_append_char(regex, '^'); // regex must match whole string
while(1) {
c = glob[i++];
switch (state) {
case START:
if (c == '\0') {
goto finish;
} else if (c== '/') {
oscap_string_append_char(regex, c);
state = SLASH;
} else if (c == '?') {
// a ? matches any single character, but
// a ? at the begining of glob pattern can't match a .
// a ? never matches a / (see man 7 glob - Pathnames)
oscap_string_append_string(regex, "[^./]");
state = NORMAL;
} else if (c == '*') {
// a * matches any string, but
// a * at the begining of glob pattern can't match a .
// a * never matches a / (see man 7 glob - Pathnames)
oscap_string_append_string(regex, "(?=[^.])[^/]*");
state = NORMAL;
} else if (c == '.' || c == '|' || c == '^' || c == '(' || c == ')'
|| c == '{' || c == '}' || c == '+' || c == '$') {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, c);
state = NORMAL;
} else if (c == '[') {
oscap_string_append_char(regex,'[');
left_bracket = i;
state = LEFT_BRACKET;
} else if (c == '\\') {
if (noescape) {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, '\\');
state = NORMAL;
} else {
state = ESCAPE;
}
} else {
oscap_string_append_char(regex, c);
state = NORMAL;
}
break;
case NORMAL:
if (c == '\0') {
goto finish;
} else if (c== '/') {
oscap_string_append_char(regex, c);
state = SLASH;
} else if (c == '?') {
// a ? matches any single character, but
// it can never match a /
oscap_string_append_string(regex, "[^/]");
} else if (c == '*') {
// a * matches any string, but
// it can never match a /
oscap_string_append_string(regex, "[^/]*");
} else if (c == '.' || c == '|' || c == '^' || c == '(' || c == ')'
|| c == '{' || c == '}' || c == '+' || c == '$' ) {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, c);
} else if (c == '[') {
oscap_string_append_char(regex,'[');
left_bracket = i;
state = LEFT_BRACKET;
} else if (c == '\\') {
if (noescape) {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, '\\');
} else {
state = ESCAPE;
}
} else {
oscap_string_append_char(regex, c);
}
break;
case LEFT_BRACKET:
if (c == '!') {
oscap_string_append_char(regex, '^');
} else if (c == '\0') {
oscap_dlprintf(DBG_E, "Can't convert glob '%s' to regular expression. '[' at position %d has no closing brace - ']'.\n", glob, left_bracket - 1);
oscap_string_free(regex);
return NULL;
} else {
oscap_string_append_char(regex, c);
}
state = CLASS;
break;
case CLASS:
if (c == '\\') {
if (noescape) {
oscap_string_append_char(regex, '\\');
}
} else if (c == ']') {
state = NORMAL;
} else if (c == '\0') {
oscap_dlprintf(DBG_E, "Can't convert glob '%s' to regular expression. '[' at position %d has no closing brace - ']'.\n", glob, left_bracket - 1);
oscap_string_free(regex);
return NULL;
}
oscap_string_append_char(regex, c);
break;
case ESCAPE:
// ?, *, [ and ] are special characters, they must be escaped in glob.
// A backslash is treated as an escape character only for these characters.
// For all other characters the backslash is just an ordinary character.
// Other characters, that are special in perl's regex,
// are not special in a glob.
if (c == '?' || c == '*' || c == '[' || c == ']') {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, c);
} else if (c == '\0') {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, '\\');
goto finish;
} else {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, c);
}
state = NORMAL;
break;
case SLASH:
if (c == '\0') {
goto finish;
} else if (c == '?') {
// a ? matches any single character, but
// a ? at the begining of glob pattern can't match a .
// a ? never matches a / (see man 7 glob - Pathnames)
oscap_string_append_string(regex, "[^./]");
state = NORMAL;
} else if (c == '*') {
// a * matches any string, but
// a * at the begining of glob pattern can't match a .
// a * never matches a / (see man 7 glob - Pathnames)
oscap_string_append_string(regex, "(?=[^.])[^/]*");
state = NORMAL;
} else if (c == '.' || c == '|' || c == '^' || c == '(' || c == ')'
|| c == '{' || c == '}' || c == '+' || c == '$' ) {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, c);
state = NORMAL;
} else if (c == '[') {
state = LEFT_BRACKET;
} else if (c == '\\') {
if (noescape) {
oscap_string_append_char(regex, '\\');
oscap_string_append_char(regex, '\\');
state = NORMAL;
} else {
state = ESCAPE;
}
} else {
oscap_string_append_char(regex, c);
state = NORMAL;
}
break;
default:
break;
}
}
finish:
oscap_string_append_char(regex, '$'); // regex must match only whole string
result = oscap_strdup(oscap_string_get_cstr(regex));
oscap_string_free(regex);
return result;
}
xmlNode *oval_test_to_dom(struct oval_test *test, xmlDoc * doc, xmlNode * parent)
{
xmlNode * test_node=NULL;
/* skip unknown test */
oval_subtype_t subtype = oval_test_get_subtype(test);
if ( subtype == OVAL_SUBTYPE_UNKNOWN ) {
oscap_dlprintf(DBG_E, "Unknown Test %s.\n", oval_test_get_id(test));
return test_node;
}
/* get test name */
const char *subtype_text = oval_subtype_get_text(subtype);
char test_name[strlen(subtype_text) + 6];
sprintf(test_name, "%s_test", subtype_text);
/* get family URI */
oval_family_t family = oval_test_get_family(test);
const char *family_text = oval_family_get_text(family);
char family_uri[strlen((const char *)OVAL_DEFINITIONS_NAMESPACE) + strlen(family_text) + 2];
sprintf(family_uri,"%s#%s", OVAL_DEFINITIONS_NAMESPACE, family_text);
/* search namespace & create child */
xmlNs *ns_family = xmlSearchNsByHref(doc, parent, BAD_CAST family_uri);
test_node = xmlNewTextChild(parent, ns_family, BAD_CAST test_name, NULL);
char *id = oval_test_get_id(test);
xmlNewProp(test_node, BAD_CAST "id", BAD_CAST id);
char version[10];
*version = '\0';
snprintf(version, sizeof(version), "%d", oval_test_get_version(test));
xmlNewProp(test_node, BAD_CAST "version", BAD_CAST version);
oval_existence_t existence = oval_test_get_existence(test);
if (existence != OVAL_AT_LEAST_ONE_EXISTS)
xmlNewProp(test_node, BAD_CAST "check_existence", BAD_CAST oval_existence_get_text(existence));
oval_check_t check = oval_test_get_check(test);
xmlNewProp(test_node, BAD_CAST "check", BAD_CAST oval_check_get_text(check));
oval_operator_t ste_operator = oval_test_get_state_operator(test);
if (ste_operator != OVAL_OPERATOR_AND)
xmlNewProp(test_node, BAD_CAST "state_operator", BAD_CAST oval_operator_get_text(ste_operator));
char *comm = oval_test_get_comment(test);
xmlNewProp(test_node, BAD_CAST "comment", BAD_CAST comm);
bool deprecated = oval_test_get_deprecated(test);
if (deprecated)
xmlNewProp(test_node, BAD_CAST "deprecated", BAD_CAST "true");
struct oval_string_iterator *notes = oval_test_get_notes(test);
if (oval_string_iterator_has_more(notes)) {
xmlNs *ns_definitions = xmlSearchNsByHref(doc, parent, OVAL_DEFINITIONS_NAMESPACE);
xmlNode *notes_node = xmlNewTextChild(test_node, ns_definitions, BAD_CAST "notes", NULL);
while (oval_string_iterator_has_more(notes)) {
char *note = oval_string_iterator_next(notes);
xmlNewTextChild(notes_node, ns_definitions, BAD_CAST "note", BAD_CAST note);
}
}
oval_string_iterator_free(notes);
struct oval_object *object = oval_test_get_object(test);
if (object) {
xmlNode *object_node = xmlNewTextChild(test_node, ns_family, BAD_CAST "object", NULL);
xmlNewProp(object_node, BAD_CAST "object_ref", BAD_CAST oval_object_get_id(object));
}
struct oval_state_iterator *ste_itr = oval_test_get_states(test);
while (oval_state_iterator_has_more(ste_itr)) {
struct oval_state *state;
state = oval_state_iterator_next(ste_itr);
xmlNode *state_node = xmlNewTextChild(test_node, ns_family, BAD_CAST "state", NULL);
xmlNewProp(state_node, BAD_CAST "state_ref", BAD_CAST oval_state_get_id(state));
}
oval_state_iterator_free(ste_itr);
return test_node;
}
