axis2_status_t AXIS2_CALL
echo_process_response_envelope(
struct axis2_callback * callback,
const axutil_env_t * env)
{
/** SOAP response has arrived here; get the soap envelope
from the callback object and do whatever you want to do with it */
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_node_t *ret_node = NULL;
axis2_status_t status = AXIS2_SUCCESS;
soap_envelope = axis2_callback_get_envelope(callback, env);
if (!soap_envelope)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Stub invoke FAILED: Error code:" " %d :: %s",
env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
printf("echo stub invoke FAILED!\n");
status = AXIS2_FAILURE;
}
else
{
ret_node = axiom_soap_envelope_get_base_node(soap_envelope, env);
if (!ret_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Stub invoke FAILED: Error code:" " %d :: %s",
env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
printf("echo stub invoke FAILED!\n");
status = AXIS2_FAILURE;
}
else
{
axis2_char_t *om_str = NULL;
om_str = axiom_node_to_string(ret_node, env);
if (om_str)
{
printf("\nReceived OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
}
printf("\necho client invoke SUCCESSFUL!\n");
}
}
return status;
}
/**
* setter for portFolioItem
*/
axis2_status_t AXIS2_CALL
axis2_PortFolio_set_portFolioItem(
axis2_PortFolio_t* PortFolio,
const axutil_env_t *env,
axutil_array_list_t* param_portFolioItem)
{
int size = 0;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if(!PortFolio)
{
return AXIS2_FAILURE;
}
size = axutil_array_list_size( param_portFolioItem, env);
if ( size < 0 )
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "portFolioItem has less than minOccurs(0)"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
PortFolio-> attrib_portFolioItem = param_portFolioItem;
return AXIS2_SUCCESS;
}
/**
* setter for trade_status
*/
axis2_status_t AXIS2_CALL
axis2_buyResponse_set_trade_status(
axis2_buyResponse_t* buyResponse,
const axutil_env_t *env,
axis2_TradeStatus_t* param_trade_status)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if(!buyResponse)
{
return AXIS2_FAILURE;
}
if( NULL == param_trade_status )
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "trade_status is NULL, but not a nullable element"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
buyResponse-> attrib_trade_status = param_trade_status;
return AXIS2_SUCCESS;
}
/**
* setter for symbol
*/
axis2_status_t AXIS2_CALL
axis2_sellRequest_ex_set_symbol(
axis2_sellRequest_ex_t* sellRequest_ex,
const axutil_env_t *env,
axis2_char_t* param_symbol)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if(!sellRequest_ex)
{
return AXIS2_FAILURE;
}
if( NULL == param_symbol )
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "symbol is NULL, but not a nullable element"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
sellRequest_ex-> attrib_symbol = param_symbol;
return AXIS2_SUCCESS;
}
/**
* setter for portFolio
*/
axis2_status_t AXIS2_CALL
axis2_getPortfolioResponse_set_portFolio(
axis2_getPortfolioResponse_t* getPortfolioResponse,
const axutil_env_t *env,
axis2_PortFolio_t* param_portFolio)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if(!getPortfolioResponse)
{
return AXIS2_FAILURE;
}
if( NULL == param_portFolio )
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "portFolio is NULL, but not a nullable element"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
getPortfolioResponse-> attrib_portFolio = param_portFolio;
return AXIS2_SUCCESS;
}
axiom_node_t* ajSoapAxis2Call(axis2_svc_client_t *client,
const axutil_env_t *env,
axiom_node_t *payload)
{
axiom_node_t *ret_node = NULL;
axis2_char_t * om_str = NULL;
if (ajDebugOn())
{
om_str = axiom_node_to_string(payload, env);
if (om_str)
{
ajDebug("\nSending OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
om_str = NULL;
}
}
/* Send request */
ret_node = axis2_svc_client_send_receive(client, env, payload);
if (ret_node)
{
if(ajDebugOn())
{
om_str = axiom_node_to_string(ret_node, env);
if (om_str)
ajDebug("\nReceived OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
om_str = NULL;
}
}
else
{
ajDebug("seqAxis2wsCall: webservice call failed: %s\n",
AXIS2_ERROR_GET_MESSAGE(env->error));
ajErr("webservice call FAILED: %s\n",
AXIS2_ERROR_GET_MESSAGE(env->error));
}
return ret_node;
}
axis2_status_t AXIS2_CALL
rm_echo_callback_on_error(
struct axis2_callback *callback,
const axutil_env_t *env,
int exception)
{
/** take necessary action on error */
printf("\nEcho client invoke FAILED. Error code:%d ::%s", exception,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_SUCCESS;
}
/**
* 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;
}
axis2_svc_client_t* ajSoapAxis2GetClient(const axutil_env_t *env,
const axis2_char_t *address)
{
AjPStr home = NULL;
axis2_endpoint_ref_t* endpoint_ref = NULL;
axis2_options_t* options = NULL;
axis2_svc_client_t* svc_client = NULL;
options = axis2_options_create(env);
endpoint_ref = axis2_endpoint_ref_create(env, address);
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
axis2_options_set_to(options, env, endpoint_ref);
/* Set up axis2c location.
** This is either from:
** EMBOSS_AXIS2C_HOME: Used by mEMBOSS as axis2c files are
** provided by the setup and there could
** be confusion with an existing axis2c
** installation otherwise.
** axis2C_HOME: The location specified during the
** EMBOSS configuration.
**
** The client uses this information to pick up the
** libraries, modules and axis2.xml file
*/
if(!ajNamGetValueC("AXIS2C_HOME",&home))
home = ajStrNewC(axis2C_HOME);
/* Create service client */
svc_client = axis2_svc_client_create(env, ajStrGetPtr(home));
if (!svc_client)
{
ajErr("Error creating webservice client: %s",
AXIS2_ERROR_GET_MESSAGE(env->error));
return NULL;
}
axis2_svc_client_set_options(svc_client, env, options);
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
ajStrDel(&home);
return svc_client;
}
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);
}
static axis2_status_t AXIS2_CALL CallbackOnFault(axis2_callback_t* pCallback, const axutil_env_t* pEnv,
int nFaultCode)
{
if (!pCallback)
{
LogError() << "pCallback is NULL";
return AXIS2_FAILURE;
}
PICallback tpCallback(reinterpret_cast<ICallback<const DataObject&>*>(axis2_callback_get_data(pCallback)));
axis2_callback_set_data(pCallback, NULL); // avoid axis2/c to destroy C++ data
if (!tpCallback.get())
{
LogError() << "pointer to ICallback is NULL";
return AXIS2_FAILURE;
}
axiom_node_t* pAxiomResponseNode = NULL;
{
axiom_soap_envelope_t* pSoapEnvelope = axis2_callback_get_envelope(pCallback, pEnv);
if (pSoapEnvelope)
{
pAxiomResponseNode = axiom_soap_envelope_get_base_node(pSoapEnvelope, pEnv);
#ifdef _DEBUG
LogDebug2() << "Received Response: \n" << staff::ColorTextBlue
<< DataObject(pAxiomResponseNode).ToString() << staff::ColorDefault;
#endif
}
}
try
{
if (!pAxiomResponseNode)
{
CreateFault(*tpCallback, AXIS2_ERROR_GET_MESSAGE(pEnv->error), ToString(nFaultCode));
}
else
{
tpCallback->OnFault(pAxiomResponseNode);
}
}
STAFF_CATCH_ALL_DESCR("Error while processing response")
return AXIS2_SUCCESS;
}
AXIS2_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 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[])
{
axutil_allocator_t *allocator = NULL;
axutil_env_t *env = NULL;
extern char *optarg;
extern int optopt;
int c;
int log_file_size = AXUTIL_LOG_FILE_SIZE;
axutil_log_levels_t log_level = AXIS2_LOG_LEVEL_DEBUG;
const axis2_char_t *log_file = AXIS2_TCP_SERVER_LOG_FILE_NAME;
int port = AXIS2_TCP_SERVER_PORT;
const axis2_char_t *repo_path = AXIS2_TCP_SERVER_REPO_PATH;
while((c = AXIS2_GETOPT(argc, argv, ":p:r:ht:l:s:f:")) != -1)
{
switch(c)
{
case 'p':
port = AXIS2_ATOI(optarg);
break;
case 'r':
repo_path = optarg;
break;
case 't':
axis2_tcp_socket_read_timeout = AXIS2_ATOI(optarg) * 1000;
break;
case 'l':
log_level = AXIS2_ATOI(optarg);
if(log_level < AXIS2_LOG_LEVEL_CRITICAL)
log_level = AXIS2_LOG_LEVEL_CRITICAL;
if(log_level > AXIS2_LOG_LEVEL_TRACE)
log_level = AXIS2_LOG_LEVEL_TRACE;
break;
case 's':
log_file_size = 1024 * 1024 * AXIS2_ATOI(optarg);
break;
case 'f':
log_file = optarg;
break;
case 'h':
usage(argv[0]);
return 0;
case ':':
fprintf(stderr, "\nOption -%c requires an operand\n", optopt);
usage(argv[0]);
return -1;
case '?':
if(isprint(optopt))
fprintf(stderr, "\nUnknown option `-%c'.\n", optopt);
usage(argv[0]);
return -1;
}
}
allocator = axutil_allocator_init(NULL);
if(!allocator)
{
system_exit(NULL, -1);
}
env = init_syetem_env(allocator, log_file);
env->log->level = log_level;
env->log->size = log_file_size;
axutil_error_init();
system_env = env;
#ifndef WIN32
signal(SIGINT, sig_handler);
signal(SIGPIPE, sig_handler);
#endif
AXIS2_LOG_INFO(env->log, "Starting Axis2 TCP server....");
AXIS2_LOG_INFO(env->log, "Server port : %d", port);
AXIS2_LOG_INFO(env->log, "Repo location : %s", repo_path);
AXIS2_LOG_INFO(env->log, "Read Timeout : %d ms", axis2_tcp_socket_read_timeout);
server = axis2_tcp_server_create(env, repo_path, port);
if(!server)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Server creation failed: Error code:" " %d :: %s",
env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
system_exit(env, -1);
}
printf("Started Simple Axis2 TCP Server ...\n");
if(axis2_transport_receiver_start(server, env) == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Server start failed: Error code:" " %d :: %s",
env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
system_exit(env, -1);
}
return 0;
}
/*
* This method invokes the right service method
*/
axiom_node_t* AXIS2_CALL
axis2_svc_skel_TraderExchange_invoke(axis2_svc_skeleton_t *svc_skeleton,
const axutil_env_t *env,
axiom_node_t *content_node,
axis2_msg_ctx_t *msg_ctx)
{
/* depending on the function name invoke the
* corresponding method
*/
axis2_op_ctx_t *operation_ctx = NULL;
axis2_op_t *operation = NULL;
axutil_qname_t *op_qname = NULL;
axis2_char_t *op_name = NULL;
axiom_node_t *ret_node = NULL;
axis2_status_t ret_val1 = AXIS2_SUCCESS;
axis2_updateRequest_t* input_val1_1;
operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
operation = axis2_op_ctx_get_op(operation_ctx, env);
op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env);
op_name = axutil_qname_get_localpart(op_qname, env);
if (op_name)
{
if ( axutil_strcmp(op_name, "update") == 0 )
{
input_val1_1 =
axis2_updateRequest_create( env);
axis2_updateRequest_deserialize(input_val1_1, env, content_node );
ret_val1 = axis2_skel_TraderExchange_update(env,
input_val1_1 );
if ( AXIS2_FAILURE == ret_val1)
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from update "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return axis2_svc_skel_TraderExchange_on_fault( svc_skeleton, env, NULL);
}
/*ret_node =
axis2__serialize(ret_val1, env, NULL, AXIS2_FALSE);
axis2__free(ret_val1, env);
axis2_updateRequest_free(input_val1_1, env);
*/
return ret_node;
}
}
printf("axis2_svc_skel_TraderExchange service ERROR: invalid OM parameters in request\n");
return content_node;
}
/*
* This method invokes the right service method
*/
axiom_node_t* AXIS2_CALL
axis2_svc_skel_TraderClient_invoke(axis2_svc_skeleton_t *svc_skeleton,
const axutil_env_t *env,
axiom_node_t *content_node,
axis2_msg_ctx_t *msg_ctx)
{
/* depending on the function name invoke the
* corresponding method
*/
axis2_op_ctx_t *operation_ctx = NULL;
axis2_op_t *operation = NULL;
axutil_qname_t *op_qname = NULL;
axis2_char_t *op_name = NULL;
axiom_node_t *ret_node = NULL;
axis2_buyResponse_t* ret_val1 = NULL;
axis2_buyRequest_t* input_val1_1;
axis2_getPortfolioResponse_t* ret_val2 = NULL;
axis2_getPortfolioRequest_t* input_val2_1;
axis2_depositResponse_t* ret_val3 = NULL;
axis2_depositRequest_t* input_val3_1;
axis2_getSymbolsResponse_t* ret_val4 = NULL;
axis2_getSymbolsRequest_t* input_val4_1;
axis2_getQuoteResponse_t* ret_val5 = NULL;
axis2_getQuoteRequest_t* input_val5_1;
axis2_createAccountResponse_t* ret_val6 = NULL;
axis2_createAccountRequest_t* input_val6_1;
axis2_sellResponse_t* ret_val7 = NULL;
axis2_sellRequest_t* input_val7_1;
operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
operation = axis2_op_ctx_get_op(operation_ctx, env);
op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env);
op_name = axutil_qname_get_localpart(op_qname, env);
if (op_name)
{
if ( axutil_strcmp(op_name, "buy") == 0 )
{
input_val1_1 =
axis2_buyRequest_create( env);
axis2_buyRequest_deserialize(input_val1_1, env, content_node );
ret_val1 = axis2_skel_TraderClient_buy(env,
input_val1_1 );
if ( NULL == ret_val1 )
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from buy "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL);
}
ret_node =
axis2_buyResponse_serialize(ret_val1, env, NULL, AXIS2_FALSE);
axis2_buyResponse_free(ret_val1, env);
axis2_buyRequest_free(input_val1_1, env);
return ret_node;
}
if ( axutil_strcmp(op_name, "getPortfolio") == 0 )
{
input_val2_1 =
axis2_getPortfolioRequest_create( env);
axis2_getPortfolioRequest_deserialize(input_val2_1, env, content_node );
ret_val2 = axis2_skel_TraderClient_getPortfolio(env,
input_val2_1 );
if ( NULL == ret_val2 )
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from getPortfolio "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL);
}
ret_node =
axis2_getPortfolioResponse_serialize(ret_val2, env, NULL, AXIS2_FALSE);
axis2_getPortfolioResponse_free(ret_val2, env);
axis2_getPortfolioRequest_free(input_val2_1, env);
return ret_node;
}
if ( axutil_strcmp(op_name, "deposit") == 0 )
{
input_val3_1 =
axis2_depositRequest_create( env);
axis2_depositRequest_deserialize(input_val3_1, env, content_node );
ret_val3 = axis2_skel_TraderClient_deposit(env,
input_val3_1 );
if ( NULL == ret_val3 )
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from deposit "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL);
}
ret_node =
axis2_depositResponse_serialize(ret_val3, env, NULL, AXIS2_FALSE);
axis2_depositResponse_free(ret_val3, env);
axis2_depositRequest_free(input_val3_1, env);
return ret_node;
}
if ( axutil_strcmp(op_name, "getSymbols") == 0 )
{
input_val4_1 =
axis2_getSymbolsRequest_create( env);
axis2_getSymbolsRequest_deserialize(input_val4_1, env, content_node );
ret_val4 = axis2_skel_TraderClient_getSymbols(env,
input_val4_1 );
if ( NULL == ret_val4 )
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from getSymbols "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL);
}
ret_node =
axis2_getSymbolsResponse_serialize(ret_val4, env, NULL, AXIS2_FALSE);
axis2_getSymbolsResponse_free(ret_val4, env);
axis2_getSymbolsRequest_free(input_val4_1, env);
return ret_node;
}
if ( axutil_strcmp(op_name, "getQuote") == 0 )
{
input_val5_1 =
axis2_getQuoteRequest_create( env);
axis2_getQuoteRequest_deserialize(input_val5_1, env, content_node );
ret_val5 = axis2_skel_TraderClient_getQuote(env,
input_val5_1 );
if ( NULL == ret_val5 )
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from getQuote "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL);
}
ret_node =
axis2_getQuoteResponse_serialize(ret_val5, env, NULL, AXIS2_FALSE);
axis2_getQuoteResponse_free(ret_val5, env);
axis2_getQuoteRequest_free(input_val5_1, env);
return ret_node;
}
if ( axutil_strcmp(op_name, "createAccount") == 0 )
{
input_val6_1 =
axis2_createAccountRequest_create( env);
axis2_createAccountRequest_deserialize(input_val6_1, env, content_node );
ret_val6 = axis2_skel_TraderClient_createAccount(env,
input_val6_1 );
if ( NULL == ret_val6 )
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from createAccount "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL);
}
ret_node =
axis2_createAccountResponse_serialize(ret_val6, env, NULL, AXIS2_FALSE);
axis2_createAccountResponse_free(ret_val6, env);
axis2_createAccountRequest_free(input_val6_1, env);
return ret_node;
}
if ( axutil_strcmp(op_name, "sell") == 0 )
{
input_val7_1 =
axis2_sellRequest_create( env);
axis2_sellRequest_deserialize(input_val7_1, env, content_node );
ret_val7 = axis2_skel_TraderClient_sell(env,
input_val7_1 );
if ( NULL == ret_val7 )
{
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from sell "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return axis2_svc_skel_TraderClient_on_fault( svc_skeleton, env, NULL);
}
ret_node =
axis2_sellResponse_serialize(ret_val7, env, NULL, AXIS2_FALSE);
axis2_sellResponse_free(ret_val7, env);
axis2_sellRequest_free(input_val7_1, env);
return ret_node;
}
}
printf("axis2_svc_skel_TraderClient service ERROR: invalid OM parameters in request\n");
return content_node;
}
axis2_status_t AXIS2_CALL
axis2_sellRequest_ex_deserialize(
axis2_sellRequest_ex_t* sellRequest_ex,
const axutil_env_t *env,
axiom_node_t* parent)
{
axis2_status_t status = AXIS2_SUCCESS;
axiom_namespace_t *ns1 = NULL;
axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axiom_node_t *first_node = NULL;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
ns1 = axiom_namespace_create (env,
"http://www.wso2.org/types",
"ns1");
if ( NULL == parent )
{
/** This should be checked above */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL elemenet for sellRequest_ex"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
current_element = axiom_node_get_data_element( parent, env);
qname = axiom_element_get_qname( current_element, env, parent);
if ( axutil_qname_equals( qname, env, sellRequest_ex-> qname ) )
{
first_node = axiom_node_get_first_child( parent, env);
}
else
{
first_node = parent;
}
/**
* building userid element
*/
current_node = first_node;
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_sellRequest_ex_set_userid( sellRequest_ex, env,
text_value);
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userid "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element userid missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/**
* building symbol element
*/
/**
* because elements are ordered this works fine
*/
if( current_node != NULL)
{
current_node = axiom_node_get_next_sibling( current_node, env);
}
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_sellRequest_ex_set_symbol( sellRequest_ex, env,
text_value);
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for symbol "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element symbol missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/**
* building qty element
*/
/**
* because elements are ordered this works fine
*/
if( current_node != NULL)
{
current_node = axiom_node_get_next_sibling( current_node, env);
}
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_sellRequest_ex_set_qty( sellRequest_ex, env,
atoi( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for qty "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element qty missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
return status;
}
axis2_status_t AXIS2_CALL
axis2_buyResponse_deserialize(
axis2_buyResponse_t* buyResponse,
const axutil_env_t *env,
axiom_node_t* parent)
{
axis2_status_t status = AXIS2_SUCCESS;
axiom_namespace_t *ns1 = NULL;
void *element = NULL;
/*axis2_char_t* text_value = NULL;*/
axutil_qname_t *qname = NULL;
axiom_node_t *first_node = NULL;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
ns1 = axiom_namespace_create (env,
"http://www.wso2.org/types",
"ns1");
if ( NULL == parent )
{
/** This should be checked above */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL elemenet for buyResponse"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
current_element = axiom_node_get_data_element( parent, env);
qname = axiom_element_get_qname( current_element, env, parent);
if ( axutil_qname_equals( qname, env, buyResponse-> qname ) )
{
first_node = axiom_node_get_first_child( parent, env);
}
else
{
first_node = parent;
}
/**
* building trade_status element
*/
current_node = first_node;
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
element = (void*)axis2_TradeStatus_create( env);
status = axis2_TradeStatus_deserialize( ( axis2_TradeStatus_t*)element, env,
axiom_node_get_first_child(current_node, env)==NULL?current_node:axiom_node_get_first_child(current_node, env));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element trade_status "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
status = axis2_buyResponse_set_trade_status( buyResponse, env,
( axis2_TradeStatus_t*)element);
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for trade_status "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element trade_status missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
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_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;
}
axis2_status_t AXIS2_CALL
axis2_PortFolio_deserialize(
axis2_PortFolio_t* PortFolio,
const axutil_env_t *env,
axiom_node_t* parent)
{
axis2_status_t status = AXIS2_SUCCESS;
axiom_namespace_t *ns1 = NULL;
int i = 0;
int element_found = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
void *element = NULL;
/*axis2_char_t* text_value = NULL;*/
axutil_qname_t *qname = NULL;
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
ns1 = axiom_namespace_create (env,
"http://www.wso2.org/types",
"ns1");
if ( NULL == parent )
{
/** This should be checked above */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL elemenet for PortFolio"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
first_node = parent;
/**
* building portFolioItem array
*/
arr_list = axutil_array_list_create( env, 10);
/**
* building portFolioItem element
*/
element_qname = axutil_qname_create( env, "portFolioItem", "","");
for ( i = 0, sequence_broken = 0, tmp_node = current_node = first_node; current_node != NULL; current_node = axiom_node_get_next_sibling( current_node, env))
{
current_element = axiom_node_get_data_element( current_node, env);
qname = axiom_element_get_qname( current_element, env, current_node);
if ( axutil_qname_equals( element_qname, env, qname) )
{
if( sequence_broken)
{
/** found element out of order */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "elements found out of order for arrayportFolioItem missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
tmp_node = current_node; /** always update the current node */
element_found = 1;
element = (void*)axis2_PortFolioItem_create( env);
status = axis2_PortFolioItem_deserialize( ( axis2_PortFolioItem_t*)element, env,
axiom_node_get_first_child(current_node, env)==NULL?current_node:axiom_node_get_first_child(current_node, env));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element portFolioItem "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
axutil_array_list_add_at( arr_list, env, i, element);
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for portFolioItem "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
i ++;
}
else
{
sequence_broken = 1;
}
}
current_node = tmp_node;
status = axis2_PortFolio_set_portFolioItem( PortFolio, env,
arr_list);
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_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_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);
/* Set up deploy folder */
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);
/* Build the SOAP request message payload using OM API. */
payload = build_om_payload_for_echo_svc (env);
/* Send request and get response */
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;
}
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_status_t AXIS2_CALL
axis2_MarketInfo_deserialize(
axis2_MarketInfo_t* MarketInfo,
const axutil_env_t *env,
axiom_node_t* parent)
{
axis2_status_t status = AXIS2_SUCCESS;
axiom_namespace_t *ns1 = NULL;
axis2_char_t* text_value = NULL;
/*axutil_qname_t *qname = NULL;*/
axiom_node_t *first_node = NULL;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
ns1 = axiom_namespace_create (env,
"http://www.wso2.org/types",
"ns1");
if ( NULL == parent )
{
/** This should be checked above */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL elemenet for MarketInfo"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
first_node = parent;
/**
* building totalTraded element
*/
current_node = first_node;
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_MarketInfo_set_totalTraded( MarketInfo, env,
atof( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for totalTraded "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element totalTraded missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/**
* building avgPrice element
*/
/**
* because elements are ordered this works fine
*/
if( current_node != NULL)
{
current_node = axiom_node_get_next_sibling( current_node, env);
}
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_MarketInfo_set_avgPrice( MarketInfo, env,
atof( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for avgPrice "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element avgPrice missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/**
* building avgPriceOfTrade element
*/
/**
* because elements are ordered this works fine
*/
if( current_node != NULL)
{
current_node = axiom_node_get_next_sibling( current_node, env);
}
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_MarketInfo_set_avgPriceOfTrade( MarketInfo, env,
atof( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for avgPriceOfTrade "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element avgPriceOfTrade missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/**
* building marketCap element
*/
/**
* because elements are ordered this works fine
*/
if( current_node != NULL)
{
current_node = axiom_node_get_next_sibling( current_node, env);
}
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_MarketInfo_set_marketCap( MarketInfo, env,
atof( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for marketCap "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element marketCap missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
return status;
}
axis2_status_t AXIS2_CALL
wsf_xml_msg_recv_invoke_business_logic_sync(
axis2_msg_recv_t * msg_recv,
const axutil_env_t * env,
axis2_msg_ctx_t * in_msg_ctx,
axis2_msg_ctx_t * out_msg_ctx)
{
axis2_op_ctx_t *op_ctx = NULL;
axis2_op_t *op_desc = NULL;
axiom_namespace_t *env_ns = NULL;
int soap_version = AXIOM_SOAP12;
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t skel_invoked = AXIS2_FALSE;
const axis2_char_t *style = NULL;
axis2_char_t *local_name = NULL;
axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
axis2_char_t *operation_name = NULL;
char *classname = NULL;
axutil_property_t *svc_info_prop = NULL;
axutil_property_t *req_info_prop = NULL;
wsf_svc_info_t *svc_info = NULL;
wsf_request_info_t *req_info = NULL;
/** store in_msg_ctx envelope */
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
axiom_node_t *in_body_node = NULL;
/* store out_msg_ctx envelope */
axiom_soap_envelope_t *default_envelope = NULL;
axiom_soap_body_t *out_body = NULL;
axiom_soap_header_t *out_header = NULL;
axiom_soap_fault_t *out_soap_fault = NULL;
axiom_node_t *result_node = NULL;
axiom_node_t *out_body_content_node = NULL;
axiom_element_t *out_body_content_element = NULL;
axiom_node_t *out_node = NULL;
zval **output_headers_zval = NULL;
TSRMLS_FETCH();
AXIS2_PARAM_CHECK(env->error, in_msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, out_msg_ctx, AXIS2_FAILURE);
op_ctx = axis2_msg_ctx_get_op_ctx(in_msg_ctx, env);
op_desc = axis2_op_ctx_get_op(op_ctx, env);
style = axis2_op_get_style(op_desc, env);
envelope = axis2_msg_ctx_get_soap_envelope(in_msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
in_body_node = axiom_soap_body_get_base_node(body, env);
if (0 == axutil_strcmp(AXIS2_STYLE_DOC, style))
{
local_name = wsf_xml_msg_recv_get_method_name(in_msg_ctx, env);
if (!local_name)
{
return AXIS2_FAILURE;
}
} else if (0 == axutil_strcmp(AXIS2_STYLE_RPC, style))
{
axiom_node_t *op_node = NULL;
axiom_element_t *op_element = NULL;
op_node = axiom_node_get_first_child(in_body_node, env);
if (!op_node)
{
return AXIS2_FAILURE;
}
op_element = axiom_node_get_data_element(op_node, env);
if (!op_element)
{
return AXIS2_FAILURE;
}
local_name = axiom_element_get_localname(op_element, env);
if (!local_name)
{
return AXIS2_FAILURE;
}
}
/** set soap version and soap namespace to local variables */
if (in_msg_ctx && axis2_msg_ctx_get_is_soap_11(in_msg_ctx, env))
{
soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */
soap_version = AXIOM_SOAP11;
}
svc_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_SVC_INFO);
if (svc_info_prop)
{
svc_info = (wsf_svc_info_t *) axutil_property_get_value(svc_info_prop, env);
if (svc_info)
{
operation_name = axutil_hash_get(svc_info->ops_to_functions, local_name,
AXIS2_HASH_KEY_STRING);
if (!operation_name)
{
return AXIS2_FAILURE;
}
} else
{
return AXIS2_FAILURE;
}
if (svc_info->ops_to_classes)
{
classname = axutil_hash_get(svc_info->ops_to_classes, local_name, AXIS2_HASH_KEY_STRING);
}
}
req_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_REQ_INFO);
if (req_info_prop)
{
req_info = (wsf_request_info_t *) axutil_property_get_value(req_info_prop, env);
if (axis2_msg_ctx_get_doing_rest(in_msg_ctx, env))
{
axis2_op_t *op = NULL;
axiom_node_t *body_child_node = NULL;
axiom_element_t *body_child = NULL;
int i = 0;
body_child_node = axiom_node_get_first_child(in_body_node, env);
if (!body_child_node)
{
op = axis2_msg_ctx_get_op(in_msg_ctx, env);
if (op)
{
body_child = axiom_element_create_with_qname(env, NULL,
axis2_op_get_qname(op, env), &body_child_node);
axiom_soap_body_add_child(body, env, body_child_node);
}
}
if (req_info->param_keys && req_info->param_values)
{
int i = 0;
for (i = 0; i < axutil_array_list_size(req_info->param_keys, env); i++)
{
axiom_node_t *node = NULL;
axiom_element_t *element = NULL;
axis2_char_t *param_key = NULL;
axis2_char_t *param_value = NULL;
param_key = axutil_array_list_get(req_info->param_keys, env, i);
param_value = axutil_array_list_get(req_info->param_values, env, i);
element = axiom_element_create(env, NULL, param_key,
NULL, &node);
axiom_element_set_text(element, env, param_value, node);
axiom_node_add_child(body_child_node, env, node);
AXIS2_FREE(env->allocator, param_key);
AXIS2_FREE(env->allocator, param_value);
}
axutil_array_list_free(req_info->param_keys, env);
axutil_array_list_free(req_info->param_values, env);
}
}
}
if (svc_info->ht_op_params)
{
zval **tmp;
char *function_type = NULL;
if (zend_hash_find(svc_info->ht_op_params,
operation_name, strlen(operation_name) + 1,
(void **) & tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING)
{
function_type = Z_STRVAL_PP(tmp);
if (strcmp(function_type, WSF_MIXED) == 0)
{
result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info,
in_msg_ctx, out_msg_ctx, operation_name,
classname, &output_headers_zval TSRMLS_CC);
} else if (strcmp(function_type, WSF_WSMESSAGE) == 0)
{
result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name,
in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC);
}
}
} else
{
/* this is where the default value for opParam is set,
If the wsdl option is set go for the MIXED mode by default */
if (svc_info->wsdl == NULL || svc_info->omit_wsdl)
{
result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name,
in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC);
} else
{
result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info,
in_msg_ctx, out_msg_ctx, operation_name,
classname, &output_headers_zval TSRMLS_CC);
}
}
if (!result_node)
{
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
} else
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "Response node is not null");
}
if (result_node)
{
if (0 == axutil_strcmp(style, AXIS2_STYLE_RPC))
{
axiom_namespace_t *ns = NULL;
axis2_char_t *response_name = NULL;
response_name = axutil_stracat(env, local_name, "Response");
ns = axiom_namespace_create(env, "http://soapenc/", "res");
if (!ns)
{
return AXIS2_FAILURE;
}
out_body_content_element = axiom_element_create(env, NULL, response_name,
ns, &out_body_content_node);
axiom_node_add_child(out_body_content_node, env, result_node);
} else
{
out_body_content_node = result_node;
}
}
if (axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env))
{
/* service implementation has set the envelope, useful when setting a SOAP fault.
No need to further process */
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "soap fault is set");
return AXIS2_SUCCESS;
}
/* create the soap envelope here */
env_ns = axiom_namespace_create(env, soap_ns, AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
if (!env_ns)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] error seting the namespces for the "
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX);
return AXIS2_FAILURE;
}
default_envelope = axiom_soap_envelope_create(env, env_ns);
if (!default_envelope)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap envelope");
return AXIS2_FAILURE;
}
out_body = axiom_soap_body_create_with_parent(env, default_envelope);
if (!out_body)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in creating the response soap body");
return AXIS2_FAILURE;
}
out_header = axiom_soap_header_create_with_parent(env, default_envelope);
if (!out_header)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap headers");
return AXIS2_FAILURE;
}
if (output_headers_zval)
{
axiom_node_t *header_base_node = NULL;
HashPosition pos;
zval **param;
char *header_str;
axiom_node_t *header_node;
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(output_headers_zval), &pos);
zend_hash_get_current_data_ex(Z_ARRVAL_PP(output_headers_zval),
(void **) & param, &pos) == SUCCESS;
zend_hash_move_forward_ex(Z_ARRVAL_PP(output_headers_zval), &pos))
{
if (Z_TYPE_PP(param) == IS_STRING)
{
header_base_node = axiom_soap_header_get_base_node(out_header, env);
if (header_base_node)
{
header_str = Z_STRVAL_PP(param);
header_node = wsf_util_deserialize_buffer(env, header_str);
axiom_node_add_child(header_base_node, env, header_node);
} else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap headers node");
return AXIS2_FAILURE;
}
}
}
}
out_node = axiom_soap_body_get_base_node(out_body, env);
if (!out_node)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap body node");
return AXIS2_FAILURE;
}
if (status != AXIS2_SUCCESS)
{
/* something went wrong, set a SOAP Fault */
axis2_char_t *fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER;
axis2_char_t *fault_reason_str = NULL;
axis2_char_t *err_msg = NULL;
if (!skel_invoked)
fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER;
;
err_msg = (char *) AXIS2_ERROR_GET_MESSAGE(env->error);
if (err_msg)
{
fault_reason_str = err_msg;
} else
{
fault_reason_str = "Error occurred while processing SOAP message";
}
out_soap_fault = axiom_soap_fault_create_default_fault(env, out_body,
fault_value_str, fault_reason_str, soap_version);
}
if (out_body_content_node)
{
axiom_node_add_child(out_node, env, out_body_content_node);
status = axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env,
default_envelope);
} else if (out_soap_fault)
{
axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, default_envelope);
status = AXIS2_FAILURE; /* if there is a failure we have to return a failure code */
} else
{
/* we should free the memory as the envelope is not used, one way case */
axiom_soap_envelope_free(default_envelope, env);
default_envelope = NULL;
}
return AXIS2_SUCCESS;
}
static axis2_status_t AXIS2_CALL
axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync(
axis2_msg_recv_t * msg_recv,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx,
axis2_msg_ctx_t * new_msg_ctx)
{
axis2_svc_skeleton_t *svc_obj = NULL;
axis2_op_ctx_t *op_ctx = NULL;
axis2_op_t *op_desc = NULL;
const axis2_char_t *style = NULL;
axiom_node_t *om_node = NULL;
axiom_element_t *om_element = NULL;
axis2_char_t *local_name = NULL;
axiom_node_t *result_node = NULL;
axiom_node_t *body_content_node = NULL;
axiom_element_t *body_content_element = NULL;
axiom_soap_envelope_t *default_envelope = NULL;
axiom_soap_body_t *out_body = NULL;
axiom_soap_header_t *out_header = NULL;
axiom_soap_fault_t *soap_fault = NULL;
axiom_node_t *out_node = NULL;
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t skel_invoked = AXIS2_FALSE;
const axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
int soap_version = AXIOM_SOAP12;
axiom_namespace_t *env_ns = NULL;
axiom_node_t *fault_node = NULL;
axiom_soap_fault_detail_t *fault_detail;
axis2_bool_t is_fault = AXIS2_FALSE;
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, new_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[axis2]Entry:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync");
/* get the implementation class for the Web Service */
svc_obj = axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx);
if(!svc_obj)
{
const axis2_char_t *svc_name = NULL;
axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(svc)
{
svc_name = axis2_svc_get_name(svc, env);
}
else
{
svc_name = "unknown";
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Impl object for service '%s' not set in message receiver. %d :: %s", svc_name,
env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
status = AXIS2_FAILURE;
}
else
{
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
op_desc = axis2_op_ctx_get_op(op_ctx, env);
style = axis2_op_get_style(op_desc, env);
if(0 == axutil_strcmp(AXIS2_STYLE_DOC, style))
{
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
om_node = axiom_soap_body_get_base_node(body, env);
om_element = axiom_node_get_data_element(om_node, env);
om_node = axiom_node_get_first_element(om_node, env);
}
else if(0 == axutil_strcmp(AXIS2_STYLE_RPC, style))
{
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
axiom_node_t *op_node = NULL;
axiom_element_t *op_element = NULL;
envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
body = axiom_soap_envelope_get_body(envelope, env);
op_node = axiom_soap_body_get_base_node(body, env);
op_element = axiom_node_get_data_element(op_node, env);
if(op_element)
{
local_name = axiom_element_get_localname(op_element, env);
if(local_name)
{
axutil_array_list_t *function_arr = NULL;
int i = 0;
int size = 0;
axis2_bool_t matches = AXIS2_FALSE;
function_arr = svc_obj->func_array;
if(function_arr)
{
size = axutil_array_list_size(function_arr, env);
}
for(i = 0; i < size; i++)
{
axis2_char_t *function_name = NULL;
function_name = (axis2_char_t *)axutil_array_list_get(function_arr, env, i);
if(!axutil_strcmp(function_name, local_name))
{
matches = AXIS2_TRUE;
}
}
if(matches)
{
om_node = axiom_node_get_first_child(op_node, env);
om_element = axiom_node_get_data_element(om_node, env);
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_MISMATCH, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RPC_NEED_MATCHING_CHILD, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
}
else
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
if(status == AXIS2_SUCCESS)
{
skel_invoked = AXIS2_TRUE;
result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx);
}
if(result_node)
{
if(0 == axutil_strcmp(style, AXIS2_STYLE_RPC))
{
axiom_namespace_t *ns = NULL;
axis2_char_t *res_name = NULL;
res_name = axutil_stracat(env, local_name, "Response");
ns = axiom_namespace_create(env, "http://soapenc/", "res");
if(!ns)
{
status = AXIS2_FAILURE;
}
else
{
body_content_element = axiom_element_create(env, NULL, res_name, ns,
&body_content_node);
axiom_node_add_child(body_content_node, env, result_node);
}
}
else
{
body_content_node = result_node;
}
}
else
{
axis2_char_t *mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op_desc, env);
if(axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) && axutil_strcmp(mep,
AXIS2_MEP_URI_ROBUST_IN_ONLY) && axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY_WSDL2) && axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2))
{
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
if(status == AXIS2_SUCCESS)
{
axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE);
}
else
{
axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code(
new_msg_ctx, env));
}
/* The new_msg_ctx is passed to the service. The status code must
* be taken from here and set to the old message context which is
* used by the worker when the request processing fails.
*/
if(svc_obj->ops->on_fault)
{
fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node);
}
is_fault = AXIS2_TRUE;
}
else
{
/* If we have a in only message result node is NULL. We create fault only if
* an error is set
*/
status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
if(status == AXIS2_SUCCESS)
{
axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE);
}
else
{
axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code(
new_msg_ctx, env));
if((!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY)) ||
(!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2)))
{
/* The new_msg_ctx is passed to the service. The status code must
* be taken from here and set to the old message context which is
* used by the worker when the request processing fails.
*/
if(svc_obj->ops->on_fault)
{
fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node);
}
is_fault = AXIS2_TRUE;
}
}
}
}
}
if(msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */
soap_version = AXIOM_SOAP11;
}
if(axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env))
{
/* service implementation has set the envelope,
useful when setting a SOAP fault.
No need to further process */
return AXIS2_SUCCESS;
}
/* create the soap envelope here */
env_ns = axiom_namespace_create(env, soap_ns, "soapenv");
if(!env_ns)
{
return AXIS2_FAILURE;
}
default_envelope = axiom_soap_envelope_create(env, env_ns);
axiom_namespace_free(env_ns, env);
if(!default_envelope)
{
return AXIS2_FAILURE;
}
out_header = axiom_soap_header_create_with_parent(env, default_envelope);
if(!out_header)
{
return AXIS2_FAILURE;
}
out_body = axiom_soap_body_create_with_parent(env, default_envelope);
if(!out_body)
{
return AXIS2_FAILURE;
}
out_node = axiom_soap_body_get_base_node(out_body, env);
if(!out_node)
{
return AXIS2_FAILURE;
}
if(status != AXIS2_SUCCESS || is_fault)
{
/* something went wrong. set a SOAP Fault */
const axis2_char_t *fault_value_str = "soapenv:Sender";
const axis2_char_t *fault_reason_str = NULL;
const axis2_char_t *err_msg = NULL;
if(!skel_invoked)
{
if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
AXIOM_SOAP11_FAULT_CODE_RECEIVER;
}
else
{
fault_value_str =
AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":"
AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER;
}
}
err_msg = AXIS2_ERROR_GET_MESSAGE(env->error);
if (err_msg && axutil_strcmp(err_msg, ""))
{
if(!axutil_strcmp(err_msg, "No Error"))
{
fault_reason_str = "An error has occurred, but could not determine exact details";
}
else
{
fault_reason_str = err_msg;
}
}
else
{
fault_reason_str = "An error has occurred, but could not determine exact details";
}
soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str,
fault_reason_str, soap_version);
if (fault_node)
{
axiom_node_t *fault_detail_node = NULL;
axis2_char_t *om_str = NULL;
fault_detail = axiom_soap_fault_detail_create_with_parent(env, soap_fault);
fault_detail_node = axiom_soap_fault_detail_get_base_node(fault_detail, env);
om_str = axiom_node_to_string(fault_detail_node, env);
if (om_str)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault_detail:%s", om_str);
AXIS2_FREE(env->allocator, om_str);
}
axiom_soap_fault_detail_add_detail_entry(fault_detail, env, fault_node);
}
}
if (body_content_node)
{
axiom_node_add_child(out_node, env, body_content_node);
status = axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
}
else if (soap_fault)
{
axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope);
status = AXIS2_SUCCESS;
}
else
{
/* we should free the memory as the envelope is not used, one way case */
axiom_soap_envelope_free(default_envelope, env);
default_envelope = NULL;
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[axis2]Exit:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync");
return status;
}
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_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;
axis2_bool_t method_get = AXIS2_FALSE;
axis2_bool_t method_head = AXIS2_FALSE;
axis2_bool_t method_put = AXIS2_FALSE;
axis2_bool_t method_delete = AXIS2_FALSE;
/* Set up the environment */
env = axutil_env_create_all("echo_rest.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of echo service */
address = "http://localhost:9090/axis2/services/echo/echoString";
if (argc > 1)
{
if (0 == strncmp(argv[1], "-mGET", 5))
{
method_get = AXIS2_TRUE;
}
else if (0 == strncmp(argv[1], "-mHEAD", 6))
{
method_head = AXIS2_TRUE;
}
else if (0 == strncmp(argv[1], "-mPUT", 5))
{
method_put = AXIS2_TRUE;
}
else if (0 == strncmp(argv[1], "-mDELETE",8 ))
{
method_delete = AXIS2_TRUE;
}
else if (0 == axutil_strcmp(argv[1], "-h"))
{
printf("Usage : %s [endpoint_url] \n", argv[0]);
printf("\nNOTE: You can test for other HTTP methods by changing the");
printf(" services.xml of the echo service\n and providing the correct REST HTTP method");
printf(" and the location to be used for operation.\n");
printf(" Also note that you have to restart the server after changing the services.xml.\n");
printf(" use %s -mGET for HTTP GET\n", argv[0]);
printf(" use %s -mHEAD for HTTP HEAD\n", argv[0]);
printf(" use %s -mDELETE for HTTP DELETE\n", argv[0]);
printf(" use %s -mPUT for HTTP PUT\n", argv[0]);
printf(" use -h for help\n");
return 0;
}
else
{
address = argv[1];
}
}
if (argc > 2)
{
if (0 == strncmp(argv[2], "-mGET", 5))
{
method_get = AXIS2_TRUE;
}
else if (0 == strncmp(argv[2], "-mHEAD", 6))
{
method_head = AXIS2_TRUE;
}
else if (0 == strncmp(argv[2], "-mPUT", 5))
{
method_put = AXIS2_TRUE;
}
else if (0 == strncmp(argv[2], "-mDELETE",8 ))
{
method_delete = AXIS2_TRUE;
}
else
{
address = 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);
/* Enable REST at the client side */
axis2_options_set_enable_rest(options, env, AXIS2_TRUE);
if (AXIS2_TRUE == method_get)
{
axis2_options_set_http_method(options, env, AXIS2_HTTP_GET);
}
else if (AXIS2_TRUE == method_head)
{
axis2_options_set_http_method(options, env, AXIS2_HTTP_HEAD);
}
else if (AXIS2_TRUE == method_put)
{
axis2_options_set_http_method(options, env, AXIS2_HTTP_PUT);
}
else if (AXIS2_TRUE == method_delete)
{
axis2_options_set_http_method(options, env, AXIS2_HTTP_DELETE);
}
/* 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);
/* 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_svc_client_get_last_response_has_fault(svc_client, env))
{
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 FAILED!\n");
}
else 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 if (method_head &&
axis2_svc_client_get_last_response_has_fault(svc_client, env))
{
/* HEAD request should probably be removed from this file,
* and be relocated to transport unit tests.
*/
printf("\necho client invoke FAILED!\n");
}
else if (method_head)
{
/* HEAD request should probably be removed from this file,
* and be relocated to transport unit tests.
*/
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;
}
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;
}
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 *google_key = NULL;
const axis2_char_t *word_to_spell = NULL;
const axis2_char_t *operation = NULL;
operation = "doSpellingSuggestion";
google_key = "00000000000000000000000000000000";
word_to_spell = "salvasion";
/* Set up the environment */
env = axutil_env_create_all("google_client.log", AXIS2_LOG_LEVEL_TRACE);
/* Set end point reference of google service */
address = "http://api.google.com/search/beta2";
if ((argc > 1) && (axutil_strcmp("-h", argv[1]) == 0))
{
printf("\nUsage : %s [google_key] [word_to_spell] \n", argv[0]);
printf
("\tgoogle_key Your Google license key. Default value won't work. You must use your key here.\n");
printf
("\tword_to_spell Word to be spelled by Google service. Default is %s\n",
word_to_spell);
printf
("NOTE: command line arguments must appear in given order, with trailing ones being optional\n");
printf("\tUse -h for help\n");
return 0;
}
if (argc > 1)
google_key = argv[1];
if (argc > 2)
word_to_spell = argv[2];
if (argc > 3)
address = argv[3];
printf("Using endpoint : %s\n", address);
printf("\nInvoking operation %s with params %s and %s\n", operation,
google_key, word_to_spell);
/* 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_soap_version(options, env, AXIOM_SOAP11);
/* Set up deploy folder. */
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);
/* Build the SOAP request message payload using OM API. */
payload =
build_soap_body_content(env, operation, google_key, word_to_spell);
/* 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;
axis2_char_t *fault_string = 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)
{
fault_string = axiom_node_to_string(axiom_soap_fault_get_base_node
(soap_fault, env), env);
printf("\nReturned SOAP fault: %s\n", fault_string);
AXIS2_FREE (env->allocator, fault_string);
}
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 -1;
}
if (ret_node)
{
if (axiom_node_get_node_type(ret_node, env) == AXIOM_ELEMENT)
{
axis2_char_t *result = NULL;
axiom_element_t *result_ele = NULL;
axiom_node_t *ret_node1 = NULL;
result_ele =
(axiom_element_t *) axiom_node_get_data_element(ret_node, env);
if (axutil_strcmp
(axiom_element_get_localname(result_ele, env),
"doSpellingSuggestionResponse") != 0)
{
print_invalid_om(env, ret_node);
return AXIS2_FAILURE;
}
ret_node1 = axiom_node_get_first_element(ret_node, env); /*return */
if (!ret_node1)
{
print_invalid_om(env, ret_node);
return AXIS2_FAILURE;
}
result_ele =
(axiom_element_t *) axiom_node_get_data_element(ret_node1, env);
result = axiom_element_get_text(result_ele, env, ret_node1);
printf("\nResult = %s\n", result);
}
else
{
print_invalid_om(env, ret_node);
return AXIS2_FAILURE;
}
}
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("Google 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;
}
int
main(
int argc,
char **argv)
{
axis2_stub_t *stub = NULL;
axiom_node_t *node = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
const axis2_char_t *client_home = NULL;
axiom_node_t *ret_node = NULL;
const axis2_char_t *operation = "get_version";
const axis2_char_t *param1 = "40";
const axis2_char_t *param2 = "8";
env = axutil_env_create_all("version_blocking.log", AXIS2_LOG_LEVEL_TRACE);
client_home = AXIS2_GETENV("AXIS2C_HOME");
if (!client_home || !strcmp(client_home, ""))
client_home = "../..";
address = "http://localhost:9090/axis2/services/version";
if (argc > 1)
operation = argv[1];
if (axutil_strcmp(operation, "-h") == 0)
{
printf("Usage : %s [operation] [param1] [param2] [endpoint_url]\n",
argv[0]);
printf("use -h for help\n");
printf("default operation get_version\n");
printf("default param1 %s\n", param1);
printf("default param2 %s\n", param2);
printf("default endpoint_url %s\n", address);
printf
("NOTE: command line arguments must appear in given order, with trailing ones being optional\n");
return 0;
}
if (argc > 2)
param1 = argv[2];
if (argc > 3)
param2 = argv[3];
if (argc > 4)
address = argv[4];
printf("Using endpoint : %s\n", address);
printf("\nInvoking operation %s\n", operation);
node = build_om_programatically(env);
stub =
axis2_version_stub_create_with_endpoint_uri_and_client_home(env, address,
client_home);
/* create node and invoke version */
if (stub)
{
ret_node = axis2_version_stub_get_version(stub, env, node);
}
if (ret_node)
{
if (axiom_node_get_node_type(ret_node, env) == AXIOM_ELEMENT)
{
axis2_char_t *result = NULL;
axiom_element_t *result_ele =
(axiom_element_t *) axiom_node_get_data_element(ret_node, env);
result = axiom_element_get_text(result_ele, env, ret_node);
printf("\nResult = %s\n", result);
}
else
{
axiom_xml_writer_t *writer = NULL;
axiom_output_t *om_output = NULL;
axis2_char_t *buffer = NULL;
writer =
axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
AXIS2_XML_PARSER_TYPE_BUFFER);
om_output = axiom_output_create(env, writer);
axiom_node_serialize(ret_node, env, om_output);
buffer = (axis2_char_t *) axiom_xml_writer_get_xml(writer, env);
printf("\nReceived invalid OM as result : %s\n", buffer);
if (buffer)
{
AXIS2_FREE(env->allocator, buffer);
buffer = NULL;
}
if (om_output)
{
axiom_output_free(om_output, env);
om_output = NULL;
}
axiom_xml_writer_free(writer, env);
}
}
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("version stub invoke FAILED!\n");
}
if (stub)
{
axis2_stub_free(stub, env);
}
if (env)
{
axutil_env_free((axutil_env_t *) env);
env = NULL;
}
return status;
}
