static void AXIS2_CALL
service_admin_counter_last_counts_free_void_arg(
void *lcounts,
const axutil_env_t *env)
{
axutil_hash_t *last_counts = NULL;
axutil_allocator_switch_to_global_pool(env->allocator);
last_counts = (axutil_hash_t *) lcounts;
if(last_counts)
{
axutil_hash_index_t *hi;
void *val;
void *key;
for (hi = axutil_hash_first(last_counts, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, (const void**)&key, NULL, &val);
if(key)
{
AXIS2_FREE(env->allocator, key);
}
if(val)
{
AXIS2_FREE(env->allocator, val);
}
}
axutil_hash_free(last_counts, env);
last_counts = NULL;
}
axutil_allocator_switch_to_local_pool(env->allocator);
}
axis2_status_t AXIS2_CALL
axis2_statistics_admin_out_op_count_handler_invoke(struct axis2_handler *handler,
const axutil_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
axis2_status_t status = AXIS2_SUCCESS;
service_admin_counter_t *counter = NULL;
axutil_param_t *param = NULL;
axis2_op_t *op = NULL;
axis2_svc_t *svc = NULL;
const axis2_char_t *svc_name = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[adminservices] Start:axis2_statistics_admin_out_op_count_handler_invoke");
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
svc = axis2_msg_ctx_get_svc(msg_ctx, env);
if(svc)
{
svc_name = axis2_svc_get_name(svc, env);
}
op = axis2_msg_ctx_get_op(msg_ctx, env);
if(op)
{
param = axis2_op_get_param(op, env, AXIS2_OUT_OPERATION_COUNTER);
if(param)
{
counter = axutil_param_get_value(param, env);
if(counter)
{
service_admin_counter_increment(counter, env, msg_ctx);
}
}
else
{
axis2_char_t *op_name = NULL;
op_name = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env);
axutil_allocator_switch_to_global_pool(env->allocator);
counter = service_admin_counter_create(env, svc_name, op_name);
if(counter)
{
service_admin_counter_increment(counter, env, msg_ctx);
param = axutil_param_create(env, AXIS2_OUT_OPERATION_COUNTER, counter);
if(param)
{
axis2_op_add_param(op, env, param);
}
}
axutil_allocator_switch_to_local_pool(env->allocator);
}
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[adminservices] End:axis2_statistics_admin_out_op_count_handler_invoke");
return status;
}
AXIS2_EXTERN void* AXIS2_CALL
sct_provider_hash_map_obtain_token(
const axutil_env_t *env,
axis2_bool_t is_encryption,
axis2_msg_ctx_t* msg_ctx,
axis2_char_t *sct_id,
int sct_id_type,
void* user_params)
{
axutil_hash_t *hash_store = NULL;
security_context_token_t *sct = NULL;
/* sct should be get from global pool */
axutil_allocator_switch_to_global_pool(env->allocator);
/* Get sct hash store */
hash_store = sct_provider_hash_map_get_sct_hash_store(env, msg_ctx);
if(!hash_store)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Cannot find security context token storage.");
return NULL;
}
/* get the sct if sct_id is given */
if(sct_id)
{
/* set env */
axutil_hash_set_env(hash_store, env);
sct = (security_context_token_t *)axutil_hash_get(
hash_store, sct_id, AXIS2_HASH_KEY_STRING);
}
if(!sct)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Cannot find security context token.");
}
axutil_allocator_switch_to_local_pool(env->allocator);
return sct;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
sct_provider_hash_map_store_token(
const axutil_env_t *env,
axis2_msg_ctx_t* msg_ctx,
axis2_char_t *sct_global_id,
axis2_char_t *sct_local_id,
void *sct,
void *user_params)
{
axutil_hash_t *hash_store = NULL;
axis2_status_t status = AXIS2_SUCCESS;
/* if given sct is null, then we can't store it */
if(!sct)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Security context token to be stored in not valid.");
return AXIS2_FAILURE;
}
/* sct should be stored in global pool */
axutil_allocator_switch_to_global_pool(env->allocator);
/* Get sct hash store */
hash_store = sct_provider_hash_map_get_sct_hash_store(env, msg_ctx);
if(hash_store)
{
/* set env */
axutil_hash_set_env(hash_store, env);
/* store sct */
if(sct_global_id)
{
axutil_hash_set(hash_store, sct_global_id, AXIS2_HASH_KEY_STRING, sct);
if(sct_local_id)
{
security_context_token_increment_ref(sct, env);
axutil_hash_set(hash_store, sct_local_id, AXIS2_HASH_KEY_STRING, sct);
}
}
else
{
if(sct_local_id)
{
axutil_hash_set(hash_store, sct_local_id, AXIS2_HASH_KEY_STRING, sct);
}
else
{
/* if both local_id and global_id are NULL, then we can't store it */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Security context token identifiers are not valid. "
"Cannot store security context token. ");
status = AXIS2_FAILURE;
}
}
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[rampart]Cannot find security context token storage.");
status = AXIS2_FAILURE;
}
axutil_allocator_switch_to_local_pool(env->allocator);
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;
}
AXIS2_EXPORT axis2_svc_skeleton_t *AXIS2_CALL
axis2_msg_recv_make_new_svc_obj(
axis2_msg_recv_t * msg_recv,
const axutil_env_t * env,
struct axis2_msg_ctx * msg_ctx)
{
struct axis2_svc *svc = NULL;
struct axis2_op_ctx *op_ctx = NULL;
struct axis2_svc_ctx *svc_ctx = NULL;
axutil_param_t *impl_info_param = NULL;
void *impl_class = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL);
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
svc_ctx = axis2_op_ctx_get_parent(op_ctx, env);
svc = axis2_svc_ctx_get_svc(svc_ctx, env);
if(!svc)
{
return NULL;
}
impl_class = axis2_svc_get_impl_class(svc, env);
if(impl_class)
{
return impl_class;
}
else
{
/* 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 impl_class;
}
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 NULL;
}
axutil_allocator_switch_to_global_pool(env->allocator);
axutil_class_loader_init(env);
impl_class = axutil_class_loader_create_dll(env, impl_info_param);
if(impl_class)
{
AXIS2_SVC_SKELETON_INIT((axis2_svc_skeleton_t *)impl_class, env);
}
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 impl_class;
(void)msg_recv;
}
}
AXIS2_EXTERN void AXIS2_CALL
savan_default_publisher_publish(
savan_publisher_t *publishermod,
const axutil_env_t *env,
void *msg_ctx,
savan_subs_mgr_t *subs_mgr)
{
savan_default_publisher_t *publishermodimpl = NULL;
axutil_array_list_t *subs_store = NULL;
int i = 0, size = 0;
savan_filter_mod_t *filtermod = NULL;
const axis2_char_t *path = NULL;
axiom_node_t *payload = NULL;
axiom_soap_envelope_t *envelope = NULL;
axiom_soap_body_t *body = NULL;
axiom_node_t *body_node = NULL;
const axis2_char_t *filter = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
axutil_property_t *topic_property = NULL;
publishermodimpl = SAVAN_INTF_TO_IMPL(publishermod);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_default_publisher_publish");
topic_property = axis2_msg_ctx_get_property(msg_ctx, env, ELEM_NAME_TOPIC);
if(topic_property)
{
filter = axutil_property_get_value(topic_property, env);
}
axutil_allocator_switch_to_global_pool(env->allocator);
if(subs_mgr)
{
subs_store = savan_subs_mgr_retrieve_all_subscribers(subs_mgr, env, filter);
}
if (!subs_store)
{
axutil_allocator_switch_to_local_pool(env->allocator);
AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "[savan] Subscriber store is NULL");
}
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
path = axis2_conf_ctx_get_root_dir(conf_ctx, env);
if(!path)
{
path = AXIS2_GETENV("AXIS2C_HOME");
}
envelope = axis2_msg_ctx_get_soap_envelope((axis2_msg_ctx_t *) msg_ctx, env);
if (!envelope)
{
axutil_allocator_switch_to_local_pool(env->allocator);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to extract the soap envelop");
}
body = axiom_soap_envelope_get_body(envelope, env);
if (!body)
{
axutil_allocator_switch_to_local_pool(env->allocator);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to extract the soap body");
}
body_node = axiom_soap_body_get_base_node(body, env);
payload = axiom_node_get_first_child(body_node, env);
size = axutil_array_list_size(subs_store, env);
for(i = 0; i < size; i++)
{
axis2_svc_client_t *svc_client = NULL;
savan_subscriber_t *sub = NULL;
sub = (savan_subscriber_t *)axutil_array_list_get(subs_store, env, i);
if (sub)
{
axis2_char_t *id = savan_subscriber_get_id(sub, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Publishing to:%s", id);
svc_client = axis2_svc_client_create(env, path);
filtermod = savan_util_get_filter_module(env, publishermodimpl->conf);
/* Ideally publishing to each subscriber should happen within a thread for each
* subscriber. However until Axis2/C provide a good thread pool to handle
* such tasks I use this sequential publishing to subscribers.
*/
if(!savan_default_publisher_publish_to_subscriber(publishermod, env, svc_client, sub,
filtermod, payload))
{
axis2_endpoint_ref_t *notifyto = savan_subscriber_get_notify_to(sub, env);
const axis2_char_t *address = NULL;
if(notifyto)
{
address = axis2_endpoint_ref_get_address(notifyto, env);
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Publishing to the Data Sink:%s proviced by subscriber:%s Failed. Check "\
"whether the Data Sink url is correct", address, id);
}
if(svc_client)
{
axis2_svc_client_free(svc_client, env);
}
}
}
axutil_allocator_switch_to_local_pool(env->allocator);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_default_publisher_publish");
}
