int axis2_xmpp_client_on_presence(
void *user_data,
ikspak *pak)
{
axis2_xmpp_session_data_t *session = NULL;
axutil_env_t *env = NULL;
char* presence_str = NULL;
axis2_status_t status = AXIS2_SUCCESS;
char request_uri[500] = "";
session = (axis2_xmpp_session_data_t*) user_data;
env = session->env;
presence_str = iks_string(iks_stack(pak->x), pak->x);
if(!presence_str)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[xmpp]Failed to serialize the "
"presence envelope");
return IKS_FILTER_EAT;
}
snprintf(request_uri, 500, "xmpp://localhost/axis2/services/%s", axis2_svc_get_name(
session->svc, env));
status = axis2_xmpp_transport_utils_process_presence_client(session->env, session,
presence_str, request_uri);
return IKS_FILTER_EAT; /* no need to pass to other filters */
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_disengage_module(
axis2_svc_t * svc,
const axutil_env_t * env,
axis2_module_desc_t * module_desc,
axis2_conf_t * conf)
{
axis2_phase_resolver_t *phase_resolver = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axis2_char_t *svcname = NULL;
AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
svcname = axis2_svc_get_name(svc, env);
phase_resolver = axis2_phase_resolver_create_with_config(env, conf);
if (!phase_resolver)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Creating phase resolver failed for service %s", svcname);
return AXIS2_FAILURE;
}
status =
axis2_phase_resolver_disengage_module_from_svc(phase_resolver, env, svc,
module_desc);
axis2_phase_resolver_free(phase_resolver, env);
return status;
}
AXIS2_EXTERN void AXIS2_CALL
axis2_arch_file_data_free(
axis2_arch_file_data_t * arch_file_data,
const axutil_env_t * env)
{
if (arch_file_data->file)
{
axutil_file_free(arch_file_data->file, env);
}
if (arch_file_data->msg_recv)
{
AXIS2_FREE(env->allocator, arch_file_data->msg_recv);
}
if (arch_file_data->module_name)
{
AXIS2_FREE(env->allocator, arch_file_data->module_name);
}
if (arch_file_data->module_dll_name)
{
AXIS2_FREE(env->allocator, arch_file_data->module_dll_name);
}
if (arch_file_data->name)
{
AXIS2_FREE(env->allocator, arch_file_data->name);
}
if (arch_file_data->svc_map)
{
axutil_hash_index_t *hi = NULL;
void *val = NULL;
for (hi = axutil_hash_first(arch_file_data->svc_map, env); hi;
hi = axutil_hash_next(env, hi))
{
axis2_svc_t *svc = NULL;
axutil_hash_this(hi, NULL, NULL, &val);
svc = (axis2_svc_t *) val;
if (svc)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Service name :%s",
axis2_svc_get_name(svc, env));
axis2_svc_free(svc, env);
}
}
axutil_hash_free(arch_file_data->svc_map, env);
}
if (arch_file_data->deployable_svcs)
{
axutil_array_list_free(arch_file_data->deployable_svcs, env);
}
if (arch_file_data)
{
AXIS2_FREE(env->allocator, arch_file_data);
}
return;
}
axis2_status_t AXIS2_CALL
axis2_statistics_admin_out_op_count_handler_invoke(struct axis2_handler *handler,
const axutil_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
axis2_status_t status = AXIS2_SUCCESS;
service_admin_counter_t *counter = NULL;
axutil_param_t *param = NULL;
axis2_op_t *op = NULL;
axis2_svc_t *svc = NULL;
const axis2_char_t *svc_name = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[adminservices] Start:axis2_statistics_admin_out_op_count_handler_invoke");
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(svc)
{
svc_name = axis2_svc_get_name(svc, env);
}
op = axis2_msg_ctx_get_op(msg_ctx, env);
if(op)
{
param = axis2_op_get_param(op, env, AXIS2_OUT_OPERATION_COUNTER);
if(param)
{
counter = axutil_param_get_value(param, env);
if(counter)
{
service_admin_counter_increment(counter, env, msg_ctx);
}
}
else
{
axis2_char_t *op_name = NULL;
op_name = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
axutil_allocator_switch_to_global_pool(env->allocator);
counter = service_admin_counter_create(env, svc_name, op_name);
if(counter)
{
service_admin_counter_increment(counter, env, msg_ctx);
param = axutil_param_create(env, AXIS2_OUT_OPERATION_COUNTER, counter);
if(param)
{
axis2_op_add_param(op, env, param);
}
}
axutil_allocator_switch_to_local_pool(env->allocator);
}
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[adminservices] End:axis2_statistics_admin_out_op_count_handler_invoke");
return status;
}
int axis2_xmpp_client_on_message(
void *user_data,
ikspak *pak)
{
axis2_xmpp_session_data_t *session = NULL;
axutil_env_t *env = NULL;
iks* body_elem = NULL;
iks* soap_elem = NULL;
char *soap_str = NULL;
char *from = NULL;
char request_uri[500] = "";
axis2_status_t status = AXIS2_SUCCESS;
session = (axis2_xmpp_session_data_t*) user_data;
env = session->env;
/* Serialize the message and pass it up */
/* extract the body of message */
body_elem = iks_find(pak->x, "body");
if(!body_elem)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[xmpp]Failed to extract body of "
"message stanza");
return IKS_FILTER_EAT;
}
soap_elem = iks_child(body_elem);
if(!soap_elem)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[xmpp]Failed to extract soap envelope"
"from message stanza");
return IKS_FILTER_EAT;
}
soap_str = iks_string(iks_stack(soap_elem), soap_elem);
if(!soap_str)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[xmpp]Failed to serialize the soap "
"envelope");
return IKS_FILTER_EAT;
}
snprintf(request_uri, 500, "xmpp://localhost/axis2/services/%s", axis2_svc_get_name(
session->svc, env));
from = iks_find_attrib(pak->x, "from");
status = axis2_xmpp_transport_utils_process_message_client(session->env, session, soap_str,
from, request_uri);
/* TODO: Check whether we need to return IKS_HOOK on failure. I think not,
* because, failure here means the failure of a single request. We should
* keep running for other requests */
session->in_msg = 1;
return IKS_FILTER_EAT; /* no need to pass to other filters */
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_disengage_module(
axis2_svc_t * svc,
const axutil_env_t * env,
axis2_module_desc_t * module_desc,
axis2_conf_t * conf)
{
axis2_phase_resolver_t *phase_resolver = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axis2_char_t *svcname = NULL;
AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
svcname = axis2_svc_get_name(svc, env);
phase_resolver = axis2_phase_resolver_create_with_config(env, conf);
if(!phase_resolver)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s",
svcname);
return AXIS2_FAILURE;
}
status = axis2_phase_resolver_disengage_module_from_svc(phase_resolver, env, svc, module_desc);
if(status == AXIS2_SUCCESS)
{
/** Remove this module from the engaged modules list */
const axutil_qname_t *mod_qname = NULL;
int i = 0, size = 0;
mod_qname = axis2_module_desc_get_qname(module_desc, env);
size = axutil_array_list_size(svc->engaged_module_list, env);
for(i = 0; i < size; i++)
{
const axutil_qname_t *module_qname_l = NULL;
axis2_module_desc_t *module_desc_l = NULL;
module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(svc->engaged_module_list, env,
i);
module_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
if(axutil_qname_equals(mod_qname, env, module_qname_l))
{
axutil_array_list_remove(svc->engaged_module_list, env, i);
break;
}
}
}
axis2_phase_resolver_free(phase_resolver, env);
return status;
}
AXIS2_EXTERN axutil_url_t* AXIS2_CALL
service_admin_util_get_server_url(
const axutil_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axis2_endpoint_ref_t *epr = NULL;
axis2_char_t *address = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_conf_t *conf = NULL;
axis2_transport_in_desc_t *transport_in = NULL;
axis2_svc_t *svc = NULL;
axis2_char_t *svc_name = NULL;
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
conf = axis2_conf_ctx_get_conf(conf_ctx, env);
svc = axis2_msg_ctx_get_svc(msg_ctx, env);
svc_name = axis2_svc_get_name(svc, env);
transport_in = axis2_conf_get_transport_in(conf, env, AXIS2_TRANSPORT_ENUM_HTTP);
if(transport_in)
{
axutil_url_t *url = NULL;
axis2_transport_receiver_t *receiver = NULL;
receiver = axis2_transport_in_desc_get_recv(transport_in, env);
if(!receiver)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Transport Receiver Not found ");
return NULL;
}
epr = axis2_transport_receiver_get_epr_for_service(receiver, env, svc_name);
if(!epr)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Endpoint reference null");
return NULL;
}
address = (axis2_char_t*)axis2_endpoint_ref_get_address(epr,env);
return axutil_url_parse_string(env, address);
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_engage_module(
axis2_svc_t * svc,
const axutil_env_t * env,
axis2_module_desc_t * module_desc,
axis2_conf_t * conf)
{
axis2_phase_resolver_t *phase_resolver = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axis2_char_t *svcname = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_engage_module");
AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
svcname = axis2_svc_get_name(svc, env);
phase_resolver = axis2_phase_resolver_create_with_config(env, conf);
if (!phase_resolver)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Creating phase resolver failed for service %s", svcname);
return AXIS2_FAILURE;
}
status = axis2_phase_resolver_engage_module_to_svc(phase_resolver, env, svc, module_desc);
if (status)
{
const axutil_qname_t *qname = NULL;
status = axutil_array_list_add(svc->engaged_module_list, env, module_desc);
qname = axis2_module_desc_get_qname(module_desc, env);
axis2_svc_add_module_qname(svc, env, qname);
}
if (phase_resolver)
{
axis2_phase_resolver_free(phase_resolver, env);
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_engage_module");
return status;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_add_param(
axis2_svc_t * svc,
const axutil_env_t * env,
axutil_param_t * param)
{
axis2_char_t *paramname = NULL;
const axis2_char_t *svcname = axis2_svc_get_name(svc, env);
AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
paramname = axutil_param_get_name(param, env);
if(axis2_svc_is_param_locked(svc, env, axutil_param_get_name(param, env)))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for service %s", paramname,
svcname);
return AXIS2_FAILURE;
}
return axutil_param_container_add_param(svc->param_container, env, param);
}
static axis2_status_t AXIS2_CALL
axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync(
axis2_msg_recv_t * msg_recv,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx,
axis2_msg_ctx_t * new_msg_ctx)
{
axis2_svc_skeleton_t *svc_obj = NULL;
axis2_op_ctx_t *op_ctx = NULL;
axis2_op_t *op_desc = NULL;
const axis2_char_t *style = NULL;
axiom_node_t *om_node = NULL;
axiom_element_t *om_element = NULL;
axis2_char_t *local_name = NULL;
axiom_node_t *result_node = NULL;
axiom_node_t *body_content_node = NULL;
axiom_element_t *body_content_element = NULL;
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 *soap_fault = NULL;
axiom_node_t *out_node = NULL;
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t skel_invoked = AXIS2_FALSE;
const axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
int soap_version = AXIOM_SOAP12;
axiom_namespace_t *env_ns = NULL;
axiom_node_t *fault_node = NULL;
axiom_soap_fault_detail_t *fault_detail;
axis2_bool_t is_fault = AXIS2_FALSE;
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, new_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[axis2]Entry:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync");
/* get the implementation class for the Web Service */
svc_obj = axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx);
if(!svc_obj)
{
const axis2_char_t *svc_name = NULL;
axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(svc)
{
svc_name = axis2_svc_get_name(svc, env);
}
else
{
svc_name = "unknown";
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Impl object for service '%s' not set in message receiver. %d :: %s", svc_name,
env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
status = AXIS2_FAILURE;
}
else
{
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
op_desc = axis2_op_ctx_get_op(op_ctx, env);
style = axis2_op_get_style(op_desc, env);
if(0 == axutil_strcmp(AXIS2_STYLE_DOC, style))
{
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
om_node = axiom_soap_body_get_base_node(body, env);
om_element = axiom_node_get_data_element(om_node, env);
om_node = axiom_node_get_first_element(om_node, env);
}
else if(0 == axutil_strcmp(AXIS2_STYLE_RPC, style))
{
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
axiom_node_t *op_node = NULL;
axiom_element_t *op_element = NULL;
envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
op_node = axiom_soap_body_get_base_node(body, env);
op_element = axiom_node_get_data_element(op_node, env);
if(op_element)
{
local_name = axiom_element_get_localname(op_element, env);
if(local_name)
{
axutil_array_list_t *function_arr = NULL;
int i = 0;
int size = 0;
axis2_bool_t matches = AXIS2_FALSE;
function_arr = svc_obj->func_array;
if(function_arr)
{
size = axutil_array_list_size(function_arr, env);
}
for(i = 0; i < size; i++)
{
axis2_char_t *function_name = NULL;
function_name = (axis2_char_t *)axutil_array_list_get(function_arr, env, i);
if(!axutil_strcmp(function_name, local_name))
{
matches = AXIS2_TRUE;
}
}
if(matches)
{
om_node = axiom_node_get_first_child(op_node, env);
om_element = axiom_node_get_data_element(om_node, env);
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_MISMATCH, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RPC_NEED_MATCHING_CHILD, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
if(status == AXIS2_SUCCESS)
{
skel_invoked = AXIS2_TRUE;
result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx);
}
if(result_node)
{
if(0 == axutil_strcmp(style, AXIS2_STYLE_RPC))
{
axiom_namespace_t *ns = NULL;
axis2_char_t *res_name = NULL;
res_name = axutil_stracat(env, local_name, "Response");
ns = axiom_namespace_create(env, "http://soapenc/", "res");
if(!ns)
{
status = AXIS2_FAILURE;
}
else
{
body_content_element = axiom_element_create(env, NULL, res_name, ns,
&body_content_node);
axiom_node_add_child(body_content_node, env, result_node);
}
}
else
{
body_content_node = result_node;
}
}
else
{
axis2_char_t *mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op_desc, env);
if(axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) && axutil_strcmp(mep,
AXIS2_MEP_URI_ROBUST_IN_ONLY) && axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY_WSDL2) && axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2))
{
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
if(status == AXIS2_SUCCESS)
{
axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE);
}
else
{
axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code(
new_msg_ctx, env));
}
/* The new_msg_ctx is passed to the service. The status code must
* be taken from here and set to the old message context which is
* used by the worker when the request processing fails.
*/
if(svc_obj->ops->on_fault)
{
fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node);
}
is_fault = AXIS2_TRUE;
}
else
{
/* If we have a in only message result node is NULL. We create fault only if
* an error is set
*/
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
if(status == AXIS2_SUCCESS)
{
axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE);
}
else
{
axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code(
new_msg_ctx, env));
if((!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY)) ||
(!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2)))
{
/* The new_msg_ctx is passed to the service. The status code must
* be taken from here and set to the old message context which is
* used by the worker when the request processing fails.
*/
if(svc_obj->ops->on_fault)
{
fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node);
}
is_fault = AXIS2_TRUE;
}
}
}
}
}
if(msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */
soap_version = AXIOM_SOAP11;
}
if(axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env))
{
/* service implementation has set the envelope,
useful when setting a SOAP fault.
No need to further process */
return AXIS2_SUCCESS;
}
/* create the soap envelope here */
env_ns = axiom_namespace_create(env, soap_ns, "soapenv");
if(!env_ns)
{
return AXIS2_FAILURE;
}
default_envelope = axiom_soap_envelope_create(env, env_ns);
axiom_namespace_free(env_ns, env);
if(!default_envelope)
{
return AXIS2_FAILURE;
}
out_header = axiom_soap_header_create_with_parent(env, default_envelope);
if(!out_header)
{
return AXIS2_FAILURE;
}
out_body = axiom_soap_body_create_with_parent(env, default_envelope);
if(!out_body)
{
return AXIS2_FAILURE;
}
out_node = axiom_soap_body_get_base_node(out_body, env);
if(!out_node)
{
return AXIS2_FAILURE;
}
if(status != AXIS2_SUCCESS || is_fault)
{
/* something went wrong. set a SOAP Fault */
const axis2_char_t *fault_value_str = "soapenv:Sender";
const axis2_char_t *fault_reason_str = NULL;
const axis2_char_t *err_msg = NULL;
if(!skel_invoked)
{
if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
AXIOM_SOAP11_FAULT_CODE_RECEIVER;
}
else
{
fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER;
}
}
err_msg = AXIS2_ERROR_GET_MESSAGE(env->error);
if (err_msg && axutil_strcmp(err_msg, ""))
{
if(!axutil_strcmp(err_msg, "No Error"))
{
fault_reason_str = "An error has occurred, but could not determine exact details";
}
else
{
fault_reason_str = err_msg;
}
}
else
{
fault_reason_str = "An error has occurred, but could not determine exact details";
}
soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str,
fault_reason_str, soap_version);
if (fault_node)
{
axiom_node_t *fault_detail_node = NULL;
axis2_char_t *om_str = NULL;
fault_detail = axiom_soap_fault_detail_create_with_parent(env, soap_fault);
fault_detail_node = axiom_soap_fault_detail_get_base_node(fault_detail, env);
om_str = axiom_node_to_string(fault_detail_node, env);
if (om_str)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault_detail:%s", om_str);
AXIS2_FREE(env->allocator, om_str);
}
axiom_soap_fault_detail_add_detail_entry(fault_detail, env, fault_node);
}
}
if (body_content_node)
{
axiom_node_add_child(out_node, env, body_content_node);
status = axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
}
else if (soap_fault)
{
axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
status = AXIS2_SUCCESS;
}
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;
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[axis2]Exit:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync");
return status;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_add_op(
axis2_svc_t * svc,
const axutil_env_t * env,
axis2_op_t * op)
{
axis2_status_t status = AXIS2_FAILURE;
axis2_msg_recv_t *msg_recv = NULL;
const axutil_qname_t *qname = NULL;
axis2_char_t *key = NULL;
const axis2_char_t *svcname = NULL;
axutil_array_list_t *mappings_list = NULL;
int size = 0;
int j = 0;
AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);
svcname = axis2_svc_get_name(svc, env);
qname = axis2_op_get_qname(op, env);
if(qname)
key = axutil_qname_get_localpart(qname, env);
mappings_list = axis2_op_get_wsamapping_list(op, env);
/* Adding action mappings into service */
if(mappings_list)
size = axutil_array_list_size(mappings_list, env);
for(j = 0; j < size; j++)
{
axis2_char_t *mapping = NULL;
mapping = (axis2_char_t *)axutil_array_list_get(mappings_list, env, j);
status = axis2_svc_add_mapping(svc, env, mapping, op);
if(AXIS2_SUCCESS != status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Adding operation %s to service %s mapping list failed", svcname, key);
return status;
}
}
status = axis2_op_set_parent(op, env, svc);
if(AXIS2_SUCCESS != status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting service %s as operation %s parent failed",
svcname, key);
return status;
}
msg_recv = axis2_op_get_msg_recv(op, env);
if(msg_recv == NULL)
{
msg_recv = axis2_desc_builder_load_default_msg_recv(env);
axis2_op_set_msg_recv(op, env, msg_recv);
}
if(key)
{
/* If service defines the operation, then we should not override with module level
* operation. Module operations are global. If any setting to be modified, those operations
* can be defined in service */
if(!axutil_hash_get(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING))
{
axutil_hash_set(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING, op);
}
}
return AXIS2_SUCCESS;
}
/**
* Here we extract all operations defined in module.xml and built execution
* chains for them by calling axis2_phase_resolver_build_execution_chains_for_module_op()
* function. Within that function handlers of the modules defined for that
* operation are added to module operation chains appropriately.
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_add_module_ops(
axis2_svc_t * svc,
const axutil_env_t * env,
axis2_module_desc_t * module_desc,
axis2_conf_t * conf)
{
axutil_hash_t *map = NULL;
axutil_hash_index_t *hash_idx = NULL;
axis2_phase_resolver_t *phase_resolver = NULL;
axis2_op_t *op_desc = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axis2_char_t *svcname = NULL;
axis2_char_t *modname = NULL;
axis2_char_t *opname = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_add_module_ops");
AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
svcname = axis2_svc_get_name(svc, env);
modname = axutil_qname_get_localpart(axis2_module_desc_get_qname(module_desc, env), env);
map = axis2_module_desc_get_all_ops(module_desc, env);
phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf, svc);
if(!phase_resolver)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s",
svcname);
return AXIS2_FAILURE;
}
for(hash_idx = axutil_hash_first(map, env); hash_idx; hash_idx = axutil_hash_next(env, hash_idx))
{
void *v = NULL;
axutil_hash_this(hash_idx, NULL, NULL, &v);
op_desc = (axis2_op_t *)v;
opname = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env);
status = axis2_phase_resolver_build_execution_chains_for_module_op(phase_resolver, env,
op_desc);
if(AXIS2_SUCCESS != status)
{
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Builidng module operation %s failed for module %s", opname, modname);
return status;
}
status = axis2_svc_add_op(svc, env, op_desc);
if(AXIS2_SUCCESS != status)
{
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding operation %s to service %s failed",
opname, svcname);
return status;
}
}
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_add_module_ops");
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_svc_client_t *AXIS2_CALL
axis2_svc_client_create_with_conf_ctx_and_svc(
const axutil_env_t * env,
const axis2_char_t * client_home,
axis2_conf_ctx_t * conf_ctx,
axis2_svc_t * svc)
{
axis2_svc_client_t *svc_client = NULL;
axis2_svc_grp_t *svc_grp = NULL;
axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
const axis2_char_t *svc_grp_name = NULL;
svc_client = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_client_t));
if(!svc_client)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create service client.");
return NULL;
}
svc_client->svc = NULL;
svc_client->conf = NULL;
svc_client->conf_ctx = NULL;
svc_client->svc_ctx = NULL;
svc_client->options = NULL;
svc_client->override_options = NULL;
svc_client->headers = NULL;
svc_client->callback_recv = NULL;
svc_client->listener_manager = NULL;
svc_client->op_client = NULL;
svc_client->last_response_soap_envelope = NULL;
svc_client->last_response_has_fault = AXIS2_FALSE;
svc_client->reuse = AXIS2_FALSE;
svc_client->auth_failed = AXIS2_FALSE;
svc_client->required_auth_is_http = AXIS2_FALSE;
svc_client->auth_type = NULL;
svc_client->http_headers = NULL;
svc_client->keep_externally_passed_ctx_and_svc = AXIS2_FALSE;
if(!axis2_svc_client_init_data(env, svc_client))
{
axis2_svc_client_free(svc_client, env);
return NULL;
}
/*create the default conf_ctx if it is NULL */
if(!axis2_svc_client_init_transports_from_conf_ctx(env, svc_client, conf_ctx, client_home))
{
axis2_svc_client_free(svc_client, env);
return NULL;
}
svc_client->conf = axis2_conf_ctx_get_conf(svc_client->conf_ctx, env);
if(svc)
{
svc_client->keep_externally_passed_ctx_and_svc = AXIS2_TRUE;
svc_client->svc = svc;
}
else
{
svc_client->svc = axis2_svc_client_create_annonymous_svc(svc_client, env);
if(!svc_client->svc)
{
axis2_svc_client_free(svc_client, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create annonymous service.");
return NULL;
}
}
/** add the service to the config context if it isn't in there already */
if(!axis2_conf_get_svc(svc_client->conf, env, axis2_svc_get_name(svc_client->svc, env)))
{
axis2_conf_add_svc(svc_client->conf, env, svc_client->svc);
}
/** create a service context for myself: create a new service group
context and then get the service context for myself as I'll need that
later for stuff that I gotta do */
svc_grp = axis2_svc_get_parent(svc_client->svc, env);
if(!svc_grp)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot access service group of service client.");
return NULL;
}
svc_grp_ctx = axis2_svc_grp_get_svc_grp_ctx(svc_grp, env, svc_client->conf_ctx);
if(!svc_grp_ctx)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Cannot access service group context of service client.");
return NULL;
}
svc_grp_name = axis2_svc_grp_get_name(svc_grp, env);
if(!svc_grp_name)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Cannot access service group name of service client.");
return NULL; /* service group name is mandatory */
}
axis2_conf_ctx_register_svc_grp_ctx(svc_client->conf_ctx, env, svc_grp_name, svc_grp_ctx);
svc_client->svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, axis2_svc_get_name(
svc_client->svc, env));
return svc_client;
}
