axis2_status_t
axis2_addr_in_extract_svc_grp_ctx_id(
const axutil_env_t * env,
axiom_soap_header_t * soap_header,
axis2_msg_ctx_t * msg_ctx)
{
axiom_node_t *node = NULL;
axiom_element_t *element = NULL;
node = axiom_soap_header_get_base_node(soap_header, env);
if (node && axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
{
axutil_qname_t *qname = NULL;
element = (axiom_element_t *) axiom_node_get_data_element(node, env);
qname = axutil_qname_create(env, AXIS2_SVC_GRP_ID, AXIS2_NAMESPACE_URI,
AXIS2_NAMESPACE_PREFIX);
if (qname)
{
axiom_node_t *child_node = NULL;
axiom_element_t *child_element = NULL;
child_element =
axiom_element_get_first_child_with_qname(element, env, qname,
node, &child_node);
if (child_element)
{
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_char_t *grp_id =
axiom_element_get_text(child_element, env,
child_node);
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
if (conf_ctx && grp_id)
{
axutil_string_t *svc_grp_ctx_id_str =
axutil_string_create(env, grp_id);
axis2_svc_grp_ctx_t *svc_ctx_grp_ctx =
axis2_conf_ctx_get_svc_grp_ctx(conf_ctx, env, grp_id);
if (!svc_ctx_grp_ctx)
{
return AXIS2_FAILURE;
}
axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env,
svc_grp_ctx_id_str);
axutil_string_free(svc_grp_ctx_id_str, env);
return AXIS2_SUCCESS;
}
}
}
axutil_qname_free(qname, env);
}
return AXIS2_FAILURE;
}
axis2_char_t* AXIS2_CALL
sandesha2_rm_elements_get_addr_ns_val_from_env(
const axutil_env_t *env,
axiom_soap_envelope_t *soap_envelope,
axis2_char_t *action)
{
axiom_soap_header_t *soap_header = NULL;
AXIS2_PARAM_CHECK(env->error, soap_envelope, NULL);
AXIS2_PARAM_CHECK(env->error, action, NULL);
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
if(soap_header)
{
axutil_array_list_t *headers = NULL;
axiom_node_t *soap_header_node = NULL;
axiom_element_t *soap_header_element = NULL;
axiom_namespace_t *addr_ns = NULL;
headers = axiom_soap_header_get_header_blocks_with_namespace_uri(
soap_header, env, AXIS2_WSA_NAMESPACE);
if(headers && 0 < axutil_array_list_size(headers, env))
{
axutil_array_list_free(headers, env);
return AXIS2_WSA_NAMESPACE;
}
headers = axiom_soap_header_get_header_blocks_with_namespace_uri(
soap_header, env, AXIS2_WSA_NAMESPACE_SUBMISSION);
if(headers && 0 < axutil_array_list_size(headers, env))
{
axutil_array_list_free(headers, env);
return AXIS2_WSA_NAMESPACE_SUBMISSION;
}
if(headers)
axutil_array_list_free(headers, env);
soap_header_node = axiom_soap_header_get_base_node(soap_header, env);
soap_header_element = axiom_node_get_data_element(soap_header_node,
env);
addr_ns = axiom_element_get_namespace(soap_header_element, env,
soap_header_node);
if(addr_ns)
{
axis2_char_t *str_addr_ns = axiom_namespace_get_uri(addr_ns, env);
return str_addr_ns;
}
}
return NULL;
}
axis2_status_t AXIS2_CALL
sandesha2_rm_elements_from_soap_envelope(
sandesha2_rm_elements_t *rm_elements,
const axutil_env_t *env,
axiom_soap_envelope_t *soap_envelope,
axis2_char_t *action)
{
axiom_soap_header_t *soap_header = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_node_t *header_node = NULL;
axiom_element_t *body_element = NULL;
axiom_node_t *body_node = NULL;
axiom_element_t *header_element = NULL;
axiom_node_t *seq_node = NULL;
axiom_element_t *seq_ack_element = NULL;
axiom_node_t *seq_ack_node = NULL;
axiom_node_t *create_seq_node = NULL;
axiom_node_t *create_seq_res_node = NULL;
axiom_node_t *terminate_seq_node = NULL;
axiom_node_t *terminate_seq_res_node = NULL;
axiom_node_t *close_seq_node = NULL;
axiom_node_t *close_seq_res_node = NULL;
axiom_node_t *ack_requested_node = NULL;
axiom_node_t *make_conn_node = NULL;
axiom_node_t *msg_pending_node = NULL;
axutil_qname_t *qname = NULL;
axis2_char_t *rm_ns_val = NULL;
axis2_char_t *addr_ns_val = NULL;
AXIS2_PARAM_CHECK(env->error, soap_envelope, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, action, AXIS2_FAILURE);
rm_ns_val = sandesha2_rm_elements_get_rm_ns_val(env, soap_envelope, action);
if(!rm_ns_val)
return AXIS2_SUCCESS;
addr_ns_val = sandesha2_rm_elements_get_addr_ns_val_from_env(env,
soap_envelope, action);
if(!addr_ns_val)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2]Cannot find the addressing version");
return AXIS2_FAILURE;
}
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
header_node = axiom_soap_header_get_base_node(soap_header, env);
header_element = axiom_node_get_data_element(header_node, env);
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
body_node = axiom_soap_body_get_base_node(soap_body, env);
body_element = axiom_node_get_data_element(body_node, env);
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_SEQ, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(header_element, env,
qname, header_node, &seq_node);
if(qname)
axutil_qname_free(qname, env);
if(seq_node)
{
rm_elements->seq = sandesha2_seq_create(env, rm_ns_val);
sandesha2_seq_from_om_node(
rm_elements->seq, env, seq_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_SEQ_ACK, rm_ns_val,
NULL);
seq_ack_element = axiom_element_get_first_child_with_qname(header_element,
env, qname, header_node, &seq_ack_node);
if(qname)
axutil_qname_free(qname, env);
if(seq_ack_element)
{
rm_elements->seq_ack = sandesha2_seq_ack_create(env, rm_ns_val);
sandesha2_seq_ack_from_om_node(
rm_elements->seq_ack, env, seq_ack_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_CREATE_SEQ, rm_ns_val,
NULL);
axiom_element_get_first_child_with_qname(body_element,
env, qname, body_node, &create_seq_node);
if(qname)
axutil_qname_free(qname, env);
if(create_seq_node)
{
rm_elements->create_seq = sandesha2_create_seq_create(env,
addr_ns_val, rm_ns_val);
sandesha2_create_seq_from_om_node(
rm_elements->create_seq, env, create_seq_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_CREATE_SEQ_RESPONSE, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &create_seq_res_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(create_seq_res_node)
{
rm_elements->create_seq_res = sandesha2_create_seq_res_create(env, rm_ns_val, addr_ns_val);
sandesha2_create_seq_res_from_om_node(rm_elements->create_seq_res, env, create_seq_res_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_TERMINATE_SEQ, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &terminate_seq_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(terminate_seq_node)
{
rm_elements->terminate_seq = sandesha2_terminate_seq_create(env, rm_ns_val);
sandesha2_terminate_seq_from_om_node(rm_elements->terminate_seq, env, terminate_seq_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_TERMINATE_SEQ_RESPONSE, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &terminate_seq_res_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(terminate_seq_res_node)
{
rm_elements->terminate_seq_res = sandesha2_terminate_seq_res_create(env, rm_ns_val);
sandesha2_terminate_seq_res_from_om_node(rm_elements->terminate_seq_res, env,
terminate_seq_res_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_CLOSE_SEQ, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &close_seq_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(close_seq_node)
{
rm_elements->close_seq = sandesha2_close_seq_create(env, rm_ns_val);
sandesha2_close_seq_from_om_node(rm_elements->close_seq, env, close_seq_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_CLOSE_SEQ_RESPONSE, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &close_seq_res_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(close_seq_res_node)
{
rm_elements->close_seq_res = sandesha2_close_seq_res_create(env, rm_ns_val);
sandesha2_close_seq_res_from_om_node(rm_elements->close_seq_res, env, close_seq_res_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_MAKE_CONNECTION, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(body_element, env, qname,
body_node, &make_conn_node);
if(qname)
{
axutil_qname_free(qname, env);
}
if(make_conn_node)
{
rm_elements->make_connection = sandesha2_make_connection_create(env, rm_ns_val);
sandesha2_make_connection_from_om_node(rm_elements->make_connection, env, make_conn_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_ACK_REQUESTED, rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(header_element, env, qname, header_node, &ack_requested_node);
if(qname)
axutil_qname_free(qname, env);
if(ack_requested_node)
{
rm_elements->ack_requested = sandesha2_ack_requested_create(env,
rm_ns_val);
sandesha2_ack_requested_from_om_node(
rm_elements->ack_requested, env, ack_requested_node);
}
qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_MESSAGE_PENDING,
rm_ns_val, NULL);
axiom_element_get_first_child_with_qname(header_element, env, qname, header_node, &msg_pending_node);
if(qname)
axutil_qname_free(qname, env);
if(msg_pending_node)
{
rm_elements->msg_pending = sandesha2_msg_pending_create(env,
rm_ns_val);
sandesha2_msg_pending_from_om_node(
rm_elements->msg_pending, env, msg_pending_node);
}
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
wsf_xml_msg_recv_invoke_business_logic_sync(
axis2_msg_recv_t * msg_recv,
const axutil_env_t * env,
axis2_msg_ctx_t * in_msg_ctx,
axis2_msg_ctx_t * out_msg_ctx)
{
axis2_op_ctx_t *op_ctx = NULL;
axis2_op_t *op_desc = NULL;
axiom_namespace_t *env_ns = NULL;
int soap_version = AXIOM_SOAP12;
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t skel_invoked = AXIS2_FALSE;
const axis2_char_t *style = NULL;
axis2_char_t *local_name = NULL;
axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
axis2_char_t *operation_name = NULL;
char *classname = NULL;
axutil_property_t *svc_info_prop = NULL;
axutil_property_t *req_info_prop = NULL;
wsf_svc_info_t *svc_info = NULL;
wsf_request_info_t *req_info = NULL;
/** store in_msg_ctx envelope */
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
axiom_node_t *in_body_node = NULL;
/* store out_msg_ctx envelope */
axiom_soap_envelope_t *default_envelope = NULL;
axiom_soap_body_t *out_body = NULL;
axiom_soap_header_t *out_header = NULL;
axiom_soap_fault_t *out_soap_fault = NULL;
axiom_node_t *result_node = NULL;
axiom_node_t *out_body_content_node = NULL;
axiom_element_t *out_body_content_element = NULL;
axiom_node_t *out_node = NULL;
zval **output_headers_zval = NULL;
TSRMLS_FETCH();
AXIS2_PARAM_CHECK(env->error, in_msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, out_msg_ctx, AXIS2_FAILURE);
op_ctx = axis2_msg_ctx_get_op_ctx(in_msg_ctx, env);
op_desc = axis2_op_ctx_get_op(op_ctx, env);
style = axis2_op_get_style(op_desc, env);
envelope = axis2_msg_ctx_get_soap_envelope(in_msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
in_body_node = axiom_soap_body_get_base_node(body, env);
if (0 == axutil_strcmp(AXIS2_STYLE_DOC, style))
{
local_name = wsf_xml_msg_recv_get_method_name(in_msg_ctx, env);
if (!local_name)
{
return AXIS2_FAILURE;
}
} else if (0 == axutil_strcmp(AXIS2_STYLE_RPC, style))
{
axiom_node_t *op_node = NULL;
axiom_element_t *op_element = NULL;
op_node = axiom_node_get_first_child(in_body_node, env);
if (!op_node)
{
return AXIS2_FAILURE;
}
op_element = axiom_node_get_data_element(op_node, env);
if (!op_element)
{
return AXIS2_FAILURE;
}
local_name = axiom_element_get_localname(op_element, env);
if (!local_name)
{
return AXIS2_FAILURE;
}
}
/** set soap version and soap namespace to local variables */
if (in_msg_ctx && axis2_msg_ctx_get_is_soap_11(in_msg_ctx, env))
{
soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */
soap_version = AXIOM_SOAP11;
}
svc_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_SVC_INFO);
if (svc_info_prop)
{
svc_info = (wsf_svc_info_t *) axutil_property_get_value(svc_info_prop, env);
if (svc_info)
{
operation_name = axutil_hash_get(svc_info->ops_to_functions, local_name,
AXIS2_HASH_KEY_STRING);
if (!operation_name)
{
return AXIS2_FAILURE;
}
} else
{
return AXIS2_FAILURE;
}
if (svc_info->ops_to_classes)
{
classname = axutil_hash_get(svc_info->ops_to_classes, local_name, AXIS2_HASH_KEY_STRING);
}
}
req_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_REQ_INFO);
if (req_info_prop)
{
req_info = (wsf_request_info_t *) axutil_property_get_value(req_info_prop, env);
if (axis2_msg_ctx_get_doing_rest(in_msg_ctx, env))
{
axis2_op_t *op = NULL;
axiom_node_t *body_child_node = NULL;
axiom_element_t *body_child = NULL;
int i = 0;
body_child_node = axiom_node_get_first_child(in_body_node, env);
if (!body_child_node)
{
op = axis2_msg_ctx_get_op(in_msg_ctx, env);
if (op)
{
body_child = axiom_element_create_with_qname(env, NULL,
axis2_op_get_qname(op, env), &body_child_node);
axiom_soap_body_add_child(body, env, body_child_node);
}
}
if (req_info->param_keys && req_info->param_values)
{
int i = 0;
for (i = 0; i < axutil_array_list_size(req_info->param_keys, env); i++)
{
axiom_node_t *node = NULL;
axiom_element_t *element = NULL;
axis2_char_t *param_key = NULL;
axis2_char_t *param_value = NULL;
param_key = axutil_array_list_get(req_info->param_keys, env, i);
param_value = axutil_array_list_get(req_info->param_values, env, i);
element = axiom_element_create(env, NULL, param_key,
NULL, &node);
axiom_element_set_text(element, env, param_value, node);
axiom_node_add_child(body_child_node, env, node);
AXIS2_FREE(env->allocator, param_key);
AXIS2_FREE(env->allocator, param_value);
}
axutil_array_list_free(req_info->param_keys, env);
axutil_array_list_free(req_info->param_values, env);
}
}
}
if (svc_info->ht_op_params)
{
zval **tmp;
char *function_type = NULL;
if (zend_hash_find(svc_info->ht_op_params,
operation_name, strlen(operation_name) + 1,
(void **) & tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING)
{
function_type = Z_STRVAL_PP(tmp);
if (strcmp(function_type, WSF_MIXED) == 0)
{
result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info,
in_msg_ctx, out_msg_ctx, operation_name,
classname, &output_headers_zval TSRMLS_CC);
} else if (strcmp(function_type, WSF_WSMESSAGE) == 0)
{
result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name,
in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC);
}
}
} else
{
/* this is where the default value for opParam is set,
If the wsdl option is set go for the MIXED mode by default */
if (svc_info->wsdl == NULL || svc_info->omit_wsdl)
{
result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name,
in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC);
} else
{
result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info,
in_msg_ctx, out_msg_ctx, operation_name,
classname, &output_headers_zval TSRMLS_CC);
}
}
if (!result_node)
{
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
} else
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "Response node is not null");
}
if (result_node)
{
if (0 == axutil_strcmp(style, AXIS2_STYLE_RPC))
{
axiom_namespace_t *ns = NULL;
axis2_char_t *response_name = NULL;
response_name = axutil_stracat(env, local_name, "Response");
ns = axiom_namespace_create(env, "http://soapenc/", "res");
if (!ns)
{
return AXIS2_FAILURE;
}
out_body_content_element = axiom_element_create(env, NULL, response_name,
ns, &out_body_content_node);
axiom_node_add_child(out_body_content_node, env, result_node);
} else
{
out_body_content_node = result_node;
}
}
if (axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env))
{
/* service implementation has set the envelope, useful when setting a SOAP fault.
No need to further process */
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "soap fault is set");
return AXIS2_SUCCESS;
}
/* create the soap envelope here */
env_ns = axiom_namespace_create(env, soap_ns, AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
if (!env_ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] error seting the namespces for the "
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
return AXIS2_FAILURE;
}
default_envelope = axiom_soap_envelope_create(env, env_ns);
if (!default_envelope)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap envelope");
return AXIS2_FAILURE;
}
out_body = axiom_soap_body_create_with_parent(env, default_envelope);
if (!out_body)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in creating the response soap body");
return AXIS2_FAILURE;
}
out_header = axiom_soap_header_create_with_parent(env, default_envelope);
if (!out_header)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap headers");
return AXIS2_FAILURE;
}
if (output_headers_zval)
{
axiom_node_t *header_base_node = NULL;
HashPosition pos;
zval **param;
char *header_str;
axiom_node_t *header_node;
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(output_headers_zval), &pos);
zend_hash_get_current_data_ex(Z_ARRVAL_PP(output_headers_zval),
(void **) & param, &pos) == SUCCESS;
zend_hash_move_forward_ex(Z_ARRVAL_PP(output_headers_zval), &pos))
{
if (Z_TYPE_PP(param) == IS_STRING)
{
header_base_node = axiom_soap_header_get_base_node(out_header, env);
if (header_base_node)
{
header_str = Z_STRVAL_PP(param);
header_node = wsf_util_deserialize_buffer(env, header_str);
axiom_node_add_child(header_base_node, env, header_node);
} else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap headers node");
return AXIS2_FAILURE;
}
}
}
}
out_node = axiom_soap_body_get_base_node(out_body, env);
if (!out_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap body node");
return AXIS2_FAILURE;
}
if (status != AXIS2_SUCCESS)
{
/* something went wrong, set a SOAP Fault */
axis2_char_t *fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER;
axis2_char_t *fault_reason_str = NULL;
axis2_char_t *err_msg = NULL;
if (!skel_invoked)
fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER;
;
err_msg = (char *) AXIS2_ERROR_GET_MESSAGE(env->error);
if (err_msg)
{
fault_reason_str = err_msg;
} else
{
fault_reason_str = "Error occurred while processing SOAP message";
}
out_soap_fault = axiom_soap_fault_create_default_fault(env, out_body,
fault_value_str, fault_reason_str, soap_version);
}
if (out_body_content_node)
{
axiom_node_add_child(out_node, env, out_body_content_node);
status = axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env,
default_envelope);
} else if (out_soap_fault)
{
axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, default_envelope);
status = AXIS2_FAILURE; /* if there is a failure we have to return a failure code */
} else
{
/* we should free the memory as the envelope is not used, one way case */
axiom_soap_envelope_free(default_envelope, env);
default_envelope = NULL;
}
return AXIS2_SUCCESS;
}
static int
ngx_squ_xml_serialize(squ_State *l)
{
int top;
char *uri, *prefix;
axiom_node_t *node;
axutil_env_t *env;
axutil_log_t *log;
axutil_error_t *error;
axiom_output_t *output;
ngx_squ_thread_t *thr;
axiom_namespace_t *ns;
axiom_soap_body_t *body;
axutil_allocator_t *a;
axiom_xml_writer_t *writer;
axiom_soap_header_t *header;
axiom_soap_envelope_t *envelope;
thr = ngx_squ_thread(l);
ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml serialize");
top = squ_gettop(l);
if (!squ_istable(l, top)) {
return squL_error(l, "invalid argument, must be a table");
}
a = ngx_squ_axis2c_allocator_create(thr);
log = ngx_squ_axis2c_log_create(thr);
error = axutil_error_create(a);
env = axutil_env_create_with_error_log(a, error, log);
squ_getfield(l, top, "uri");
uri = (char *) squL_optstring(l, -1,
"http://www.w3.org/2003/05/soap-envelope");
squ_getfield(l, top, "prefix");
prefix = (char *) squL_optstring(l, -1, "soap");
ns = axiom_namespace_create(env, uri, prefix);
envelope = axiom_soap_envelope_create(env, ns);
squ_getfield(l, top, "header");
if (!squ_isnil(l, -1)) {
if (!squ_istable(l, -1)) {
return squL_error(l, "the value of \"header\" must be a table");
}
header = axiom_soap_header_create_with_parent(env, envelope);
node = axiom_soap_header_get_base_node(header, env);
ngx_squ_xml_serialize_tables(l, env, node);
}
squ_getfield(l, top, "body");
if (!squ_isnil(l, -1)) {
if (!squ_istable(l, -1)) {
return squL_error(l, "the value of \"body\" must be a table");
}
body = axiom_soap_body_create_with_parent(env, envelope);
node = axiom_soap_body_get_base_node(body, env);
ngx_squ_xml_serialize_tables(l, env, node);
}
squ_settop(l, top);
writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE,
AXIS2_FALSE,
AXIS2_XML_PARSER_TYPE_BUFFER);
output = axiom_output_create(env, writer);
axiom_soap_envelope_serialize(envelope, env, output, AXIS2_FALSE);
squ_pushstring(l, axiom_xml_writer_get_xml(writer, env));
return 1;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rampart_shb_build_message(
const axutil_env_t *env,
axis2_msg_ctx_t *msg_ctx,
rampart_context_t *rampart_context,
axiom_soap_envelope_t *soap_envelope)
{
axis2_status_t status = AXIS2_SUCCESS;
axiom_soap_header_t *soap_header = NULL;
axiom_node_t *soap_header_node = NULL;
axiom_element_t *soap_header_ele = NULL;
axiom_soap_header_block_t *sec_header_block = NULL;
axiom_namespace_t *sec_ns_obj = NULL;
axiom_node_t *sec_node = NULL;
axiom_element_t *sec_ele = NULL;
axis2_bool_t server_side = AXIS2_FALSE;
/*
* sign parts list. Moved this up the building process. This was originally
* in the rampart_sig_sign_message
*/
axutil_array_list_t *sign_parts_list = NULL;
AXIS2_ENV_CHECK(env,AXIS2_FAILURE);
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
soap_header_node = axiom_soap_header_get_base_node(soap_header, env);
soap_header_ele = (axiom_element_t *)axiom_node_get_data_element(
soap_header_node, env);
sec_ns_obj = axiom_namespace_create(env, RAMPART_WSSE_XMLNS,
RAMPART_WSSE);
sec_header_block = axiom_soap_header_add_header_block(soap_header,
env, RAMPART_SECURITY, sec_ns_obj); /* sec_ns_obj is cloned there */
server_side = axis2_msg_ctx_get_server_side(msg_ctx, env);
if(!sec_header_block)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Security header block is NULL");
axiom_namespace_free(sec_ns_obj, env);
return AXIS2_SUCCESS;
}
axiom_soap_header_block_set_must_understand_with_bool(sec_header_block,
env, AXIS2_TRUE);
sec_node = axiom_soap_header_block_get_base_node(sec_header_block, env);
sec_ele = (axiom_element_t *)
axiom_node_get_data_element(sec_node, env);
sign_parts_list = axutil_array_list_create(env, 4);
/*Timestamp Inclusion*/
if(rampart_context_is_include_timestamp(rampart_context,env))
{
int ttl = -1;
axis2_bool_t need_millisecond = AXIS2_TRUE;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Building Timestamp Token");
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Using default timeToLive value %d",
RAMPART_TIMESTAMP_TOKEN_DEFAULT_TIME_TO_LIVE);
ttl = rampart_context_get_ttl(rampart_context,env);
need_millisecond = rampart_context_get_need_millisecond_precision(rampart_context, env);
status = rampart_timestamp_token_build(env, sec_node, ttl, need_millisecond);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart][shb] Timestamp Token build failed. ERROR");
axiom_namespace_free(sec_ns_obj, env);
return AXIS2_FAILURE;
}
}
/*Check whether we need username token*/
/*User name tokens includes in messages sent from client to server*/
if(!axis2_msg_ctx_get_server_side(msg_ctx,env))
{
if(rampart_context_is_include_username_token(rampart_context,env))
{
/*Now we are passing rampart_context here so inside this method
relevant parameters are extracted. */
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Building UsernameToken");
status = rampart_username_token_build(
env,
rampart_context,
sec_node,
sec_ns_obj);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart][shb] UsernameToken build failed. ERROR");
axiom_namespace_free(sec_ns_obj, env);
return AXIS2_FAILURE;
}
}
}
/*Custom tokens are included if its available in the rampart context*/
if(!axis2_msg_ctx_get_server_side(msg_ctx,env))
{
axutil_array_list_t *token_list = NULL;
token_list = rampart_context_get_custom_tokens(rampart_context, env);
if(token_list){
int size = 0, i = 0;
size = axutil_array_list_size(token_list, env);
for (i = 0; i < size; i++){
axiom_node_t *token_node = NULL;
token_node = (axiom_node_t*)axutil_array_list_get(token_list, env, i);
if(token_node){
axis2_status_t status = AXIS2_FAILURE;
status = axiom_node_add_child(sec_node, env, token_node);
if(status != AXIS2_SUCCESS){
return AXIS2_FAILURE;
}
}
}
}
}
if (rampart_context_is_include_supporting_token(rampart_context, env, server_side, AXIS2_FALSE, RP_PROPERTY_SAML_TOKEN))
{
status = rampart_saml_supporting_token_build(env, rampart_context, sec_node, sign_parts_list);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart][shb] SAML Supporting token build failed. ERROR");
axutil_array_list_free(sign_parts_list, env);
axiom_namespace_free(sec_ns_obj, env);
return AXIS2_FAILURE;
}
}
if (rampart_context_is_include_supporting_token(rampart_context, env, server_side, AXIS2_FALSE, RP_PROPERTY_ISSUED_TOKEN))
{
status = rampart_issued_supporting_token_build(rampart_context, env, sec_node, sign_parts_list);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart][shb] Issued supporting token build failed. ERROR");
axutil_array_list_free(sign_parts_list, env);
axiom_namespace_free(sec_ns_obj, env);
return AXIS2_FAILURE;
}
}
/*Signature Confirmation support. Only in the server side*/
if(axis2_msg_ctx_get_server_side(msg_ctx,env)){
axis2_bool_t sign_conf_reqd = AXIS2_FALSE;
/*Sign_conf_reqd <- Get from context <- policy*/
sign_conf_reqd = rampart_context_is_sig_confirmation_reqd(rampart_context, env);
if(sign_conf_reqd){
status = rampart_sig_confirm_signature(env, msg_ctx, rampart_context, sec_node);
}
}
/*check the binding*/
if((rampart_context_get_binding_type(rampart_context,env)) == RP_PROPERTY_ASYMMETRIC_BINDING)
{
axis2_status_t status = AXIS2_FAILURE;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Asymmetric Binding. ");
status = rampart_shb_do_asymmetric_binding(env, msg_ctx, rampart_context, soap_envelope, sec_node, sec_ns_obj, sign_parts_list);
axiom_namespace_free(sec_ns_obj, env);
if(AXIS2_FAILURE == status){
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] Asymmetric Binding failed");
if(axis2_msg_ctx_get_server_side(msg_ctx,env)){
AXIS2_ERROR_SET(env->error, RAMPART_ERROR_INVALID_SECURITY , AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] %s", AXIS2_ERROR_GET_MESSAGE(env->error));
rampart_create_fault_envelope(env, RAMPART_FAULT_INVALID_SECURITY,
" Asymmetric Binding failed. Check configurations ", RAMPART_FAULT_IN_POLICY, msg_ctx);
}
axutil_array_list_free(sign_parts_list, env);
return AXIS2_FAILURE;
}else{
axutil_array_list_free(sign_parts_list, env);
return AXIS2_SUCCESS;
}
}
else if((rampart_context_get_binding_type(rampart_context,env)) == RP_PROPERTY_SYMMETRIC_BINDING)
{
axis2_status_t status = AXIS2_FAILURE;
/*Do Symmetric_binding specific things*/
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Symmetric Binding. ");
status = rampart_shb_do_symmetric_binding(env, msg_ctx, rampart_context, soap_envelope, sec_node, sec_ns_obj, sign_parts_list);
axiom_namespace_free(sec_ns_obj, env);
if(AXIS2_FAILURE == status){
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][shb] Symmetric Binding failed");
if(axis2_msg_ctx_get_server_side(msg_ctx,env)){
AXIS2_ERROR_SET(env->error, RAMPART_ERROR_INVALID_SECURITY, AXIS2_FAILURE);
rampart_create_fault_envelope(env, RAMPART_FAULT_INVALID_SECURITY,
" Symmetric Binding failed. Check configurations ", RAMPART_FAULT_IN_POLICY, msg_ctx);
}
axutil_array_list_free(sign_parts_list, env);
return AXIS2_FAILURE;
}else{
axutil_array_list_free(sign_parts_list, env);
return AXIS2_SUCCESS;
}
}
else if((rampart_context_get_binding_type(rampart_context,env)) == RP_PROPERTY_TRANSPORT_BINDING)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][shb] Using transport binding");
axiom_namespace_free(sec_ns_obj, env);
axutil_array_list_free(sign_parts_list, env);
return AXIS2_SUCCESS;
}else{
axutil_array_list_free(sign_parts_list, env);
axiom_namespace_free(sec_ns_obj, env);
return AXIS2_FAILURE;
}
}
axis2_status_t AXIS2_CALL
axis2_addr_out_handler_invoke(
struct axis2_handler * handler,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx)
{
axis2_char_t *addr_ver_from_msg_ctx = NULL;
const axis2_char_t *addr_ns = NULL;
axis2_msg_info_headers_t *msg_info_headers = NULL;
axis2_ctx_t *ctx = NULL;
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_header_t *soap_header = NULL;
axiom_node_t *soap_header_node = NULL;
axiom_element_t *soap_header_ele = NULL;
axis2_endpoint_ref_t *epr_to = NULL;
axis2_endpoint_ref_t *epr_reply_to = NULL;
axis2_endpoint_ref_t *epr_from = NULL;
axis2_endpoint_ref_t *epr_fault_to = NULL;
axutil_property_t *property = NULL;
const axis2_char_t *wsa_action = NULL;
axis2_bool_t set_must_understand = AXIS2_FALSE;
axutil_property_t *must_understand_prop;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log, "Starting addressing out handler");
soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
if(!soap_envelope)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP envelope. Stop processing addressing");
return AXIS2_SUCCESS; /* Can happen in case of ONE-WAY services/clients */
}
msg_info_headers = axis2_msg_ctx_get_msg_info_headers(msg_ctx, env);
if(msg_info_headers)
{
wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env);
}
else
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No addressing in use");
return AXIS2_SUCCESS; /* No addressing in use */
}
if(!wsa_action || !*wsa_action)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No action present. Stop processing addressing");
return AXIS2_SUCCESS; /* If no action present, assume no addressing in use */
}
ctx = axis2_msg_ctx_get_base(msg_ctx, env);
property = axis2_ctx_get_property(ctx, env, AXIS2_WSA_VERSION);
if(property)
{
addr_ver_from_msg_ctx = axutil_property_get_value(property, env);
property = NULL;
}
must_understand_prop = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_ADDR_ADD_MUST_UNDERSTAND_TO_ADDR_HEADERS);
if(must_understand_prop)
{
axis2_char_t *value = axutil_property_get_value(must_understand_prop, env);
if(axutil_strcmp(value, AXIS2_VALUE_TRUE) == 0)
set_must_understand = AXIS2_TRUE;
}
/* Setting version 1.0 as the default addressing namespace */
addr_ns = AXIS2_WSA_NAMESPACE;
if(addr_ver_from_msg_ctx)
{
if(!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ver_from_msg_ctx))
{
addr_ns = AXIS2_WSA_NAMESPACE_SUBMISSION;
}
}
else if(axis2_msg_ctx_get_op_ctx(msg_ctx, env))
{
axis2_op_ctx_t *op_ctx = NULL;
axis2_msg_ctx_t *in_msg_ctx = NULL;
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
if(op_ctx)
{
in_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
}
if(in_msg_ctx)
{
axis2_ctx_t *in_ctx = NULL;
in_ctx = axis2_msg_ctx_get_base(in_msg_ctx, env);
property = axis2_ctx_get_property(in_ctx, env, AXIS2_WSA_VERSION);
if(property)
{
addr_ns = axutil_property_get_value(property, env);
property = NULL;
}
if(!addr_ns || !*addr_ns)
{
addr_ns = AXIS2_WSA_NAMESPACE;
}
}
}
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
if(!soap_header)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP header. Stop processing addressing");
return AXIS2_SUCCESS; /* No SOAP header, so no point proceeding */
}
else
{
/* By this time, we definitely have some addressing information to be sent. This is because,
* we have tested at the start of this whether msg_info_headers are null or not.
* So rather than declaring addressing namespace in each and every addressing header, lets
* define that in the Header itself.
*/
const axis2_char_t *action = NULL;
const axis2_char_t *address = NULL;
const axis2_char_t *svc_group_context_id = NULL;
const axis2_char_t *message_id = NULL;
axis2_relates_to_t *relates_to = NULL;
axiom_node_t *relates_to_header_node = NULL;
axiom_element_t *relates_to_header_ele = NULL;
axiom_namespace_t *addressing_namespace = NULL;
soap_header_node = axiom_soap_header_get_base_node(soap_header, env);
soap_header_ele = (axiom_element_t *)axiom_node_get_data_element(soap_header_node, env);
addressing_namespace = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
axiom_element_declare_namespace(soap_header_ele, env, soap_header_node,
addressing_namespace);
epr_to = axis2_msg_info_headers_get_to(msg_info_headers, env);
if(epr_to)
{
axiom_soap_body_t *body = axiom_soap_envelope_get_body(soap_envelope, env);
if(body)
{
/* In case of a SOAP fault, we got to send the response to
the adress specified by FaultTo */
if(axiom_soap_body_has_fault(body, env))
{
axis2_endpoint_ref_t *epr_fault_to = axis2_msg_info_headers_get_fault_to(
msg_info_headers, env);
if(epr_fault_to)
{
const axis2_char_t *fault_to_address = axis2_endpoint_ref_get_address(
epr_fault_to, env);
if(fault_to_address)
{
if(axutil_strcmp(AXIS2_WSA_NONE_URL, fault_to_address)
&& axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, fault_to_address))
{
axis2_endpoint_ref_set_address(epr_to, env, fault_to_address);
}
}
}
}
}
address = axis2_endpoint_ref_get_address(epr_to, env);
if(address && *address)
{
axiom_node_t *to_header_block_node = NULL;
axiom_soap_header_block_t *to_header_block = NULL;
axutil_array_list_t *ref_param_list = NULL;
int size = 0;
to_header_block = axiom_soap_header_add_header_block(soap_header, env,
AXIS2_WSA_TO, addressing_namespace);
if(set_must_understand == AXIS2_TRUE)
{
axiom_soap_header_block_set_must_understand_with_bool(to_header_block, env, AXIS2_TRUE);
}
to_header_block_node = axiom_soap_header_block_get_base_node(to_header_block, env);
if(to_header_block_node)
{
axiom_element_t *to_header_block_element = NULL;
to_header_block_element = (axiom_element_t *)axiom_node_get_data_element(
to_header_block_node, env);
if(to_header_block_element)
{
axiom_element_set_text(to_header_block_element, env, address,
to_header_block_node);
}
}
ref_param_list = axis2_endpoint_ref_get_ref_param_list(epr_to, env);
size = axutil_array_list_size(ref_param_list, env);
if(ref_param_list && size > 0)
{
axiom_soap_header_block_t *reference_header_block = NULL;
axiom_node_t *reference_node = NULL;
int i = 0;
for(i = 0; i < size; i++)
{
axiom_node_t *temp_node = NULL;
temp_node = (axiom_node_t *)axutil_array_list_get(ref_param_list, env, i);
if(temp_node)
{
axiom_element_t *temp_ele = NULL;
temp_ele = axiom_node_get_data_element(temp_node, env);
if(temp_ele)
{
reference_header_block = axiom_soap_header_add_header_block(
soap_header, env, axiom_element_get_localname(temp_ele, env),
axiom_element_get_namespace(temp_ele, env, temp_node));
if(set_must_understand)
{
axiom_soap_header_block_set_must_understand_with_bool(reference_header_block, env, AXIS2_TRUE);
}
reference_node = axiom_soap_header_block_get_base_node(
reference_header_block, env);
if(reference_node)
{
axiom_element_t *reference_ele = NULL;
reference_ele = (axiom_element_t *)axiom_node_get_data_element(
reference_node, env);
if(reference_ele)
{
axiom_namespace_t *addr_ns_obj = NULL;
axiom_attribute_t *reference_attr = NULL;
addr_ns_obj = axiom_namespace_create(env, addr_ns,
AXIS2_WSA_DEFAULT_PREFIX);
reference_attr = axiom_attribute_create(env,
/*"isReferenceParameter"*/
AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, "true",
addr_ns_obj);
axiom_element_add_attribute(reference_ele, env,
reference_attr, reference_node);
axiom_element_set_text(reference_ele, env,
axiom_element_get_text(temp_ele, env, temp_node),
reference_node);
}
}
}
}
}
}
}
}/* if(epr_to) */
axiom_namespace_free(addressing_namespace, env);
action = axis2_msg_info_headers_get_action(msg_info_headers, env);
if(action && *action)
{
axis2_addr_out_handler_process_string_info(env, action, AXIS2_WSA_ACTION, &soap_header,
addr_ns, set_must_understand);
}
epr_reply_to = axis2_msg_info_headers_get_reply_to(msg_info_headers, env);
if(!epr_reply_to)
{
const axis2_char_t *anonymous_uri = NULL;
axis2_bool_t anonymous = axis2_msg_info_headers_get_reply_to_anonymous(
msg_info_headers, env);
axis2_bool_t none = axis2_msg_info_headers_get_reply_to_none(msg_info_headers, env);
if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION))
{
if(none)
{
anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION;
}
else if(anonymous)
{
anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION;
}
}
else
{
if(none)
{
anonymous_uri = AXIS2_WSA_NONE_URL;
}
else if(anonymous)
{
anonymous_uri = AXIS2_WSA_ANONYMOUS_URL;
}
}
if(anonymous_uri)
{
epr_reply_to = axis2_endpoint_ref_create(env, anonymous_uri);
}
if(epr_reply_to)
{
axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr_reply_to);
}
}
/* add the service group id as a reference parameter */
svc_group_context_id = axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id(msg_ctx,
env), env);
axis2_addr_out_handler_add_to_soap_header(env, epr_reply_to, AXIS2_WSA_REPLY_TO,
soap_header, addr_ns);
epr_from = axis2_msg_info_headers_get_from(msg_info_headers, env);
if(epr_from)
{
axis2_addr_out_handler_add_to_soap_header(env, epr_from, AXIS2_WSA_FROM, soap_header,
addr_ns);
}
epr_fault_to = axis2_msg_info_headers_get_fault_to(msg_info_headers, env);
if(!epr_fault_to)
{
const axis2_char_t *anonymous_uri = NULL;
axis2_bool_t anonymous = axis2_msg_info_headers_get_fault_to_anonymous(
msg_info_headers, env);
axis2_bool_t none = axis2_msg_info_headers_get_fault_to_none(msg_info_headers, env);
if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION))
{
if(none)
{
anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION;
}
else if(anonymous)
{
anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION;
}
}
else
{
if(none)
anonymous_uri = AXIS2_WSA_NONE_URL;
else if(anonymous)
anonymous_uri = AXIS2_WSA_ANONYMOUS_URL;
}
if(anonymous_uri)
{
epr_fault_to = axis2_endpoint_ref_create(env, anonymous_uri);
}
}
if(epr_fault_to)
{
/* optional */
axis2_addr_out_handler_add_to_soap_header(env, epr_fault_to, AXIS2_WSA_FAULT_TO,
soap_header, addr_ns);
}
message_id = axis2_msg_info_headers_get_message_id(msg_info_headers, env);
if(message_id)
{
axis2_addr_out_handler_process_string_info(env, message_id, AXIS2_WSA_MESSAGE_ID,
&soap_header, addr_ns, set_must_understand);
}
relates_to = axis2_msg_info_headers_get_relates_to(msg_info_headers, env);
if(relates_to)
{
const axis2_char_t *value = NULL;
value = axis2_relates_to_get_value(relates_to, env);
relates_to_header_node = axis2_addr_out_handler_process_string_info(env, value,
AXIS2_WSA_RELATES_TO, &soap_header, addr_ns, set_must_understand);
}
if(relates_to_header_node)
{
const axis2_char_t *relationship_type = NULL;
relationship_type = axis2_relates_to_get_relationship_type(relates_to, env);
if(relationship_type && *relationship_type)
{
axiom_attribute_t *om_attr = NULL;
axiom_namespace_t *addr_ns_obj = NULL;
axiom_namespace_t *dec_ns = NULL;
relates_to_header_ele = (axiom_element_t *)axiom_node_get_data_element(
relates_to_header_node, env);
if(relates_to_header_ele)
{
dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env,
addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
if(dec_ns)
{
addr_ns_obj = dec_ns;
}
else
{
addr_ns_obj
= axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
}
if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION))
{
om_attr = axiom_attribute_create(env,
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE,
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION,
addr_ns_obj);
}
else
{
om_attr = axiom_attribute_create(env,
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE,
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE, addr_ns_obj);
}
axiom_element_add_attribute(relates_to_header_ele, env, om_attr,
relates_to_header_node);
dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env,
addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
if(!dec_ns)
{
dec_ns = axiom_element_find_namespace(relates_to_header_ele, env,
relates_to_header_node, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
if(dec_ns)
{
axiom_namespace_free(addr_ns_obj, env);
addr_ns_obj = NULL;
axiom_attribute_set_namespace(om_attr, env, dec_ns);
}
}
}
}
}
}
return AXIS2_SUCCESS;
}
axis2_status_t
axis2_addr_out_handler_add_to_soap_header(
const axutil_env_t * env,
axis2_endpoint_ref_t * endpoint_ref,
const axis2_char_t * type,
axiom_soap_header_t * soap_header,
const axis2_char_t * addr_ns)
{
axiom_soap_header_block_t *header_block = NULL;
const axis2_char_t *address = NULL;
axutil_array_list_t *ref_param_list = NULL;
axutil_array_list_t *meta_data_list = NULL;
axutil_array_list_t *extension_list = NULL;
axiom_node_t *header_block_node = NULL;
axiom_node_t *header_node = NULL;
axiom_namespace_t *addr_ns_obj = NULL;
int size = 0;
AXIS2_PARAM_CHECK(env->error, endpoint_ref, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, type, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE);
header_node = axiom_soap_header_get_base_node(soap_header, env);
addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
header_block = axiom_soap_header_add_header_block(soap_header, env, type, addr_ns_obj);
if(addr_ns_obj)
{
axiom_namespace_free(addr_ns_obj, env);
addr_ns_obj = NULL;
}
address = axis2_endpoint_ref_get_address(endpoint_ref, env);
if(address && *address)
{
axiom_node_t *hb_node = NULL;
axiom_element_t *hb_ele = NULL;
axiom_node_t *address_node = NULL;
axiom_element_t *address_ele = NULL;
hb_node = axiom_soap_header_block_get_base_node(header_block, env);
hb_ele = (axiom_element_t *)axiom_node_get_data_element(hb_node, env);
addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
address_ele = axiom_element_create(env, hb_node, EPR_ADDRESS, addr_ns_obj, &address_node);
axiom_namespace_free(addr_ns_obj, env);
if(address_ele)
{
axiom_namespace_t *dec_ns = NULL;
axiom_element_set_text(address_ele, env, address, address_node);
dec_ns = axiom_element_find_declared_namespace(address_ele, env, addr_ns,
AXIS2_WSA_DEFAULT_PREFIX);
}
}
header_block_node = axiom_soap_header_block_get_base_node(header_block, env);
axis2_addr_out_handler_add_to_header(env, endpoint_ref, &header_block_node, addr_ns);
ref_param_list = axis2_endpoint_ref_get_ref_param_list(endpoint_ref, env);
if(ref_param_list && axutil_array_list_size(ref_param_list, env) > 0)
{
axiom_node_t *reference_node = NULL;
axiom_element_t *reference_ele = NULL;
axutil_array_list_t *ref_attribute_list = NULL;
int i = 0;
addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
reference_ele = axiom_element_create(env, header_block_node, EPR_REFERENCE_PARAMETERS,
addr_ns_obj, &reference_node);
axiom_namespace_free(addr_ns_obj, env);
ref_attribute_list = axis2_endpoint_ref_get_ref_attribute_list(endpoint_ref, env);
if(ref_attribute_list)
{
int j = 0;
size = axutil_array_list_size(ref_attribute_list, env);
for(j = 0; j < size; j++)
{
axiom_attribute_t *attr = (axiom_attribute_t *)axutil_array_list_get(
ref_attribute_list, env, j);
if(attr)
{
axiom_element_add_attribute(reference_ele, env, attr, reference_node);
}
}
}
size = axutil_array_list_size(ref_param_list, env);
for(i = 0; i < size; i++)
{
axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(ref_param_list, env, i);
if(ref_node)
{
axiom_node_add_child(reference_node, env, ref_node);
}
}
}
meta_data_list = axis2_endpoint_ref_get_metadata_list(endpoint_ref, env);
if(meta_data_list && axutil_array_list_size(meta_data_list, env) > 0)
{
axiom_node_t *reference_node = NULL;
axiom_element_t *reference_ele = NULL;
axutil_array_list_t *meta_attribute_list = NULL;
int i = 0;
if(!reference_node) /* may be we alredy created this in ref params block */
{
addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
reference_ele = axiom_element_create(env, header_block_node, AXIS2_WSA_METADATA,
addr_ns_obj, &reference_node);
axiom_namespace_free(addr_ns_obj, env);
}
meta_attribute_list = axis2_endpoint_ref_get_metadata_attribute_list(endpoint_ref, env);
if(meta_attribute_list)
{
int j = 0;
size = axutil_array_list_size(meta_attribute_list, env);
for(j = 0; j < size; j++)
{
axiom_attribute_t *attr = (axiom_attribute_t *)axutil_array_list_get(
meta_attribute_list, env, j);
if(attr)
{
axiom_element_add_attribute(reference_ele, env, attr, reference_node);
}
}
}
size = axutil_array_list_size(meta_data_list, env);
for(i = 0; i < size; i++)
{
axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(meta_data_list, env, i);
if(ref_node)
{
axiom_node_add_child(reference_node, env, ref_node);
}
}
}
extension_list = axis2_endpoint_ref_get_extension_list(endpoint_ref, env);
if(extension_list && axutil_array_list_size(extension_list, env) > 0)
{
int i = 0;
size = axutil_array_list_size(extension_list, env);
for(i = 0; i < size; i++)
{
axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(extension_list, env, i);
if(ref_node)
{
axiom_node_add_child(header_block_node, env, ref_node);
}
}
}
return AXIS2_SUCCESS;
}
static axis2_bool_t
axis2_svc_client_fill_soap_envelope(
const axutil_env_t * env,
axis2_svc_client_t * svc_client,
axis2_msg_ctx_t * msg_ctx,
const axiom_node_t * payload)
{
const axis2_char_t *soap_version_uri;
int soap_version;
axiom_soap_envelope_t *envelope = NULL;
AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE);
soap_version_uri = axis2_options_get_soap_version_uri(svc_client->options, env);
if(!soap_version_uri)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot find soap version uri.");
return AXIS2_FALSE;
}
if(axutil_strcmp(soap_version_uri, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) == 0)
{
soap_version = AXIOM_SOAP11;
}
else
{
soap_version = AXIOM_SOAP12;
}
envelope = axiom_soap_envelope_create_default_soap_envelope(env, soap_version);
if(!envelope)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create default soap envelope.");
return AXIS2_FALSE;
}
if(svc_client->headers)
{
axiom_soap_header_t *soap_header = NULL;
soap_header = axiom_soap_envelope_get_header(envelope, env);
if(soap_header)
{
axiom_node_t *header_node = NULL;
header_node = axiom_soap_header_get_base_node(soap_header, env);
if(header_node)
{
int size = 0;
int i = 0;
size = axutil_array_list_size(svc_client->headers, env);
while(i < size)
{
axiom_node_t *node = NULL;
node = axutil_array_list_remove(svc_client->headers, env, 0);
/* This removes and retrieves data. The order of the
* removal is chosen such that the headers are appended
* in the order they were added.
*/
size--;
if(node)
{
axiom_node_add_child(header_node, env, node);
}
}
}
}
}
if(payload)
{
axiom_soap_body_t *soap_body = NULL;
soap_body = axiom_soap_envelope_get_body(envelope, env);
if(soap_body)
{
axiom_node_t *node = NULL;
node = axiom_soap_body_get_base_node(soap_body, env);
if(node)
{
axiom_node_add_child(node, env, (axiom_node_t *)payload);
}
}
}
axis2_msg_ctx_set_soap_envelope(msg_ctx, env, envelope);
return AXIS2_TRUE;
}
