void axis2_stub_ExchangeTrader_registerClient_start( axis2_stub_t *stub, const axutil_env_t *env,
axis2_registerClientRequest_t* registerClientRequest14,
axis2_status_t ( AXIS2_CALL *on_complete ) (struct axis2_callback *, const axutil_env_t *) ,
axis2_status_t ( AXIS2_CALL *on_error ) (struct axis2_callback *, const axutil_env_t *, int ) )
{
axis2_callback_t *callback = NULL;
axis2_svc_client_t *svc_client = NULL;
axis2_options_t *options = NULL;
const axis2_char_t *soap_action = NULL;
axiom_node_t *payload = NULL;
payload = axis2_registerClientRequest_serialize(registerClientRequest14, env, NULL, AXIS2_FALSE);
options = axis2_stub_get_options( stub, env);
if ( NULL == options )
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub: Error code:"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return;
}
svc_client = axis2_stub_get_svc_client (stub, env );
soap_action =axis2_options_get_action ( options, env );
if ( NULL == soap_action )
{
soap_action = "\"\"";
axis2_options_set_action( options, env, soap_action );
}
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
callback = axis2_callback_create(env);
/* Set our on_complete fucntion pointer to the callback object */
axis2_callback_set_on_complete(callback, on_complete);
/* Set our on_error function pointer to the callback object */
axis2_callback_set_on_error(callback, on_error);
/* Send request */
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
}
void AXIS2_CALL
axis2_stub_start_op_IIp2Location_get( axis2_stub_t *stub, const axutil_env_t *env,
adb_get_t* _get,
void *user_data,
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_getResponse_t* _getResponse, void *data) ,
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
{
axis2_callback_t *callback = NULL;
axis2_svc_client_t *svc_client = NULL;
axis2_options_t *options = NULL;
const axis2_char_t *soap_action = NULL;
axiom_node_t *payload = NULL;
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
axutil_string_t *soap_act = NULL;
struct axis2_stub_IIp2Location_get_callback_data *callback_data;
callback_data = (struct axis2_stub_IIp2Location_get_callback_data*) AXIS2_MALLOC(env->allocator,
sizeof(struct axis2_stub_IIp2Location_get_callback_data));
if(NULL == callback_data)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
return;
}
payload = adb_get_serialize(_get, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
svc_client = axis2_stub_get_svc_client(stub, env );
options = axis2_stub_get_options( stub, env);
if (NULL == options)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
return;
}
soap_act =axis2_options_get_soap_action (options, env);
if (NULL == soap_act)
{
is_soap_act_set = AXIS2_FALSE;
soap_action = "urn:get";
soap_act = axutil_string_create(env, "urn:get");
axis2_options_set_soap_action(options, env, soap_act);
}
axis2_options_set_soap_version(options, env, AXIOM_SOAP12);
callback = axis2_callback_create(env);
/* Set our on_complete fucntion pointer to the callback object */
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_IIp2Location_get);
/* Set our on_error function pointer to the callback object */
axis2_callback_set_on_error(callback, axis2_stub_on_error_IIp2Location_get);
callback_data-> data = user_data;
callback_data-> on_complete = on_complete;
callback_data-> on_error = on_error;
axis2_callback_set_data(callback, (void*)callback_data);
/* Send request */
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
if (!is_soap_act_set)
{
axis2_options_set_soap_action(options, env, NULL);
axis2_options_set_action(options, env, NULL);
}
}
int
main(
int argc,
char **argv)
{
const axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
axis2_endpoint_ref_t *endpoint_ref = NULL;
axis2_endpoint_ref_t *reply_to = NULL;
axis2_options_t *options = NULL;
const axis2_char_t *client_home = NULL;
axis2_svc_client_t *svc_client = NULL;
axiom_node_t *payload = NULL;
axis2_callback_t *callback = NULL;
int count = 0;
/* Set up the environment */
env =
axutil_env_create_all("echo_non_blocking_dual.log",
AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of echo service */
address = "http://localhost:9090/axis2/services/echo";
if (argc > 1)
address = argv[1];
if (axutil_strcmp(address, "-h") == 0)
{
printf("Usage : %s [endpoint_url]\n", argv[0]);
printf("use -h for help\n");
return 0;
}
printf("Using endpoint : %s\n", address);
/* Create EPR with given address */
endpoint_ref = axis2_endpoint_ref_create(env, address);
/* Setup options */
options = axis2_options_create(env);
axis2_options_set_to(options, env, endpoint_ref);
axis2_options_set_use_separate_listener(options, env, AXIS2_TRUE);
/* Seperate listner needs addressing, hence addressing stuff in options */
axis2_options_set_action(options, env,
"http://ws.apache.org/axis2/c/samples/echoString");
reply_to =
axis2_endpoint_ref_create(env,
"http://localhost:6060/axis2/services/__ANONYMOUS_SERVICE__/__OPERATION_OUT_IN__");
axis2_options_set_reply_to(options, env, reply_to);
/* Set up deploy folder. It is from the deploy folder, the configuration is picked up
* using the axis2.xml file.
* In this sample client_home points to the Axis2/C default deploy folder. The client_home can
* be different from this folder on your system. For example, you may have a different folder
* (say, my_client_folder) with its own axis2.xml file. my_client_folder/modules will have the
* modules that the client uses
*/
client_home = AXIS2_GETENV("AXIS2C_HOME");
if (!client_home || !strcmp(client_home, ""))
client_home = "../..";
/* Create service client */
svc_client = axis2_svc_client_create(env, client_home);
if (!svc_client)
{
printf
("Error creating service client, Please check AXIS2C_HOME again\n");
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));
return -1;
}
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
/*axis2_svc_client_engage_module(svc_client, env, "sandesha2"); */
/* Build the SOAP request message payload using OM API. */
payload = build_om_payload_for_echo_svc(env);
/* Create the callback object with default on_complete and on_error
callback functions */
callback = axis2_callback_create(env);
/* Set our on_complete fucntion pointer to the callback object */
axis2_callback_set_on_complete(callback, echo_callback_on_complete);
/* Set our on_error function pointer to the callback object */
axis2_callback_set_on_error(callback, echo_callback_on_error);
/* Send request */
axis2_svc_client_send_receive_non_blocking(svc_client, env,
payload, callback);
/** Wait till callback is complete. Simply keep the parent thread running
until our on_complete or on_error is invoked */
while (count < MAX_COUNT)
{
if (isComplete)
{
/* We are done with the callback */
break;
}
/* AXIS2_SLEEP(1); */
count++;
}
if (!(count < MAX_COUNT))
{
printf("\necho client invoke FAILED. Counter timed out.\n");
}
if (svc_client)
{
AXIS2_SLEEP(1);
axis2_svc_client_free(svc_client, env);
svc_client = NULL;
}
if (env)
{
axutil_env_free((axutil_env_t *) env);
env = NULL;
}
return 0;
}
int main(int argc, char** argv)
{
const axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
axis2_endpoint_ref_t* endpoint_ref = NULL;
axis2_endpoint_ref_t* reply_to = NULL;
axis2_options_t *options = NULL;
const axis2_char_t *client_home = NULL;
axis2_svc_client_t* svc_client = NULL;
axiom_node_t *payload = NULL;
axis2_callback_t *callback = NULL;
axis2_callback_t *callback2 = NULL;
axis2_callback_t *callback3 = NULL;
axutil_property_t *property = NULL;
axis2_char_t *offered_seq_id = NULL;
axis2_bool_t offer = AXIS2_TRUE;
neethi_policy_t *policy = NULL;
axis2_status_t status = AXIS2_FAILURE;
/* Set up the environment */
env = axutil_env_create_all("rm_echo_1_1_amqp.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of echo service */
address = "amqp://127.0.0.1:5672/axis2/services/RM11SampleService";
if (argc > 1)
{
if (axutil_strcmp(argv[1], "-h") == 0)
{
printf("Usage : %s [endpoint_url]\n", argv[0]);
printf("use -h for help\n");
return 0;
}
else
{
address = argv[1];
}
}
printf ("Using endpoint : %s\n", address);
/* Create EPR with given address */
endpoint_ref = axis2_endpoint_ref_create(env, address);
/* Setup options */
options = axis2_options_create(env);
axis2_options_set_to(options, env, endpoint_ref);
axis2_options_set_use_separate_listener(options, env, AXIS2_TRUE);
/* Seperate listner needs addressing, hence addressing stuff in options */
/*axis2_options_set_action(options, env,
"http://127.0.0.1:8080/axis2/services/RM11SampleService/anonOutInOp");*/
axis2_options_set_action(options, env, "urn:wsrm:EchoString");
reply_to = axis2_endpoint_ref_create(env,
"amqp://localhost:5672/axis2/services/__ANONYMOUS_SERVICE__");
axis2_options_set_reply_to(options, env, reply_to);
axis2_options_set_transport_in_protocol(options, env, AXIS2_TRANSPORT_ENUM_AMQP);
/* Set up deploy folder. It is from the deploy folder, the configuration is
* picked up using the axis2.xml file.
* In this sample client_home points to the Axis2/C default deploy folder.
* The client_home can be different from this folder on your system. For
* example, you may have a different folder (say, my_client_folder) with its
* own axis2.xml file. my_client_folder/modules will have the modules that
* the client uses
*/
client_home = AXIS2_GETENV("AXIS2C_HOME");
if (!client_home)
{
client_home = "../../..";
}
/* Create service client */
svc_client = axis2_svc_client_create(env, client_home);
if (!svc_client)
{
printf("Error creating service client\n");
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));
return -1;
}
/*Create the policy, from file*/
policy = neethi_util_create_policy_from_file(env, "../policy/rm11-policy.xml");
if(!policy)
{
printf("\nPolicy creation failed from the file");
return 0;
}
status = axis2_svc_client_set_policy(svc_client, env, policy);
if(status == AXIS2_FAILURE)
{
printf("Policy setting failed\n");
}
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
axis2_svc_client_engage_module(svc_client, env, "sandesha2");
/* Offer sequence */
if(offer)
{
offered_seq_id = axutil_uuid_gen(env);
property = axutil_property_create(env);
if(property)
{
axutil_property_set_value(property, env, axutil_strdup(env, offered_seq_id));
axis2_options_set_property(options, env, SANDESHA2_CLIENT_OFFERED_SEQ_ID, property);
}
}
/* RM Version 1.1 */
property = axutil_property_create_with_args(env, 3, 0, 0, SANDESHA2_SPEC_VERSION_1_1);
if(property)
{
axis2_options_set_property(options, env, SANDESHA2_CLIENT_RM_SPEC_VERSION, property);
}
payload = build_om_payload_for_echo_svc(env, "echo1");
callback = axis2_callback_create(env);
axis2_callback_set_on_complete(callback, rm_echo_callback_on_complete);
axis2_callback_set_on_error(callback, rm_echo_callback_on_error);
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
wait_on_callback(env, callback);
payload = build_om_payload_for_echo_svc(env, "echo2");
callback2 = axis2_callback_create(env);
axis2_callback_set_on_complete(callback2, rm_echo_callback_on_complete);
axis2_callback_set_on_error(callback2, rm_echo_callback_on_error);
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback2);
wait_on_callback(env, callback2);
AXIS2_SLEEP(SANDESHA2_MAX_COUNT);
callback3 = axis2_callback_create(env);
axis2_callback_set_on_complete(callback3, rm_echo_callback_on_complete);
axis2_callback_set_on_error(callback3, rm_echo_callback_on_error);
sandesha2_client_terminate_seq_with_svc_client(env, svc_client, callback3);
AXIS2_SLEEP(SANDESHA2_MAX_COUNT);
if (svc_client)
{
axis2_svc_client_free(svc_client, env);
svc_client = NULL;
}
return 0;
}
int main(int argc, char** argv)
{
const axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
axis2_endpoint_ref_t* endpoint_ref = NULL;
axis2_endpoint_ref_t* reply_to = NULL;
axis2_options_t *options = NULL;
const axis2_char_t *client_home = NULL;
axis2_svc_client_t* svc_client = NULL;
axiom_node_t *payload = NULL;
axis2_callback_t *callback = NULL;
neethi_policy_t *policy = NULL;
axis2_status_t status = AXIS2_FAILURE;
int i = 0;
/* Set up the environment */
env = axutil_env_create_all("rm_echo_1_1.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of echo service */
address = "http://127.0.0.1:9090/axis2/services/RM11SampleService";
if (argc > 1)
{
if (axutil_strcmp(argv[1], "-h") == 0)
{
printf("Usage : %s [endpoint_url]\n", argv[0]);
printf("use -h for help\n");
return 0;
}
else
{
address = argv[1];
}
}
printf ("Using endpoint : %s\n", address);
/* Create EPR with given address */
endpoint_ref = axis2_endpoint_ref_create(env, address);
/* Setup options */
options = axis2_options_create(env);
axis2_options_set_to(options, env, endpoint_ref);
axis2_options_set_use_separate_listener(options, env, AXIS2_TRUE);
/* Seperate listner needs addressing, hence addressing stuff in options */
/*axis2_options_set_action(options, env,
"http://127.0.0.1:8080/axis2/services/RM11SampleService/anonOutInOp");*/
axis2_options_set_action(options, env, "urn:wsrm:EchoString");
reply_to = axis2_endpoint_ref_create(env,
"http://localhost:6060/axis2/services/__ANONYMOUS_SERVICE__/"\
"__OPERATION_OUT_IN__");
axis2_options_set_reply_to(options, env, reply_to);
/* Set up deploy folder. It is from the deploy folder, the configuration is
* picked up using the axis2.xml file.
* In this sample client_home points to the Axis2/C default deploy folder.
* The client_home can be different from this folder on your system. For
* example, you may have a different folder (say, my_client_folder) with its
* own axis2.xml file. my_client_folder/modules will have the modules that
* the client uses
*/
client_home = AXIS2_GETENV("AXIS2C_HOME");
if (!client_home)
{
client_home = "../../deploy";
}
/* Create service client */
svc_client = axis2_svc_client_create(env, client_home);
if (!svc_client)
{
printf("Error creating service client\n");
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));
return -1;
}
/*Create the policy, from file*/
policy = neethi_util_create_policy_from_file(env, "policy/rm11-policy.xml");
if(!policy)
{
printf("\nPolicy creation failed from the file");
return 0;
}
status = axis2_svc_client_set_policy(svc_client, env, policy);
if(status == AXIS2_FAILURE)
{
printf("Policy setting failed\n");
}
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
axis2_svc_client_engage_module(svc_client, env, "sandesha2");
for(i = 1; i < 4; i++)
{
axis2_char_t echo_str[7];
sprintf(echo_str, "%s%d", "echo", i);
payload = build_om_payload_for_echo_svc(env, echo_str);
callback = axis2_callback_create(env);
axis2_callback_set_on_complete(callback, rm_echo_callback_on_complete);
axis2_callback_set_on_error(callback, rm_echo_callback_on_error);
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
wait_on_callback(env, callback);
}
axis2_svc_client_close(svc_client, env);
AXIS2_SLEEP(2 * 2 * SANDESHA2_MAX_COUNT);
if (svc_client)
{
axis2_svc_client_free(svc_client, env);
svc_client = NULL;
}
return 0;
}
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);
}
