AXIS2_EXTERN axis2_callback_t *AXIS2_CALL
axis2_callback_create(
const axutil_env_t * env)
{
axis2_callback_t *callback = NULL;
AXIS2_ENV_CHECK(env, NULL);
callback = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_t));
if (!callback)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create callback.");
return NULL;
}
callback->complete = AXIS2_FALSE;
callback->envelope = NULL;
callback->error = AXIS2_ERROR_NONE;
callback->data = NULL;
callback->mutex = NULL;
callback->on_complete = axis2_callback_on_complete;
callback->on_error = axis2_callback_on_error;
callback->mutex = axutil_thread_mutex_create(env->allocator,
AXIS2_THREAD_MUTEX_DEFAULT);
return callback;
}
AXIS2_EXTERN axis2_transport_receiver_t *AXIS2_CALL
axis2_udp_receiver_create(
const axutil_env_t * env,
const axis2_char_t * repo,
const int port,
axis2_char_t *multicast_group)
{
axis2_udp_receiver_impl_t *receiver = NULL;
receiver = (axis2_udp_receiver_impl_t *) AXIS2_MALLOC(env->allocator, sizeof(axis2_udp_receiver_impl_t));
if (!receiver)
{
AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
receiver->is_multicast = AXIS2_FALSE;
receiver->conf_ctx = NULL;
receiver->conf_ctx_private = NULL;
receiver->port = port;
receiver->udp_receiver.ops = &udp_transport_recvr_ops;
receiver->multicast_group = multicast_group;
receiver->socket = AXIS2_INVALID_SOCKET;
receiver->send_socket = AXIS2_INVALID_SOCKET;
receiver->owns_socket = AXIS2_TRUE;
receiver->max_packet_size = AXIS2_UDP_PACKET_MAX_SIZE;
if (multicast_group)
{
receiver->is_multicast = AXIS2_TRUE;
}
receiver->mutex = axutil_thread_mutex_create(env->allocator,
AXIS2_THREAD_MUTEX_DEFAULT);
/*
* We are creating the receiver in two instances. When we create the receiver from the server
* we create the conf context. If we are creating the receiver while creating the conf we are
* not creating the conf as conf is already there.
*/
if (repo)
{
receiver->conf_ctx_private = axis2_build_conf_ctx(env, repo);
if (!receiver->conf_ctx_private)
{
AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI,
"unable to create private configuration context for repo path %s", repo);
axis2_udp_receiver_free((axis2_transport_receiver_t *) receiver,
env);
return NULL;
}
receiver->conf_ctx = receiver->conf_ctx_private;
}
axutil_thread_mutex_lock(receiver->mutex);
return &(receiver->udp_receiver);
}
AXIS2_EXTERN service_admin_counter_t* AXIS2_CALL
service_admin_counter_create(
const axutil_env_t *env,
const axis2_char_t *svc_name,
const axis2_char_t *op_name)
{
service_admin_counter_t *counter = NULL;
counter = (service_admin_counter_t *)AXIS2_MALLOC(env->allocator,
sizeof(service_admin_counter_t));
if(!counter)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
counter->count = 0;
counter->last_counts = axutil_hash_make(env);
if(!counter->last_counts)
{
service_admin_counter_free(counter, env);
}
counter->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT);
if(!counter->mutex)
{
service_admin_counter_free(counter, env);
return NULL;
}
if(svc_name)
{
counter->svc_name = axutil_strdup(env, svc_name);
}
if(op_name)
{
counter->op_name = axutil_strdup(env, op_name);
}
return counter;
}
AXIS2_EXTERN axutil_log_t *AXIS2_CALL
axutil_log_create_default(
axutil_allocator_t *allocator)
{
axutil_log_impl_t *log_impl;
if (!allocator)
return NULL;
log_impl = (axutil_log_impl_t *) AXIS2_MALLOC(allocator,
sizeof(axutil_log_impl_t));
if (!log_impl)
return NULL;
log_impl->mutex =
axutil_thread_mutex_create(allocator, AXIS2_THREAD_MUTEX_DEFAULT);
if (!log_impl->mutex)
{
fprintf(stderr, "cannot create log mutex \n");
return NULL;
}
axutil_thread_mutex_lock(log_impl->mutex);
log_impl->file_name = NULL;
log_impl->log.size = AXUTIL_LOG_FILE_SIZE;
log_impl->stream = stderr;
axutil_thread_mutex_unlock(log_impl->mutex);
/* by default, log is enabled */
log_impl->log.enabled = 1;
log_impl->log.level = AXIS2_LOG_LEVEL_DEBUG;
log_impl->log.ops = &axutil_log_ops_var;
return &(log_impl->log);
}
AXIS2_EXTERN axis2_svc_t *AXIS2_CALL
axis2_svc_create(
const axutil_env_t * env)
{
axis2_svc_t *svc = NULL;
svc = (axis2_svc_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_t));
if(!svc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
return NULL;
}
svc->parent = NULL;
svc->axis_svc_name = NULL;
svc->filename = NULL;
svc->svc_desc = NULL;
svc->wsdl_path = NULL;
svc->folder_path = NULL;
svc->last_update = 0;
svc->param_container = NULL;
svc->flow_container = NULL;
svc->op_alias_map = NULL;
svc->op_action_map = NULL;
svc->op_rest_map = NULL;
svc->module_list = NULL;
svc->ns_map = NULL;
svc->ns_count = 0;
svc->schema_list = NULL;
svc->schema_mapping_table = NULL;
svc->schema_loc_adjusted = AXIS2_FALSE;
svc->custom_schema_name_prefix = NULL;
svc->custom_schema_name_suffix = NULL;
svc->schema_target_ns = NULL;
svc->schema_target_ns_prefix = NULL;
svc->target_ns = NULL;
svc->target_ns_prefix = NULL;
svc->sc_calc_count = 0;
svc->impl_class = NULL;
svc->qname = NULL;
svc->style = NULL;
svc->base = NULL;
svc->param_container = axutil_param_container_create(env);
if(!svc->param_container)
{
axis2_svc_free(svc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service param container creation failed");
return NULL;
}
svc->flow_container = axis2_flow_container_create(env);
if(!svc->flow_container)
{
axis2_svc_free(svc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service flow container creation failed");
return NULL;
}
svc->op_alias_map = axutil_hash_make(env);
if(!svc->op_alias_map)
{
axis2_svc_free(svc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation alias map creation failed");
return NULL;
}
svc->op_action_map = axutil_hash_make(env);
if(!svc->op_action_map)
{
axis2_svc_free(svc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation action map creation failed");
return NULL;
}
svc->op_rest_map = axutil_hash_make(env);
if(!svc->op_rest_map)
{
axis2_svc_free(svc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation rest map creation failed");
return NULL;
}
/** Create module list of default size */
svc->module_list = axutil_array_list_create(env, 0);
if(!svc->module_list)
{
axis2_svc_free(svc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service module list creation failed");
return NULL;
}
svc->schema_list = axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
if(!svc->schema_list)
{
axis2_svc_free(svc, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service schema list creation failed");
return NULL;
}
svc->engaged_module_list = axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
if(!svc->engaged_module_list)
{
axis2_svc_free(svc, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service engaged modules list creation failed");
return NULL;
}
svc->schema_loc_adjusted = AXIS2_FALSE;
if(svc->schema_target_ns_prefix)
{
AXIS2_FREE(env->allocator, svc->schema_target_ns_prefix);
svc->schema_target_ns_prefix = NULL;
}
svc->schema_target_ns_prefix = axutil_strdup(env, "ns");
if(svc->target_ns)
{
AXIS2_FREE(env->allocator, svc->target_ns);
svc->target_ns = NULL;
}
svc->target_ns = axutil_strdup(env, "http://ws.apache.org/axis2");
if(svc->target_ns_prefix)
{
AXIS2_FREE(env->allocator, svc->target_ns_prefix);
svc->target_ns_prefix = NULL;
}
svc->target_ns_prefix = axutil_strdup(env, "tns");
svc->sc_calc_count = 0;
svc->base = axis2_desc_create(env);
if(!svc->base)
{
axis2_svc_free(svc, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service base creation failed");
return NULL;
}
svc->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT);
if(!svc->mutex)
{
axis2_svc_free(svc, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service mutex creation failed");
return NULL;
}
return svc;
}
AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL
axis2_conf_ctx_create(
const axutil_env_t * env,
axis2_conf_t * conf)
{
axis2_conf_ctx_t *conf_ctx = NULL;
conf_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_conf_ctx_t));
if(!conf_ctx)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
return NULL;
}
conf_ctx->base = NULL;
conf_ctx->conf = NULL;
conf_ctx->root_dir = NULL;
conf_ctx->op_ctx_map = NULL;
conf_ctx->svc_ctx_map = NULL;
conf_ctx->svc_grp_ctx_map = NULL;
conf_ctx->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT);
if(!conf_ctx->mutex)
{
axis2_conf_ctx_free(conf_ctx, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create thread mutex");
return NULL;
}
if(conf)
conf_ctx->conf = conf;
conf_ctx->base = axis2_ctx_create(env);
if(!(conf_ctx->base))
{
axis2_conf_ctx_free(conf_ctx, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create base context");
return NULL;
}
conf_ctx->op_ctx_map = axutil_hash_make(env);
if(!(conf_ctx->op_ctx_map))
{
axis2_conf_ctx_free(conf_ctx, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create operation context map");
return NULL;
}
conf_ctx->svc_ctx_map = axutil_hash_make(env);
if(!(conf_ctx->svc_ctx_map))
{
axis2_conf_ctx_free(conf_ctx, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create service context map");
return NULL;
}
conf_ctx->svc_grp_ctx_map = axutil_hash_make(env);
if(!(conf_ctx->svc_grp_ctx_map))
{
axis2_conf_ctx_free(conf_ctx, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create service group context map");
return NULL;
}
return conf_ctx;
}
AXIS2_EXTERN axutil_log_t *AXIS2_CALL
axutil_log_create(
axutil_allocator_t *allocator,
axutil_log_ops_t *ops,
const axis2_char_t *stream_name)
{
axutil_log_impl_t *log_impl;
axis2_char_t *path_home;
axis2_char_t log_file_name[AXUTIL_LOG_FILE_NAME_SIZE];
axis2_char_t log_dir[AXUTIL_LOG_FILE_NAME_SIZE];
axis2_char_t tmp_filename[AXUTIL_LOG_FILE_NAME_SIZE];
if (!allocator)
return NULL;
log_impl = (axutil_log_impl_t *) AXIS2_MALLOC(allocator,
sizeof(axutil_log_impl_t));
if (!log_impl)
return NULL;
log_impl->mutex =
axutil_thread_mutex_create(allocator, AXIS2_THREAD_MUTEX_DEFAULT);
if (!log_impl->mutex)
{
fprintf(stderr, "cannot create log mutex \n");
return NULL;
}
#ifndef WIN32
signal(SIGXFSZ, SIG_IGN);
#endif
/* default log file is axis2.log */
if (stream_name)
AXIS2_SNPRINTF(tmp_filename, AXUTIL_LOG_FILE_NAME_SIZE, "%s", stream_name);
else
AXIS2_SNPRINTF(tmp_filename, AXUTIL_LOG_FILE_NAME_SIZE, "%s", "axis2.log");
/* we write all logs to AXIS2C_HOME/logs if it is set otherwise
* to the working dir
*/
if (stream_name && !(axutil_rindex(stream_name, AXIS2_PATH_SEP_CHAR)))
{
path_home = AXIS2_GETENV("AXIS2C_HOME");
if (path_home)
{
AXIS2_SNPRINTF(log_dir, AXUTIL_LOG_FILE_NAME_SIZE, "%s%c%s",
path_home, AXIS2_PATH_SEP_CHAR, "logs");
if (AXIS2_SUCCESS ==
axutil_file_handler_access(log_dir, AXIS2_F_OK))
{
AXIS2_SNPRINTF(log_file_name, AXUTIL_LOG_FILE_NAME_SIZE,
"%s%c%s", log_dir, AXIS2_PATH_SEP_CHAR, tmp_filename);
}
else
{
fprintf(stderr, "log folder %s does not exist - log file %s "\
"is written to . dir\n", log_dir, tmp_filename);
AXIS2_SNPRINTF(log_file_name, AXUTIL_LOG_FILE_NAME_SIZE, "%s",
tmp_filename);
}
}
else
{
fprintf(stderr,
"AXIS2C_HOME is not set - log is written to . dir\n");
AXIS2_SNPRINTF(log_file_name, AXUTIL_LOG_FILE_NAME_SIZE, "%s",
tmp_filename);
}
}
else
{
AXIS2_SNPRINTF(log_file_name, AXUTIL_LOG_FILE_NAME_SIZE, "%s",
tmp_filename);
}
log_impl->file_name = AXIS2_MALLOC(allocator, AXUTIL_LOG_FILE_NAME_SIZE);
log_impl->log.size = AXUTIL_LOG_FILE_SIZE;
sprintf(log_impl->file_name, "%s", log_file_name);
axutil_thread_mutex_lock(log_impl->mutex);
log_impl->stream = axutil_file_handler_open(log_file_name, "a+");
axutil_log_impl_rotate((axutil_log_t *) log_impl);
axutil_thread_mutex_unlock(log_impl->mutex);
if (!log_impl->stream)
log_impl->stream = stderr;
/* by default, log is enabled */
log_impl->log.enabled = 1;
log_impl->log.level = AXIS2_LOG_LEVEL_DEBUG;
if (ops)
{
log_impl->log.ops = ops;
}
else
{
log_impl->log.ops = &axutil_log_ops_var;
}
return &(log_impl->log);
}