axis2_status_t AXIS2_CALL
axutil_log_out_handler_invoke(
struct axis2_handler * handler,
const axutil_env_t * env,
struct axis2_msg_ctx * msg_ctx)
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_node_t *ret_node = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log, "Starting logging out handler .........");
soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
if (soap_envelope)
{
ret_node = axiom_soap_envelope_get_base_node(soap_envelope, env);
if (ret_node)
{
axis2_char_t *om_str = NULL;
om_str = axiom_node_to_string(ret_node, env);
if (om_str)
{
AXIS2_LOG_INFO(env->log, "Output message: %s", om_str);
}
}
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axiom_soap_header_get_base_node(
axiom_soap_header_t * soap_header,
const axutil_env_t * env)
{
if(!soap_header->om_ele_node)
{
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
axiom_namespace_t *parent_ns = NULL;
axiom_element_t *this_ele = NULL;
axiom_node_t *this_node = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_node_t *body_node = NULL;
parent_node = axiom_soap_envelope_get_base_node(soap_header->soap_envelope, env);
if(!parent_node || axiom_node_get_node_type(parent_node, env) != AXIOM_ELEMENT)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
this_ele = axiom_element_create(env, NULL, AXIOM_SOAP_HEADER_LOCAL_NAME, parent_ns,
&this_node);
if(!this_ele)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
soap_body = axiom_soap_envelope_get_body(soap_header->soap_envelope, env);
if(soap_body)
{
body_node = axiom_soap_body_get_base_node(soap_body, env);
axiom_node_insert_sibling_before(body_node, env, this_node);
}
else
{
axiom_node_add_child(parent_node, env, this_node);
}
soap_header->om_ele_node = this_node;
}
return soap_header->om_ele_node;
}
axis2_status_t AXIS2_CALL
echo_process_response_envelope(
struct axis2_callback * callback,
const axutil_env_t * env)
{
/** SOAP response has arrived here; get the soap envelope
from the callback object and do whatever you want to do with it */
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_node_t *ret_node = NULL;
axis2_status_t status = AXIS2_SUCCESS;
soap_envelope = axis2_callback_get_envelope(callback, env);
if (!soap_envelope)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Stub invoke FAILED: Error code:" " %d :: %s",
env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
printf("echo stub invoke FAILED!\n");
status = AXIS2_FAILURE;
}
else
{
ret_node = axiom_soap_envelope_get_base_node(soap_envelope, env);
if (!ret_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Stub invoke FAILED: Error code:" " %d :: %s",
env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
printf("echo stub invoke FAILED!\n");
status = AXIS2_FAILURE;
}
else
{
axis2_char_t *om_str = NULL;
om_str = axiom_node_to_string(ret_node, env);
if (om_str)
{
printf("\nReceived OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
}
printf("\necho client invoke SUCCESSFUL!\n");
}
}
return status;
}
AXIS2_EXTERN axiom_soap_body_t *AXIS2_CALL
axiom_soap_body_create_with_parent(
const axutil_env_t * env,
axiom_soap_envelope_t * envelope)
{
axiom_soap_body_t *soap_body = NULL;
axiom_element_t *ele = NULL;
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
axiom_namespace_t *om_ns = NULL;
AXIS2_PARAM_CHECK(env->error, envelope, NULL);
soap_body = axiom_soap_body_create(env);
if(!soap_body)
{
return NULL;
}
/*get parent node from SOAP envelope */
parent_node = axiom_soap_envelope_get_base_node(envelope, env);
if(!parent_node)
{
axiom_soap_body_free(soap_body, env);
return NULL;
}
parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
axiom_soap_body_free(soap_body, env);
return NULL;
}
om_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
ele = axiom_element_create(env, parent_node, AXIOM_SOAP_BODY_LOCAL_NAME, om_ns,
&(soap_body->om_ele_node));
if(!ele)
{
axiom_soap_body_free(soap_body, env);
return NULL;
}
axiom_soap_envelope_set_body(envelope, env, soap_body);
return soap_body;
}
static axis2_status_t AXIS2_CALL CallbackOnFault(axis2_callback_t* pCallback, const axutil_env_t* pEnv,
int nFaultCode)
{
if (!pCallback)
{
LogError() << "pCallback is NULL";
return AXIS2_FAILURE;
}
PICallback tpCallback(reinterpret_cast<ICallback<const DataObject&>*>(axis2_callback_get_data(pCallback)));
axis2_callback_set_data(pCallback, NULL); // avoid axis2/c to destroy C++ data
if (!tpCallback.get())
{
LogError() << "pointer to ICallback is NULL";
return AXIS2_FAILURE;
}
axiom_node_t* pAxiomResponseNode = NULL;
{
axiom_soap_envelope_t* pSoapEnvelope = axis2_callback_get_envelope(pCallback, pEnv);
if (pSoapEnvelope)
{
pAxiomResponseNode = axiom_soap_envelope_get_base_node(pSoapEnvelope, pEnv);
#ifdef _DEBUG
LogDebug2() << "Received Response: \n" << staff::ColorTextBlue
<< DataObject(pAxiomResponseNode).ToString() << staff::ColorDefault;
#endif
}
}
try
{
if (!pAxiomResponseNode)
{
CreateFault(*tpCallback, AXIS2_ERROR_GET_MESSAGE(pEnv->error), ToString(nFaultCode));
}
else
{
tpCallback->OnFault(pAxiomResponseNode);
}
}
STAFF_CATCH_ALL_DESCR("Error while processing response")
return AXIS2_SUCCESS;
}
axis2_char_t*
wsdl_util_create_request_envelope(
const axutil_env_t *env,
axiom_node_t *payload,
int soap_version)
{
axiom_soap_envelope_t* envelope = NULL;
axiom_soap_header_t* header = NULL;
axiom_soap_body_t* body = NULL;
axiom_node_t* envelope_node = NULL;
if ((soap_version == AXIOM_SOAP11) || (soap_version == AXIOM_SOAP12))
{
envelope = axiom_soap_envelope_create_with_soap_version_prefix(env, soap_version, AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
}
else
{
AXIS2_LOG_DEBUG_MSG(env->log, "Unknown SOAP version");
}
header = axiom_soap_header_create_with_parent(env, envelope);
if (!header)
{
return NULL;
}
body = axiom_soap_body_create_with_parent(env, envelope);
if (!body)
{
return NULL;
}
if (payload)
{
axiom_soap_body_add_child(body, env, payload);
}
envelope_node = axiom_soap_envelope_get_base_node(envelope, env);
return axiom_node_to_string(envelope_node, env);
}
axis2_char_t *
wsf_util_get_soap_msg_from_op_client (
axis2_op_client_t * op_client,
axutil_env_t * env,
axis2_wsdl_msg_labels_t msg_label)
{
if (op_client) {
axiom_soap_envelope_t *soap_env = NULL;
const axis2_msg_ctx_t *msg_ctx = NULL;
axiom_node_t *node = NULL;
msg_ctx = axis2_op_client_get_msg_ctx (op_client, env, msg_label);
if (!msg_ctx)
return NULL;
soap_env = axis2_msg_ctx_get_soap_envelope (msg_ctx, env);
if (!soap_env)
return NULL;
node = axiom_soap_envelope_get_base_node (soap_env, env);
return axiom_node_to_string (node, env);
}
return NULL;
}
/**
* Verifes that Body, Timestamp, To, Action, and MessageId elements are signed and located
* where expected by the application logic. Timestamp is checked for expiration regardless
* of its actual location.
*/
axis2_status_t verify_references(axiom_node_t *sig_node, const axutil_env_t *env, axis2_msg_ctx_t *msg_ctx, axiom_soap_envelope_t *envelope) {
axiom_node_t *si_node = NULL;
axiom_node_t *ref_node = NULL;
axis2_status_t status = AXIS2_SUCCESS;
si_node = oxs_axiom_get_first_child_node_by_name(env,sig_node, OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS);
if(!si_node) {
axis2_char_t *tmp = axiom_node_to_string(sig_node, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart]sig = %s", tmp);
NO_U_FAIL("Couldn't find SignedInfo!");
}
axutil_qname_t *qname = NULL;
axiom_element_t *parent_elem = NULL;
axiom_children_qname_iterator_t *qname_iter = NULL;
parent_elem = axiom_node_get_data_element(si_node, env);
if(!parent_elem)
{
NO_U_FAIL("Could not get Reference elem");
}
axis2_char_t *ref = NULL;
axis2_char_t *ref_id = NULL;
axiom_node_t *signed_node = NULL;
axiom_node_t *envelope_node = NULL;
short signed_elems[5] = {0,0,0,0,0};
envelope_node = axiom_soap_envelope_get_base_node(envelope, env);
qname = axutil_qname_create(env, OXS_NODE_REFERENCE, OXS_DSIG_NS, NULL);
qname_iter = axiom_element_get_children_with_qname(parent_elem, env, qname, si_node);
while (axiom_children_qname_iterator_has_next(qname_iter , env)) {
ref_node = axiom_children_qname_iterator_next(qname_iter, env);
axis2_char_t *txt = axiom_node_to_string(ref_node, env);
/* get reference to a signed element */
ref = oxs_token_get_reference(env, ref_node);
if(ref == NULL || strlen(ref) == 0 || ref[0] != '#') {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unsupported reference ID in %s", txt);
status = AXIS2_FAILURE;
break;
}
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] %s, ref = %s", txt, ref);
/* get rid of '#' */
ref_id = axutil_string_substring_starting_at(axutil_strdup(env, ref), 1);
signed_node = oxs_axiom_get_node_by_id(env, envelope_node, OXS_ATTR_ID, ref_id, OXS_WSU_XMLNS);
if(!signed_node) {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Error retrieving elementwith ID=%s", ref_id);
status = AXIS2_FAILURE;
break;
}
if(verify_node(signed_node, env, msg_ctx, ref, signed_elems)) {
status = AXIS2_FAILURE;
break;
}
}
axutil_qname_free(qname, env);
qname = NULL;
if(status == AXIS2_FAILURE) {
NO_U_FAIL("Failed to verify location of signed elements!");
}
/* This is needed to make sure that all security-critical elements are signed */
for(int i = 0; i < 5; i++) {
if(signed_elems[i] == 0) {
NO_U_FAIL("Not all required elements are signed");
}
}
return status;
}
AXIS2_EXTERN axiom_soap_header_t *AXIS2_CALL
axiom_soap_header_create_with_parent(
const axutil_env_t * env,
axiom_soap_envelope_t * envelope)
{
axiom_soap_header_t *soap_header = NULL;
/*axiom_element_t *this_ele = NULL;
axiom_node_t *this_node = NULL;*/
axiom_node_t *body_node = NULL;
axiom_node_t *parent_node = NULL;
axiom_element_t *parent_ele = NULL;
/*axiom_namespace_t *parent_ns = NULL;*/
AXIS2_PARAM_CHECK(env->error, envelope, NULL);
soap_header = axiom_soap_header_create(env);
if(!soap_header)
{
return NULL;
}
soap_header->soap_version = axiom_soap_envelope_get_soap_version(envelope, env);
parent_node = axiom_soap_envelope_get_base_node(envelope, env);
if(!parent_node || axiom_node_get_node_type(parent_node, env) != AXIOM_ELEMENT)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
parent_ele = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
if(axiom_node_get_first_element(parent_node, env))
{
body_node = axiom_node_get_first_element(parent_node, env);
axiom_node_detach(body_node, env);
}
/*parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node);
this_ele = axiom_element_create(env, parent_node,
AXIOM_SOAP_HEADER_LOCAL_NAME, parent_ns,
&this_node);
if (!this_ele)
{
axiom_soap_header_free(soap_header, env);
return NULL;
}
soap_header->om_ele_node = this_node;*/
axiom_soap_envelope_set_header(envelope, env, soap_header);
if(body_node)
{
axiom_node_add_child(parent_node, env, body_node);
}
soap_header->soap_envelope = envelope;
return soap_header;
}
AXIS2_EXTERN axiom_node_t *AXIS2_CALL
axis2_svc_client_send_receive_with_op_qname(
axis2_svc_client_t * svc_client,
const axutil_env_t * env,
const axutil_qname_t * op_qname,
const axiom_node_t * payload)
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_node_t *soap_node = NULL;
axis2_op_t *op = NULL;
axutil_param_t *param = NULL;
axutil_uri_t *action_uri = NULL;
axis2_char_t *action_str = NULL;
axis2_bool_t qname_free_flag = AXIS2_FALSE;
axis2_msg_ctx_t *res_msg_ctx = NULL;
axis2_msg_ctx_t *msg_ctx = NULL;
AXIS2_PARAM_CHECK(env->error, svc_client, NULL);
svc_client->last_response_soap_envelope = NULL;
svc_client->last_response_has_fault = AXIS2_FALSE;
svc_client->auth_failed = AXIS2_FALSE;
svc_client->required_auth_is_http = AXIS2_FALSE;
if(svc_client->auth_type)
{
AXIS2_FREE(env->allocator, svc_client->auth_type);
}
svc_client->auth_type = NULL;
op = axis2_svc_get_op_with_qname(svc_client->svc, env, op_qname);
if(op)
{
param = axis2_op_get_param(op, env, AXIS2_SOAP_ACTION);
if(param)
{
action_uri = (axutil_uri_t *)axutil_param_get_value(param, env);
action_str = axutil_uri_to_string(action_uri, env, AXIS2_URI_UNP_OMITUSERINFO);
axis2_options_set_action(svc_client->options, env, action_str);
}
}
if(!op_qname)
{
op_qname = axutil_qname_create(env, AXIS2_ANON_OUT_IN_OP, NULL, NULL);
if(!op_qname)
return NULL;
qname_free_flag = AXIS2_TRUE;
}
/* If dual channel blocking. We come to this block if the client indicate to use
* a separate listener but don't provide a callback function to acted upon when
* response is received in the listener thread. What we do here is we create a callback
* and call axis2_svc_client_send_receive_non_blocking_with_op_qname with it. */
if(axis2_options_get_use_separate_listener(svc_client->options, env))
{
axis2_callback_t *callback = NULL;
axis2_msg_ctx_t *msg_ctx = NULL;
long index = 0;
/* This means doing a Request-Response invocation using two channels.
If the transport is a two way transport (e.g. http), only one channel is used
(e.g. in http cases 202 OK is sent to say no response available).
Axis2 gets blocked and return when the response is available. */
callback = axis2_callback_create(env);
if(!callback)
{
return NULL;
}
/* Call two channel non blocking invoke to do the work and wait on the callback. We don't
* set a callback function for the callback. That functionality is handled here.
*/
axis2_svc_client_send_receive_non_blocking_with_op_qname(svc_client, env, op_qname,
payload, callback);
index = axis2_options_get_timeout_in_milli_seconds(svc_client->options, env) / 10;
while(!axis2_callback_get_complete(callback, env))
{
if(index-- >= 0)
{
AXIS2_USLEEP(10000);
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RESPONSE_TIMED_OUT, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Response time out.");
return NULL;
}
}
soap_envelope = axis2_callback_get_envelope(callback, env);
msg_ctx = axis2_callback_get_msg_ctx(callback, env);
axis2_op_client_add_in_msg_ctx(svc_client->op_client, env, msg_ctx);
/* start of hack to get rid of memory leak */
/*msg_ctx = axis2_msg_ctx_create(env, axis2_svc_ctx_get_conf_ctx(svc_client-> svc_ctx, env),
NULL, NULL);
if(!msg_ctx)
return NULL;
axis2_op_client_add_in_msg_ctx(svc_client->op_client, env, msg_ctx);
axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope);*/
/* end of hack to get rid of memory leak */
/* process the result of the invocation */
if(!soap_envelope)
{
if(axis2_callback_get_error(callback, env) != AXIS2_ERROR_NONE)
{
AXIS2_ERROR_SET(env->error, axis2_callback_get_error(callback, env), AXIS2_FAILURE);
return NULL;
}
}
}
else
{
msg_ctx = axis2_msg_ctx_create(env, axis2_svc_ctx_get_conf_ctx(svc_client->svc_ctx, env),
NULL, NULL);
if(!msg_ctx)
return NULL;
if(!axis2_svc_client_fill_soap_envelope(env, svc_client, msg_ctx, payload))
{
return NULL;
}
if(!axis2_svc_client_create_op_client(svc_client, env, op_qname))
{
return NULL;
}
axis2_op_client_add_msg_ctx(svc_client->op_client, env, msg_ctx);
axis2_op_client_execute(svc_client->op_client, env, AXIS2_TRUE);
axis2_svc_client_set_http_info(svc_client, env, msg_ctx);
svc_client->auth_failed = axis2_msg_ctx_get_auth_failed(msg_ctx, env);
svc_client->required_auth_is_http = axis2_msg_ctx_get_required_auth_is_http(msg_ctx, env);
if(axis2_msg_ctx_get_auth_type(msg_ctx, env))
{
svc_client->auth_type = axutil_strdup(env, axis2_msg_ctx_get_auth_type(msg_ctx, env));
}
res_msg_ctx = (axis2_msg_ctx_t *)axis2_op_client_get_msg_ctx(svc_client-> op_client, env,
AXIS2_WSDL_MESSAGE_LABEL_IN);
if(res_msg_ctx)
{
soap_envelope = axis2_msg_ctx_get_soap_envelope(res_msg_ctx, env);
}
else
{
axis2_op_client_add_msg_ctx(svc_client->op_client, env, res_msg_ctx);
/* set in msg_ctx to be NULL to reset */
}
}
if(qname_free_flag)
{
axutil_qname_free((axutil_qname_t *)op_qname, env);
}
if(!soap_envelope)
{
return NULL;
}
svc_client->last_response_soap_envelope = soap_envelope;
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
if(!soap_body)
{
axiom_node_t *node = axiom_soap_envelope_get_base_node(soap_envelope, env);
if(node)
{
axiom_element_t *envelope_element = (axiom_element_t *)axiom_node_get_data_element(
node, env);
axiom_util_get_first_child_element_with_localname(envelope_element, env, node,
AXIOM_SOAP_BODY_LOCAL_NAME, &soap_node);
if(soap_node)
{
return axiom_node_get_first_element(soap_node, env);
}
}
return NULL;
}
if(axis2_msg_ctx_get_doing_rest(res_msg_ctx, env))
{
/* All HTTP 4xx and 5xx status codes are treated as errors */
if(axis2_msg_ctx_get_status_code(res_msg_ctx, env) >= 400)
{
svc_client->last_response_has_fault = AXIS2_TRUE;
}
else
{
svc_client->last_response_has_fault = AXIS2_FALSE;
}
}
else
{
svc_client->last_response_has_fault = axiom_soap_body_has_fault(soap_body, env);
}
if(AXIOM_SOAP11 == axiom_soap_envelope_get_soap_version(soap_envelope, env))
{
axiom_soap_body_convert_fault_to_soap11(soap_body, env);
}
soap_node = axiom_soap_body_get_base_node(soap_body, env);
if(!soap_node)
{
return NULL;
}
return axiom_node_get_first_element(soap_node, env);
}
