Diff: oval_sexp.c - oval

	oval_sexp.c	oval_sexp.c

	skipping to change at line 62	skipping to change at line 62

	#ifndef _A	#ifndef _A
	# define _A(x) assert(x)	# define _A(x) assert(x)
	#endif	#endif

	SEXP_t oval_value_to_sexp(struct oval_value val, oval_datatype_t dtype)	SEXP_t oval_value_to_sexp(struct oval_value val, oval_datatype_t dtype)
	{	{
	SEXP_t *val_sexp = NULL;	SEXP_t *val_sexp = NULL;
	char *val_rptr = NULL;	char *val_rptr = NULL;


	/* todo: remove calls to SEXP_datatype_set() */

	switch (dtype) {	switch (dtype) {

	case OVAL_DATATYPE_VERSION:	case OVAL_DATATYPE_EVR_STRING:
	val_rptr = oval_value_get_text (val);	case OVAL_DATATYPE_IPV4ADDR:
		case OVAL_DATATYPE_IPV6ADDR:
	if (val_rptr != NULL) {
	val_sexp = SEXP_string_newf("%s", val_rptr);
	SEXP_datatype_set(val_sexp, "version");
	}

	break;
	case OVAL_DATATYPE_EVR_STRING:
	val_rptr = oval_value_get_text (val);

	if (val_rptr != NULL) {
	val_sexp = SEXP_string_newf("%s", val_rptr);
	SEXP_datatype_set(val_sexp, "evr_str");
	}

	break;
	case OVAL_DATATYPE_STRING:	case OVAL_DATATYPE_STRING:

		case OVAL_DATATYPE_VERSION:
	val_rptr = oval_value_get_text (val);	val_rptr = oval_value_get_text (val);


	if (val_rptr != NULL) {	if (val_rptr != NULL) {
	val_sexp = SEXP_string_newf("%s", val_rptr);	val_sexp = SEXP_string_newf("%s", val_rptr);
	}	}

	break;	break;
	case OVAL_DATATYPE_FLOAT:	case OVAL_DATATYPE_FLOAT:
	val_sexp = SEXP_number_newf(oval_value_get_float(val));	val_sexp = SEXP_number_newf(oval_value_get_float(val));
	break;	break;
	case OVAL_DATATYPE_INTEGER:	case OVAL_DATATYPE_INTEGER:
	val_sexp = SEXP_number_newi_64(oval_value_get_integer(val));	val_sexp = SEXP_number_newi_64(oval_value_get_integer(val));

	skipping to change at line 123	skipping to change at line 106
	}	}

	return val_sexp;	return val_sexp;
	}	}

	static SEXP_t oval_entity_to_sexp(struct oval_entity ent)	static SEXP_t oval_entity_to_sexp(struct oval_entity ent)
	{	{
	SEXP_t elm, elm_name;	SEXP_t elm, elm_name;
	SEXP_t r0, r1, *r2;	SEXP_t r0, r1, *r2;
	oval_datatype_t datatype;	oval_datatype_t datatype;

		oval_entity_varref_type_t vr_type;

	elm_name = SEXP_list_new(r0 = SEXP_string_newf("%s", oval_entity_get _name(ent)),	elm_name = SEXP_list_new(r0 = SEXP_string_newf("%s", oval_entity_get _name(ent)),
	/* operation */	/* operation */
	r1 = SEXP_string_new(":operation", 10),	r1 = SEXP_string_new(":operation", 10),
	r2 = SEXP_number_newu_32(oval_entity_get_op eration(ent)), NULL);	r2 = SEXP_number_newu_32(oval_entity_get_op eration(ent)), NULL);

		SEXP_vfree(r0, r1, r2, NULL);
	SEXP_free(r0);
	SEXP_free(r1);
	SEXP_free(r2);

	elm = SEXP_list_new(NULL);	elm = SEXP_list_new(NULL);
	datatype = oval_entity_get_datatype(ent);	datatype = oval_entity_get_datatype(ent);
	probe_ent_setdatatype(elm, datatype);	probe_ent_setdatatype(elm, datatype);


	if (oval_entity_get_varref_type(ent) == OVAL_ENTITY_VARREF_ATTRIBUTE	vr_type = oval_entity_get_varref_type(ent);
	) {	if (vr_type == OVAL_ENTITY_VARREF_ATTRIBUTE
		\|\| vr_type == OVAL_ENTITY_VARREF_ELEMENT) {
	/* var_ref */	/* var_ref */
	struct oval_variable *var;	struct oval_variable *var;

	var = oval_entity_get_variable(ent);	var = oval_entity_get_variable(ent);


	SEXP_list_add(elm_name, r0 = SEXP_string_new(":var_ref", 8)) ;	SEXP_list_add(elm_name, r0 = SEXP_string_new(":var_ref", 8)) ;

	SEXP_free(r0);	SEXP_list_add(elm_name, r1 = SEXP_string_newf("%s", oval_var
		iable_get_id(var)));
	SEXP_list_add(elm_name, r0 = SEXP_string_newf("%s", oval_var
	iable_get_id(var)));
	SEXP_free(r0);

	SEXP_list_add(elm, elm_name);	SEXP_list_add(elm, elm_name);

	SEXP_free(elm_name);	SEXP_vfree(r0, r1, elm_name, NULL);

	} else {	} else {
	/* value */	/* value */

		struct oval_value *val;

	SEXP_list_add(elm, elm_name);	SEXP_list_add(elm, elm_name);
	SEXP_free(elm_name);	SEXP_free(elm_name);

		val = oval_entity_get_value(ent);


	if (datatype != OVAL_DATATYPE_RECORD) {	if (datatype != OVAL_DATATYPE_RECORD
		&& val != NULL) {
	SEXP_t *val_sexp;	SEXP_t *val_sexp;


	val_sexp = oval_value_to_sexp(oval_entity_get_value( ent), datatype);	val_sexp = oval_value_to_sexp(val, datatype);
	if (val_sexp != NULL) {	if (val_sexp != NULL) {
	SEXP_list_add(elm, val_sexp);	SEXP_list_add(elm, val_sexp);
	SEXP_free(val_sexp);	SEXP_free(val_sexp);
	}	}
	}	}
	}	}

	return (elm);	return (elm);
	}	}


	static int oval_varref_to_sexp(void sess, struct oval_entity entity, stru ct oval_syschar syschar, SEXP_t *out_sexp)	static int oval_varref_attr_to_sexp(void sess, struct oval_entity entity, struct oval_syschar syschar, SEXP_t *out_sexp)
	{	{
	unsigned int val_cnt = 0;	unsigned int val_cnt = 0;
	SEXP_t val_lst, val_sexp, varref, id_sexp, *val_cnt_sexp;	SEXP_t val_lst, val_sexp, varref, id_sexp, *val_cnt_sexp;
	oval_datatype_t dt;	oval_datatype_t dt;
	struct oval_variable *var;	struct oval_variable *var;
	struct oval_value_iterator *vit;	struct oval_value_iterator *vit;
	struct oval_value *val;	struct oval_value *val;
	oval_syschar_collection_flag_t flag;	oval_syschar_collection_flag_t flag;
	char msg[100];	char msg[100];
	int ret = 0;	int ret = 0;

	skipping to change at line 196	skipping to change at line 177
	return -1;	return -1;
	}	}

	flag = oval_variable_get_collection_flag(var);	flag = oval_variable_get_collection_flag(var);
	switch (flag) {	switch (flag) {
	case SYSCHAR_FLAG_COMPLETE:	case SYSCHAR_FLAG_COMPLETE:
	case SYSCHAR_FLAG_INCOMPLETE:	case SYSCHAR_FLAG_INCOMPLETE:
	vit = oval_variable_get_values(var);	vit = oval_variable_get_values(var);
	if (oval_value_iterator_has_more(vit))	if (oval_value_iterator_has_more(vit))
	break;	break;

		oval_value_iterator_free(vit);
	/* fall through */	/* fall through */
	case SYSCHAR_FLAG_DOES_NOT_EXIST:	case SYSCHAR_FLAG_DOES_NOT_EXIST:
	snprintf(msg, sizeof(msg), "Referenced variable has no value s (%s).", oval_variable_get_id(var));	snprintf(msg, sizeof(msg), "Referenced variable has no value s (%s).", oval_variable_get_id(var));
	ret = 1;	ret = 1;
	break;	break;
	default:	default:
	snprintf(msg, sizeof(msg), "There was a problem processing r eferenced variable (%s).", oval_variable_get_id(var));	snprintf(msg, sizeof(msg), "There was a problem processing r eferenced variable (%s).", oval_variable_get_id(var));
	ret = 1;	ret = 1;
	}	}


	skipping to change at line 247	skipping to change at line 229
	varref = SEXP_list_new(id_sexp, val_cnt_sexp, val_lst, NULL);	varref = SEXP_list_new(id_sexp, val_cnt_sexp, val_lst, NULL);

	SEXP_free(id_sexp);	SEXP_free(id_sexp);
	SEXP_free(val_cnt_sexp);	SEXP_free(val_cnt_sexp);
	SEXP_free(val_lst);	SEXP_free(val_lst);

	*out_sexp = varref;	*out_sexp = varref;
	return 0;	return 0;
	}	}


		static int oval_varref_elm_to_sexp(void sess, struct oval_variable var, o
		val_datatype_t dt, SEXP_t **out_sexp)
		{
		SEXP_t *val_lst;
		struct oval_value_iterator *val_itr;
		oval_syschar_collection_flag_t flag;

		if (oval_probe_query_variable(sess, var) != 0)
		return -1;

		flag = oval_variable_get_collection_flag(var);
		if (flag != SYSCHAR_FLAG_COMPLETE
		&& flag != SYSCHAR_FLAG_INCOMPLETE) {
		*out_sexp = SEXP_list_new(NULL);
		return 0;
		}

		val_lst = SEXP_list_new(NULL);

		val_itr = oval_variable_get_values(var);
		while (oval_value_iterator_has_more(val_itr)) {
		struct oval_value *val;
		SEXP_t *vs;

		val = oval_value_iterator_next(val_itr);
		vs = oval_value_to_sexp(val, dt);
		if (vs == NULL) {
		oscap_dlprintf(DBG_E, "Failed to convert OVAL value
		to SEXP: "
		"datatype: %s, text: %s.\n",
		oval_datatype_get_text(dt),
		oval_value_get_text(val));
		oscap_seterr(OSCAP_EFAMILY_OVAL, OVAL_EOVALINT, "Fai
		led to convert OVAL value to SEXP");
		oval_value_iterator_free(val_itr);
		SEXP_free(val_lst);
		return -1;
		}
		SEXP_list_add(val_lst, vs);
		SEXP_free(vs);
		}
		oval_value_iterator_free(val_itr);

		*out_sexp = val_lst;
		return 0;
		}

	static SEXP_t oval_filter_to_sexp(struct oval_filter filter)	static SEXP_t oval_filter_to_sexp(struct oval_filter filter)
	{	{
	SEXP_t elm, attr, r0, r1;	SEXP_t elm, attr, r0, r1;
	oval_filter_action_t act;	oval_filter_action_t act;
	struct oval_state *ste;	struct oval_state *ste;
	char *ste_id;	char *ste_id;

	act = oval_filter_get_filter_action(filter);	act = oval_filter_get_filter_action(filter);
	ste = oval_filter_get_state(filter);	ste = oval_filter_get_state(filter);
	ste_id = oval_state_get_id(ste);	ste_id = oval_state_get_id(ste);

	skipping to change at line 370	skipping to change at line 396
	SEXP_free(r0);	SEXP_free(r0);
	}	}
	}	}

	r0 = SEXP_list_new(elm_name, NULL);	r0 = SEXP_list_new(elm_name, NULL);
	SEXP_free(elm_name);	SEXP_free(elm_name);

	return (r0);	return (r0);
	}	}


	int oval_object2sexp(void sess, const char typestr, struct oval_syschar * syschar, SEXP_t **out_sexp)	int oval_object_to_sexp(void sess, const char typestr, struct oval_syscha r syschar, SEXP_t *out_sexp)
	{	{
	unsigned int ent_cnt, varref_cnt;	unsigned int ent_cnt, varref_cnt;
	int ret = -1;	int ret = -1;
	SEXP_t obj_sexp, obj_name, elm, varrefs, ent_lst, lst, *stmp;	SEXP_t obj_sexp, obj_name, elm, varrefs, ent_lst, lst, *stmp;
	SEXP_t r0, r1, *r2;	SEXP_t r0, r1, *r2;

	struct oval_object *object;	struct oval_object *object;
	struct oval_object_content_iterator *cit;	struct oval_object_content_iterator *cit;
	struct oval_behavior_iterator *bit;	struct oval_behavior_iterator *bit;
	struct oval_object_content *content;	struct oval_object_content *content;

	skipping to change at line 410	skipping to change at line 436
	* Object content	* Object content
	*/	*/

	ent_lst = SEXP_list_new(NULL);	ent_lst = SEXP_list_new(NULL);
	varrefs = NULL;	varrefs = NULL;
	ent_cnt = varref_cnt = 0;	ent_cnt = varref_cnt = 0;

	cit = oval_object_get_object_contents(object);	cit = oval_object_get_object_contents(object);
	while (oval_object_content_iterator_has_more(cit)) {	while (oval_object_content_iterator_has_more(cit)) {
	oval_check_t ochk;	oval_check_t ochk;

		oval_entity_varref_type_t vr_type;

	content = oval_object_content_iterator_next(cit);	content = oval_object_content_iterator_next(cit);
	elm = NULL;	elm = NULL;
	lst = ent_lst;	lst = ent_lst;

	switch (oval_object_content_get_type(content)) {	switch (oval_object_content_get_type(content)) {
	case OVAL_OBJECTCONTENT_ENTITY:	case OVAL_OBJECTCONTENT_ENTITY:
	entity = oval_object_content_get_entity(content);	entity = oval_object_content_get_entity(content);
	elm = oval_entity_to_sexp(entity);	elm = oval_entity_to_sexp(entity);


	if (elm == NULL)	if (elm == NULL)
	break;	break;

	ochk = oval_object_content_get_varCheck(content);	ochk = oval_object_content_get_varCheck(content);
	if (ochk != OVAL_CHECK_UNKNOWN) {	if (ochk != OVAL_CHECK_UNKNOWN) {
	probe_ent_attr_add(elm, "var_check",	probe_ent_attr_add(elm, "var_check",
	r0 = SEXP_number_newu_32( ochk));	r0 = SEXP_number_newu_32( ochk));
	SEXP_free(r0);	SEXP_free(r0);
	}	}


	if (oval_entity_get_varref_type(entity) == OVAL_ENTI	vr_type = oval_entity_get_varref_type(entity);
	TY_VARREF_ATTRIBUTE) {	if (vr_type == OVAL_ENTITY_VARREF_ATTRIBUTE) {
	ret = oval_varref_to_sexp(sess, entity, sysc	ret = oval_varref_attr_to_sexp(sess, entity,
	har, &stmp);	syschar, &stmp);

	if (ret != 0) {	if (ret != 0) {
	SEXP_free(elm);	SEXP_free(elm);
	elm = NULL;	elm = NULL;
	break;	break;
	}	}

	if (varrefs == NULL) {	if (varrefs == NULL) {
	varrefs = SEXP_list_new(NULL);	varrefs = SEXP_list_new(NULL);
	}	}
	SEXP_list_add(varrefs, stmp);	SEXP_list_add(varrefs, stmp);
	SEXP_free(stmp);	SEXP_free(stmp);
	// todo: don't add duplicates	// todo: don't add duplicates
	++varref_cnt;	++varref_cnt;

	lst = obj_sexp;	lst = obj_sexp;
	++ent_cnt;	++ent_cnt;

		} else if (vr_type == OVAL_ENTITY_VARREF_ELEMENT) {
		SEXP_t *val_lst;
		struct oval_variable *var;
		oval_datatype_t dt;

		var = oval_entity_get_variable(entity);
		dt = oval_entity_get_datatype(entity);

		ret = oval_varref_elm_to_sexp(sess, var, dt,
		&val_lst);
		if (ret != 0) {
		SEXP_free(elm);
		elm = NULL;
		break;
		}

		SEXP_list_add(elm, val_lst);
		SEXP_free(val_lst);
	}	}
	break;	break;

	case OVAL_OBJECTCONTENT_SET:	case OVAL_OBJECTCONTENT_SET:
	elm = oval_set_to_sexp(oval_object_content_get_setob ject(content));	elm = oval_set_to_sexp(oval_object_content_get_setob ject(content));
	break;	break;

	case OVAL_OBJECTCONTENT_FILTER:	case OVAL_OBJECTCONTENT_FILTER:
	elm = oval_filter_to_sexp(oval_object_content_get_fi lter(content));	elm = oval_filter_to_sexp(oval_object_content_get_fi lter(content));
	break;	break;

	skipping to change at line 553	skipping to change at line 596
	}	}
	ochk = oval_record_field_get_ent_check(rf);	ochk = oval_record_field_get_ent_check(rf);
	if (ochk != OVAL_CHECK_UNKNOWN) {	if (ochk != OVAL_CHECK_UNKNOWN) {
	probe_ent_attr_add(rf_sexp, "entity_check", r0 = SEXP_number _newu_32(ochk));	probe_ent_attr_add(rf_sexp, "entity_check", r0 = SEXP_number _newu_32(ochk));
	SEXP_free(r0);	SEXP_free(r0);
	}	}

	return rf_sexp;	return rf_sexp;
	}	}


	static struct oval_sysent oval_sysent_from_sexp(struct oval_syschar_model model, SEXP_t * sexp);	static struct oval_sysent oval_sexp_to_sysent(struct oval_syschar_model m odel, struct oval_sysitem item, SEXP_t sexp);

	static struct oval_record_field oval_record_field_ITEM_from_sexp(SEXP_t s exp)	static struct oval_record_field oval_record_field_ITEM_from_sexp(SEXP_t s exp)
	{	{
	struct oval_sysent *sysent;	struct oval_sysent *sysent;
	struct oval_record_field *rf;	struct oval_record_field *rf;


	sysent = oval_sysent_from_sexp(NULL, sexp);	sysent = oval_sexp_to_sysent(NULL, NULL, sexp);
	if (sysent == NULL)	if (sysent == NULL)
	return NULL;	return NULL;

	rf = oval_record_field_new(OVAL_RECORD_FIELD_ITEM);	rf = oval_record_field_new(OVAL_RECORD_FIELD_ITEM);
	oval_record_field_set_name(rf, oscap_strdup(oval_sysent_get_name(sys ent)));	oval_record_field_set_name(rf, oscap_strdup(oval_sysent_get_name(sys ent)));
	oval_record_field_set_value(rf, oscap_strdup(oval_sysent_get_value(s ysent)));	oval_record_field_set_value(rf, oscap_strdup(oval_sysent_get_value(s ysent)));
	oval_record_field_set_datatype(rf, oval_sysent_get_datatype(sysent)) ;	oval_record_field_set_datatype(rf, oval_sysent_get_datatype(sysent)) ;
	oval_record_field_set_mask(rf, oval_sysent_get_mask(sysent));	oval_record_field_set_mask(rf, oval_sysent_get_mask(sysent));
	oval_record_field_set_status(rf, oval_sysent_get_status(sysent));	oval_record_field_set_status(rf, oval_sysent_get_status(sysent));

	oval_sysent_free(sysent);	oval_sysent_free(sysent);

	return rf;	return rf;
	}	}


	int oval_state2sexp(void sess, struct oval_state state, SEXP_t **out_sexp )	int oval_state_to_sexp(void sess, struct oval_state state, SEXP_t **out_s exp)
	{	{
	SEXP_t ste, ste_name, *ste_ent;	SEXP_t ste, ste_name, *ste_ent;
	SEXP_t r0, r1, r2, r3, *r4;	SEXP_t r0, r1, r2, r3, *r4;
	char buffer[128];	char buffer[128];
	size_t buflen;	size_t buflen;
	const char *subtype_name;	const char *subtype_name;
	struct oval_state_content_iterator *contents;	struct oval_state_content_iterator *contents;


	subtype_name = oval_subtype2str(oval_state_get_subtype(state));	subtype_name = oval_subtype_to_str(oval_state_get_subtype(state));

	if (subtype_name == NULL) {	if (subtype_name == NULL) {
	_D("FAIL: unknown subtype: %d\n", oval_state_get_subtype(sta te));	_D("FAIL: unknown subtype: %d\n", oval_state_get_subtype(sta te));
	return (-1);	return (-1);
	}	}

	buflen = snprintf(buffer, sizeof buffer, "%s_state", subtype_name);	buflen = snprintf(buffer, sizeof buffer, "%s_state", subtype_name);
	_A(buflen < sizeof buffer);	_A(buflen < sizeof buffer);

	ste_name = SEXP_list_new(r0 = SEXP_string_new(buffer, buflen),	ste_name = SEXP_list_new(r0 = SEXP_string_new(buffer, buflen),

	skipping to change at line 608	skipping to change at line 651
	r3 = SEXP_string_new(":operator", 9),	r3 = SEXP_string_new(":operator", 9),
	r4 = SEXP_number_newu(oval_state_get_operat or(state)),	r4 = SEXP_number_newu(oval_state_get_operat or(state)),
	NULL);	NULL);

	ste = SEXP_list_new(ste_name, NULL);	ste = SEXP_list_new(ste_name, NULL);
	SEXP_vfree(r0, r1, r2, r3, r4, ste_name, NULL);	SEXP_vfree(r0, r1, r2, r3, r4, ste_name, NULL);

	contents = oval_state_get_contents(state);	contents = oval_state_get_contents(state);
	while (oval_state_content_iterator_has_more(contents)) {	while (oval_state_content_iterator_has_more(contents)) {
	oval_check_t ochk;	oval_check_t ochk;

		oval_entity_varref_type_t vr_type;
	struct oval_entity *ent;	struct oval_entity *ent;
	struct oval_state_content *content = oval_state_content_iter ator_next(contents);	struct oval_state_content *content = oval_state_content_iter ator_next(contents);
	struct oval_record_field_iterator *rf_itr;	struct oval_record_field_iterator *rf_itr;

	ent = oval_state_content_get_entity(content);	ent = oval_state_content_get_entity(content);
	ste_ent = oval_entity_to_sexp(ent);	ste_ent = oval_entity_to_sexp(ent);
	if (ste_ent == NULL) {	if (ste_ent == NULL) {
	goto fail;	goto fail;
	}	}


	skipping to change at line 643	skipping to change at line 687
	probe_ent_attr_add(ste_ent, "var_check", r0 = SEXP_n umber_newu_32(ochk));	probe_ent_attr_add(ste_ent, "var_check", r0 = SEXP_n umber_newu_32(ochk));
	SEXP_free(r0);	SEXP_free(r0);
	}	}

	ochk = oval_state_content_get_ent_check(content);	ochk = oval_state_content_get_ent_check(content);
	if (ochk != OVAL_CHECK_UNKNOWN) {	if (ochk != OVAL_CHECK_UNKNOWN) {
	probe_ent_attr_add(ste_ent, "entity_check", r0 = SEX P_number_newu_32(ochk));	probe_ent_attr_add(ste_ent, "entity_check", r0 = SEX P_number_newu_32(ochk));
	SEXP_free(r0);	SEXP_free(r0);
	}	}


	if (oval_entity_get_varref_type(ent) == OVAL_ENTITY_VARREF_A	vr_type = oval_entity_get_varref_type(ent);
	TTRIBUTE) {	if (vr_type == OVAL_ENTITY_VARREF_ATTRIBUTE
		\|\| vr_type == OVAL_ENTITY_VARREF_ELEMENT) {
	SEXP_t *val_lst;	SEXP_t *val_lst;
	struct oval_variable *var;	struct oval_variable *var;

	struct oval_value_iterator *val_itr;
	oval_datatype_t dt;	oval_datatype_t dt;

	oval_syschar_collection_flag_t flag;

	var = oval_entity_get_variable(ent);	var = oval_entity_get_variable(ent);

	if (oval_probe_query_variable(sess, var) != 0) {
	goto fail;
	}

	dt = oval_entity_get_datatype(ent);	dt = oval_entity_get_datatype(ent);

	val_lst = SEXP_list_new(NULL);


	flag = oval_variable_get_collection_flag(var);	if (oval_varref_elm_to_sexp(sess, var, dt, &val_lst)
	if (flag == SYSCHAR_FLAG_COMPLETE	!= 0)
	\|\| flag == SYSCHAR_FLAG_INCOMPLETE) {	goto fail;
	val_itr = oval_variable_get_values(var);
	while (oval_value_iterator_has_more(val_itr)
	) {
	struct oval_value *val;
	SEXP_t *vs;

	val = oval_value_iterator_next(val_i
	tr);
	vs = oval_value_to_sexp(val, dt);
	if (vs == NULL) {
	oscap_dlprintf(DBG_E, "Faile
	d to convert OVAL value to SEXP: "
	"datatype: %s
	, text: %s.\n",
	oval_datatype
	_get_text(dt),
	oval_value_ge
	t_text(val));
	oscap_seterr(OSCAP_EFAMILY_O
	VAL, OVAL_EOVALINT, "Failed to convert OVAL value to SEXP");
	oval_value_iterator_free(val
	_itr);
	SEXP_free(val_lst);
	goto fail;
	}
	SEXP_list_add(val_lst, vs);
	SEXP_free(vs);
	}
	oval_value_iterator_free(val_itr);
	}

	SEXP_list_add(ste_ent, val_lst);	SEXP_list_add(ste_ent, val_lst);
	SEXP_free(val_lst);	SEXP_free(val_lst);
	}	}

	SEXP_list_add(ste, ste_ent);	SEXP_list_add(ste, ste_ent);
	SEXP_free(ste_ent);	SEXP_free(ste_ent);
	}	}
	oval_state_content_iterator_free(contents);	oval_state_content_iterator_free(contents);

	*out_sexp = ste;	*out_sexp = ste;
	return (0);	return (0);

	fail:	fail:
	oval_state_content_iterator_free(contents);	oval_state_content_iterator_free(contents);
	SEXP_vfree(ste, ste_ent, NULL);	SEXP_vfree(ste, ste_ent, NULL);
	return (-1);	return (-1);
	}	}


	static struct oval_message oval_sexp2msg(const SEXP_t msg)	static struct oval_message oval_sexp_to_msg(const SEXP_t msg)
	{	{
	struct oval_message *message;	struct oval_message *message;
	SEXP_t *r0;	SEXP_t *r0;
	oval_message_level_t lvl;	oval_message_level_t lvl;
	char *str;	char *str;

	message = oval_message_new();	message = oval_message_new();
	r0 = SEXP_list_first(msg);	r0 = SEXP_list_first(msg);
	lvl = SEXP_number_getu(r0);	lvl = SEXP_number_getu(r0);
	SEXP_free(r0);	SEXP_free(r0);
	oval_message_set_level(message, lvl);	oval_message_set_level(message, lvl);
	r0 = SEXP_list_nth(msg, 2);	r0 = SEXP_list_nth(msg, 2);
	str = SEXP_string_cstr(r0);	str = SEXP_string_cstr(r0);
	SEXP_free(r0);	SEXP_free(r0);
	oval_message_set_text(message, str);	oval_message_set_text(message, str);
	oscap_free(str);	oscap_free(str);

	return message;	return message;
	}	}


	static struct oval_sysent oval_sysent_from_sexp(struct oval_syschar_model model, SEXP_t * sexp)	static struct oval_sysent oval_sexp_to_sysent(struct oval_syschar_model m odel, struct oval_sysitem item, SEXP_t sexp)
	{	{
	char *key;	char *key;
	oval_syschar_status_t status;	oval_syschar_status_t status;
	oval_datatype_t dt;	oval_datatype_t dt;
	struct oval_sysent *ent;	struct oval_sysent *ent;

	key = probe_ent_getname(sexp);	key = probe_ent_getname(sexp);
	if (!key)	if (!key)
	return NULL;	return NULL;


		if (strcmp("message", key) == 0 && item != NULL) {
		struct oval_message *msg;
		oval_message_level_t lvl;
		SEXP_t lvl_sexp, txt_sexp;
		char txt[1024];

		lvl_sexp = probe_obj_getattrval(sexp, "level");
		lvl = SEXP_number_getu_32(lvl_sexp);

		txt_sexp = probe_ent_getval(sexp);
		SEXP_string_cstr_r(txt_sexp, txt, sizeof txt);

		SEXP_vfree(lvl_sexp, txt_sexp);

		/* TODO: sanity checks */

		msg = oval_message_new();

		oval_message_set_level(msg, lvl);
		oval_message_set_text(msg, txt);
		oval_sysitem_add_message(item, msg);

		return (NULL);
		}

	status = probe_ent_getstatus(sexp);	status = probe_ent_getstatus(sexp);
	dt = probe_ent_getdatatype(sexp);	dt = probe_ent_getdatatype(sexp);

	ent = oval_sysent_new(model);	ent = oval_sysent_new(model);
	oval_sysent_set_name(ent, key);	oval_sysent_set_name(ent, key);
	oval_sysent_set_status(ent, status);	oval_sysent_set_status(ent, status);
	oval_sysent_set_datatype(ent, dt);	oval_sysent_set_datatype(ent, dt);
	oval_sysent_set_mask(ent, probe_ent_getmask(sexp));	oval_sysent_set_mask(ent, probe_ent_getmask(sexp));


	if (status != OVAL_STATUS_EXISTS)	if (status != SYSCHAR_STATUS_EXISTS)
	return ent;	return ent;

	if (dt == OVAL_DATATYPE_RECORD) {	if (dt == OVAL_DATATYPE_RECORD) {
	SEXP_t srf, srfs;	SEXP_t srf, srfs;

	probe_ent_getvals(sexp, &srfs);	probe_ent_getvals(sexp, &srfs);
	SEXP_list_foreach(srf, srfs) {	SEXP_list_foreach(srf, srfs) {
	struct oval_record_field *rf;	struct oval_record_field *rf;

	rf = oval_record_field_ITEM_from_sexp(srf);	rf = oval_record_field_ITEM_from_sexp(srf);

	skipping to change at line 794	skipping to change at line 835
	case SEXP_NUM_UINT32:	case SEXP_NUM_UINT32:
	case SEXP_NUM_UINT64:	case SEXP_NUM_UINT64:
	snprintf(val, sizeof(val), "%" PRIu64, SEXP_ number_getu_64(sval));	snprintf(val, sizeof(val), "%" PRIu64, SEXP_ number_getu_64(sval));
	break;	break;
	default:	default:
	dE("Unexpected SEXP number datatype: %d, nam e: '%s'.\n", sndt, key);	dE("Unexpected SEXP number datatype: %d, nam e: '%s'.\n", sndt, key);
	valp = '\0';	valp = '\0';
	break;	break;
	}	}
	break;	break;

		case OVAL_DATATYPE_EVR_STRING:
		case OVAL_DATATYPE_IPV4ADDR:
		case OVAL_DATATYPE_IPV6ADDR:
	case OVAL_DATATYPE_STRING:	case OVAL_DATATYPE_STRING:

	case OVAL_DATATYPE_EVR_STRING:	case OVAL_DATATYPE_VERSION:
	valp = SEXP_string_cstr(sval);	valp = SEXP_string_cstr(sval);
	break;	break;
	default:	default:
	dE("Unexpected OVAL datatype: %d, '%s', name: '%s'.\ n",	dE("Unexpected OVAL datatype: %d, '%s', name: '%s'.\ n",
	dt, oval_datatype_get_text(dt), key);	dt, oval_datatype_get_text(dt), key);
	valp = '\0';	valp = '\0';
	break;	break;
	}	}

	oval_sysent_set_value(ent, valp);	oval_sysent_set_value(ent, valp);
	if (valp != val)	if (valp != val)
	oscap_free(valp);	oscap_free(valp);
	SEXP_free(sval);	SEXP_free(sval);
	}	}

	return ent;	return ent;
	}	}


	static struct oval_sysitem oval_sysitem_from_sexp(struct oval_syschar_mode l model, SEXP_t * sexp)	static struct oval_sysitem oval_sexp_to_sysitem(struct oval_syschar_model model, SEXP_t * sexp)
	{	{
	_A(sexp);	_A(sexp);


	static int id_counter = 1; /* TODO better ID generator */	char name, id;
		SEXP_t *id_sexp;
	char *name;
	struct oval_sysitem *sysitem = NULL;	struct oval_sysitem *sysitem = NULL;


		id_sexp = probe_ent_getattrval(sexp, "id");
		id = SEXP_string_cstr(id_sexp);
		SEXP_free(id_sexp);

		sysitem = oval_syschar_model_get_sysitem(model, id);

		if (sysitem) {
		oscap_free(id);
		return sysitem;
		}

	name = probe_ent_getname(sexp);	name = probe_ent_getname(sexp);


	if (name == NULL)	if (name == NULL) {
		oscap_free(id);
	return NULL;	return NULL;

	else {	} else {
	char *endptr = strrchr(name, '_');	char *endptr = strrchr(name, '_');

	if (strcmp(endptr, "_item") != 0)	if (strcmp(endptr, "_item") != 0)
	goto cleanup;	goto cleanup;

	*endptr = '\0'; // cut off the '_item' part	*endptr = '\0'; // cut off the '_item' part
	}	}


	int type = oval_str2subtype(name);	int type = oval_str_to_subtype(name);

	_D("Syschar entry type: %d '%s' => %s\n", type, name, (type ? "OK" : "FAILED to decode"));	_D("Syschar entry type: %d '%s' => %s\n", type, name, (type ? "OK" : "FAILED to decode"));

		#ifndef NDEBUG
	char id[16];	if (!type)
		abort();
		#endif
	SEXP_t *sub;	SEXP_t *sub;
	struct oval_sysent *sysent;	struct oval_sysent *sysent;

	int status = probe_ent_getstatus(sexp);	int status = probe_ent_getstatus(sexp);


	sprintf(id, "%d", id_counter++);	sysitem = oval_sysitem_new(model, id);
	sysitem = oval_sysitem_get_new(model, id);
	oval_sysitem_set_status(sysitem, status);	oval_sysitem_set_status(sysitem, status);
	oval_sysitem_set_subtype(sysitem, type);	oval_sysitem_set_subtype(sysitem, type);

	//oval_sysitem_set_subtype_name(sysitem, name);


	if (status == OVAL_STATUS_EXISTS) {	for (int i = 2; (sub = SEXP_list_nth(sexp, i)) != NULL; ++i) {
	for (int i = 2; (sub = SEXP_list_nth(sexp, i)) != NULL; ++i)	if ((sysent = oval_sexp_to_sysent(model, sysitem, sub)) != NULL)
	{	oval_sysitem_add_sysent(sysitem, sysent);
	if ((sysent = oval_sysent_from_sexp(model, sub)) !=	SEXP_free(sub);
	NULL)
	oval_sysitem_add_sysent(sysitem, sysent);
	SEXP_free(sub);
	}
	}	}

	cleanup:	cleanup:

		oscap_free(id);
	oscap_free(name);	oscap_free(name);
	return sysitem;	return sysitem;
	}	}


	int oval_sexp2sysch(const SEXP_t cobj, struct oval_syschar syschar)	int oval_sexp_to_sysch(const SEXP_t cobj, struct oval_syschar syschar)
	{	{
	oval_syschar_collection_flag_t flag;	oval_syschar_collection_flag_t flag;
	SEXP_t messages, msg, items, item;	SEXP_t messages, msg, items, item;
	struct oval_syschar_model *model;	struct oval_syschar_model *model;

	_A(cobj != NULL);	_A(cobj != NULL);

	flag = probe_cobj_get_flag(cobj);	flag = probe_cobj_get_flag(cobj);
	oval_syschar_set_flag(syschar, flag);	oval_syschar_set_flag(syschar, flag);

	messages = probe_cobj_get_msgs(cobj);	messages = probe_cobj_get_msgs(cobj);
	SEXP_list_foreach(msg, messages) {	SEXP_list_foreach(msg, messages) {
	struct oval_message *omsg;	struct oval_message *omsg;


	omsg = oval_sexp2msg(msg);	omsg = oval_sexp_to_msg(msg);
	if (omsg != NULL)	if (omsg != NULL)
	oval_syschar_add_message(syschar, omsg);	oval_syschar_add_message(syschar, omsg);
	}	}
	SEXP_free(messages);	SEXP_free(messages);

	model = oval_syschar_get_model(syschar);	model = oval_syschar_get_model(syschar);
	items = probe_cobj_get_items(cobj);	items = probe_cobj_get_items(cobj);
	SEXP_list_foreach(item, items) {	SEXP_list_foreach(item, items) {
	struct oval_sysitem *sysitem;	struct oval_sysitem *sysitem;


	sysitem = oval_sysitem_from_sexp(model, item);	sysitem = oval_sexp_to_sysitem(model, item);
	if (sysitem != NULL)	if (sysitem != NULL)
	oval_syschar_add_sysitem(syschar, sysitem);	oval_syschar_add_sysitem(syschar, sysitem);
	}	}
	SEXP_free(items);	SEXP_free(items);

	return 0;	return 0;
	}	}

End of changes. 53 change blocks.
	119 lines changed or deleted	165 lines changed or added
This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/