src/omxmlsec/saml/response.c

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <saml.h>
#include <saml_req.h>

AXIS2_EXTERN saml_status_t* AXIS2_CALL saml_status_create(const axutil_env_t *env)
{
	saml_status_t *status = NULL;
	status = (saml_status_t*)AXIS2_MALLOC(env->allocator, sizeof(saml_status_t));

	if(status)
	{
		status->status_value = NULL;
		status->status_msg = NULL;
		status->status_code = NULL;
		status->status_detail = NULL;
	}
	return status;
}
AXIS2_EXTERN void saml_status_free(saml_status_t *status, const axutil_env_t *env)
{
	if(status->status_value)
	{
		axutil_qname_free(status->status_value, env);
	}
	if(status->status_code)
	{
		AXIS2_FREE(env->allocator, status->status_code);
	}
	if(status->status_msg)
	{
		AXIS2_FREE(env->allocator, status->status_msg);
	}
	status->status_detail = NULL;
	AXIS2_FREE(env->allocator, status);
	status = NULL;
}

AXIS2_EXTERN int AXIS2_CALL saml_status_build(saml_status_t *status, 
											  axiom_node_t *node, 
											  const axutil_env_t *env)
{
	
	axiom_element_t *element = NULL;
	axiom_child_element_iterator_t *iterator = NULL;
	axiom_node_t *child_node;
	axis2_char_t *qname = NULL;

	if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
	{
		return AXIS2_FAILURE;
	}
	
	if ((element = axiom_node_get_data_element(node, env)) == NULL)
	{
		return AXIS2_FAILURE;
	}
	iterator = axiom_element_get_child_elements(element, env, node);
	if(iterator)
	{
		while(axiom_child_element_iterator_has_next(iterator, env))
		{
		
			child_node = axiom_child_element_iterator_next(iterator, env);
			element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);

			if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), 
																		SAML_STATUS_CODE)))
			{
				qname = axiom_element_get_attribute_value_by_name(element, env, SAML_STATUS_VALUE);
				if(qname)
					status->status_value = axutil_qname_create_from_string(env, qname); 

			}
			else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), 
																		SAML_STATUS_MESSAGE)))
			{
				status->status_msg = 	axiom_element_get_text(element, env, child_node);
			}
			else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), 
																		SAML_STATUS_DETAIL)))
			{
				status->status_detail = child_node;
			}
		}
		return AXIS2_SUCCESS;
	}
	return AXIS2_FAILURE;

}

AXIS2_EXTERN axiom_node_t* AXIS2_CALL saml_status_to_om(saml_status_t *status, 
														axiom_node_t *parent, 
														const axutil_env_t *env)
{	
	axiom_element_t *e = NULL, *ce = NULL;
	axiom_node_t *n = NULL, *cn = NULL;	
	axiom_namespace_t *ns = NULL;
	axiom_attribute_t *attr = NULL;

	ns = axiom_namespace_create(env, SAML_PROTOCOL_NMSP, SAML_PROTOCOL_PREFIX);
	e = axiom_element_create(env, parent, SAML_STATUS, ns, &n);

	if(e)
	{
		if(status->status_detail)
		{
			
			axiom_node_add_child(n, env, status->status_detail);
			
		}
		if(status->status_msg)
		{	
			ns = axiom_namespace_create(env, SAML_PROTOCOL_NMSP, SAML_PROTOCOL_PREFIX);
			ce = axiom_element_create(env, n, SAML_STATUS_MESSAGE, ns, &cn);
			if(ce)
			{
				axiom_element_set_text(ce, env, status->status_msg, cn);
			}
		}
		if(status->status_code)
		{	
			ns = axiom_namespace_create(env, SAML_PROTOCOL_NMSP, SAML_PROTOCOL_PREFIX);
			ce = axiom_element_create(env, n, SAML_STATUS_CODE, ns, &cn);
			if(ce)
			{
				axiom_element_set_text(ce, env, status->status_code, cn);
				attr = axiom_attribute_create(env, SAML_STATUS_VALUE,axutil_qname_to_string(status->status_value, env), NULL);
				axiom_element_add_attribute(ce, env, attr, cn);
			}
		}
	}
	return n;
	
}

AXIS2_EXTERN int AXIS2_CALL saml_status_set_status_value(saml_status_t *status, const axutil_env_t *env, axutil_qname_t *qname)
{
	if(status->status_value)
	{
		axutil_qname_free(status->status_value, env);
	}
	status->status_value = qname;
	return AXIS2_SUCCESS;
}

AXIS2_EXTERN axutil_qname_t* AXIS2_CALL saml_status_get_status_value(saml_status_t *status, const axutil_env_t *env)
{
	if(status)
		return status->status_value;
	else
		return NULL;
}
AXIS2_EXTERN int AXIS2_CALL saml_status_set_status_msg(saml_status_t *status, const axutil_env_t *env,  axis2_char_t *msg)
{
	if(status)
	{
		AXIS2_FREE(env->allocator, status->status_msg);
	}
	status->status_msg = axutil_strdup(env, msg);
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_char_t* AXIS2_CALL saml_status_get_status_msg(saml_status_t *status, const axutil_env_t *env)
{
	if(status)
		return status->status_msg;
	else
		return NULL;
}
AXIS2_EXTERN int AXIS2_CALL saml_status_set_status_detail(saml_status_t *status, axiom_node_t *det, const axutil_env_t *env)
{
	if(status->status_detail)
	{
		axiom_node_free_tree(status->status_detail, env);
	}
	status->status_detail = det;
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN axiom_node_t* AXIS2_CALL saml_status_get_status_detail(saml_status_t *status, const axutil_env_t *env)
{
	if(status)
		return status->status_detail;
	else
		return NULL;
}

AXIS2_EXTERN saml_response_t* saml_response_create(const axutil_env_t *env)
{
	saml_response_t *response = NULL;
	response = (saml_response_t*)AXIS2_MALLOC(env->allocator, sizeof(saml_response_t));
	if(response)
	{
		response->response_id = NULL;
		response->issue_instant = NULL;
		response->major_version = NULL;
		response->minor_version = NULL;
		response->recepient = NULL;
		response->request_response_id = NULL;
		response->sig_ctx = NULL;
		response->status = saml_status_create(env);
		response->saml_assertions = axutil_array_list_create(env, SAML_ARRAY_LIST_DEF);
		response->signature = NULL;
		response->original_xml = NULL;
	}
	return response;
}
AXIS2_EXTERN void saml_response_free(saml_response_t *response, const axutil_env_t *env)
{
	int size =0, i = 0;
	saml_assertion_t *assertion = NULL;
	if(response->major_version)
	{
		AXIS2_FREE(env->allocator, response->major_version);
	}
	if(response->minor_version)
	{
		AXIS2_FREE(env->allocator, response->minor_version);
	}
	if(response->issue_instant)
	{
		axutil_date_time_free(response->issue_instant, env);
	}
	if(response->recepient)
	{
		AXIS2_FREE(env->allocator, response->recepient);
	}
	if(response->response_id)
	{
		AXIS2_FREE(env->allocator, response->response_id);
	}
	if(response->sig_ctx)
	{
		oxs_sign_ctx_free(response->sig_ctx, env);
	}
	if(response->status)
	{
		saml_status_free(response->status, env);
	}
	if(response->request_response_id)
	{
		AXIS2_FREE(env->allocator, response->request_response_id);
	}
	if(response->saml_assertions)
	{
		size = axutil_array_list_size(response->saml_assertions, env);
		for(i = 0; i < size ; i++)
		{
			assertion = (saml_assertion_t*)axutil_array_list_get(response->saml_assertions, env, i);
			if(assertion)
			{
				saml_assertion_free(assertion, env);
			}
		}
		axutil_array_list_free(response->saml_assertions, env);
	}
	response->original_xml = NULL;
	response->signature = NULL;
	AXIS2_FREE(env->allocator, response);
	response = NULL;
}

AXIS2_EXTERN int AXIS2_CALL saml_response_build(saml_response_t *response,
												axiom_node_t *node, 
												const axutil_env_t *env)
{
	axutil_hash_t *attr_hash = NULL;
	axiom_element_t *element = NULL;
	axutil_hash_index_t *hi = NULL;
	axiom_child_element_iterator_t *iterator = NULL;
	axiom_node_t *child_node;
	saml_assertion_t *assertion;

	if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
	{
		return AXIS2_FAILURE;
	}
	
	if ((element = axiom_node_get_data_element(node, env)) == NULL)
	{
		return AXIS2_FAILURE;
	}
	
	response->original_xml = node;
	/* initialize the attributes */
	attr_hash = axiom_element_get_all_attributes(element, env);	

	for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
	{
		void *v = NULL;
        axutil_hash_this(hi, NULL, NULL, &v);
		if (v)
		{
			axis2_char_t *attr_val = NULL;
			axiom_attribute_t *attr = (axiom_attribute_t*)v;			
			attr_val = axiom_attribute_get_value(attr, env);

			if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_RESPONSE_ID))
			{
				response->response_id=  attr_val;
			}
			if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_IN_RESPONSE_TO))
			{
				response->request_response_id =  attr_val;
			}
			else if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_MAJORVERSION))
			{
				response->major_version = attr_val;
			}
			else if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_MINORVERSION))
			{
				response->minor_version = attr_val;
			}
			else if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_ISSUE_INSTANT))
			{
				response->issue_instant = axutil_date_time_create(env);
				axutil_date_time_deserialize_date(response->issue_instant, env, attr_val);
			}
			else if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_RECEPIENT))
			{
				response->recepient = attr_val;
			}
		}
	}

	iterator = axiom_element_get_child_elements(element, env, node);
	if(iterator)
	{
		while(axiom_child_element_iterator_has_next(iterator, env))
		{
		
			axis2_char_t *t = NULL;
			child_node = axiom_child_element_iterator_next(iterator, env);
			element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
			t = axiom_node_to_string(child_node, env);
			if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env),
																		SAML_SIGNATURE)))
			{
				response->signature = child_node;
			}
			else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), 
																		SAML_STATUS)))
			{
				response->status = (saml_status_t*)AXIS2_MALLOC(env->allocator,
															sizeof(saml_status_t));
				if(response->status)
				{
					saml_status_build(response->status, child_node, env);
				}
			}
			else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), 
																		SAML_ASSERTION)))
			{
				assertion = saml_assertion_create(env);
				if(assertion)
				{
					saml_assertion_build(assertion, child_node, env);
					axutil_array_list_add(response->saml_assertions, env, assertion);
				}
			}
		
		}

	}

	return AXIS2_SUCCESS;



}

AXIS2_EXTERN axiom_node_t* AXIS2_CALL saml_response_to_om(saml_response_t *response, 
														  axiom_node_t *parent, 
														  const axutil_env_t *env)
{
	int size = 0, i = 0;
	axiom_element_t *e = NULL;
	axiom_node_t *n = NULL;	
	axiom_namespace_t *ns = NULL;
	axiom_attribute_t *attr = NULL;
	saml_assertion_t *assertion = NULL;
	axis2_char_t *t = NULL;
	ns = axiom_namespace_create(env, SAML_PROTOCOL_NMSP, SAML_PROTOCOL_PREFIX);
	e = axiom_element_create(env, parent, SAML_RESPONSE, ns, &n);
	
	if(e)
	{
		if(response->minor_version && response->issue_instant)
		{
			if(!response->response_id)
				response->response_id = saml_id_generate_random_bytes(env);
			attr = axiom_attribute_create(env, SAML_RESPONSE_ID, response->response_id, NULL);
			axiom_element_add_attribute(e, env, attr, n);
			
			attr = axiom_attribute_create(env, SAML_MAJORVERSION, SAML_MAJOR_VERSION, NULL);
			axiom_element_add_attribute(e, env, attr, n);
			
			attr = axiom_attribute_create(env, SAML_MINORVERSION, response->minor_version, NULL);
			axiom_element_add_attribute(e, env, attr, n);

			attr = axiom_attribute_create(env, SAML_ISSUE_INSTANT, axutil_date_time_serialize_date_time(response->issue_instant, env), NULL);
			axiom_element_add_attribute(e, env, attr, n);
		}
		else
		{
			return NULL;
		}
		t = axiom_node_to_string(n, env);
		if(response->request_response_id && response->recepient)
		{
			attr = axiom_attribute_create(env, SAML_IN_RESPONSE_TO, response->request_response_id, NULL);
			axiom_element_add_attribute(e, env, attr, n);
			attr = axiom_attribute_create(env, SAML_RECEPIENT, response->recepient, NULL);
			axiom_element_add_attribute(e, env, attr, n);
		
		}
		t = axiom_node_to_string(n, env);

		if(response->saml_assertions)
		{
			size = axutil_array_list_size(response->saml_assertions, env);

			for(i = 0 ; i < size ; i++)
			{
				assertion = (saml_assertion_t*)axutil_array_list_get(response->saml_assertions, env, i);
				if(assertion)
					saml_assertion_to_om(assertion, n, env);

			}
		}
		if(response->status)
		{
			saml_status_to_om(response->status, n, env);
		}
		if(response->sig_ctx)
		{
			saml_response_sign(response, n, env);		
		}
	}
	return n;


}
AXIS2_EXTERN axis2_char_t* AXIS2_CALL saml_response_get_id(saml_response_t *response, const axutil_env_t *env)
{
	if(response)
	{
		return response->response_id;
	}
	else
		return NULL;
}
AXIS2_EXTERN int AXIS2_CALL saml_response_set_major_version(saml_response_t *response, const axutil_env_t *env, int version)
{
	if(response->major_version)
	{
		AXIS2_FREE(env->allocator,response->major_version);
	}
	response->minor_version = AXIS2_MALLOC(env->allocator,8);
	sprintf(response->major_version, "%d", version);	
	return AXIS2_SUCCESS;
}

AXIS2_EXTERN int AXIS2_CALL saml_response_set_minor_version(saml_response_t *response, const axutil_env_t *env, int version)
{
	if(response->minor_version)
	{
		AXIS2_FREE(env->allocator,response->minor_version);
	}
	response->minor_version = AXIS2_MALLOC(env->allocator, 8);
	sprintf(response->minor_version, "%d", version);	
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN int AXIS2_CALL saml_response_set_issue_instant(saml_response_t *response, const axutil_env_t *env, axutil_date_time_t *date_time)
{
	if(response->issue_instant)
	{
		axutil_date_time_free(response->issue_instant, env);
	}
	response->issue_instant = date_time;
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN axutil_date_time_t* AXIS2_CALL saml_response_get_issue_instant(saml_response_t *response, const axutil_env_t *env)
{
	if(response)
		return response->issue_instant;
	else
		return NULL;
}

AXIS2_EXTERN int AXIS2_CALL saml_response_set_recepient(saml_response_t *response, const axutil_env_t *env, axis2_char_t *recepient)
{
	if(response->recepient)
	{
		AXIS2_FREE(env->allocator, response->issue_instant);
	}
	response->recepient= axutil_strdup(env, recepient);
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_char_t* AXIS2_CALL saml_response_get_recepient(saml_response_t *response, const axutil_env_t *env)
{
	if(response)
		return response->recepient;
	else
		return NULL;
}

AXIS2_EXTERN int AXIS2_CALL saml_response_set_status(saml_response_t *response, const axutil_env_t *env, saml_status_t *status)
{
	if(response->status)
	{
		saml_status_free(response->status, env);
	}
	response->status = status;
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN saml_status_t* AXIS2_CALL saml_response_get_status(saml_response_t *response, const axutil_env_t *env)
{
	if(response)
		return response->status;
	else
		return NULL;
}

AXIS2_EXTERN int AXIS2_CALL saml_response_set_assertions(saml_response_t *response, const axutil_env_t *env, axutil_array_list_t *assertions)
{
	int size = 0, i = 0;
	saml_assertion_t *assert = NULL;
	if(response->saml_assertions)
	{
		size = axutil_array_list_size(response->saml_assertions, env);
		for(i = 0; i < size; i++)
		{
			assert = (saml_assertion_t*)axutil_array_list_get(response->saml_assertions, env, i);
			if(assert)
				saml_assertion_free(assert, env);
		}
		axutil_array_list_free(response->saml_assertions, env);
	}
	response->saml_assertions = assertions;
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN axutil_array_list_t*  AXIS2_CALL saml_response_get_assertions(saml_response_t *response, const axutil_env_t *env)
{
	if(response)
		return response->saml_assertions;
	else
		return NULL;
}

AXIS2_EXTERN int AXIS2_CALL saml_response_add_assertion(saml_response_t *response, const axutil_env_t *env, saml_assertion_t *assertion)
{
	if(!response->saml_assertions)
	{
		axutil_array_list_create(env, SAML_ARRAY_LIST_DEF);
	}
	axutil_array_list_add(response->saml_assertions, env, assertion);
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN int AXIS2_CALL saml_response_remove_assertion(saml_response_t *response, const axutil_env_t *env, int index)
{
	saml_assertion_t *assert;
	if(response->saml_assertions)
	{
		assert = axutil_array_list_remove(response->saml_assertions, env, index);
		if(assert)
		{
			saml_assertion_free(assert, env);
		}
		
	}
	return AXIS2_FAILURE;
}
AXIS2_EXTERN int AXIS2_CALL saml_response_set_in_reponses_to(saml_response_t *response, const axutil_env_t *env, axis2_char_t *request_response)
{
	if(response->request_response_id)
	{
		AXIS2_FREE(env->allocator,response->request_response_id);
	}
	response->request_response_id = axutil_strdup(env, request_response);
	return AXIS2_SUCCESS;
}

AXIS2_EXTERN axis2_char_t* AXIS2_CALL saml_response_get_in_reponses_to(saml_response_t *response, const axutil_env_t *env)
{
	if(response)
		return response->request_response_id;
	else
		return NULL;
}
AXIS2_EXTERN int AXIS2_CALL saml_response_set_signature(saml_response_t *response, const axutil_env_t *env, oxs_sign_ctx_t *sig_ctx)
{
	if(response->sig_ctx)
	{
		oxs_sign_ctx_free(response->sig_ctx, env);
	}
	response->sig_ctx = sig_ctx;
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN int AXIS2_CALL saml_response_unset_signature(saml_response_t *response, const axutil_env_t *env)
{
	if(response->sig_ctx)
	{
		oxs_sign_ctx_free(response->sig_ctx, env);
	}
	response->sig_ctx = NULL;
	return AXIS2_SUCCESS;
}
AXIS2_EXTERN int AXIS2_CALL saml_response_sign(saml_response_t *response, axiom_node_t *node, const axutil_env_t *env)
{
	 axiom_node_t *n= NULL;
	 axis2_char_t *id = NULL;	 
	 oxs_sign_part_t* sig_part = NULL;
	 axutil_array_list_t *sig_parts = NULL;
	 int size = 0, i = 0;

	 sig_parts = oxs_sign_ctx_get_sign_parts(response->sig_ctx, env);
	 if(sig_parts)
	 {
		 size = axutil_array_list_size(sig_parts, env);
		 for(i = 0; i < size; i++)
		 {
			sig_part = axutil_array_list_get(sig_parts, env, i);
			if(sig_part)
			{
				oxs_sign_part_set_node(sig_part, env, node);
			}
		 }
	 }
	id = axiom_node_to_string(node, env);
	 oxs_xml_sig_sign(env, response->sig_ctx, node, &n);
	id = axiom_node_to_string(node, env);
	id = axiom_node_to_string(n, env);

     /*Finally build KeyInfo*/
	 oxs_xml_key_info_build(env, n, oxs_sign_ctx_get_certificate(response->sig_ctx, env), OXS_KIBP_X509DATA_X509CERTIFICATE);
	 return AXIS2_SUCCESS;
}
AXIS2_EXTERN void AXIS2_CALL saml_response_set_default_signature(saml_response_t *response, const axutil_env_t *env, oxs_sign_ctx_t *sig_ctx)
{
	if(response->sig_ctx)
	{
		oxs_sign_ctx_free(response->sig_ctx, env);
	}
	response->sig_ctx = sig_ctx;
	saml_util_set_sig_ctx_defaults(response->sig_ctx, env, SAML_RESPONSE_ID);
}
AXIS2_EXTERN int AXIS2_CALL saml_status_set_status_code(saml_status_t *status, const axutil_env_t *env, axis2_char_t *code)
{
	if(status->status_code)
	{
		AXIS2_FREE(env->allocator, status->status_code);
	}
	status->status_code = axutil_strdup(env, code);
	return AXIS2_SUCCESS;
}

AXIS2_EXTERN int AXIS2_CALL
saml_response_signature_verify(saml_response_t *response, const axutil_env_t *env)
{			
	return oxs_xml_sig_verify(env, response->sig_ctx, response->signature, response->original_xml);
}

AXIS2_EXTERN int AXIS2_CALL
saml_response_is_sign_set(saml_response_t *response, const axutil_env_t *env)
{
	if (response->sig_ctx)
	{
		return AXIS2_TRUE;
	}
	return AXIS2_FALSE;
}

AXIS2_EXTERN int AXIS2_CALL
saml_response_is_signed(saml_response_t *response, const axutil_env_t *env)
{
	if (response->signature)
	{
		return AXIS2_TRUE;
	}
	return AXIS2_FALSE;
}