AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_test_proxy_auth(
axis2_options_t * options,
const axutil_env_t * env,
const axis2_bool_t test_proxy_auth)
{
axutil_property_t *test_auth_property = NULL;
if (test_proxy_auth)
{
test_auth_property = axutil_property_create(env);
axutil_property_set_value(test_auth_property, env,
axutil_strdup(env, AXIS2_VALUE_TRUE));
axis2_options_set_property(options, env, AXIS2_TEST_PROXY_AUTH,
test_auth_property);
}
else
{
test_auth_property = axutil_property_create(env);
axutil_property_set_value(test_auth_property, env,
axutil_strdup(env, AXIS2_VALUE_FALSE));
axis2_options_set_property(options, env, AXIS2_TEST_PROXY_AUTH,
test_auth_property);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_use_separate_listener(
axis2_options_t * options,
const axutil_env_t * env,
const axis2_bool_t use_separate_listener)
{
axutil_property_t *property = NULL;
options->use_separate_listener = use_separate_listener;
if(use_separate_listener)
{
property = axutil_property_create(env);
axutil_property_set_value(property, env, axutil_strdup(env, AXIS2_VALUE_TRUE));
axis2_options_set_property(options, env, AXIS2_USE_SEPARATE_LISTENER, property);
}
else
{
property = axutil_property_create(env);
axutil_property_set_value(property, env, axutil_strdup(env, AXIS2_VALUE_FALSE));
axis2_options_set_property(options, env, AXIS2_USE_SEPARATE_LISTENER, property);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_enable_rest(
axis2_options_t * options,
const axutil_env_t * env,
const axis2_bool_t enable_rest)
{
axutil_property_t *rest_property = NULL;
if (enable_rest)
{
rest_property = axutil_property_create(env);
axutil_property_set_value(rest_property, env,
axutil_strdup(env, AXIS2_VALUE_TRUE));
axis2_options_set_property(options, env, AXIS2_ENABLE_REST,
rest_property);
}
else
{
rest_property = axutil_property_create(env);
axutil_property_set_value(rest_property, env,
axutil_strdup(env, AXIS2_VALUE_FALSE));
axis2_options_set_property(options, env, AXIS2_ENABLE_REST,
rest_property);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_http_auth_info(
axis2_options_t * options,
const axutil_env_t * env,
const axis2_char_t * username,
const axis2_char_t * password,
const axis2_char_t * auth_type)
{
axis2_bool_t force_http_auth = AXIS2_FALSE;
axutil_property_t *prop_un = NULL;
axutil_property_t *prop_pw = NULL;
prop_un = axutil_property_create(env);
axutil_property_set_value(prop_un, env, axutil_strdup(env, username));
axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_UNAME, prop_un);
prop_pw = axutil_property_create(env);
axutil_property_set_value(prop_pw, env, axutil_strdup(env, password));
axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_PASSWD, prop_pw);
if (auth_type)
{
if ((axutil_strcasecmp (auth_type, AXIS2_HTTP_AUTH_TYPE_BASIC) == 0) ||
(axutil_strcasecmp (auth_type, AXIS2_HTTP_AUTH_TYPE_DIGEST) == 0))
{
force_http_auth = AXIS2_TRUE;
}
}
if (force_http_auth)
{
axutil_property_t *http_auth_property = axutil_property_create(env);
axutil_property_t *http_auth_type_property = axutil_property_create(env);
axutil_property_set_value(http_auth_property, env,
axutil_strdup(env, AXIS2_VALUE_TRUE));
axis2_options_set_property(options, env, AXIS2_FORCE_HTTP_AUTH,
http_auth_property);
axutil_property_set_value(http_auth_type_property, env,
axutil_strdup(env, auth_type));
axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_TYPE,
http_auth_type_property);
}
else
{
axutil_property_t *http_auth_property = axutil_property_create(env);
axutil_property_set_value(http_auth_property, env,
axutil_strdup(env, AXIS2_VALUE_FALSE));
axis2_options_set_property(options, env, AXIS2_FORCE_HTTP_AUTH,
http_auth_property);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_timeout_in_milli_seconds(
axis2_options_t * options,
const axutil_env_t * env,
const long timeout_in_milli_seconds)
{
options->timeout_in_milli_seconds = timeout_in_milli_seconds;
/* set the property AXIS2_HTTP_CONNECTION_TIMEOUT,
* to be picked up by http_sender
*/
if (options->timeout_in_milli_seconds > 0)
{
axis2_char_t time_str[19]; /* supports 18 digit timeout */
axutil_property_t *property = axutil_property_create(env);
sprintf(time_str, "%ld", options->timeout_in_milli_seconds);
if (property)
{
axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_value(property, env,
axutil_strdup(env, time_str));
axis2_options_set_property(options, env, AXIS2_HTTP_CONNECTION_TIMEOUT,
property);
}
}
return AXIS2_SUCCESS;
}
axutil_property_t *AXIS2_CALL
axutil_property_create_with_args(
const axutil_env_t * env,
axis2_scope_t scope,
axis2_bool_t own_value,
AXIS2_FREE_VOID_ARG free_func,
void *value)
{
axutil_property_t *property = NULL;
AXIS2_ENV_CHECK(env, NULL);
property = (axutil_property_t *)axutil_property_create(env);
if(!property)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
property->value = value;
property->scope = scope;
property->own_value = own_value;
property->free_func = free_func;
return property;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_http_method(
axis2_options_t * options,
const axutil_env_t * env,
const axis2_char_t * http_method)
{
axutil_property_t *method_property = NULL;
method_property = axutil_property_create(env);
axutil_property_set_value(method_property, env, axutil_strdup(env, http_method));
axis2_options_set_property(options, env, AXIS2_HTTP_METHOD, method_property);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_http_headers(
axis2_options_t * options,
const axutil_env_t * env,
axutil_array_list_t * http_header_list)
{
axutil_property_t *headers_property = NULL;
headers_property = axutil_property_create(env);
axutil_property_set_value(headers_property, env, http_header_list);
axis2_options_set_property(options, env, AXIS2_TRANSPORT_HEADER_PROPERTY, headers_property);
axutil_property_set_free_func(headers_property, env, axutil_array_list_free_void_arg);
return AXIS2_SUCCESS;
}
axutil_property_t *AXIS2_CALL
axutil_property_clone(
axutil_property_t * property,
const axutil_env_t * env)
{
axutil_property_t *new_property = NULL;
AXIS2_ENV_CHECK(env, NULL);
new_property = axutil_property_create(env);
axutil_property_set_free_func(new_property, env, property->free_func);
axutil_property_set_scope(new_property, env, property->scope);
axutil_property_set_own_value(new_property, env, property->own_value);
axutil_property_set_value(new_property, env, property->value);
return new_property;
}
void AxisEnvironmentWrapper::insert(const std::string&key, const std::string &value){
//Copy the value;
char * property_value = (char*)AXIS2_MALLOC(_env->allocator, sizeof(std::string::value_type)*value.size());
strcpy(property_value, value.c_str());
//Create and insert the property
axutil_property_t *property = NULL;
property = axutil_property_create(_env);
axutil_property_set_scope(property, _env, AXIS2_SCOPE_REQUEST);
axutil_property_set_value(property, _env, property_value);
axutil_property_set_free_func(property, _env, axis2_single_type_free);
/*axis2_status_t status = */axis2_ctx_set_property(_ctx, _env, strdup(key.c_str()), property);
}
AXIS2_EXTERN axis2_char_t* AXIS2_CALL
axis2_amqp_util_conf_ctx_get_dual_channel_queue_name(
axis2_conf_ctx_t* conf_ctx,
const axutil_env_t* env)
{
axutil_property_t* property = NULL;
axis2_char_t* queue_name = NULL;
axis2_char_t* value = NULL;
/* Get property */
property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_AMQP_CONF_CTX_PROPERTY_QUEUE_NAME);
if(!property) /* Very first call */
{
property = axutil_property_create(env);
axis2_conf_ctx_set_property(conf_ctx, env, AXIS2_AMQP_CONF_CTX_PROPERTY_QUEUE_NAME,
property);
}
/* Get queue name */
value = (axis2_char_t*)axutil_property_get_value(property, env);
/* AMQP listener and the sender are the two parties that are
* interested in the queue. Either party can create the queue.
* If the queue is already created by one party, "value" is
* not NULL. If "value" is NULL, that mean the caller of
* this method is supposed to create the queue */
if(value)
{
queue_name = (axis2_char_t*)AXIS2_MALLOC(env->allocator, axutil_strlen(value) + 1);
strcpy(queue_name, value);
/*axutil_property_set_value(property, env, NULL);*/
}
else
{
/* Create new queue name */
queue_name = axutil_stracat(env, AXIS2_AMQP_TEMP_QUEUE_NAME_PREFIX, axutil_uuid_gen(env));
/* Put queue name in the conf_ctx so that the sender will know */
axutil_property_set_value(property, env, (void*)queue_name);
}
return queue_name;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_enable_mtom(
axis2_options_t * options,
const axutil_env_t * env,
axis2_bool_t enable_mtom)
{
options->enable_mtom = enable_mtom;
if(enable_mtom)
{
axutil_property_t *property = axutil_property_create(env);
if(property)
{
axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_value(property, env, axutil_strdup(env, AXIS2_VALUE_TRUE));
axis2_options_set_property(options, env, AXIS2_ENABLE_MTOM, property);
}
}
return AXIS2_SUCCESS;
}
static axis2_status_t AXIS2_CALL
axis2_udp_transport_add_backchannel_info(const axutil_env_t *env, axis2_ctx_t *ctx, axis2_socket_t socket)
{
axis2_udp_backchannel_info_t *binfo = NULL;
axutil_property_t *prop = NULL;
binfo = AXIS2_MALLOC(env->allocator, sizeof(axis2_udp_backchannel_info_t));
if (!binfo)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
return AXIS2_FAILURE;
}
/* We set the axis2_svc and oparation. When the response comes it will bypass the dispatchers
and will directly go the service and operation
*/
binfo->op = NULL;
binfo->svc = NULL;
binfo->socket = socket;
prop = axutil_property_create(env);
axutil_property_set_value(prop, env, binfo);
axis2_ctx_set_property(ctx, env, AXIS2_UDP_BACKCHANNEL_INFO, prop);
return AXIS2_SUCCESS;
}
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;
axutil_property_t *property = NULL;
axis2_listener_manager_t *listener_manager = NULL;
axis2_char_t *offered_seq_id = NULL;
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_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);
/* 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 = "../../..";
}
/* 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;
}
/* Offer sequence */
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");
/*status = axis2_svc_client_send_robust(svc_client, env, payload);
if(status)
{
printf("\necho client single channel invoke SUCCESSFUL!\n");
}
payload = NULL;*/
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");
}
payload = build_om_payload_for_echo_svc(env, "echo2");
/*status = axis2_svc_client_send_robust(svc_client, env, payload);
if(status)
{
printf("\necho client single channel invoke SUCCESSFUL!\n");
}
payload = NULL;*/
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");
}
payload = build_om_payload_for_echo_svc(env, "echo3");
/*status = axis2_svc_client_send_robust(svc_client, env, payload);
if(status)
{
printf("\necho client single channel invoke SUCCESSFUL!\n");
}
payload = NULL;*/
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);
sandesha2_client_terminate_seq_with_svc_client_and_seq_key(env, svc_client, NULL, NULL);
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_libcurl_send(
axis2_libcurl_t *data,
axiom_output_t * om_output,
const axutil_env_t * env,
axis2_msg_ctx_t * msg_ctx,
axiom_soap_envelope_t * out,
const axis2_char_t * str_url,
const axis2_char_t * soap_action)
{
struct curl_slist *headers = NULL;
axiom_soap_body_t *soap_body;
axis2_bool_t is_soap = AXIS2_TRUE;
axis2_bool_t send_via_get = AXIS2_FALSE;
axis2_bool_t send_via_head = AXIS2_FALSE;
axis2_bool_t send_via_put = AXIS2_FALSE;
axis2_bool_t send_via_delete = AXIS2_FALSE;
axis2_bool_t doing_mtom = AXIS2_FALSE;
axiom_node_t *body_node = NULL;
axiom_node_t *data_out = NULL;
axutil_property_t *method = NULL;
axis2_char_t *method_value = NULL;
axiom_xml_writer_t *xml_writer = NULL;
axis2_char_t *buffer = NULL;
unsigned int buffer_size = 0;
int content_length = -1;
axis2_char_t *content_type = NULL;
/*axis2_char_t *content_len = AXIS2_HTTP_HEADER_CONTENT_LENGTH_; */
const axis2_char_t *char_set_enc = NULL;
axis2_char_t *content = AXIS2_HTTP_HEADER_CONTENT_TYPE_;
axis2_char_t *soap_action_header = AXIS2_HTTP_HEADER_SOAP_ACTION_;
axutil_stream_t *in_stream;
axutil_property_t *trans_in_property;
axutil_string_t *char_set_enc_str;
axis2_byte_t *output_stream = NULL;
int output_stream_size = 0;
CURL *handler;
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_conf_t *conf = NULL;
axis2_transport_out_desc_t *trans_desc = NULL;
axutil_param_t *write_xml_declaration_param = NULL;
axutil_hash_t *transport_attrs = NULL;
axis2_bool_t write_xml_declaration = AXIS2_FALSE;
axutil_property_t *property;
int *response_length = NULL;
axis2_http_status_line_t *status_line = NULL;
axis2_char_t *status_line_str = NULL;
axis2_char_t *tmp_strcat = NULL;
int status_code = 0;
AXIS2_PARAM_CHECK(env->error, data, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, data->handler, AXIS2_FAILURE);
handler = data->handler;
curl_easy_reset(handler);
curl_easy_setopt(handler, CURLOPT_ERRORBUFFER, data->errorbuffer);
headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_USER_AGENT_AXIS2C);
headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_ACCEPT_);
headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_EXPECT_);
if(AXIS2_FAILURE == axis2_libcurl_set_options(handler, env, msg_ctx))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[axis2libcurl]Setting options in Libcurl failed");
return AXIS2_FAILURE;
}
if (AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env))
{
is_soap = AXIS2_FALSE;
}
else
{
is_soap = AXIS2_TRUE;
}
if (!is_soap)
{
soap_body = axiom_soap_envelope_get_body(out, env);
if (!soap_body)
{
AXIS2_HANDLE_ERROR(env,
AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
body_node = axiom_soap_body_get_base_node(soap_body, env);
if (!body_node)
{
AXIS2_HANDLE_ERROR(env,
AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
data_out = axiom_node_get_first_element(body_node, env);
method = (axutil_property_t *) axis2_msg_ctx_get_property(msg_ctx, env,
AXIS2_HTTP_METHOD);
if (method)
{
method_value =
(axis2_char_t *) axutil_property_get_value(method, env);
}
/* The default is POST */
if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_GET))
{
send_via_get = AXIS2_TRUE;
}
else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_HEAD))
{
send_via_head = AXIS2_TRUE;
}
else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_PUT))
{
send_via_put = AXIS2_TRUE;
}
else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_DELETE))
{
send_via_delete = AXIS2_TRUE;
}
}
conf_ctx = axis2_msg_ctx_get_conf_ctx (msg_ctx, env);
if (conf_ctx)
{
conf = axis2_conf_ctx_get_conf (conf_ctx, env);
}
if (conf)
{
trans_desc = axis2_conf_get_transport_out (conf,
env, AXIS2_TRANSPORT_ENUM_HTTP);
}
if (trans_desc)
{
write_xml_declaration_param =
axutil_param_container_get_param
(axis2_transport_out_desc_param_container (trans_desc, env), env,
AXIS2_XML_DECLARATION);
}
if (write_xml_declaration_param)
{
transport_attrs =
axutil_param_get_attributes (write_xml_declaration_param, env);
if (transport_attrs)
{
axutil_generic_obj_t *obj = NULL;
axiom_attribute_t *write_xml_declaration_attr = NULL;
axis2_char_t *write_xml_declaration_attr_value = NULL;
obj = axutil_hash_get (transport_attrs, AXIS2_ADD_XML_DECLARATION,
AXIS2_HASH_KEY_STRING);
if (obj)
{
write_xml_declaration_attr = (axiom_attribute_t *)
axutil_generic_obj_get_value (obj,
env);
}
if (write_xml_declaration_attr)
{
write_xml_declaration_attr_value =
axiom_attribute_get_value (write_xml_declaration_attr, env);
}
if (write_xml_declaration_attr_value &&
0 == axutil_strcasecmp (write_xml_declaration_attr_value,
AXIS2_VALUE_TRUE))
{
write_xml_declaration = AXIS2_TRUE;
}
}
}
if (write_xml_declaration)
{
axiom_output_write_xml_version_encoding (om_output, env);
}
if (!send_via_get && !send_via_head && !send_via_delete)
{
xml_writer = axiom_output_get_xml_writer(om_output, env);
char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env);
if (!char_set_enc_str)
{
char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
}
else
{
char_set_enc = axutil_string_get_buffer(char_set_enc_str, env);
}
if (!send_via_put && is_soap)
{
doing_mtom = axis2_msg_ctx_get_doing_mtom(msg_ctx, env);
axiom_output_set_do_optimize(om_output, env, doing_mtom);
axiom_soap_envelope_serialize(out, env, om_output, AXIS2_FALSE);
if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
if (AXIS2_ESC_DOUBLE_QUOTE != *soap_action)
{
axis2_char_t *tmp_soap_action = NULL;
tmp_soap_action =
AXIS2_MALLOC(env->allocator,
(axutil_strlen(soap_action) +
5) * sizeof(axis2_char_t));
sprintf(tmp_soap_action, "\"%s\"", soap_action);
tmp_strcat = axutil_stracat(env, soap_action_header,tmp_soap_action);
headers = curl_slist_append(headers, tmp_strcat);
AXIS2_FREE(env->allocator, tmp_strcat);
AXIS2_FREE(env->allocator, tmp_soap_action);
}
else
{
tmp_strcat = axutil_stracat(env, soap_action_header, soap_action);
headers = curl_slist_append(headers, tmp_strcat );
AXIS2_FREE(env->allocator, tmp_strcat);
}
}
if (doing_mtom)
{
/*axiom_output_flush(om_output, env, &output_stream,
&output_stream_size);*/
axiom_output_flush(om_output, env);
content_type =
(axis2_char_t *) axiom_output_get_content_type(om_output,
env);
if (AXIS2_TRUE != axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
if (axutil_strcmp(soap_action, ""))
{
/* handle SOAP action for SOAP 1.2 case */
axis2_char_t *temp_content_type = NULL;
temp_content_type = axutil_stracat (env,
content_type,
AXIS2_CONTENT_TYPE_ACTION);
content_type = temp_content_type;
temp_content_type = axutil_stracat (env,
content_type,
soap_action);
AXIS2_FREE (env->allocator, content_type);
content_type = temp_content_type;
temp_content_type =
axutil_stracat (env, content_type,
AXIS2_ESC_DOUBLE_QUOTE_STR);
AXIS2_FREE (env->allocator, content_type);
content_type = temp_content_type;
}
}
}
else if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
axis2_char_t *temp_content_type = NULL;
content_type =
(axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
content_type = axutil_stracat(env, content_type,
AXIS2_CONTENT_TYPE_CHARSET);
temp_content_type =
axutil_stracat(env, content_type, char_set_enc);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
}
else
{
axis2_char_t *temp_content_type = NULL;
content_type =
(axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP;
content_type = axutil_stracat(env, content_type,
AXIS2_CONTENT_TYPE_CHARSET);
temp_content_type =
axutil_stracat(env, content_type, char_set_enc);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
if (axutil_strcmp(soap_action, ""))
{
temp_content_type =
axutil_stracat(env, content_type,
AXIS2_CONTENT_TYPE_ACTION);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
temp_content_type =
axutil_stracat(env, content_type, soap_action);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
}
temp_content_type = axutil_stracat(env, content_type,
AXIS2_SEMI_COLON_STR);
AXIS2_FREE(env->allocator, content_type);
content_type = temp_content_type;
}
}
else if (is_soap)
{
AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "Attempt to send SOAP"
"message using HTTP PUT failed");
return AXIS2_FAILURE;
}
else
{
axutil_property_t *content_type_property = NULL;
axutil_hash_t *content_type_hash = NULL;
axis2_char_t *content_type_value = NULL;
axiom_node_serialize(data_out, env, om_output);
content_type_property =
(axutil_property_t *)
axis2_msg_ctx_get_property(msg_ctx, env,
AXIS2_USER_DEFINED_HTTP_HEADER_CONTENT_TYPE);
if (content_type_property)
{
content_type_hash =
(axutil_hash_t *)
axutil_property_get_value(content_type_property, env);
if (content_type_hash)
{
content_type_value =
(char *) axutil_hash_get(content_type_hash,
AXIS2_HTTP_HEADER_CONTENT_TYPE,
AXIS2_HASH_KEY_STRING);
}
}
if (content_type_value)
{
content_type = content_type_value;
}
else
{
content_type = axutil_strdup(env,AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML);
}
}
buffer = axiom_xml_writer_get_xml(xml_writer, env);
if (!doing_mtom)
{
buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env);
}
else
buffer_size = output_stream_size;
{
/*
* Curl calculates the content-length automatically.
* This commented section is not only unnecessary,
* it interferes with authentication.
*
* NTLM, for example, will send an empty request
* first (no body) to get the auth challenge
* before resending with actual content.
*/
/*char tmp_buf[10];
sprintf(tmp_buf, "%d", buffer_size);
tmp_strcat = axutil_stracat(env, content_len, tmp_buf);
headers = curl_slist_append(headers, tmp_strcat);
AXIS2_FREE(env->allocator, tmp_strcat);
tmp_strcat = NULL;*/
tmp_strcat = axutil_stracat(env, content, content_type);
headers = curl_slist_append(headers, tmp_strcat);
AXIS2_FREE(env->allocator, tmp_strcat);
tmp_strcat = NULL;
}
if (!doing_mtom)
{
curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE, buffer_size);
curl_easy_setopt(handler, CURLOPT_POSTFIELDS, buffer);
}
else
{
curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE,
output_stream_size);
curl_easy_setopt(handler, CURLOPT_POSTFIELDS, output_stream);
}
if (send_via_put)
{
curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, AXIS2_HTTP_PUT);
}
curl_easy_setopt(handler, CURLOPT_URL, str_url);
}
else
{
axis2_char_t *request_param;
axis2_char_t *url_encode;
request_param =
(axis2_char_t *) axis2_http_sender_get_param_string(NULL, env,
msg_ctx);
url_encode = axutil_strcat(env, str_url, AXIS2_Q_MARK_STR,
request_param, NULL);
if (send_via_get)
{
curl_easy_setopt(handler, CURLOPT_HTTPGET, 1);
}
else if (send_via_head)
{
curl_easy_setopt(handler, CURLOPT_NOBODY, 1);
}
else if (send_via_delete)
{
curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, AXIS2_HTTP_DELETE);
}
curl_easy_setopt(handler, CURLOPT_URL, url_encode);
}
{
axis2_bool_t manage_session;
manage_session = axis2_msg_ctx_get_manage_session(msg_ctx, env);
if (manage_session == AXIS2_TRUE)
{
if (data->cookies == AXIS2_FALSE)
{
/* Ensure cookies enabled to manage session */
/* Pass empty cookie string to enable cookies */
curl_easy_setopt(handler, CURLOPT_COOKIEFILE, " ");
data->cookies = AXIS2_TRUE;
}
}
else if (data->cookies == AXIS2_TRUE)
{
/* Pass special string ALL to reset cookies if any have been enabled. */
/* If cookies have ever been enabled, we reset every time as long as
manage_session is false, as there is no clear curl option to
turn off the cookie engine once enabled. */
curl_easy_setopt(handler, CURLOPT_COOKIELIST, AXIS2_ALL);
}
}
curl_easy_setopt(handler, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(handler, CURLOPT_WRITEFUNCTION,
axis2_libcurl_write_memory_callback);
curl_easy_setopt(handler, CURLOPT_WRITEDATA, data);
curl_easy_setopt (handler, CURLOPT_HEADERFUNCTION, axis2_libcurl_header_callback);
curl_easy_setopt (handler, CURLOPT_WRITEHEADER, data);
/* Free response data from previous request */
if( data->size )
{
if (data->memory)
{
AXIS2_FREE(data->env->allocator, data->memory);
}
data->size = 0;
}
if (curl_easy_perform(handler))
{
AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "%s", &data->errorbuffer);
AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
in_stream = axutil_stream_create_libcurl(env, data->memory, data->size);
trans_in_property = axutil_property_create(env);
axutil_property_set_scope(trans_in_property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_free_func(trans_in_property, env,
libcurl_stream_free);
axutil_property_set_value(trans_in_property, env, in_stream);
axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN,
trans_in_property);
if (axutil_array_list_size(data->alist, env) > 0)
{
status_line_str = axutil_array_list_get(data->alist, env, 0);
if (status_line_str)
{
status_line = axis2_http_status_line_create(env, status_line_str);
}
}
if (status_line)
{
status_code = axis2_http_status_line_get_status_code(status_line, env);
}
axis2_msg_ctx_set_status_code (msg_ctx, env, status_code);
AXIS2_FREE(data->env->allocator, content_type);
content_type = axis2_libcurl_get_content_type(data, env);
if (content_type)
{
if (strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)
&& strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_XOP_XML))
{
axis2_ctx_t *axis_ctx =
axis2_op_ctx_get_base (axis2_msg_ctx_get_op_ctx (msg_ctx, env),
env);
property = axutil_property_create (env);
axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_value (property,
env, axutil_strdup (env, content_type));
axis2_ctx_set_property (axis_ctx,
env, MTOM_RECIVED_CONTENT_TYPE, property);
}
}
content_length = axis2_libcurl_get_content_length(data, env);
if (content_length >= 0)
{
response_length = AXIS2_MALLOC (env->allocator, sizeof (int));
memcpy (response_length, &content_length, sizeof (int));
property = axutil_property_create (env);
axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_value (property, env, response_length);
axis2_msg_ctx_set_property (msg_ctx, env,
AXIS2_HTTP_HEADER_CONTENT_LENGTH, property);
}
curl_slist_free_all (headers);
/* release the read http headers. */
/* (commenting out the call below is a clever way to force a premature EOF
condition in subsequent messages, as they will be read using the content-length
of the first message.) */
axis2_libcurl_free_headers(data, env);
AXIS2_FREE(data->env->allocator, content_type);
axis2_http_status_line_free( status_line, env);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_options_set_ntlm_http_auth_info(
axis2_options_t * options,
const axutil_env_t * env,
const axis2_char_t * username,
const axis2_char_t * password,
const int flags,
const axis2_char_t * domain,
const axis2_char_t * workstation,
const axis2_char_t * auth_type)
{
axis2_bool_t force_http_auth = AXIS2_FALSE;
axis2_char_t temp_str[4];
axutil_property_t *prop_un = NULL;
axutil_property_t *prop_pw = NULL;
axutil_property_t *prop_fg = NULL;
axutil_property_t *prop_do = NULL;
axutil_property_t *prop_wo = NULL;
prop_un = axutil_property_create(env);
axutil_property_set_value(prop_un, env, axutil_strdup(env, username));
axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_UNAME, prop_un);
prop_pw = axutil_property_create(env);
axutil_property_set_value(prop_pw, env, axutil_strdup(env, password));
axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_PASSWD, prop_pw);
sprintf(temp_str, "%d", flags);
prop_fg = axutil_property_create(env);
axutil_property_set_value(prop_fg, env, axutil_strdup(env, temp_str));
axis2_options_set_property(options, env, AXIS2_NTLM_AUTH_FLAGS, prop_fg);
if(domain)
{
prop_do = axutil_property_create(env);
axutil_property_set_value(prop_do, env, axutil_strdup(env, domain));
axis2_options_set_property(options, env, AXIS2_NTLM_AUTH_DOMAIN, prop_do);
}
if(workstation)
{
prop_wo = axutil_property_create(env);
axutil_property_set_value(prop_wo, env, axutil_strdup(env, workstation));
axis2_options_set_property(options, env, AXIS2_NTLM_AUTH_WORKSTATION, prop_wo);
}
if(auth_type)
{
if(axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_NTLM) == 0)
{
force_http_auth = AXIS2_TRUE;
}
}
if(force_http_auth)
{
axutil_property_t *http_auth_property = axutil_property_create(env);
axutil_property_t *http_auth_type_property = axutil_property_create(env);
axutil_property_set_value(http_auth_property, env, axutil_strdup(env, AXIS2_VALUE_TRUE));
axis2_options_set_property(options, env, AXIS2_FORCE_HTTP_AUTH, http_auth_property);
axutil_property_set_value(http_auth_type_property, env, axutil_strdup(env, auth_type));
axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_TYPE, http_auth_type_property);
}
else
{
axutil_property_t *http_auth_property = axutil_property_create(env);
axutil_property_set_value(http_auth_property, env, axutil_strdup(env, AXIS2_VALUE_FALSE));
axis2_options_set_property(options, env, AXIS2_FORCE_HTTP_AUTH, http_auth_property);
}
return AXIS2_SUCCESS;
}
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_status_t AXIS2_CALL
axis2_addr_in_handler_invoke(
struct axis2_handler * handler,
const axutil_env_t * env,
struct axis2_msg_ctx * msg_ctx)
{
axiom_soap_envelope_t *soap_envelope = NULL;
axiom_soap_header_t *soap_header = NULL;
axutil_property_t *property = NULL;
axis2_status_t status = AXIS2_FAILURE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log, "Starting addressing in handler");
soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
if (soap_envelope)
{
soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
if (soap_header)
{
axutil_array_list_t *addr_headers = NULL;
axis2_ctx_t *ctx = NULL;
axis2_char_t *addr_ns_str = NULL;
axis2_msg_info_headers_t *msg_info_headers =
axis2_msg_ctx_get_msg_info_headers(msg_ctx, env);
addr_headers =
axiom_soap_header_get_header_blocks_with_namespace_uri
(soap_header, env, AXIS2_WSA_NAMESPACE_SUBMISSION);
if (addr_headers)
{
addr_ns_str =
axutil_strdup(env, AXIS2_WSA_NAMESPACE_SUBMISSION);
/*status =
axis2_addr_in_extract_addr_submission_info(env, soap_header,
&msg_info_headers,
addr_headers,
msg_ctx);*/
status = axis2_addr_in_extract_addr_params(env,
soap_header,
&msg_info_headers,
addr_headers,
AXIS2_WSA_NAMESPACE_SUBMISSION,
msg_ctx);
}
else
{
addr_headers =
axiom_soap_header_get_header_blocks_with_namespace_uri
(soap_header, env, AXIS2_WSA_NAMESPACE);
if (addr_headers)
{
addr_ns_str = axutil_strdup(env, AXIS2_WSA_NAMESPACE);
/*status = axis2_addr_in_extract_addr_final_info(env,
soap_header,
&msg_info_headers,
addr_headers,
msg_ctx);*/
status = axis2_addr_in_extract_addr_params(env,
soap_header,
&msg_info_headers,
addr_headers,
AXIS2_WSA_NAMESPACE, msg_ctx);
axis2_addr_in_extract_ref_params(env, soap_header,
axis2_msg_ctx_get_msg_info_headers
(msg_ctx, env));
}
else
{
/* addressing headers are not present in the SOAP message */
AXIS2_LOG_INFO(env->log, AXIS2_LOG_SI,
"No Addressing Headers present in the IN message. Addressing In Handler cannot do anything.");
return AXIS2_SUCCESS; /* no addressing heades means addressing not in use */
}
}
ctx = axis2_msg_ctx_get_base(msg_ctx, env);
if (ctx)
{
property = axutil_property_create(env);
axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST);
axutil_property_set_value(property, env, addr_ns_str);
axis2_ctx_set_property(ctx, env, AXIS2_WSA_VERSION, property);
}
/* extract service group context, if available */
axis2_addr_in_extract_svc_grp_ctx_id(env, soap_header, msg_ctx);
axutil_array_list_free(addr_headers, env);
return status;
}
}
return AXIS2_SUCCESS;
}
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;
}
