int AXIS2_CALL
savan_subs_mgr_svc_init_with_conf(
axis2_svc_skeleton_t *svc_skeleton,
const axutil_env_t *env,
axis2_conf_t *conf)
{
/*savan_subs_mgr_t *subs_mgr = NULL;
axutil_array_list_t *topic_param_list = NULL;
axis2_svc_t *subs_svc = NULL;
axis2_op_t *op = NULL;
int i = 0, size = 0;*/
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Start:savan_subs_mgr_svc_init_with_conf");
/*subs_mgr = savan_subs_mgr_get_subs_mgr(env, NULL, conf);
if(!subs_mgr)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Could not create the database. Check \
whether database path is correct and accessible. Exit loading the Savan module");
AXIS2_ERROR_HANDLE(env, SAVAN_ERROR_DATABASE_CREATION_ERROR, AXIS2_FAILURE);
return AXIS2_FAILURE;
}*/
savan_subs_mgr_svc_init(svc_skeleton, env);
/*subs_svc = axis2_conf_get_svc(conf, env, "subscription");
op = axis2_svc_get_op_with_name(subs_svc, env, "get_topic_list");
topic_param_list = axis2_op_get_all_params(op, env);
if(topic_param_list)
{
size = axutil_array_list_size(topic_param_list, env);
}
for(i = 0; i < size; i++)
{
axutil_param_t *topic_param = NULL;
axis2_char_t *topic_url_str = NULL;
axis2_char_t *topic_name = NULL;
topic_param = axutil_array_list_get(topic_param_list, env, i);
topic_url_str = axutil_param_get_value(topic_param, env);
topic_name = axutil_param_get_name(topic_param, env);
if(!axutil_strcmp(topic_name, "wsamapping"))
{
continue;
}
if(savan_db_mgr_insert_topic(env, dbname, topic_name, topic_url_str))
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Topic %s added", topic_url_str);
}
else
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Topic %s could not be added", topic_url_str);
}
}*/
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] End:savan_subs_mgr_svc_init_with_conf");
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_char_t* AXIS2_CALL
service_admin_util_get_epr_address(const axutil_env_t *env,
axis2_msg_ctx_t *msg_ctx,
axis2_char_t *service_name)
{
axis2_endpoint_ref_t *epr = NULL;
axis2_char_t *address = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_conf_t *conf = NULL;
axis2_transport_in_desc_t *transport_in = NULL;
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
conf = axis2_conf_ctx_get_conf(conf_ctx, env);
transport_in = axis2_conf_get_transport_in(conf, env, AXIS2_TRANSPORT_ENUM_HTTP);
if(transport_in)
{
axis2_transport_receiver_t *receiver = NULL;
receiver = axis2_transport_in_desc_get_recv(transport_in, env);
if(!receiver)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Transport Receiver Not found ");
return NULL;
}
epr = axis2_transport_receiver_get_epr_for_service(receiver, env, service_name);
if(!epr)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Endpoint reference null");
return NULL;
}
address = (axis2_char_t*)axis2_endpoint_ref_get_address(epr,env);
}
return address;
}
/**
* Verify that an addressing element is located in <Envelope>/<Header>
*/
int verify_addr_hdr_elem_loc(axiom_node_t *signed_node, const axutil_env_t *env, axis2_char_t *ref) {
axiom_node_t *parent = axiom_node_get_parent(signed_node,env);
if(axutil_strcmp(OXS_NODE_HEADER, axiom_util_get_localname(parent, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] parent of addressing elem is %s", axiom_node_to_string(parent, env));
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected location of signed addressing elem with ID = %s", ref);
return 1;
}
parent = axiom_node_get_parent(parent,env);
if(axutil_strcmp(OXS_NODE_ENVELOPE, axiom_util_get_localname(parent, env))) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] second parent of addressing elem is %s", axiom_node_to_string(parent, env));
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected location of signed addressing elem with ID = %s", ref);
return 1;
}
parent = axiom_node_get_parent(parent,env);
if(parent) {
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] parent of Envelope = %s", axiom_node_to_string(parent, env));
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected location of signed Body with ID = %s", ref);
return 1;
}
return 0;
}
static axis2_op_t *AXIS2_CALL
axis2_addr_disp_find_op(
axis2_msg_ctx_t * msg_ctx,
const axutil_env_t * env,
axis2_svc_t * svc)
{
const axis2_char_t *action = NULL;
axutil_qname_t *name = NULL;
axis2_op_t *op = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, svc, NULL);
if(axis2_msg_ctx_get_doing_rest(msg_ctx, env))
return NULL;
action = axis2_msg_ctx_get_wsa_action(msg_ctx, env);
if(action)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Checking for operation using WSA Action : %s",
action);
name = axutil_qname_create(env, action, NULL, NULL);
op = axis2_svc_get_op_with_qname(svc, env, name);
if(op)
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Operation found using WSA Action");
axutil_qname_free(name, env);
}
return op;
}
axiom_node_t *
axis2_listener_notify(const axutil_env_t *env, axiom_node_t *node)
{
axis2_char_t *str = NULL;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Start:axis2_listener_notify");
AXIS2_ENV_CHECK(env, NULL);
str = axiom_node_to_string(node, env);
if (str)
printf("\nReceived : %s\n", str);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "End:axis2_listener_notify");
return NULL;
}
WSF_PHP_API axis2_msg_recv_t *WSF_CALL
wsf_xml_msg_recv_create(
const axutil_env_t * env)
{
axis2_msg_recv_t *msg_recv = NULL;
axis2_status_t status = AXIS2_FAILURE;
AXIS2_ENV_CHECK(env, NULL);
msg_recv = axis2_msg_recv_create(env);
if (NULL == msg_recv)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "xml msg recv null");
return NULL;
}
status = axis2_msg_recv_set_scope(msg_recv, env, AXIS2_APPLICATION_SCOPE);
if (AXIS2_TRUE != status)
{
axis2_msg_recv_free(msg_recv, env);
return NULL;
}
axis2_msg_recv_set_invoke_business_logic(msg_recv, env,
wsf_xml_msg_recv_invoke_business_logic_sync);
return msg_recv;
}
axis2_status_t AXIS2_CALL
savan_client_add_sub_id_to_soap_header(
savan_client_t *client,
const axutil_env_t *env,
axis2_svc_client_t *svc_client)
{
axiom_namespace_t *ns = NULL;
axiom_node_t *id_node = NULL;
axiom_element_t *id_elem = NULL;
/* Create a node with the subscription id and attach it as a soap header
* to the service client */
ns = axiom_namespace_create(env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX);
id_elem = axiom_element_create(env, NULL, ELEM_NAME_ID, ns, &id_node);
if (!id_elem)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] [client] Failed to "
"create element for Identifier node");
return AXIS2_FAILURE;
}
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "client->sub_id:%s\n", client->sub_id);
axiom_element_set_text(id_elem, env, client->sub_id, id_node);
axis2_svc_client_add_header(svc_client, env, id_node);
return AXIS2_SUCCESS;
}
int
wsf_util_engage_module (
axis2_conf_t * conf,
axis2_char_t * module_name,
axutil_env_t * env,
axis2_svc_t * svc)
{
axis2_module_desc_t *module = NULL;
axutil_qname_t *mod_qname = NULL;
axis2_phase_resolver_t *phase_resolver = NULL;
int status = AXIS2_FAILURE;
mod_qname = axutil_qname_create (env, module_name, NULL, NULL);
module = axis2_conf_get_module (conf, env, mod_qname);
if (module) {
status = axis2_svc_engage_module (svc, env, module, conf);
if (!status) {
phase_resolver =
axis2_phase_resolver_create_with_config (env, conf);
if (!phase_resolver) {
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
" [wsf-log] PHASE RESLOVER NULL");
return AXIS2_FAILURE;
}
status =
axis2_phase_resolver_engage_module_to_svc (phase_resolver,
env, svc, module);
}
}
return status;
}
static xsltStylesheetPtr
savan_xpath_filter_mod_get_filter_template(
const axutil_env_t *env,
axis2_char_t *filter_template_path,
xmlChar *filter)
{
xsltStylesheetPtr xslt_template_xslt = NULL;
xmlDocPtr xslt_template_xml = NULL;
xmlChar* xpathExpr = NULL;
xmlXPathContextPtr xpathCtx = NULL;
xmlXPathObjectPtr xpathObj = NULL;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] filter_template_path:%s", filter_template_path);
xslt_template_xml = xmlParseFile(filter_template_path);
xpathExpr = (xmlChar*)"//@select";
xpathCtx = xmlXPathNewContext(xslt_template_xml);
xpathObj = xmlXPathEvalExpression(xpathExpr, xpathCtx);
savan_xpath_filter_mod_update_filter_template(xpathObj->nodesetval, filter);
xslt_template_xslt = xsltParseStylesheetDoc(xslt_template_xml);
xmlXPathFreeObject(xpathObj);
xmlXPathFreeContext(xpathCtx);
return xslt_template_xslt;
}
AXIS2_EXTERN void AXIS2_CALL
axis2_arch_file_data_free(
axis2_arch_file_data_t * arch_file_data,
const axutil_env_t * env)
{
if (arch_file_data->file)
{
axutil_file_free(arch_file_data->file, env);
}
if (arch_file_data->msg_recv)
{
AXIS2_FREE(env->allocator, arch_file_data->msg_recv);
}
if (arch_file_data->module_name)
{
AXIS2_FREE(env->allocator, arch_file_data->module_name);
}
if (arch_file_data->module_dll_name)
{
AXIS2_FREE(env->allocator, arch_file_data->module_dll_name);
}
if (arch_file_data->name)
{
AXIS2_FREE(env->allocator, arch_file_data->name);
}
if (arch_file_data->svc_map)
{
axutil_hash_index_t *hi = NULL;
void *val = NULL;
for (hi = axutil_hash_first(arch_file_data->svc_map, env); hi;
hi = axutil_hash_next(env, hi))
{
axis2_svc_t *svc = NULL;
axutil_hash_this(hi, NULL, NULL, &val);
svc = (axis2_svc_t *) val;
if (svc)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Service name :%s",
axis2_svc_get_name(svc, env));
axis2_svc_free(svc, env);
}
}
axutil_hash_free(arch_file_data->svc_map, env);
}
if (arch_file_data->deployable_svcs)
{
axutil_array_list_free(arch_file_data->deployable_svcs, env);
}
if (arch_file_data)
{
AXIS2_FREE(env->allocator, arch_file_data);
}
return;
}
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;
}
axis2_op_t *AXIS2_CALL
axis2_req_uri_disp_find_op(
axis2_msg_ctx_t * msg_ctx,
const axutil_env_t * env,
axis2_svc_t * svc)
{
axis2_endpoint_ref_t *endpoint_ref = NULL;
axis2_op_t *op = NULL;
AXIS2_PARAM_CHECK(env->error, svc, NULL);
if(axis2_msg_ctx_get_doing_rest(msg_ctx, env))
return NULL;
endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env);
if(endpoint_ref)
{
const axis2_char_t *address = NULL;
address = axis2_endpoint_ref_get_address(endpoint_ref, env);
if(address)
{
axis2_char_t **url_tokens = NULL;
url_tokens = axutil_parse_request_url_for_svc_and_op(env, address);
if(url_tokens)
{
if(url_tokens[1])
{
axutil_qname_t *op_qname = NULL;
AXIS2_LOG_DEBUG(
env->log,
AXIS2_LOG_SI,
"Checking for operation using \
target endpoint uri fragment : %s",
url_tokens[1]);
op_qname = axutil_qname_create(env, url_tokens[1], NULL, NULL);
op = axis2_svc_get_op_with_name(svc, env, axutil_qname_get_localpart(op_qname,
env));
axutil_qname_free(op_qname, env);
if(op)
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Operation found using target endpoint uri fragment");
}
if(url_tokens[0])
AXIS2_FREE(env->allocator, url_tokens[0]);
if(url_tokens[1])
AXIS2_FREE(env->allocator, url_tokens[1]);
AXIS2_FREE(env->allocator, url_tokens);
}
}
}
return op;
}
axiom_node_t *axis2_saml_issuer_issue(
const axutil_env_t * env,
trust_context_t *trust_ctx)
{
axis2_char_t *token_type = NULL;
axiom_node_t *issued_saml_token = NULL;
axiom_node_t *rstr_node = NULL;
axiom_node_t *requested_sec_token_node = NULL;
trust_rst_t *rst = NULL; /*Created RST Context*/
trust_rstr_t *rstr = NULL; /*Used for Creating RSTR*/
rst = trust_context_get_rst(trust_ctx, env);
token_type = trust_rst_get_token_type(rst, env);
if(token_type)
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sts] token type: %s !", token_type);
else
return NULL;
if (axutil_strcmp(token_type, SAML_TOKEN))
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sts] token type not equal..!");
return NULL;
}
rstr = trust_rstr_create(env);
issued_saml_token = create_saml_token(env);
trust_rstr_set_requested_security_token(rstr, env, issued_saml_token);
trust_rstr_set_wst_ns_uri(rstr, env, "http://schemas.xmlsoap.org/ws/2005/02/trust");
trust_rstr_set_requested_proof_token(rstr, env, trust_util_create_random_session_key_proof_token_element(env,
"http://schemas.xmlsoap.org/ws/2005/02/trust")
);
trust_context_set_rstr(trust_ctx, env, rstr);
rstr_node = trust_context_build_rstr_node(trust_ctx, env);
return rstr_node;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
sandesha2_seq_mgr_has_seq_timedout(
const axutil_env_t *env,
axis2_char_t *property_key,
sandesha2_seq_property_mgr_t *seq_prop_mgr,
axis2_svc_t *svc)
{
sandesha2_property_bean_t *property_bean = NULL;
axis2_bool_t seq_timedout = AXIS2_FALSE;
long last_activated_time = -1;
long current_time = -1;
long timeout_interval = -1;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_seq_mgr_has_seq_timedout");
AXIS2_PARAM_CHECK(env->error, property_key, AXIS2_FALSE);
AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, AXIS2_FALSE);
property_bean = sandesha2_utils_get_property_bean(env, svc);
timeout_interval = sandesha2_property_bean_get_inactive_timeout_interval(property_bean, env);
if(timeout_interval <= 0)
{
return AXIS2_FALSE;
}
last_activated_time = sandesha2_seq_mgr_get_last_activated_time(env, property_key, seq_prop_mgr);
current_time = sandesha2_utils_get_current_time_in_millis(env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]timeout_interval:%ld", timeout_interval);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]last_activated_time:%ld", last_activated_time);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]current_time:%ld", current_time);
if(last_activated_time > 0 && ((last_activated_time + timeout_interval) < current_time))
{
seq_timedout = AXIS2_TRUE;
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Exit:sandesha2_seq_mgr_has_seq_timedout");
return seq_timedout;
}
AXIS2_EXTERN axis2_char_t* AXIS2_CALL
service_admin_util_get_wsdl_for_service(axutil_env_t *env,
axis2_char_t *service_name,
axis2_conf_t *conf)
{
axis2_transport_in_desc_t *transport_in = axis2_conf_get_transport_in(conf, env, AXIS2_TRANSPORT_ENUM_HTTP);
if(transport_in)
{
axis2_endpoint_ref_t *epr = NULL;
axis2_char_t *address = NULL;
axis2_transport_receiver_t *receiver = axis2_transport_in_desc_get_recv(transport_in, env);
if(!receiver)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Transport Receiver Not found ");
return NULL;
}
epr = axis2_transport_receiver_get_epr_for_service(receiver, env, service_name);
if(!epr)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Endpoint reference null");
return NULL;
}
address = (axis2_char_t*)axis2_endpoint_ref_get_address(epr,env);
if(address)
{
int length = axutil_strlen(address);
if(address[length -1 ] == '\\')
{
address = axutil_stracat(env, address,"?wsdl");
}else{
address = axutil_stracat(env, address,"\?wsdl");
}
}
return address;
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_add_handler_at(
axis2_phase_t * phase,
const axutil_env_t * env,
const int idx,
axis2_handler_t * handler)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"axis2_handler_t *%s added to the index %d of the phase %s", axutil_string_get_buffer(
axis2_handler_get_name(handler, env), env), idx, phase->name);
return axutil_array_list_add_at(phase->handlers, env, idx, handler);
}
/**
* Traverse thru the node and its descendents. Check if the localname is equal to the given name
* @param env Environment. MUST NOT be NULL,
* @param node the node to be searched
* @param localname the local name of the node to be searched
* @return the node if found, else NULL
*/
AXIS2_EXTERN axiom_node_t* AXIS2_CALL
oxs_axiom_get_node_by_local_name(
const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *local_name)
{
axis2_char_t *temp_name = NULL;
if(!node)
{
return NULL;
}
if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
{
return NULL;
}
temp_name = axiom_util_get_localname(node, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[rampart]Checking node %s for %s", temp_name, local_name );
if(!axutil_strcmp(temp_name, local_name))
{
/* Gottcha.. return this node */
return node;
}
else
{
/* Doesn't match? Get the children and search for them */
axiom_node_t *temp_node = NULL;
temp_node = axiom_node_get_first_element(node, env);
while(temp_node)
{
axiom_node_t *res_node = NULL;
res_node = oxs_axiom_get_node_by_local_name(env, temp_node, local_name);
if(res_node)
{
return res_node;
}
temp_node = axiom_node_get_next_sibling(temp_node, env);
}
}
return NULL;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
savan_xpath_filter_mod_apply(
savan_filter_mod_t *filtermod,
const axutil_env_t *env,
savan_subscriber_t *subscriber,
axiom_node_t *payload)
{
axis2_char_t *payload_string = NULL;
xmlDocPtr payload_doc = NULL;
xsltStylesheetPtr xslt_template_filter = NULL;
xmlChar *xfilter = NULL;
xmlDocPtr result_doc;
savan_xpath_filter_mod_t *filtermodimpl = NULL;
filtermodimpl = SAVAN_INTF_TO_IMPL(filtermod);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[savan] Entry:savan_xpath_filter_mod_apply");
xfilter = (xmlChar *) savan_subscriber_get_filter(subscriber, env);
if(!xfilter)
{
return AXIS2_FALSE;
}
payload_string = axiom_node_to_string(payload, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[savan] payload_string before applying filter %s:%s", xfilter, payload_string);
payload_doc = (xmlDocPtr)xmlParseDoc((xmlChar*)payload_string);
xslt_template_filter = (xsltStylesheetPtr) savan_xpath_filter_mod_get_filter_template(env,
filtermodimpl->filter_template_path, xfilter);
result_doc = (xmlDocPtr)xsltApplyStylesheet(xslt_template_filter, payload_doc, NULL);
if(result_doc)
{
/*free(payload_string);*/ /* In apache freeing this give seg fault:damitha */
xmlFreeDoc(result_doc);
return AXIS2_TRUE;
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_xpath_filter_mod_apply");
return AXIS2_FALSE;
}
AXIS2_EXTERN int AXIS2_CALL
openssl_sig_sign(const axutil_env_t *env,
openssl_pkey_t *prvkey,
oxs_buffer_t *input_buf,
oxs_buffer_t *output_buf)
{
unsigned char sig_buf[4096]; /*Enough for the signature*/
unsigned int sig_len;
const EVP_MD* digest;
EVP_MD_CTX md_ctx;
EVP_PKEY* pkey = NULL;
int err, ret;
/*Get the key*/
/*open_pkey = oxs_sign_ctx_get_private_key(sign_ctx, env);*/
pkey = openssl_pkey_get_key(prvkey, env);
if(!pkey){
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIGN_FAILED,"Cannot load the private key" );
}
/*TODO: Set the digest according to the signature method*/
digest = EVP_sha1();
/*MD Ctx init*/
EVP_MD_CTX_init(&md_ctx);
/*Sign init*/
ret = EVP_SignInit(&md_ctx, digest);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[openssl][sig] Signing content %s", oxs_buffer_get_data(input_buf, env) );
EVP_SignUpdate (&md_ctx, oxs_buffer_get_data(input_buf, env), oxs_buffer_get_size(input_buf, env));
sig_len = sizeof(sig_buf);
err = EVP_SignFinal (&md_ctx,
sig_buf,
&sig_len,
pkey);
if (err != 1) {
ERR_print_errors_fp (stderr);
}
/*Fill the output buffer*/
oxs_buffer_populate(output_buf, env, sig_buf, sig_len);
EVP_MD_CTX_cleanup(&md_ctx);
return sig_len;
}
void
test_log_write(
)
{
char msg[20];
printf("start of test_log_write\n\n");
axutil_allocator_t *allocator = axutil_allocator_init(NULL);
if (!allocator)
{
printf("allocator is NULL\n");
return;
}
axutil_error_t *error = axutil_error_create(allocator);
if (!error)
{
printf("cannot create error\n");
return;
}
axutil_log_t *log22 = axutil_log_create(allocator, NULL, NULL);
if (!log22)
{
printf("cannot create log\n");
return;
}
log22->level = AXIS2_LOG_LEVEL_DEBUG;
const axutil_env_t *env =
axutil_env_create_with_error_log(allocator, error, log22);
if (!env)
{
printf("cannot create env with error and log\n");
return;
}
strcpy(msg, "abcd test123");
AXIS2_LOG_CRITICAL(env->log, AXIS2_LOG_SI, "log1 %s", "test1");
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "log2 %d", 2);
AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "log3 %s", "test3");
AXIS2_LOG_INFO(env->log, AXIS2_LOG_SI, "log4 %s %s", "info1", "info2");
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "log5 %s %d", "test", 5);
printf("end of test_log_write \n\n");
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_fault_code_set_sub_code(
axiom_soap_fault_code_t * fault_code,
const axutil_env_t * env,
axiom_soap_fault_sub_code_t * fault_subcode)
{
AXIS2_PARAM_CHECK(env->error, fault_subcode, AXIS2_FAILURE);
if(!(fault_code->subcode))
{
fault_code->subcode = fault_subcode;
return AXIS2_SUCCESS;
}
else
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"trying to set fault subcode to fault code more than once ");
}
return AXIS2_FAILURE;
}
/*Create function */
axis2_svc_skeleton_t *
savan_subs_mgr_svc_create(
const axutil_env_t *env)
{
axis2_svc_skeleton_t *svc_skeleton = NULL;
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "savan_subs_mgr_svc service create called");
/* Allocate memory for the structs */
svc_skeleton = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_skeleton_t));
svc_skeleton->ops = &savan_subs_mgr_svc_skeleton_ops_var;
svc_skeleton->func_array = NULL;
/* Assign function pointers */
return svc_skeleton;
}
/**
* Set a security processed result to the message context
* @param env Environment structure
* @param msg_ctx message context sttucture
* @param key key of the security processed result
* @param value value of the security processed result
* @return status of the operation
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rampart_set_security_processed_result(
const axutil_env_t *env,
axis2_msg_ctx_t *msg_ctx,
axis2_char_t *key,
void *value)
{
axutil_hash_t *sec_processed_results = NULL;
sec_processed_results = rampart_get_all_security_processed_results(env, msg_ctx);
if(!sec_processed_results)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Cannot retrieve security processed results container.");
return AXIS2_FAILURE;
}
axutil_hash_set(sec_processed_results, key, AXIS2_HASH_KEY_STRING, value);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[rampart]Set %s in Security Processed Results of message context ", key);
return AXIS2_SUCCESS;
}
axiom_node_t *
build_om_programatically(
const axutil_env_t * env)
{
axiom_node_t *version_om_node = NULL;
axiom_element_t *version_om_ele = NULL;
axiom_namespace_t *ns1 = NULL;
axiom_xml_writer_t *xml_writer = NULL;
axiom_output_t *om_output = NULL;
axis2_char_t *buffer = NULL;
ns1 =
axiom_namespace_create(env, "urn:aewebservices71",
"ns1");
version_om_ele =
axiom_element_create(env, NULL, "GetVersion", ns1, &version_om_node);
xml_writer =
axiom_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE, AXIS2_FALSE,
AXIS2_XML_PARSER_TYPE_BUFFER);
om_output = axiom_output_create(env, xml_writer);
axiom_node_serialize(version_om_node, env, om_output);
buffer = (axis2_char_t *) axiom_xml_writer_get_xml(xml_writer, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "\nSending OM node in XML : %s \n",
buffer);
if (om_output)
{
axiom_output_free(om_output, env);
om_output = NULL;
}
axiom_namespace_free(ns1, env);
return version_om_node;
}
/**
* Prints all ke/val pairs in the security processed results. For debugging purposes
* @env the environment
* @msg_ctx the message context in which data are extracted
* @return void
*/
AXIS2_EXTERN void AXIS2_CALL
rampart_print_security_processed_results_set(
const axutil_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axutil_hash_t *sec_processed_results = NULL;
axutil_hash_index_t *hi = NULL;
const void *key = NULL;
void *val = NULL;
sec_processed_results = rampart_get_all_security_processed_results(env, msg_ctx);
if(!sec_processed_results)
{
return;
}
for (hi = axutil_hash_first(sec_processed_results, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[rampart](key, val) %s = %s\n", (axis2_char_t*)key, (axis2_char_t*)val);
}
}
void
test_validate_data_and_payload_creation(const axutil_env_t* env)
{
wsf_wsdl_data_t* data = NULL;
wsf_wsdl_data_template_t* data_template = NULL;
axis2_bool_t success;
axis2_char_t* payload;
AXIS2_LOG_DEBUG_MSG(env->log, "[wsf_wsdl_test] Starting test_wsdl_data...");
data = create_params(env);
if (data)
{
AXIS2_LOG_DEBUG_MSG(env->log, "[wsf_wsdl_test]data is not NULL, again a good sign!");
}
data_template = create_template(env);
if (data_template)
{
AXIS2_LOG_DEBUG_MSG(env->log, "[wsf_wsdl_test]wow!, even template is not NULL!");
}
success = validate_data(env, NULL, data_template, data, VALIDATION_CRITERIA_REQUEST_MODE_TYPE);
if (success)
{
AXIS2_LOG_DEBUG_MSG(env->log, "[wsf_wsdl_test]validation result : SUCCESS!!!");
}
payload = create_payload(env, data);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_wsdl_test]payload : %s", payload);
AXIS2_LOG_DEBUG_MSG(env->log, "[wsf_wsdl_test] Ending test_wsdl_data...");
}
WSF_WSDL_EXTERN axis2_bool_t WSF_WSDL_CALL
wsf_wsdl_request(
const axutil_env_t* env,
axis2_char_t* wsdl_file_name,
const axis2_char_t* operation_name,
wsf_wsdl_data_t* parameters,
axis2_char_t* script_binding_home,
axis2_svc_client_t* svc_client,
axutil_hash_t* svc_client_user_options,
axis2_char_t* service_name,
axis2_char_t* port_name,
wsf_wsdl_data_t** response)
{
int soap_version = 2;
int has_fault = AXIS2_FALSE;
int binding_style = WSDL_BINDING_STYLE_DOC_LIT_W;
axis2_char_t* payload = NULL;
axiom_node_t* payload_node = NULL;
axis2_char_t* request_buffer = NULL;
axiom_node_t* type_map = NULL;
axis2_char_t *res_text = NULL;
axiom_node_t* sig_axiom = NULL;
axiom_node_t *fault_node = NULL;
axiom_node_t* wsdl_axiom = NULL;
axiom_node_t* params_node = NULL;
axiom_node_t* returns_node = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_node_t *body_base_node = NULL;
/*axis2_char_t *wrapper_element = NULL;*/
axiom_node_t* operation_axiom = NULL;
axiom_soap_fault_t *soap_fault = NULL;
axis2_options_t *client_options = NULL;
/*axis2_char_t *wrapper_element_ns = NULL;*/
/*axiom_node_t *axiom_soap_base_node = NULL; */
axiom_soap_envelope_t *response_envelope = NULL;
wsf_wsdl_data_template_t* input_template = NULL;
wsf_wsdl_data_template_t* output_template = NULL;
axis2_bool_t is_version1_wsdl = AXIS2_FALSE;
axis2_char_t* xslt_location = NULL;
axis2_char_t* type_map_file = NULL;
AXIS2_LOG_TRACE_MSG(env->log, "Starting execution of wsf_wsdl_request...");
xslt_location = axutil_strcat(env, script_binding_home, WSF_WSDL_XSLT_LOCATION_POSTFIX, NULL);
type_map_file = axutil_strcat(env, script_binding_home, WSF_WSDL_TYPE_MAP_POSTFIX, NULL);
client_options = (axis2_options_t *)axis2_svc_client_get_options(svc_client, env);
axis2_options_set_xml_parser_reset(client_options, env, AXIS2_FALSE);
if (!wsf_wsdl_parser_load_wsdl(env, wsdl_file_name, xslt_location, &wsdl_axiom, &sig_axiom, &is_version1_wsdl, AXIS2_FALSE))
return AXIS2_FALSE;
wsdl_util_create_type_map(env, type_map_file, &type_map);
wsdl_util_manage_client_options(env,
svc_client,
svc_client_user_options,
client_options,
operation_name,
wsdl_axiom,
is_version1_wsdl,
sig_axiom,
service_name,
port_name,
&operation_axiom,
&soap_version);
wsdl_util_identify_binding_style(env, operation_axiom, &binding_style);
if (!operation_axiom)
{
AXIS2_LOG_ERROR_MSG(env->log, "Operation axiom is NULL");
if (wsdl_axiom)
axiom_node_free_tree(wsdl_axiom, env);
if (sig_axiom)
axiom_node_free_tree(sig_axiom, env);
if (type_map)
axiom_node_free_tree(type_map, env);
return AXIS2_FALSE;
}
wsdl_util_get_params_node(env, operation_axiom, ¶ms_node);
wsdl_util_get_returns_node(env, operation_axiom, &returns_node);
wsdl_data_util_axiom_to_template(env, params_node, &input_template);
wsdl_data_util_axiom_to_template(env, returns_node, &output_template);
#ifdef WSDL_DEBUG_MODE
{
axis2_char_t* buffer = NULL;
wsdl_data_util_serialize_data(env, parameters, &buffer);
AXIS2_LOG_DEBUG_MSG(env->log, buffer);
AXIS2_FREE(env->allocator, buffer);
wsdl_data_util_serialize_template(env, input_template, &buffer);
AXIS2_LOG_DEBUG_MSG(env->log, buffer);
AXIS2_FREE(env->allocator, buffer);
buffer = NULL;
}
#endif
if (wsdl_data_util_validate_data(env, type_map, input_template, parameters, VALIDATION_CRITERIA_REQUEST_MODE_TYPE) == AXIS2_TRUE)
{
payload_node = wsdl_data_util_create_payload(env, parameters, binding_style);
payload = payload_node? axiom_node_to_string(payload_node, env) : NULL;
// axiom_node_free_tree(payload_node, env);
}
else
{
AXIS2_LOG_ERROR_MSG(env->log, "User data is not valid or not in proper format");
if (input_template)
wsdl_data_template_free(env, input_template);
if (output_template)
wsdl_data_template_free(env, output_template);
if (wsdl_axiom)
axiom_node_free_tree(wsdl_axiom, env);
if (sig_axiom)
axiom_node_free_tree(sig_axiom, env);
if (type_map)
axiom_node_free_tree(type_map, env);
return AXIS2_FALSE;
}
if (!payload_node)
{
AXIS2_LOG_ERROR_MSG(env->log, "Request payload is not found");
if (input_template)
wsdl_data_template_free(env, input_template);
if (output_template)
wsdl_data_template_free(env, output_template);
if (wsdl_axiom)
axiom_node_free_tree(wsdl_axiom, env);
if (sig_axiom)
axiom_node_free_tree(sig_axiom, env);
if (type_map)
axiom_node_free_tree(type_map, env);
return AXIS2_FALSE;
}
request_buffer = (axis2_char_t*)wsdl_util_create_request_envelope(env, payload_node, soap_version);
if (!request_buffer)
{
AXIS2_LOG_ERROR_MSG(env->log, "Error in creating request payload dom");
if (input_template)
wsdl_data_template_free(env, input_template);
if (output_template)
wsdl_data_template_free(env, output_template);
if (wsdl_axiom)
axiom_node_free_tree(wsdl_axiom, env);
if (sig_axiom)
axiom_node_free_tree(sig_axiom, env);
if (type_map)
axiom_node_free_tree(type_map, env);
return AXIS2_FALSE;
}
response_envelope = (axiom_soap_envelope_t*)wsdl_util_send_receive_soap_envelope_with_op_client(env,
svc_client,
client_options,
request_buffer);
if (response_envelope)
{
has_fault = AXIS2_TRUE;
soap_body = axiom_soap_envelope_get_body (response_envelope, env);
if (soap_body)
{
soap_fault = axiom_soap_body_get_fault (soap_body, env);
}
if (soap_fault)
{
soap_version = axis2_options_get_soap_version(client_options, env);
fault_node = axiom_soap_fault_get_base_node(soap_fault, env);
if (fault_node)
{
res_text = axiom_node_to_string(fault_node, env);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "Fault payload is %s", res_text);
if (input_template)
wsdl_data_template_free(env, input_template);
if (output_template)
wsdl_data_template_free(env, output_template);
if (wsdl_axiom)
axiom_node_free_tree(wsdl_axiom, env);
if (sig_axiom)
axiom_node_free_tree(sig_axiom, env);
if (type_map)
axiom_node_free_tree(type_map, env);
return AXIS2_FALSE;
}
}
if (soap_body)
{
body_base_node = axiom_soap_body_get_base_node(soap_body, env);
}
if (body_base_node && !soap_fault)
{
axis2_char_t *response_buffer = NULL;
wsf_wsdl_data_t *response_data = NULL;
response_buffer = axiom_node_to_string(body_base_node, env);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"Response buffer is %s", response_buffer);
AXIS2_FREE(env->allocator, response_buffer);
wsdl_data_util_axiom_to_data(env, body_base_node, &response_data);
#ifdef WSDL_DEBUG_MODE
{
axis2_char_t* buffer = NULL;
wsdl_data_util_serialize_data(env, response_data, &buffer);
AXIS2_LOG_DEBUG_MSG(env->log, buffer);
AXIS2_FREE(env->allocator, buffer);
wsdl_data_util_serialize_template(env, output_template, &buffer);
AXIS2_LOG_DEBUG_MSG(env->log, buffer);
AXIS2_FREE(env->allocator, buffer);
buffer = NULL;
}
#endif
if (wsdl_data_util_validate_data(env, type_map, output_template, response_data, VALIDATION_CRITERIA_RESPONSE_MODE) == AXIS2_TRUE)
{
AXIS2_LOG_DEBUG_MSG(env->log, "Valid response!!!");
*response = response_data;
if (input_template)
wsdl_data_template_free(env, input_template);
if (output_template)
wsdl_data_template_free(env, output_template);
if (wsdl_axiom)
axiom_node_free_tree(wsdl_axiom, env);
if (sig_axiom)
axiom_node_free_tree(sig_axiom, env);
if (type_map)
axiom_node_free_tree(type_map, env);
return AXIS2_TRUE;
}
else
{
AXIS2_LOG_ERROR_MSG(env->log, "Response data is not valid or not in proper format");
if (input_template)
wsdl_data_template_free(env, input_template);
if (output_template)
wsdl_data_template_free(env, output_template);
if (wsdl_axiom)
axiom_node_free_tree(wsdl_axiom, env);
if (sig_axiom)
axiom_node_free_tree(sig_axiom, env);
if (type_map)
axiom_node_free_tree(type_map, env);
return AXIS2_FALSE;
}
}
}
else /* response_envelope == NULL */
{
AXIS2_LOG_ERROR_MSG(env->log, "Response envelope not found");
}
if (input_template)
wsdl_data_template_free(env, input_template);
if (output_template)
wsdl_data_template_free(env, output_template);
if (wsdl_axiom)
axiom_node_free_tree(wsdl_axiom, env);
if (sig_axiom)
axiom_node_free_tree(sig_axiom, env);
if (type_map)
axiom_node_free_tree(type_map, env);
return AXIS2_FALSE;
}
axis2_status_t AXIS2_CALL
sandesha2_out_handler_invoke(
struct axis2_handler *handler,
const axutil_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
axutil_property_t *temp_prop = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_conf_t *conf = NULL;
axis2_char_t *str_done = NULL;
axis2_char_t *dummy_msg_str = NULL;
axis2_bool_t dummy_msg = AXIS2_FALSE;
axis2_svc_t *svc = NULL;
axutil_qname_t *module_qname = NULL;
sandesha2_msg_ctx_t *rm_msg_ctx = NULL;
sandesha2_msg_processor_t *msg_processor = NULL;
int msg_type = -1;
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_out_handler_invoke");
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_SEQ_PROP_MAKE_CONNECTION_OUT_PATH);
if (temp_prop)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[sandesha2] In make connection out path. So return here.");
return AXIS2_SUCCESS;
temp_prop = NULL;
}
if(sandesha2_util_is_rstr_msg(env, msg_ctx))
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[sandesha2] A RSTR message. Sandesha don't process.");
return AXIS2_SUCCESS;
}
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
if(!conf_ctx)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2] Configuration Context is NULL");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONF_CTX_NULL, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(!svc)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]Axis2 Service is NULL");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SVC_NULL, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
module_qname = axutil_qname_create(env, SANDESHA2_MODULE, NULL, NULL);
if(!axis2_svc_is_module_engaged(svc, env, module_qname))
{
if(module_qname)
{
axutil_qname_free(module_qname, env);
}
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]RM is not engaged. So return here");
return AXIS2_SUCCESS;
}
if(module_qname)
{
axutil_qname_free(module_qname, env);
}
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE);
if(temp_prop)
{
str_done = (axis2_char_t *) axutil_property_get_value(temp_prop, env);
}
if(str_done && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, str_done))
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"[sandesha2]Application Processing Done. So return here.");
return AXIS2_SUCCESS;
}
temp_prop = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, temp_prop);
conf = axis2_conf_ctx_get_conf(conf_ctx, env);
if(!sandesha2_permanent_storage_mgr_create_db(env, conf_ctx))
{
return AXIS2_FAILURE;
}
/* Getting rm message */
rm_msg_ctx = sandesha2_msg_init_init_msg(env, msg_ctx);
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_CLIENT_DUMMY_MESSAGE);
if(NULL != temp_prop)
{
dummy_msg_str = (axis2_char_t *) axutil_property_get_value(temp_prop, env);
}
if(dummy_msg_str && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, dummy_msg_str))
{
dummy_msg = AXIS2_TRUE;
}
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SVC_CLIENT_CLOSED);
if(temp_prop)
{
axis2_char_t *spec_version = NULL;
axis2_endpoint_ref_t *reply_to = axis2_msg_ctx_get_reply_to(msg_ctx, env);
if(reply_to)
{
axis2_char_t *address = axis2_endpoint_ref_get_address(reply_to, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "dam_reply_to_address:%s", address);
}
spec_version = sandesha2_utils_get_rm_version(env, msg_ctx);
if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version))
{
axis2_char_t *action = NULL;
axutil_string_t *str_action = NULL;
action = sandesha2_spec_specific_consts_get_terminate_seq_action(env, spec_version);
str_action = axutil_string_create(env, action);
axis2_msg_ctx_set_soap_action(msg_ctx, env, str_action);
axutil_string_free(str_action, env);
/*axis2_msg_ctx_set_reply_to(msg_ctx, env, NULL);*/
msg_type = sandesha2_msg_ctx_set_msg_type(rm_msg_ctx, env,
SANDESHA2_MSG_TYPE_CLOSE_SEQ);
}
else if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_0, spec_version))
{
axutil_property_t *property = NULL;
axutil_string_t *str_action = NULL;
/*axis2_msg_info_headers_set_action(axis2_msg_ctx_get_msg_info_headers(msg_ctx, env),
* env, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE); */
str_action = axutil_string_create(env, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE);
axis2_msg_ctx_set_soap_action(msg_ctx, env, str_action);
axutil_string_free(str_action, env);
property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
axis2_msg_ctx_set_property(msg_ctx, env, "Sandesha2LastMessage", property);
/*axis2_msg_ctx_set_reply_to(msg_ctx, env, NULL);*/
}
}
msg_type = sandesha2_msg_ctx_get_msg_type(rm_msg_ctx, env);
if(msg_type == SANDESHA2_MSG_TYPE_UNKNOWN)
{
axis2_msg_ctx_t *req_msg_ctx = NULL;
axis2_op_ctx_t *op_ctx = NULL;
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
req_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
if(req_msg_ctx) /* For the server side */
{
sandesha2_msg_ctx_t *req_rm_msg_ctx = NULL;
sandesha2_seq_t *seq_part = NULL;
req_rm_msg_ctx = sandesha2_msg_init_init_msg(env, req_msg_ctx);
seq_part = sandesha2_msg_ctx_get_sequence(req_rm_msg_ctx, env);
if(seq_part)
{
msg_processor = (sandesha2_msg_processor_t *)
sandesha2_app_msg_processor_create(env); /* rm intended msg */
}
if(req_rm_msg_ctx)
sandesha2_msg_ctx_free(req_rm_msg_ctx, env);
}
else if(!axis2_msg_ctx_get_server_side(msg_ctx, env))
{
msg_processor = (sandesha2_msg_processor_t *) sandesha2_app_msg_processor_create(env);
}
}
else
{
msg_processor = sandesha2_msg_processor_create_msg_processor(env, rm_msg_ctx);
}
if(msg_processor)
{
sandesha2_msg_processor_process_out_msg(msg_processor, env, rm_msg_ctx);
sandesha2_msg_processor_free(msg_processor, env);
}
if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
{
/* Message should not be sent in an exception situation */
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Pausing message context");
axis2_msg_ctx_set_paused(msg_ctx, env, AXIS2_TRUE);
if(rm_msg_ctx)
{
sandesha2_msg_ctx_free(rm_msg_ctx, env);
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Error in processing the message");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_PROCESS_MSG, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE);
if(temp_prop)
{
axutil_property_set_value(temp_prop, env, AXIS2_VALUE_FALSE);
}
if(rm_msg_ctx)
{
sandesha2_msg_ctx_free(rm_msg_ctx, env);
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_out_handler_invoke");
return AXIS2_SUCCESS;
}
axis2_status_t
axis2_addr_in_extract_addr_params(
const axutil_env_t * env,
axiom_soap_header_t * soap_header,
axis2_msg_info_headers_t ** msg_info_headers_p,
axutil_array_list_t * addr_headers,
const axis2_char_t * addr_ns_str,
axis2_msg_ctx_t * msg_ctx)
{
axutil_hash_t *header_block_ht = NULL;
axutil_hash_index_t *hash_index = NULL;
axis2_msg_info_headers_t *msg_info_headers = *(msg_info_headers_p);
axis2_status_t status = AXIS2_SUCCESS;
axis2_bool_t to_found = AXIS2_FALSE;
axis2_bool_t reply_to_found = AXIS2_FALSE;
axis2_bool_t fault_to_found = AXIS2_FALSE;
axis2_bool_t action_found = AXIS2_FALSE;
axis2_bool_t msg_id_found = AXIS2_FALSE;
AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_info_headers_p, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, addr_headers, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE);
if (!msg_info_headers)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No messgae info header. Creating new");
msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL);
if (!msg_info_headers)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MSG_INFO_HEADERS, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"No message information headers available");
return AXIS2_FAILURE;
}
}
header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env);
if (!header_block_ht)
{
return AXIS2_FAILURE;
}
/* Iterate thru header blocks */
for (hash_index = axutil_hash_first(header_block_ht, env); hash_index;
hash_index = axutil_hash_next(env, hash_index))
{
void *hb = NULL;
axiom_soap_header_block_t *header_block = NULL;
axiom_node_t *header_block_node = NULL;
axiom_element_t *header_block_ele = NULL;
axis2_char_t *ele_localname = NULL;
axis2_endpoint_ref_t *epr = NULL;
axis2_char_t *role = NULL;
axutil_hash_this(hash_index, NULL, NULL, &hb);
header_block = (axiom_soap_header_block_t *) hb;
header_block_node =
axiom_soap_header_block_get_base_node(header_block, env);
header_block_ele =
(axiom_element_t *) axiom_node_get_data_element(header_block_node,
env);
ele_localname = axiom_element_get_localname(header_block_ele, env);
role = axiom_soap_header_block_get_role(header_block, env);
if (role && !axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NONE))
{
/* Role is none, no need of processing */
continue;
}
if (!axutil_strcmp(ele_localname, AXIS2_WSA_TO))
{
/* Here the addressing epr overidde what ever already there in the message context */
epr =
axis2_endpoint_ref_create(env,
axiom_element_get_text
(header_block_ele, env,
header_block_node));
if (AXIS2_TRUE == to_found)
{
/* Duplicate To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
axis2_msg_info_headers_set_to(msg_info_headers, env, epr);
axis2_addr_in_extract_to_epr_ref_params(env, epr, soap_header,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_FROM))
{
epr = axis2_msg_info_headers_get_from(msg_info_headers, env);
if (!epr)
{
/* The address is not known now. Pass the empty
string and fill this once the element
under this is processed. */
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_from(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_REPLY_TO))
{
epr = axis2_msg_info_headers_get_reply_to(msg_info_headers, env);
if (reply_to_found == AXIS2_TRUE)
{
/* Duplicate Reply To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_REPLY_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
if (!epr)
{
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
reply_to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_FAULT_TO))
{
epr = axis2_msg_info_headers_get_fault_to(msg_info_headers, env);
if (fault_to_found == AXIS2_TRUE)
{
/* Duplicate Fault To */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_FAULT_TO, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
axis2_msg_info_headers_set_fault_to(msg_info_headers, env,
NULL);
continue;
}
if (!epr)
{
epr = axis2_endpoint_ref_create(env, "");
axis2_msg_info_headers_set_fault_to(msg_info_headers, env, epr);
}
axis2_addr_in_extract_epr_information(env, header_block, epr,
addr_ns_str);
axiom_soap_header_block_set_processed(header_block, env);
fault_to_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_MESSAGE_ID))
{
axis2_char_t *text = NULL;
if (msg_id_found == AXIS2_TRUE)
{
/* Duplicate Message ID */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_MESSAGE_ID,
addr_ns_str, msg_ctx);
status = AXIS2_FAILURE;
continue;
}
text =
axiom_element_get_text(header_block_ele, env,
header_block_node);
axis2_msg_info_headers_set_in_message_id(msg_info_headers, env, text);
axiom_soap_header_block_set_processed(header_block, env);
msg_id_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_ACTION))
{
axis2_char_t *text = NULL;
if (action_found == AXIS2_TRUE)
{
/* Duplicate Action */
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_ACTION, addr_ns_str,
msg_ctx);
status = AXIS2_FAILURE;
continue;
}
text =
axiom_element_get_text(header_block_ele, env,
header_block_node);
axis2_msg_info_headers_set_action(msg_info_headers, env, text);
axiom_soap_header_block_set_processed(header_block, env);
action_found = AXIS2_TRUE;
}
else if (!axutil_strcmp(ele_localname, AXIS2_WSA_RELATES_TO))
{
axis2_char_t *address = NULL;
axutil_qname_t *rqn = NULL;
axiom_attribute_t *relationship_type = NULL;
const axis2_char_t *relationship_type_default_value = NULL;
const axis2_char_t *relationship_type_value = NULL;
axis2_relates_to_t *relates_to = NULL;
if (!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ns_str))
{
relationship_type_default_value =
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION;
}
else
{
relationship_type_default_value =
AXIS2_WSA_ANONYMOUS_URL_SUBMISSION;
}
rqn =
axutil_qname_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE,
NULL, NULL);
relationship_type =
axiom_element_get_attribute(header_block_ele, env, rqn);
if (!relationship_type)
{
relationship_type_value =
AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION;
}
else
{
relationship_type_value =
axiom_attribute_get_value(relationship_type, env);
}
address =
axiom_element_get_text(header_block_ele, env,
header_block_node);
relates_to =
axis2_relates_to_create(env, address, relationship_type_value);
axis2_msg_info_headers_set_relates_to(msg_info_headers, env,
relates_to);
axiom_soap_header_block_set_processed(header_block, env);
axutil_qname_free(rqn, env);
}
}
/* If an action is not found, it's a false*/
if (action_found == AXIS2_FALSE)
{
axis2_addr_in_create_fault_envelope(env,
AXIS2_WSA_PREFIX_ACTION, addr_ns_str, msg_ctx);
status = AXIS2_FAILURE;
}
return status;
}
static axis2_status_t AXIS2_CALL
axis2_msg_recv_load_and_init_svc_impl(
axis2_msg_recv_t *msg_recv,
const axutil_env_t *env,
struct axis2_svc *svc)
{
axutil_param_t *impl_info_param = NULL;
void *impl_class = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if(!svc)
{
return AXIS2_FAILURE;
}
impl_class = axis2_svc_get_impl_class(svc, env);
if(impl_class)
{
return AXIS2_SUCCESS;
}
/* When we load the DLL we have to make sure that only one thread will load it */
axutil_thread_mutex_lock(axis2_svc_get_mutex(svc, env));
/* If more than one thread tries to acquires the lock, first thread loads the DLL.
Others should not load the DLL */
impl_class = axis2_svc_get_impl_class(svc, env);
if(impl_class)
{
axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env));
return AXIS2_SUCCESS;
}
impl_info_param = axis2_svc_get_param(svc, env, AXIS2_SERVICE_CLASS);
if(!impl_info_param)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE);
axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env));
return AXIS2_FAILURE;
}
axutil_allocator_switch_to_global_pool(env->allocator);
axutil_class_loader_init(env);
impl_class = axutil_class_loader_create_dll(env, impl_info_param);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "loading the services from msg_recv_load_and_init_svc");
if(impl_class)
{
axis2_svc_skeleton_t *skel = (axis2_svc_skeleton_t *)impl_class;
axis2_conf_t *conf = NULL;
conf = axis2_conf_ctx_get_conf(msg_recv->conf_ctx, env);
if (skel->ops->init)
{
AXIS2_SVC_SKELETON_INIT(skel, env);
}
if (skel->ops->init_with_conf)
{
AXIS2_SVC_SKELETON_INIT_WITH_CONF(skel, env, conf);
}
}
axis2_svc_set_impl_class(svc, env, impl_class);
axutil_allocator_switch_to_local_pool(env->allocator);
axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env));
return AXIS2_SUCCESS;
}