| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <axis2_svc.h> |
| #include <axis2_addr.h> |
| #include <axutil_property.h> |
| #include <axis2_module.h> |
| #include "../deployment/axis2_desc_builder.h" |
| |
| struct axis2_svc |
| { |
| axis2_svc_grp_t *parent; |
| axis2_char_t *axis_svc_name; |
| /** to keep last update time of the service */ |
| long last_update; |
| axis2_char_t *filename; |
| /** to store module descriptions at deploy time parsing */ |
| axutil_array_list_t *module_list; |
| |
| /* service description */ |
| axis2_char_t *svc_desc; |
| |
| /*wsdl file path*/ |
| axis2_char_t *wsdl_path; |
| /** |
| * WSDL related stuff |
| */ |
| axutil_hash_t *ns_map; |
| /* count of the entries in the namespace map */ |
| int ns_count; |
| /* to keep the XML scheama either from WSDL or |
| * C2WSDL(in the future) |
| */ |
| axutil_array_list_t *schema_list; |
| /** |
| * A table that keeps a mapping of unique XSD names (Strings) |
| * against the schema objects. This is populated in the first |
| * instance the schemas are asked for and then used to serve |
| * the subsequent requests |
| */ |
| axutil_hash_t *schema_mapping_table; |
| /** |
| * This is where operations are kept |
| */ |
| axutil_hash_t *op_alias_map; |
| /** |
| * This is where action mappings are kept |
| */ |
| axutil_hash_t *op_action_map; |
| /** |
| * Keeps track whether the schema locations are adjusted |
| */ |
| axis2_bool_t schema_loc_adjusted; |
| /** |
| * A custom schema name prefix. if set this will be used to |
| * modify the schema names |
| */ |
| axis2_char_t *custom_schema_name_prefix; |
| /** |
| * A custom schema name suffix. will be attached to the |
| * schema file name when the files are uniquely named. |
| * A good place to add a file extension if needed |
| */ |
| axis2_char_t *custom_schema_name_suffix; |
| /* to store the target namespace for the schema */ |
| axis2_char_t *schema_target_ns; |
| axis2_char_t *schema_target_ns_prefix; |
| /* to keep the service target name space */ |
| axis2_char_t *target_ns; |
| axis2_char_t *target_ns_prefix; |
| /* Used for schema name calculations */ |
| int sc_calc_count; |
| |
| void *impl_class; |
| axutil_qname_t *qname; |
| axis2_char_t *style; |
| axutil_array_list_t *engaged_modules; |
| /** parameter container to hold service related parameters */ |
| struct axutil_param_container *param_container; |
| /** flow container that encapsulates the flow related data */ |
| struct axis2_flow_container *flow_container; |
| }; |
| |
| AXIS2_EXTERN axis2_svc_t *AXIS2_CALL |
| axis2_svc_create(const axutil_env_t *env) |
| { |
| axis2_svc_t *svc = NULL; |
| |
| AXIS2_ENV_CHECK(env, 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); |
| return NULL; |
| } |
| |
| svc->parent = NULL; |
| svc->axis_svc_name = NULL; |
| svc->filename = NULL; |
| svc->svc_desc = NULL; |
| svc->wsdl_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->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->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); |
| 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); |
| 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); |
| return NULL; |
| } |
| |
| /** create module list of default size */ |
| 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); |
| return NULL; |
| } |
| |
| 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); |
| return NULL; |
| } |
| |
| svc->schema_list = axutil_array_list_create(env, |
| AXIS2_ARRAY_LIST_DEFAULT_CAPACITY); |
| if (! svc->schema_list) |
| { |
| axis2_svc_free(svc, env); |
| return NULL; |
| } |
| |
| svc->engaged_modules = axutil_array_list_create(env, |
| AXIS2_ARRAY_LIST_DEFAULT_CAPACITY); |
| if (! svc->engaged_modules) |
| { |
| axis2_svc_free(svc, env); |
| 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; |
| |
| return svc; |
| } |
| |
| AXIS2_EXTERN axis2_svc_t *AXIS2_CALL |
| axis2_svc_create_with_qname(const axutil_env_t *env, |
| const axutil_qname_t *qname) |
| { |
| axis2_svc_t *svc = NULL; |
| axis2_status_t status = AXIS2_FAILURE; |
| |
| AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE); |
| |
| svc = axis2_svc_create(env); |
| if (! svc) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| status = axis2_svc_set_qname(svc, env, qname); |
| if (AXIS2_FAILURE == status) |
| { |
| axis2_svc_free(svc, env); |
| return NULL; |
| } |
| |
| return svc; |
| } |
| |
| AXIS2_EXTERN void AXIS2_CALL |
| axis2_svc_free(axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, void); |
| |
| if (svc->param_container) |
| { |
| axutil_param_container_free(svc->param_container, env); |
| } |
| |
| if (svc->flow_container) |
| { |
| axis2_flow_container_free(svc->flow_container, env); |
| } |
| |
| if (svc->filename) |
| { |
| AXIS2_FREE(env->allocator, svc->filename); |
| svc->filename = NULL; |
| } |
| |
| if (svc->svc_desc) |
| { |
| AXIS2_FREE (env->allocator, svc->svc_desc); |
| svc->svc_desc = NULL; |
| } |
| |
| svc->parent = NULL; |
| |
| if (svc->module_list) |
| { |
| int i = 0; |
| int size = 0; |
| |
| size = axutil_array_list_size(svc->module_list, env); |
| for (i = 0; i < size; i++) |
| { |
| axutil_qname_t *qname = NULL; |
| qname = axutil_array_list_get(svc->module_list, env, i); |
| if (qname) |
| { |
| axutil_qname_free(qname, env); |
| } |
| } |
| axutil_array_list_free(svc->module_list, env); |
| } |
| |
| if (svc->schema_list) |
| { |
| axutil_array_list_free(svc->schema_list, env); |
| } |
| |
| if (svc->engaged_modules) |
| { |
| axutil_array_list_free(svc->engaged_modules, env); |
| } |
| |
| if (svc->axis_svc_name) |
| { |
| AXIS2_FREE(env->allocator, svc->axis_svc_name); |
| svc->axis_svc_name = NULL; |
| } |
| |
| if (svc->op_alias_map) |
| { |
| axutil_hash_index_t *hi = NULL; |
| void *val = NULL; |
| |
| for (hi = axutil_hash_first(svc->op_alias_map, env); hi; |
| hi = axutil_hash_next(env, hi)) |
| { |
| axutil_hash_this(hi, NULL, NULL, &val); |
| |
| if (val) |
| { |
| if (axis2_op_is_from_module((axis2_op_t *)val, env) == AXIS2_FALSE ) |
| { |
| axis2_op_free((axis2_op_t *)val, env); |
| } |
| val = NULL; |
| } |
| } |
| |
| axutil_hash_free(svc->op_alias_map, env); |
| } |
| |
| if (svc->op_action_map) |
| { |
| axutil_hash_index_t *hi = NULL; |
| const void *key = NULL; |
| |
| for (hi = axutil_hash_first(svc->op_action_map, env); hi; |
| hi = axutil_hash_next(env, hi)) |
| { |
| axutil_hash_this(hi, &key, NULL, NULL); |
| |
| if (key) |
| { |
| AXIS2_FREE(env->allocator, (axis2_char_t *)key); |
| key = NULL; |
| } |
| } |
| axutil_hash_free(svc->op_action_map, env); |
| } |
| |
| if (svc->schema_target_ns_prefix) |
| { |
| AXIS2_FREE(env->allocator, svc->schema_target_ns_prefix); |
| svc->schema_target_ns_prefix = NULL; |
| } |
| |
| if (svc->target_ns) |
| { |
| AXIS2_FREE(env->allocator, svc->target_ns); |
| svc->target_ns = NULL; |
| } |
| |
| if (svc->target_ns_prefix) |
| { |
| AXIS2_FREE(env->allocator, svc->target_ns_prefix); |
| svc->target_ns_prefix = NULL; |
| } |
| |
| if (svc->qname) |
| { |
| axutil_qname_free(svc->qname, env); |
| } |
| |
| if(svc->style) |
| { |
| AXIS2_FREE(env->allocator, svc->style); |
| } |
| |
| if (svc) |
| { |
| AXIS2_FREE(env->allocator, svc); |
| svc = NULL; |
| } |
| |
| return; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_add_op(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axis2_op_t *op) |
| { |
| axis2_status_t status = AXIS2_FAILURE; |
| axis2_msg_recv_t *msg_recv = NULL; |
| const axutil_qname_t *qname = NULL; |
| axis2_char_t *key = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE); |
| |
| status = axis2_op_set_parent(op, env, svc); |
| if (AXIS2_SUCCESS != status) |
| { |
| return status; |
| } |
| msg_recv = axis2_op_get_msg_recv(op, env); |
| if (msg_recv == NULL) |
| { |
| msg_recv = axis2_desc_builder_load_default_msg_recv(env); |
| axis2_op_set_msg_recv(op, env, msg_recv); |
| } |
| qname = axis2_op_get_qname(op, env); |
| if (qname) |
| key = axutil_qname_get_localpart(qname, env); |
| if (key) |
| axutil_hash_set(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING, op); |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axis2_op_t *AXIS2_CALL |
| axis2_svc_get_op_with_qname(const axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axutil_qname_t *op_qname) |
| { |
| axis2_op_t *op = NULL; |
| axis2_char_t *key = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK(env->error, op_qname, NULL); |
| |
| key = axutil_qname_get_localpart(op_qname, env); |
| op = axutil_hash_get(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING); |
| if (! op) |
| { |
| op = axutil_hash_get(svc->op_action_map, key, AXIS2_HASH_KEY_STRING); |
| } |
| |
| return op; |
| } |
| |
| AXIS2_EXTERN axis2_op_t *AXIS2_CALL |
| axis2_svc_get_op_with_name(const axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *nc_name) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK(env->error, nc_name, NULL); |
| |
| return (axis2_op_t *) axutil_hash_get(svc->op_alias_map, nc_name, |
| AXIS2_HASH_KEY_STRING); |
| } |
| |
| AXIS2_EXTERN axutil_hash_t *AXIS2_CALL |
| axis2_svc_get_all_ops(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| return svc->op_alias_map; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_parent(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axis2_svc_grp_t *svc_grp) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); |
| |
| svc->parent = svc_grp; |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL |
| axis2_svc_get_parent(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| return svc->parent; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_qname(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axutil_qname_t *qname) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE); |
| if (svc->qname) |
| { |
| axutil_qname_free(svc->qname, env); |
| } |
| |
| if (qname) |
| { |
| svc->qname = axutil_qname_clone((axutil_qname_t *)qname, env); |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL |
| axis2_svc_get_qname(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| return svc->qname; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_add_param(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axutil_param_t *param) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE); |
| |
| |
| if (AXIS2_TRUE == axis2_svc_is_param_locked(svc, env, |
| axutil_param_get_name(param, env))) |
| { |
| AXIS2_ERROR_SET(env->error, |
| AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| else |
| { |
| return axutil_param_container_add_param(svc->param_container, env, param); |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axutil_param_t *AXIS2_CALL |
| axis2_svc_get_param(const axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *name) |
| { |
| axutil_param_t *param = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, name, NULL); |
| |
| param = axutil_param_container_get_param(svc->param_container, env, name); |
| if (param == NULL && svc->parent) |
| { |
| param = axis2_svc_grp_get_param(svc->parent, env, name); |
| } |
| return param; |
| } |
| |
| AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL |
| axis2_svc_get_all_params(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| return axutil_param_container_get_params(svc->param_container, env); |
| } |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_svc_is_param_locked(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *param_name) |
| { |
| axis2_bool_t locked = AXIS2_FALSE; |
| axutil_param_t *param = NULL; |
| axis2_svc_grp_t *parent = NULL; |
| axis2_bool_t ret = AXIS2_FALSE; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FALSE); |
| AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE); |
| |
| /* checking the locked value of parent */ |
| |
| parent = axis2_svc_get_parent(svc, env); |
| if (parent) |
| locked = axis2_svc_grp_is_param_locked(parent, env, param_name); |
| if (parent && AXIS2_TRUE == locked) |
| { |
| return AXIS2_TRUE; |
| } |
| param = axis2_svc_get_param(svc, env, param_name); |
| if (param) |
| { |
| ret = axutil_param_is_locked(param, env); |
| } |
| return ret; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_engage_module(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axis2_module_desc_t *module_desc, |
| axis2_conf_t *conf) |
| { |
| axis2_phase_resolver_t *phase_resolver = NULL; |
| axis2_status_t status = AXIS2_FAILURE; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); |
| |
| phase_resolver = axis2_phase_resolver_create_with_config(env, conf); |
| if (!phase_resolver) |
| { |
| return AXIS2_FAILURE; |
| } |
| status = axis2_phase_resolver_engage_module_to_svc(phase_resolver, env, svc, |
| module_desc); |
| if (status) |
| { |
| const axutil_qname_t *qname = NULL; |
| status = axutil_array_list_add(svc->engaged_modules, env, module_desc); |
| qname = axis2_module_desc_get_qname(module_desc, env); |
| axis2_svc_add_module_qname(svc, env, qname); |
| } |
| if (phase_resolver) |
| { |
| axis2_phase_resolver_free(phase_resolver, env); |
| } |
| |
| return status; |
| } |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_svc_is_module_engaged(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axutil_qname_t *module_qname) |
| { |
| int i = 0, size = 0; |
| size = axutil_array_list_size(svc->engaged_modules, env); |
| for (i = 0; i < size; i++) |
| { |
| const axutil_qname_t *module_qname_l = NULL; |
| axis2_module_desc_t *module_desc_l = NULL; |
| |
| module_desc_l = (axis2_module_desc_t *) axutil_array_list_get( |
| svc->engaged_modules, env, i); |
| module_qname_l = axis2_module_desc_get_qname(module_desc_l, env); |
| |
| if (axutil_qname_equals(module_qname, env, module_qname_l)) |
| { |
| return AXIS2_TRUE; |
| } |
| } |
| return AXIS2_FALSE; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_disengage_module(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axis2_module_desc_t *module_desc, |
| axis2_conf_t *conf) |
| { |
| axis2_phase_resolver_t *phase_resolver = NULL; |
| axis2_status_t status = AXIS2_FAILURE; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); |
| |
| phase_resolver = axis2_phase_resolver_create_with_config(env, conf); |
| if (!phase_resolver) |
| { |
| return AXIS2_FAILURE; |
| } |
| status = axis2_phase_resolver_disengage_module_from_svc(phase_resolver, env, svc, |
| module_desc); |
| |
| axis2_phase_resolver_free(phase_resolver, env); |
| |
| return status; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_add_module_ops(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axis2_module_desc_t *module_desc, |
| axis2_conf_t *conf) |
| { |
| axutil_hash_t *map = NULL; |
| axutil_hash_index_t *index = NULL; |
| axis2_phase_resolver_t *phase_resolver = NULL; |
| axis2_op_t *op_desc = NULL; |
| axis2_status_t status = AXIS2_FAILURE; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); |
| |
| map = axis2_module_desc_get_all_ops(module_desc, env); |
| phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf, svc); |
| |
| if (!phase_resolver) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| for (index = axutil_hash_first(map, env); index; index = |
| axutil_hash_next(env, index)) |
| { |
| axutil_array_list_t *mappings_list = NULL; |
| int size = 0; |
| int j = 0; |
| void *v = NULL; |
| axutil_hash_this(index, NULL, NULL, &v); |
| op_desc = (axis2_op_t *) v; |
| mappings_list = axis2_op_get_wsamapping_list(op_desc, env); |
| /* adding WSA mapping into service */ |
| size = axutil_array_list_size(mappings_list, env); |
| |
| if (AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error)) |
| { |
| if (phase_resolver) |
| { |
| axis2_phase_resolver_free(phase_resolver, env); |
| } |
| return AXIS2_FAILURE; |
| } |
| for (j = 0; j < size; j++) |
| { |
| axis2_char_t *mapping = NULL; |
| |
| mapping = (axis2_char_t *) axutil_array_list_get(mappings_list, env, j); |
| status = axis2_svc_add_mapping(svc, env, mapping, op_desc); |
| if (AXIS2_SUCCESS != status) |
| { |
| if (phase_resolver) |
| { |
| axis2_phase_resolver_free(phase_resolver, env); |
| } |
| return status; |
| } |
| } |
| |
| status = axis2_phase_resolver_build_module_op(phase_resolver, env, op_desc); |
| |
| if (AXIS2_SUCCESS != status) |
| { |
| if (phase_resolver) |
| { |
| axis2_phase_resolver_free(phase_resolver, env); |
| } |
| return status; |
| } |
| |
| status = axis2_svc_add_op(svc, env, op_desc); |
| if (AXIS2_SUCCESS != status) |
| { |
| if (phase_resolver) |
| { |
| axis2_phase_resolver_free(phase_resolver, env); |
| } |
| return status; |
| } |
| |
| } |
| |
| if (phase_resolver) |
| { |
| axis2_phase_resolver_free(phase_resolver, env); |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN const axis2_char_t *AXIS2_CALL |
| axis2_svc_get_name(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| if (svc->qname) |
| { |
| return axutil_qname_get_localpart(svc->qname, env); |
| } |
| |
| return NULL; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_name(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *axis_svc_name) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, axis_svc_name, AXIS2_FAILURE); |
| |
| if (svc->axis_svc_name) |
| { |
| AXIS2_FREE(env->allocator, svc->axis_svc_name); |
| svc->axis_svc_name = NULL; |
| } |
| svc->axis_svc_name = axutil_strdup(env, axis_svc_name); |
| if (!svc->axis_svc_name) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_last_update(axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN long AXIS2_CALL |
| axis2_svc_get_last_update(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| return svc->last_update; |
| } |
| |
| AXIS2_EXTERN const axis2_char_t *AXIS2_CALL |
| axis2_svc_get_file_name(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| return svc->filename; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_file_name(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *filename) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, filename, AXIS2_FAILURE); |
| |
| if (svc->filename) |
| { |
| AXIS2_FREE(env->allocator, svc->filename); |
| svc->filename = NULL; |
| } |
| svc->filename = (axis2_char_t *) axutil_strdup(env, filename); |
| if (!svc->filename) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN const axis2_char_t *AXIS2_CALL |
| axis2_svc_get_svc_desc(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| return svc->svc_desc; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_svc_desc(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *svc_desc) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, svc_desc, AXIS2_FAILURE); |
| |
| if (svc->svc_desc) |
| { |
| AXIS2_FREE(env->allocator, svc->svc_desc); |
| svc->svc_desc = NULL; |
| } |
| svc->svc_desc = (axis2_char_t *) axutil_strdup(env, svc_desc); |
| if (!svc->svc_desc) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_add_mapping(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *mapping_key , |
| axis2_op_t *op_desc) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, mapping_key, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE); |
| |
| axutil_hash_set(svc->op_action_map, axutil_strdup(env, mapping_key), |
| AXIS2_HASH_KEY_STRING, op_desc); |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_add_module_qname(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axutil_qname_t *module_qname) |
| { |
| axutil_qname_t *qmodule_qname_l = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE); |
| |
| qmodule_qname_l = axutil_qname_clone((axutil_qname_t *)module_qname, env); |
| return axutil_array_list_add(svc->module_list, env, |
| qmodule_qname_l); |
| } |
| |
| AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL |
| axis2_svc_get_all_module_qnames(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| return svc->module_list; |
| } |
| |
| AXIS2_EXTERN const axis2_char_t *AXIS2_CALL |
| axis2_svc_get_target_ns(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| return svc->target_ns; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_target_ns(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *ns) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, ns, AXIS2_FAILURE); |
| |
| if (svc->target_ns) |
| { |
| AXIS2_FREE(env->allocator, svc->target_ns); |
| svc->target_ns = NULL; |
| } |
| svc->target_ns = axutil_strdup(env, ns); |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN const axis2_char_t *AXIS2_CALL |
| axis2_svc_get_target_ns_prefix(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| return svc->target_ns_prefix; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_target_ns_prefix(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *prefix) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE); |
| |
| 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, prefix); |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axutil_hash_t *AXIS2_CALL |
| axis2_svc_get_ns_map(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, NULL); |
| return svc->ns_map; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_ns_map(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axutil_hash_t *ns_map) |
| { |
| axutil_hash_index_t *hi = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, ns_map, AXIS2_FAILURE); |
| |
| |
| if (svc->ns_map) |
| { |
| for (hi = axutil_hash_first(svc->ns_map, env); hi; |
| hi = axutil_hash_next(env, hi)) |
| { |
| void * value = NULL; |
| void *key = NULL; |
| axutil_hash_this(hi, (const void **)&key, NULL, |
| (void **)&value); |
| if (key) |
| { |
| AXIS2_FREE(env->allocator, key); |
| key = NULL; |
| } |
| if (value) |
| { |
| AXIS2_FREE(env->allocator, value); |
| value = NULL; |
| } |
| } |
| axutil_hash_free(svc->ns_map, env); |
| } |
| svc->ns_map = ns_map; |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axutil_hash_t *AXIS2_CALL |
| axis2_svc_swap_mapping_table(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| axutil_hash_t *orig_table) |
| { |
| axutil_hash_t *new_table = NULL; |
| axutil_hash_index_t *hi = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK(env->error, orig_table, AXIS2_FAILURE); |
| |
| new_table = axutil_hash_make(env); |
| |
| for (hi = axutil_hash_first(orig_table, env); env; |
| hi = axutil_hash_next(env, hi)) |
| { |
| void * value = NULL; |
| void *key = NULL; |
| |
| axutil_hash_this(hi, (const void **)&key, NULL, |
| (void **)&value); |
| axutil_hash_set(new_table, value, AXIS2_HASH_KEY_STRING, key); |
| } |
| return new_table; |
| } |
| |
| AXIS2_EXTERN void *AXIS2_CALL |
| axis2_svc_get_impl_class(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| return svc->impl_class; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_impl_class(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| void *impl_class) |
| { |
| svc->impl_class = impl_class; |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL |
| axis2_svc_get_param_container(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| return svc->param_container; |
| } |
| |
| AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL |
| axis2_svc_get_flow_container(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| return svc->flow_container; |
| } |
| |
| |
| AXIS2_EXTERN const axis2_char_t *AXIS2_CALL |
| axis2_svc_get_svc_wsdl_path(const axis2_svc_t *svc, |
| const axutil_env_t *env) |
| { |
| return svc->wsdl_path; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_svc_set_svc_wsdl_path(axis2_svc_t *svc, |
| const axutil_env_t *env, |
| const axis2_char_t *wsdl_path) |
| { |
| AXIS2_PARAM_CHECK(env->error, wsdl_path, AXIS2_FAILURE); |
| svc->wsdl_path = (axis2_char_t *)wsdl_path; |
| return AXIS2_SUCCESS; |
| } |