AXIS2_EXTERN axis2_status_t AXIS2_CALL
savan_client_unsubscribe(
savan_client_t *client,
const axutil_env_t *env,
axis2_svc_client_t *svc_client)
{
axis2_options_t *wsa_options = NULL;
const axis2_char_t *old_action = NULL;
axiom_namespace_t *ns = NULL;
axiom_node_t *reply = NULL;
axiom_node_t *unsub_node = NULL;
axiom_element_t *unsub_elem = NULL;
axis2_status_t status = AXIS2_FAILURE;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_unsubscribe");
/* set wsa action as Unsub. remember the old action */
wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env);
old_action = axis2_options_get_action(wsa_options, env);
axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_UNSUB);
/* create the body of the Unsub request */
ns = axiom_namespace_create (env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX);
unsub_elem = axiom_element_create(env, NULL, ELEM_NAME_UNSUB, ns, &unsub_node);
savan_client_add_sub_id_to_soap_header(client, env, svc_client);
/* send the Unsub request and wait for the response */
reply = axis2_svc_client_send_receive(svc_client, env, unsub_node);
/* reset the old action */
axis2_options_set_action(wsa_options, env, old_action);
if (!reply)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to send unsubscribe "
"request. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
status = AXIS2_FAILURE;
}
else
status = AXIS2_SUCCESS;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_unsubscribe");
return status;
}
/**
* auto generated method signature
* for "registerClient|http://www.wso2.org" operation.
* @param registerClientRequest14
* @return
*/
axis2_registerClientResponse_t* axis2_stub_ExchangeTrader_registerClient( axis2_stub_t *stub, const axutil_env_t *env,
axis2_registerClientRequest_t* registerClientRequest14)
{
axis2_svc_client_t *svc_client = NULL;
axis2_options_t *options = NULL;
axiom_node_t *ret_node = NULL;
const axis2_char_t *soap_action = NULL;
axutil_qname_t *op_qname = NULL;
axiom_node_t *payload = NULL;
axis2_registerClientResponse_t* ret_val = 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 NULL;
}
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 );
op_qname = axutil_qname_create(env,
"registerClient" ,
"http://www.wso2.org",
NULL);
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
if ( NULL == ret_node )
{
return NULL;
}
ret_val = axis2_registerClientResponse_create(env);
axis2_registerClientResponse_deserialize(ret_val, env, ret_node );
return ret_val;
}
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);
}
/**
* auto generated method signature for in only mep invocations
* for "sell|http://www.wso2.org" operation.
* @param sellRequest_ex17
* @param on_complete callback to handle on complete
* @param on_error callback to handle on error
*/
axis2_status_t
axis2_stub_ExchangeTrader_sell( axis2_stub_t *stub, const axutil_env_t *env ,
axis2_sellRequest_ex_t* sellRequest_ex17)
{
axis2_status_t status;
axis2_svc_client_t *svc_client = NULL;
axis2_options_t *options = NULL;
const axis2_char_t *soap_action = NULL;
axutil_qname_t *op_qname = NULL;
axiom_node_t *payload = NULL;
payload = axis2_sellRequest_ex_serialize(sellRequest_ex17, 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 AXIS2_FAILURE;
}
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 );
op_qname = axutil_qname_create(env,
"sell" ,
"http://www.wso2.org",
NULL);
status = axis2_svc_client_send_robust_with_op_qname( svc_client, env, op_qname, payload);
return status;
}
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;
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;
}
adb_getResponse_t* AXIS2_CALL
axis2_stub_op_IIp2Location_get( axis2_stub_t *stub, const axutil_env_t *env,
adb_get_t* _get)
{
axis2_svc_client_t *svc_client = NULL;
axis2_options_t *options = NULL;
axiom_node_t *ret_node = NULL;
const axis2_char_t *soap_action = NULL;
axutil_qname_t *op_qname = NULL;
axiom_node_t *payload = NULL;
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
axutil_string_t *soap_act = NULL;
adb_getResponse_t* ret_val;
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 (adb_getResponse_t*)NULL;
}
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);
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
if (!is_soap_act_set)
{
axis2_options_set_soap_action(options, env, NULL);
axis2_options_set_action( options, env, NULL);
}
if(soap_act)
{
axutil_string_free(soap_act, env);
}
if ( NULL == ret_node )
{
return (adb_getResponse_t*)NULL;
}
ret_val = adb_getResponse_create(env);
if(adb_getResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
{
if(ret_val != NULL)
{
adb_getResponse_free(ret_val, env);
}
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getResponse_deserialize: "
"This should be due to an invalid XML");
return (adb_getResponse_t*)NULL;
}
return ret_val;
}
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_options_t *options = NULL;
const axis2_char_t *client_home = NULL;
axis2_svc_client_t *svc_client = NULL;
axiom_node_t *payload = NULL;
axiom_node_t *ret_node = NULL;
/* Set up the environment */
env =
axutil_env_create_all("echo_blocking_addr_amqp.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of echo service */
address = "amqp://localhost:5672/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_action(options, env,
"http://ws.apache.org/axis2/c/samples/echoString");
/* 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);
/* Engage addressing module */
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
/* Build the SOAP request message payload using OM API. */
payload = build_om_payload_for_echo_svc(env);
/* Send request */
ret_node = axis2_svc_client_send_receive(svc_client, env, payload);
if (ret_node)
{
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");
}
else
{
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 client invoke FAILED!\n");
}
if (svc_client)
{
axis2_svc_client_free(svc_client, env);
svc_client = NULL;
}
if (env)
{
axutil_env_free((axutil_env_t *) env);
env = NULL;
}
return 0;
}
AXIS2_EXTERN axis2_char_t * AXIS2_CALL
savan_client_get_status(
savan_client_t *client,
const axutil_env_t *env,
axis2_svc_client_t *svc_client)
{
axis2_options_t *wsa_options = NULL;
const axis2_char_t *old_action = NULL;
axutil_qname_t *qname = NULL;
axiom_namespace_t *ns = NULL;
axiom_node_t *reply = NULL;
axiom_node_t *status_node = NULL;
axiom_node_t *expires_node = NULL;
axiom_element_t *status_elem = NULL;
axiom_element_t *expires_elem = NULL;
axis2_char_t *expires = NULL;
axis2_char_t *status_elem_localname = NULL;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_get_status");
/* Set wsa action as GetStatus. remember the old action */
wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env);
old_action = axis2_options_get_action(wsa_options, env);
axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_GET_STATUS);
/* Create the body of the GetStatus request */
ns = axiom_namespace_create (env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX);
status_elem = axiom_element_create(env, NULL, ELEM_NAME_GETSTATUS, ns, &status_node);
savan_client_add_sub_id_to_soap_header(client, env, svc_client);
/* Send the GetStatus request and wait for the response */
reply = axis2_svc_client_send_receive(svc_client, env, status_node);
/* Reset the old action */
axis2_options_set_action(wsa_options, env, old_action);
if (!reply)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to send get status "
"request. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
status_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env);
/* Check whether we have received a GetStatusResponse */
status_elem_localname = axiom_element_get_localname(status_elem, env);
if (axutil_strcmp(ELEM_NAME_GETSTATUS_RESPONSE, status_elem_localname))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve GetStatusResponse"\
"element. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
/* Now read Expires sub element */
qname = axutil_qname_create(env, ELEM_NAME_EXPIRES, EVENTING_NAMESPACE, NULL);
expires_elem = axiom_element_get_first_child_with_qname(status_elem, env, qname, reply,
&expires_node);
axutil_qname_free(qname, env);
if(!expires_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve Expires"\
"element. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
expires_elem = (axiom_element_t *) axiom_node_get_data_element(expires_node, env);
expires = axiom_element_get_text(expires_elem, env, expires_node);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_get_status");
return expires;
}
void
wsdl_util_manage_client_options(
const axutil_env_t* env,
axis2_svc_client_t* svc_client,
axutil_hash_t* svc_client_user_options,
axis2_options_t* client_options,
const axis2_char_t* operation_name,
axiom_node_t* wsdl_axiom,
axis2_bool_t is_version1_wsdl,
axiom_node_t* sig_axiom,
axis2_char_t* service_name,
axis2_char_t* port_name,
axiom_node_t** operation_axiom,
int* soap_version)
{
axis2_char_t* endpoint_address = NULL;
axis2_char_t* classmap = NULL;
axis2_char_t* proxy_host = NULL;
axis2_char_t* proxy_port = NULL;
axis2_bool_t option_supported = AXIS2_TRUE; /* ;-) */
int string_malloc_length = -1;
axis2_bool_t is_multiple_interfaces = AXIS2_FALSE;
axis2_bool_t multiple_ep = AXIS2_FALSE;
axis2_endpoint_ref_t *to_epr = NULL;
axis2_char_t *soap_action = NULL;
axis2_char_t *wsa_action = NULL;
axis2_bool_t is_http_method_post = AXIS2_TRUE;
axiom_node_t* binding_node = NULL;
axis2_char_t *ssl_server_key_filename = NULL;
axis2_char_t *ssl_client_key_filename = NULL;
axis2_char_t *passphrase = NULL;
axutil_hash_t* wsdl_policy_hash = NULL;
/* allocations */
string_malloc_length = sizeof(axis2_char_t) * 256;
endpoint_address = (axis2_char_t *)AXIS2_MALLOC(env->allocator, string_malloc_length);
classmap = (axis2_char_t *)AXIS2_MALLOC(env->allocator, string_malloc_length);
soap_action = (axis2_char_t *)AXIS2_MALLOC(env->allocator, string_malloc_length);
wsa_action = (axis2_char_t *)AXIS2_MALLOC(env->allocator, string_malloc_length);
strcpy(soap_action, "");
strcpy(wsa_action, "");
if (svc_client_user_options)
{
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_ENDPOINT))
{
strcpy(endpoint_address, (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_ENDPOINT, AXIS2_HASH_KEY_STRING));
}
else
{
strcpy(endpoint_address, "");
}
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_CLASSMAP))
{
strcpy(classmap, (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_CLASSMAP, AXIS2_HASH_KEY_STRING));
}
else
{
strcpy(classmap, "");
}
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_USE_SOAP))
{
axis2_char_t* use_soap = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_USE_SOAP, AXIS2_HASH_KEY_STRING);
if (axutil_strcmp(use_soap, WSF_WSDL_SOAP_1_2) == 0)
{
*soap_version = 2;
AXIS2_LOG_DEBUG_MSG(env->log, "soap version SOAP12");
}
else if (axutil_strcmp(use_soap, WSF_WSDL_SOAP_1_1) == 0)
{
*soap_version = 1;
AXIS2_LOG_DEBUG_MSG(env->log, "soap version SOAP11");
}
else
{
/* TODO: support REST */
}
}
else
{
/* default to soap version 1.2 */
*soap_version = 2;
AXIS2_LOG_DEBUG_MSG(env->log, "default to soap version 1.2");
}
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_PROXY_HOST))
{
proxy_host = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_PROXY_HOST, AXIS2_HASH_KEY_STRING);
}
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_PROXY_PORT))
{
proxy_port = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_PROXY_PORT, AXIS2_HASH_KEY_STRING);
}
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_CLIENT_CERT))
{
ssl_server_key_filename = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_CLIENT_CERT, AXIS2_HASH_KEY_STRING);
}
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_PASSPHRASE))
{
ssl_client_key_filename = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_PASSPHRASE, AXIS2_HASH_KEY_STRING);
}
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_SERVER_CERT))
{
passphrase = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_SERVER_CERT, AXIS2_HASH_KEY_STRING);
}
if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_HTTP_METHOD))
{
if (axutil_strcasecmp((axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_HTTP_METHOD, AXIS2_HASH_KEY_STRING), AXIS2_HTTP_GET) == 0)
{
is_http_method_post = AXIS2_FALSE;
}
}
}
else
{
strcpy(endpoint_address, "");
}
is_multiple_interfaces = AXIS2_FALSE;
/* TODO: add support for multiple port/interface types */
if (axutil_strcmp(endpoint_address, "") == 0)
{
axis2_char_t* sig_endpoint_address = NULL;
if (wsdl_util_get_endpoint_address(sig_axiom, env, &sig_endpoint_address) == AXIS2_SUCCESS)
{
strcpy(endpoint_address, (char *)sig_endpoint_address);
}
}
else
{
multiple_ep = 1;
/* TODO: add suppor for multiple endpoints */
}
if (option_supported) /* get binding details */
{
axiom_node_t* op_axiom = NULL;
int soap_ver = 2;
axis2_char_t* wsa_action_binding_details = NULL;
axis2_char_t* soap_action_binding_details = NULL;
if (wsdl_util_find_operation(env,
operation_name, endpoint_address,
AXIS2_TRUE /* is_multiple */,
sig_axiom,
&op_axiom,
&soap_ver) == AXIS2_SUCCESS)
{
*operation_axiom = op_axiom;
*soap_version = soap_ver;
if (wsdl_util_get_binding_details(env,
op_axiom,
&wsa_action, &soap_action) == AXIS2_SUCCESS)
{
if (wsa_action_binding_details)
strcpy (wsa_action, wsa_action_binding_details);
if (soap_action_binding_details)
strcpy (soap_action, soap_action_binding_details);
/*TODO: check this condition */
//if (wsa_action_binding_details || soap_action_binding_details)
//{
// soap_version = soap_version_binding_details;
//}
}
}
}
if (wsf_wsdl_util_get_binding_node(env,
wsdl_axiom,
is_version1_wsdl,
service_name,
port_name,
&binding_node))
{
if (wsf_wsdl_util_get_all_policies_from_wsdl(env,
wsdl_axiom,
is_version1_wsdl,
binding_node,
operation_name,
&wsdl_policy_hash))
{
wsf_wsdl_util_configure_security_for_svc_client(env,
svc_client_user_options,
wsdl_policy_hash,
svc_client);
}
}
to_epr = axis2_endpoint_ref_create (env, endpoint_address);
axis2_options_set_to (client_options, env, to_epr);
/** enable ssl **/
if (option_supported) /* wsf_client_enable_ssl */
{
axutil_property_t *ssl_server_key_prop = NULL;
axutil_property_t *ssl_client_key_prop = NULL;
axutil_property_t *passphrase_prop = NULL;
ssl_server_key_prop =
axutil_property_create_with_args (env, 0, AXIS2_TRUE, 0,
axutil_strdup (env, ssl_server_key_filename));
axis2_options_set_property (client_options, env, WSF_WSDL_SERVER_CERT, ssl_server_key_prop);
ssl_client_key_prop = axutil_property_create_with_args (env, 0, AXIS2_TRUE, 0,
axutil_strdup (env, ssl_client_key_filename));
axis2_options_set_property (client_options, env, WSF_WSDL_KEY_FILE, ssl_client_key_prop);
passphrase_prop = axutil_property_create_with_args (env, 0, AXIS2_TRUE, 0, axutil_strdup (env, passphrase));
axis2_options_set_property (client_options, env, WSF_WSDL_SSL_PASSPHRASE, passphrase_prop);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"[wsf-client] setting ssh options %s -- %s -- %s ",
ssl_server_key_filename, ssl_client_key_filename, passphrase);
}
if (axutil_strcmp(soap_action, "") != 0){
axutil_string_t *action_string = axutil_string_create (env, soap_action);
axis2_options_set_soap_action (client_options, env, action_string);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"soap action present :- %s",
soap_action);
}
if (axutil_strcmp(wsa_action, "") != 0){
axis2_options_set_action(client_options, env, wsa_action);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"addressing action present :- %s",
wsa_action);
axis2_svc_client_engage_module (svc_client, env, WSF_WSDL_MODULE_ADDRESSING);
}
if (*soap_version)
{
axis2_options_set_soap_version (client_options, env,
*soap_version);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"[wsf_wsdl]soap version in wsdl mode is %d",
*soap_version);
}
/*
Add proxy options */
if (proxy_host && proxy_port)
{
axis2_svc_client_set_proxy (svc_client, env, proxy_host, proxy_port);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"[wsf_wsdl_client] setting proxy options %s -- %s -- ", proxy_host,
proxy_port);
}
/*
Default header type is POST, so only setting the HTTP_METHOD if GET */
if (is_http_method_post == AXIS2_FALSE)
{
axutil_property_t *property = axutil_property_create (env);
axutil_property_set_value (property, env, axutil_strdup (env, AXIS2_HTTP_GET));
axis2_options_set_property (client_options, env, AXIS2_HTTP_METHOD, property);
AXIS2_LOG_DEBUG_MSG(env->log, "[wsf_client] setting http method get property");
}
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
savan_client_renew(
savan_client_t *client,
const axutil_env_t *env,
axis2_svc_client_t *svc_client,
axutil_hash_t *options)
{
axis2_options_t *wsa_options = NULL;
const axis2_char_t *old_action = NULL;
axiom_namespace_t *ns = NULL;
axiom_node_t *reply = NULL;
axiom_node_t *renew_node = NULL;
axiom_node_t *expires_node = NULL;
axiom_element_t *renew_elem = NULL;
axiom_element_t *expires_elem = NULL;
axis2_char_t *expires = NULL;
axis2_char_t *renew_elem_localname = NULL;
axutil_qname_t *qname = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_renew");
/* Set wsa action as Renew. remember the old action */
wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env);
old_action = axis2_options_get_action(wsa_options, env);
axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_RENEW);
/* Create the body of the Renew request */
ns = axiom_namespace_create (env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX);
renew_elem = axiom_element_create(env, NULL, ELEM_NAME_RENEW, ns, &renew_node);
/* Extract the values from the options map */
expires = axutil_hash_get(options, SAVAN_OP_KEY_EXPIRES, AXIS2_HASH_KEY_STRING);
if(expires)
{
/* Expires element */
expires_elem = axiom_element_create(env, renew_node, ELEM_NAME_EXPIRES, ns,
&expires_node);
axiom_element_set_text(expires_elem, env, expires, expires_node);
}
savan_client_add_sub_id_to_soap_header(client, env, svc_client);
/* send the Renew request and wait for the response */
reply = axis2_svc_client_send_receive(svc_client, env, renew_node);
/* reset the old action */
axis2_options_set_action(wsa_options, env, old_action);
if (!reply)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[savan] Failed to send renew request. Error: %d Reason: %s",
env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
renew_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env);
/* Check whether we have received a RenewResponse */
renew_elem_localname = axiom_element_get_localname(renew_elem, env);
if (axutil_strcmp(ELEM_NAME_RENEW_RESPONSE, renew_elem_localname))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve RenewResponse"\
"element. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
/* Get Expires element from RenewResponse element */
qname = axutil_qname_create(env, ELEM_NAME_EXPIRES, EVENTING_NAMESPACE, NULL);
expires_elem = axiom_element_get_first_child_with_qname(renew_elem, env, qname, reply,
&expires_node);
axutil_qname_free(qname, env);
if(!expires_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve Expires"\
"element. Error: %d Reason: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
expires = axiom_element_get_text(expires_elem, env, expires_node);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_renew");
return expires;
}
int
main(
int argc,
char** argv)
{
const axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
const axis2_char_t *client_home = NULL;
axis2_char_t *file_name = NULL;
axis2_char_t *policy_file = NULL;
axis2_endpoint_ref_t* endpoint_ref = NULL;
axis2_options_t *options = NULL;
axis2_svc_client_t* svc_client = NULL;
axiom_node_t *payload = NULL;
axiom_node_t *ret_node = NULL;
axis2_status_t status = AXIS2_FAILURE;
neethi_policy_t *policy = NULL;
/*axutil_property_t *property = NULL;
int i = 0;*/
/* Set up the environment */
env = axutil_env_create_all("echo.log", AXIS2_LOG_LEVEL_TRACE);
/*if (argc == 4)
AXIS2_SLEEP(10); */
/* Set end-point-reference of echo service */
address = "http://localhost:9090/axis2/services/echo";
if(argc > 2)
{
address = argv[1];
client_home = argv[2];
printf("Using endpoint : %s\n", address);
printf("Using client_home : %s\n", client_home);
}
if((axutil_strcmp(argv[1], "-h") == 0) || (axutil_strcmp(argv[1], "--help") == 0))
{
printf("Usage : %s [endpoint_url] [client_home]\n", argv[0]);
printf("use -h for help\n");
return 0;
}
/* Create end-point-reference 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_action(options, env, "http://example.com/ws/2004/09/policy/Test/EchoRequest");
/*axis2_options_set_action(options, env,
"http://xmlsoap.org/Ping");*/
/*axis2_options_set_action(options, env,
"urn:echoString");*/
/*axis2_options_set_soap_action(options, env, axutil_string_create(env, "http://xmlsoap.org/Ping"));
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);*/
axis2_options_set_soap_version(options, env, AXIOM_SOAP12);
/*If the client home is not specified, use the WSFC_HOME*/
if(!client_home)
{
client_home = AXIS2_GETENV("WSFC_HOME");
printf("\nNo client_home specified. Using default %s", client_home);
}
/* Create service client */
printf("client_home= %s", client_home);
svc_client = axis2_svc_client_create(env, client_home);
if(!svc_client)
{
printf("Error creating service client\n");
return -1;
}
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
/*
property = axutil_property_create(env);
axutil_property_set_scope(property, env, AXIS2_SCOPE_APPLICATION);
axutil_property_set_value(property, env, AXIS2_WSA_NAMESPACE_SUBMISSION);
axis2_options_set_property(options, env, AXIS2_WSA_VERSION, property);
*/
/*We need to specify the client's policy file location*/
if(client_home)
{
file_name = axutil_stracat(env, client_home, AXIS2_PATH_SEP_STR);
policy_file = axutil_stracat(env, file_name, "policy.xml");
AXIS2_FREE(env->allocator, file_name);
file_name = NULL;
}
else
{
printf("Client Home not Specified\n");
printf("echo client invoke FAILED!\n");
return 0;
}
/*Create the policy, from file*/
policy = neethi_util_create_policy_from_file(env, policy_file);
if(policy_file)
{
AXIS2_FREE(env->allocator, policy_file);
policy_file = NULL;
}
if(!policy)
{
printf("\nPolicy creation failed from the file. %s\n", policy_file);
}
status = axis2_svc_client_set_policy(svc_client, env, policy);
if(status == AXIS2_FAILURE)
{
printf("Policy setting failed\n");
}
/* Build the SOAP request message payload using OM API.*/
payload = build_om_payload_for_echo_svc(env);
/*axis2_options_set_enable_mtom(options, env, AXIS2_TRUE);*/
/*If not engaged in the client's axis2.xml, uncomment this line*/
axis2_svc_client_engage_module(svc_client, env, "rampart");
/* Send request */
ret_node = axis2_svc_client_send_receive(svc_client, env, payload);
if(axis2_svc_client_get_last_response_has_fault(svc_client, env))
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_soap_fault_t *soap_fault = NULL;
printf("\nResponse has a SOAP fault\n");
soap_envelope = axis2_svc_client_get_last_response_soap_envelope(svc_client, env);
if(soap_envelope)
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
if(soap_body)
soap_fault = axiom_soap_body_get_fault(soap_body, env);
if(soap_fault)
{
printf("\nReturned SOAP fault: %s\n", axiom_node_to_string(
axiom_soap_fault_get_base_node(soap_fault, env), env));
}
printf("echo client invoke FAILED!\n");
return -1;
}
if(ret_node)
{
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);
}
printf("\necho client invoke SUCCESSFUL!\n");
AXIS2_FREE(env->allocator, om_str);
ret_node = NULL;
}
else
{
printf("echo client invoke FAILED!\n");
return -1;
}
if(svc_client)
{
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_options_t *options = NULL;
const axis2_char_t *client_home = NULL;
axis2_svc_client_t* svc_client = NULL;
axiom_node_t *payload = NULL;
axis2_status_t status = AXIS2_FAILURE;
axutil_property_t *property = NULL;
axis2_char_t *seq_key = NULL;
neethi_policy_t *policy = NULL;
/* Set up the environment */
env = axutil_env_create_all("rm_ping_1_0_amqp.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of echo service */
address = "amqp://127.0.0.1:5672/axis2/services/RM10SampleService";
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_xml_parser_reset(options, env, AXIS2_FALSE);
if(endpoint_ref)
{
axis2_options_set_to(options, env, endpoint_ref);
}
axis2_options_set_action(options, env, "urn:wsrm:Ping");
/* 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));
}
/*Create the policy, from file*/
policy = neethi_util_create_policy_from_file(env, "../policy/rm10-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);
/* Engage addressing module */
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
axis2_svc_client_engage_module(svc_client, env, "sandesha2");
/* RM Version 1.0 */
property = axutil_property_create_with_args(env, 0, 0, 0, SANDESHA2_SPEC_VERSION_1_0);
if(property)
{
axis2_options_set_property(options, env, SANDESHA2_CLIENT_RM_SPEC_VERSION, property);
}
seq_key = axutil_uuid_gen(env);
property = axutil_property_create_with_args(env, 0, 0, 0, seq_key);
if(property)
{
axis2_options_set_property(options, env, SANDESHA2_CLIENT_SEQ_KEY, property);
}
/* Send request */
payload = build_om_programatically(env, "ping1", seq_key);
status = axis2_svc_client_send_robust(svc_client, env, payload);
if(status)
{
printf("\nping client invoke SUCCESSFUL!\n");
}
payload = NULL;
payload = build_om_programatically(env, "ping2", seq_key);
status = axis2_svc_client_send_robust(svc_client, env, payload);
if(status)
{
printf("\nping client invoke SUCCESSFUL!\n");
}
payload = NULL;
property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
axis2_options_set_property(options, env, "Sandesha2LastMessage", property);
payload = build_om_programatically(env, "ping3", seq_key);
status = axis2_svc_client_send_robust(svc_client, env, payload);
if(status)
{
printf("\nping client invoke SUCCESSFUL!\n");
}
/** Wait till callback is complete. Simply keep the parent thread running
until our on_complete or on_error is invoked */
/*This sleep is for wait the main thread until sandesha sends the terminatesequence
*messages. */
AXIS2_SLEEP(SANDESHA2_SLEEP);
AXIS2_FREE(env->allocator, seq_key);
if (svc_client)
{
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_options_t *options = NULL;
const axis2_char_t *client_home = NULL;
axis2_svc_client_t *svc_client = NULL;
axiom_node_t *payload = NULL;
axiom_node_t *ret_node = NULL;
const axis2_char_t *image_name = "resources/axis2.jpg";
/* Set up the environment */
env = axutil_env_create_all("mtom_callback.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of mtom service */
address = "http://localhost:9090/axis2/services/mtom_callback";
if (argc > 1)
address = argv[1];
if (axutil_strcmp(address, "-h") == 0)
{
printf
("Usage : %s [endpoint_url] [image_name] \n",
argv[0]);
printf("use -h for help\n");
return 0;
}
if (argc > 2)
image_name = argv[2];
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_action(options, env,
"http://ws.apache.org/axis2/c/samples/mtomCallbackSample");
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
axis2_options_set_enable_mtom(options, env, AXIS2_TRUE);
/* 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("WSFC_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 WSFC_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);
/* Engage addressing module */
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
/* Build the SOAP request message payload using OM API. */
payload =
build_om_programatically(env, image_name);
/* Send request */
ret_node = axis2_svc_client_send_receive(svc_client, env, payload);
if (ret_node)
{
axis2_char_t *om_str = NULL;
om_str = axiom_node_to_string(ret_node, env);
if (om_str)
{
if (axis2_svc_client_get_last_response_has_fault(svc_client, env) == AXIS2_TRUE)
{
printf("\nRecieved Fault : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
}
else
{
printf("\nReceived OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
printf("\nmtom client invoke SUCCESSFUL!\n");
process_response_node(env, ret_node);
}
}
}
else
{
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("\nmtom client invoke FAILED!\n");
printf("\nSending callback may not be set. Check the log for more details.\n");
}
if (svc_client)
{
axis2_svc_client_free(svc_client, env);
svc_client = NULL;
}
if (env)
{
axutil_env_free((axutil_env_t *) env);
env = NULL;
}
return 0;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
savan_client_subscribe(
savan_client_t *client,
const axutil_env_t *env,
axis2_svc_client_t *svc_client,
axutil_hash_t *options)
{
axis2_options_t *wsa_options = NULL;
const axis2_char_t *old_action = NULL;
axiom_node_t *reply = NULL;
axiom_node_t *sub_node = NULL;
axiom_element_t *body_elem = NULL;
axis2_char_t *sub_id = NULL;
axis2_char_t *sub_url = NULL;
axis2_char_t *sub_elem_local_name = NULL;
savan_subscriber_t *subscriber = NULL;
/*axis2_char_t *endto = NULL;*/
axis2_char_t *notify = NULL;
axis2_char_t *filter = NULL;
axis2_char_t *filter_dialect = NULL;
axis2_char_t *expires = NULL;
axis2_status_t status = AXIS2_SUCCESS;
axis2_endpoint_ref_t *endpoint_ref = NULL;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_subscribe");
/* set wsa action as Subscribe. remember the old action */
wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env);
old_action = axis2_options_get_action(wsa_options, env);
axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_SUB);
/* extract the values from the options map */
/* endto endpoint reference is used by the event source to send a subscription end message. Default is not
* to send this message by the event source. How this should be provided by the client?
*/
/*endto = axutil_hash_get(options, SAVAN_OP_KEY_ENDTO_EPR, AXIS2_HASH_KEY_STRING);*/
notify = axutil_hash_get(options, SAVAN_OP_KEY_NOTIFY_EPR, AXIS2_HASH_KEY_STRING);
filter = axutil_hash_get(options, SAVAN_OP_KEY_FILTER, AXIS2_HASH_KEY_STRING);
filter_dialect = axutil_hash_get(options, SAVAN_OP_KEY_FILTER_DIALECT, AXIS2_HASH_KEY_STRING);
expires = axutil_hash_get(options, SAVAN_OP_KEY_EXPIRES, AXIS2_HASH_KEY_STRING);
subscriber = savan_subscriber_create(env);
/*endpoint_ref = axis2_endpoint_ref_create(env, endto);
savan_subscriber_set_end_to(subscriber, env, endpoint_ref);*/
endpoint_ref = axis2_endpoint_ref_create(env, notify);
savan_subscriber_set_notify_to(subscriber, env, endpoint_ref);
savan_subscriber_set_filter(subscriber, env, filter);
savan_subscriber_set_filter_dialect(subscriber, env, filter_dialect);
if(expires)
{
savan_subscriber_set_expires(subscriber, env, expires);
}
/* Create the Subscriber node */
sub_node = savan_util_create_subscriber_node(env, subscriber, NULL);
if(!sub_node)
{
status = axutil_error_get_status_code(env->error);
savan_subscriber_free(subscriber, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Could not create the subscriber node");
return status;
}
/* send the Subscription and wait for the response */
reply = axis2_svc_client_send_receive(svc_client, env, sub_node);
/* reset the old action */
axis2_options_set_action(wsa_options, env, old_action);
if (!reply)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[savan] Failed to send subscription request. Error: %d Reason: %s",
env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/* Extract the subscription id from the response and store for future
* requests */
/* Get Body element from body node */
body_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env);
/* Check whether we have received a SubscribeResponse */
sub_elem_local_name = axiom_element_get_localname(body_elem, env);
if (axutil_strcmp(ELEM_NAME_SUB_RESPONSE, sub_elem_local_name))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Subscription failed");
return AXIS2_FAILURE;
}
sub_id = savan_client_get_sub_id_from_response(body_elem, reply, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "sub_id3:%s", sub_id);
client->sub_id = axutil_strdup(env, sub_id);
sub_url = savan_client_get_sub_url_from_response(body_elem, reply, env);
client->sub_url = axutil_strdup(env, sub_url);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_subscribe");
return AXIS2_SUCCESS;
}
static axis2_status_t
savan_default_publisher_publish_to_subscriber(
savan_publisher_t *publishermod,
const axutil_env_t *env,
axis2_svc_client_t *svc_client,
savan_subscriber_t *subscriber,
savan_filter_mod_t *filtermod,
axiom_node_t *payload)
{
axis2_options_t *options = NULL;
axis2_status_t status = AXIS2_SUCCESS;
axis2_endpoint_ref_t *to = NULL;
const axis2_char_t *address = NULL;
axis2_bool_t filter_apply = AXIS2_TRUE;
axis2_endpoint_ref_t *notifyto = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_default_publisher_publish_to_subscriber");
options = (axis2_options_t *) axis2_svc_client_get_options(svc_client, env);
if(!options)
{
options = axis2_options_create(env);
axis2_svc_client_set_options(svc_client, env, options);
}
axis2_options_set_action(options, env, "http://ws.apache.org/ws/2007/05/eventing-extended/Publish");
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
notifyto = savan_subscriber_get_notify_to(subscriber, env);
if(notifyto)
{
address = axis2_endpoint_ref_get_address(notifyto, env);
if(address)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Publishing to:%s", address);
to = axis2_endpoint_ref_create(env, address);
axis2_options_set_to(options, env, to);
}
}
axis2_options_set_xml_parser_reset(options, env, AXIS2_FALSE);
#ifdef SAVAN_FILTERING
/* If this is a filtering request and filter module is defined then filter the request.
*/
{
axis2_char_t *filter_dialect = NULL;
filter_dialect = savan_subscriber_get_filter_dialect(subscriber, env);
if(!axutil_strcmp(filter_dialect, SYNAPSE_FILTER_DIALECT))
{
/* Do nothing */
}
else if(filtermod && savan_subscriber_get_filter(subscriber, env))
{
/* Apply the filter, and check whether it evaluates to success */
filter_apply = savan_filter_mod_apply(filtermod ,env, subscriber, payload);
if(!filter_apply)
{
status = axutil_error_get_status_code(env->error);
if(AXIS2_SUCCESS != status)
{
axiom_node_detach(payload, env);
return status;
}
}
}
else
{
AXIS2_HANDLE_ERROR(env, SAVAN_ERROR_FILTER_MODULE_COULD_NOT_BE_RETRIEVED,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
#endif
if(filter_apply)
{
axis2_svc_client_fire_and_forget(svc_client, env, payload);
}
axiom_node_detach(payload, env); /*insert this to prevent payload corruption in subsequent
"publish" calls with some payload.*/
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_default_publisher_publish_to_subscriber");
return status;
}
rampart_issued_token_t * AXIS2_CALL
get_issued_token(const axutil_env_t *env, rp_property_t *issued_token, rampart_context_t *rampart_context)
{
axis2_endpoint_ref_t *endpoint_ref = NULL;
axis2_options_t *options = NULL;
axis2_svc_client_t *svc_client = NULL;
axiom_node_t *rst_node = NULL;
axiom_node_t *return_rstr_node = NULL;
trust_rstr_t *rstr = NULL;
axiom_node_t *assertion = NULL;
rampart_saml_token_t *saml = NULL;
rampart_issued_token_t *token = NULL;
axis2_op_client_t* op_client = NULL;
axis2_msg_ctx_t *in_msg_ctx = NULL;
axis2_status_t status = AXIS2_SUCCESS;
neethi_policy_t *issuer_policy = NULL;
trust_rst_t *rst = NULL;
rp_issued_token_t *it = (rp_issued_token_t *)rp_property_get_value(issued_token, env);
/*Setting Issuer's EPR*/
endpoint_ref = endpoint_ref = axis2_endpoint_ref_create(env, "http://127.0.0.1:9090/axis2/services/saml_sts");
options = axis2_options_create(env);
axis2_options_set_to(options, env, endpoint_ref);
/*Create the policy, from file*/
issuer_policy = neethi_util_create_policy_from_file(env, sts_ploicy);
if(!issuer_policy)
{
printf("\nPolicy creation failed from the file. %s\n", policy_file);
}
/*axis2_options_set_action(options, env, action); WSA Action*/
svc_client = axis2_svc_client_create(env, client_home);
if (!svc_client)
{
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 NULL;
}
axis2_options_set_action(options, env, "http://example.com/ws/2004/09/policy/Test/EchoRequest");
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
rst = trust_rst_create(env);
trust_rst_set_wst_ns_uri(rst, env, "http://schemas.xmlsoap.org/ws/2005/02/trust");
rst_node = trust_rst_build_rst_with_issued_token_assertion(rst, env, it);
if (status == AXIS2_SUCCESS)
{
status = axis2_svc_client_set_policy(svc_client, env, issuer_policy);
if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Policy setting failed.");
}
/*Building the RST */
if(rst_node)
{
return_rstr_node = axis2_svc_client_send_receive(svc_client, env, rst_node);
rstr = trust_rstr_create(env);
trust_rstr_set_wst_ns_uri(rstr, env, "http://schemas.xmlsoap.org/ws/2005/02/trust");
trust_rstr_populate_rstr(rstr, env, return_rstr_node);
assertion = trust_rstr_get_requested_security_token(rstr, env);
}
}
saml = rampart_saml_token_create(env, assertion, RAMPART_ST_CONFIR_TYPE_SENDER_VOUCHES);
rampart_saml_token_set_token_type(saml, env, RAMPART_ST_TYPE_SIGNED_SUPPORTING_TOKEN);
token = rampart_issued_token_create(env);
rampart_issued_token_set_token(token, env, saml, RP_PROPERTY_SAML_TOKEN);
return token;
}
int main(int argc, char** argv)
{
const axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
const axis2_char_t *client_home = NULL;
axis2_char_t *file_name = NULL;
axis2_char_t *policy_file = NULL;
axis2_endpoint_ref_t* endpoint_ref = NULL;
axis2_options_t *options = NULL;
axis2_svc_client_t* svc_client = NULL;
axiom_node_t *payload = NULL;
axiom_node_t *ret_node = NULL;
axis2_status_t status = AXIS2_FAILURE;
neethi_policy_t *policy = NULL;
rampart_config_t* client_config = NULL;
axutil_property_t *property = NULL;
rampart_saml_token_t *saml = NULL;
axiom_node_t *assertion = NULL;
/* Set up the environment */
env = axutil_env_create_all("echo.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end-point-reference of echo service */
address = "http://localhost:9090/axis2/services/echo";
if (argc > 2)
{
address = argv[1];
client_home = argv[2];
printf("Using endpoint : %s\n", address);
printf("Using client_home : %s\n", client_home);
}
if ((axutil_strcmp(argv[1], "-h") == 0) || (axutil_strcmp(argv[1], "--help") == 0))
{
printf("Usage : %s [endpoint_url] [client_home]\n", argv[0]);
printf("use -h for help\n");
return 0;
}
/* Create end-point-reference 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_action(options, env,
"http://example.com/ws/2004/09/policy/Test/EchoRequest");
/*axis2_options_set_action(options, env,
"urn:echo");*/
/*If the client home is not specified, use the AXIS2C_HOME*/
if (!client_home)
{
client_home = AXIS2_GETENV("AXIS2C_HOME");
printf("\nNo client_home specified. Using default %s", client_home);
}
/* Create service client */
printf("client_home= %s", client_home);
svc_client = axis2_svc_client_create(env, client_home);
if (!svc_client)
{
printf("Error creating service client\n");
return -1;
}
client_config = rampart_config_create(env);
if(!client_config)
{
printf("Cannot create rampart config\n");
return 0;
}
assertion = create_saml_assertion(env);
saml = rampart_saml_token_create(env, assertion, RAMPART_ST_CONFIR_TYPE_SENDER_VOUCHES);
rampart_saml_token_set_token_type(saml, env, RAMPART_ST_TYPE_SIGNED_SUPPORTING_TOKEN);
rampart_config_add_saml_token(client_config, env, saml);
property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST ,
AXIS2_TRUE, (void *)rampart_config_free, client_config);
axis2_options_set_property(options, env, RAMPART_CLIENT_CONFIGURATION, property);
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
/*We need to specify the client's policy file location*/
if(client_home)
{
file_name = axutil_stracat(env, client_home, AXIS2_PATH_SEP_STR);
policy_file = axutil_stracat(env, file_name, "policy.xml" );
AXIS2_FREE(env->allocator, file_name);
file_name = NULL;
}else{
printf("Client Home not Specified\n");
printf("echo client invoke FAILED!\n");
return 0;
}
/*Create the policy, from file*/
policy = neethi_util_create_policy_from_file(env, policy_file);
if(!policy)
{
printf("\nPolicy creation failed from the file. %s\n", policy_file);
}
if(policy_file){
AXIS2_FREE(env->allocator, policy_file);
policy_file = NULL;
}
status = axis2_svc_client_set_policy(svc_client, env, policy);
if(status == AXIS2_FAILURE)
{
printf("Policy setting failed\n");
}
/* Build the SOAP request message payload using OM API.*/
payload = build_om_payload_for_echo_svc(env);
/*If not engaged in the client's axis2.xml, uncomment this line*/
axis2_svc_client_engage_module(svc_client, env, "rampart");
/* Send request */
ret_node = axis2_svc_client_send_receive(svc_client, env, payload);
if (axis2_svc_client_get_last_response_has_fault(svc_client, env))
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_soap_fault_t *soap_fault = NULL;
printf ("\nResponse has a SOAP fault\n");
soap_envelope =
axis2_svc_client_get_last_response_soap_envelope(svc_client, env);
if (soap_envelope)
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
if (soap_body)
soap_fault = axiom_soap_body_get_fault(soap_body, env);
if (soap_fault)
{
printf("\nReturned SOAP fault: %s\n",
axiom_node_to_string(axiom_soap_fault_get_base_node(soap_fault,env),
env));
}
printf("echo client invoke FAILED!\n");
return -1;
}
if (ret_node)
{
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);
}
printf("\necho client invoke SUCCESSFUL!\n");
AXIS2_FREE(env->allocator, om_str);
ret_node = NULL;
}
else
{
printf("echo client invoke FAILED!\n");
return -1;
}
if (svc_client)
{
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_listener_manager_t *listener_manager = NULL;
int i;
axis2_status_t status = AXIS2_FAILURE;
axiom_node_t *result = NULL;
neethi_policy_t *policy = NULL;
/* Set up the environment */
env = axutil_env_create_all("rm_echo_single_1_1.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of echo service */
/*address = "http://127.0.0.1:9090/axis2/services/RM11SampleService";*/
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);
/* 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");
reply_to = axis2_endpoint_ref_create(env, AXIS2_WSA_ANONYMOUS_URL);
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;
}
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");
listener_manager = axis2_listener_manager_create(env);
if (!listener_manager)
{
return AXIS2_FAILURE;
}
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);
result = axis2_svc_client_send_receive(svc_client, env, payload);
if(result)
{
/*axis2_char_t *om_str = NULL;
om_str = axiom_node_to_string(result, env);
if (om_str)
{
printf("\nReceived OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
}*/
printf("\necho client two way single channel invoke SUCCESSFUL!\n");
result = NULL;
}
else
{
printf("\necho client two way single channel invoke FAILED!\n");
}
}
AXIS2_SLEEP(SANDESHA2_SLEEP);
axis2_svc_client_close(svc_client, env);
AXIS2_SLEEP(6 * SANDESHA2_SLEEP);
if (svc_client)
{
axis2_svc_client_free(svc_client, env);
svc_client = NULL;
}
return 0;
}
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);
}
}
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);
}