Moving axis svn, part of TLP move INFRA-2441

git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68

2 files changed, 1644 insertions, 0 deletions

diff --git a/src/core/util/Makefile.am b/src/core/util/Makefile.am
new file mode 100644
index 0000000..e5609a2
--- /dev/null
+++ b/src/core/util/Makefile.am
@@ -0,0 +1,9 @@
+noinst_LTLIBRARIES = libaxis2_core_utils.la
+#noinst_HEADERS = axis2_core_utils.h
+
+libaxis2_core_utils_la_SOURCES =	core_utils.c
+
+INCLUDES = -I$(top_builddir)/include \
+            -I$(top_builddir)/src/core/engine \
+            -I$(top_builddir)/util/include \
+            -I$(top_builddir)/axiom/include
diff --git a/src/core/util/core_utils.c b/src/core/util/core_utils.c
new file mode 100644
index 0000000..5ae9f31
--- /dev/null
+++ b/src/core/util/core_utils.c
@@ -0,0 +1,1635 @@
+/*
+ * 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_core_utils.h>
+#include <axutil_string.h>
+#include <axis2_conf.h>
+#include <axis2_relates_to.h>
+#include <axis2_addr.h>
+#include <axis2_http_transport.h>
+#include <axutil_uuid_gen.h>
+#include <axutil_property.h>
+#include <axis2_conf_ctx.h>
+
+
+/* internal structure to keep the rest map in a multi level hash */
+typedef struct
+{
+    /* the structure will keep as many as following fields */
+
+    /* if the mapped value is directly the operation */
+    axis2_op_t *op_desc;
+
+    /* if the mapped value is a constant, this keeps a hash map of
+     possible constants => corrosponding map_internal structure */
+    axutil_hash_t *consts_map;
+
+    /* if the mapped value is a param, this keeps a hash map of
+     possible param_values => corrosponding_map_internal structre */
+    axutil_hash_t *params_map;
+
+} axutil_core_utils_map_internal_t;
+
+/* some functions to use internally in handling rest map */
+/* infer op from the live url */
+axis2_op_t *
+axis2_core_utils_infer_op_from_parent_rest_map(
+    const axutil_env_t *env,
+    axutil_hash_t *rest_map,
+    axis2_char_t *live_url,
+    axutil_array_list_t *param_keys,
+    axutil_array_list_t *param_values);
+
+/* build the restmap recursively - internal function*/
+axis2_status_t AXIS2_CALL
+axis2_core_utils_internal_build_rest_map_recursively(
+    const axutil_env_t * env,
+    axis2_char_t * url,
+    axutil_core_utils_map_internal_t *mapping_struct,
+    axis2_op_t *op_desc);
+
+/* infer op from the live url recursively */
+axis2_op_t *AXIS2_CALL
+axis2_core_utils_internal_infer_op_from_rest_map_recursively(
+    const axutil_env_t *env,
+    const axutil_core_utils_map_internal_t *parent_mapping_struct,
+    axis2_char_t *live_url,
+    axutil_array_list_t *param_keys,
+    axutil_array_list_t *param_values);
+
+/* match a pattern with a url component */
+axis2_status_t
+axis2_core_utils_match_url_component_with_pattern(
+    const axutil_env_t *env,
+    axis2_char_t *pattern,
+    axis2_char_t *url_component,
+    axutil_array_list_t *param_keys,
+    axutil_array_list_t *param_values);
+
+AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL
+axis2_core_utils_create_out_msg_ctx(
+    const axutil_env_t * env,
+    axis2_msg_ctx_t * in_msg_ctx)
+{
+    axis2_ctx_t *ctx = NULL;
+    axis2_msg_ctx_t *new_msg_ctx = NULL;
+    axis2_conf_ctx_t *conf_ctx = NULL;
+    axis2_transport_in_desc_t *transport_in = NULL;
+    axis2_transport_out_desc_t *transport_out = NULL;
+    axis2_msg_info_headers_t *old_msg_info_headers = NULL;
+    axis2_msg_info_headers_t *msg_info_headers = NULL;
+    axis2_endpoint_ref_t *reply_to = NULL;
+    axis2_endpoint_ref_t *fault_to = NULL;
+    axis2_endpoint_ref_t *to = NULL;
+    const axis2_char_t *msg_id = NULL;
+    axis2_relates_to_t *relates_to = NULL;
+    const axis2_char_t *action = NULL;
+    axis2_op_ctx_t *op_ctx = NULL;
+    axis2_svc_ctx_t *svc_ctx = NULL;
+    axis2_bool_t doing_rest = AXIS2_FALSE;
+    axis2_bool_t doing_mtom = AXIS2_FALSE;
+    axis2_bool_t server_side = AXIS2_FALSE;
+    axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
+    axis2_char_t *msg_uuid = NULL;
+    axutil_stream_t *out_stream = NULL;
+    axutil_param_t *expose_headers_param = NULL;
+    axis2_bool_t expose_headers = AXIS2_FALSE;
+
+    AXIS2_PARAM_CHECK(env->error, in_msg_ctx, NULL);
+
+    conf_ctx = axis2_msg_ctx_get_conf_ctx(in_msg_ctx, env);
+    transport_in = axis2_msg_ctx_get_transport_in_desc(in_msg_ctx, env);
+    transport_out = axis2_msg_ctx_get_transport_out_desc(in_msg_ctx, env);
+
+    new_msg_ctx = axis2_msg_ctx_create(env, conf_ctx, transport_in, transport_out);
+    if(!new_msg_ctx)
+    {
+        return NULL;
+    }
+
+    if(transport_in)
+    {
+        expose_headers_param = axutil_param_container_get_param(
+            axis2_transport_in_desc_param_container(transport_in, env), env, AXIS2_EXPOSE_HEADERS);
+    }
+    if(expose_headers_param)
+    {
+        axis2_char_t *expose_headers_value = NULL;
+        expose_headers_value = axutil_param_get_value(expose_headers_param, env);
+        if(expose_headers_value && 0 == axutil_strcasecmp(expose_headers_value, AXIS2_VALUE_TRUE))
+        {
+            expose_headers = AXIS2_TRUE;
+        }
+    }
+    if(expose_headers)
+    {
+        axis2_msg_ctx_set_transport_headers(new_msg_ctx, env,
+            axis2_msg_ctx_extract_transport_headers(in_msg_ctx, env));
+    }
+    axis2_msg_ctx_set_http_accept_record_list(new_msg_ctx, env,
+        axis2_msg_ctx_extract_http_accept_record_list(in_msg_ctx, env));
+    axis2_msg_ctx_set_http_accept_charset_record_list(new_msg_ctx, env,
+        axis2_msg_ctx_extract_http_accept_charset_record_list(in_msg_ctx, env));
+    axis2_msg_ctx_set_http_accept_language_record_list(new_msg_ctx, env,
+        axis2_msg_ctx_extract_http_accept_language_record_list(in_msg_ctx, env));
+
+    old_msg_info_headers = axis2_msg_ctx_get_msg_info_headers(in_msg_ctx, env);
+    if(!old_msg_info_headers)
+    {
+        return NULL;
+    }
+    msg_info_headers = axis2_msg_ctx_get_msg_info_headers(new_msg_ctx, env);
+    if(!msg_info_headers)
+    {
+        /* if there is no msg info header in ew msg ctx, then create one */
+        msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL);
+        if(!msg_info_headers)
+            return NULL;
+        axis2_msg_ctx_set_msg_info_headers(new_msg_ctx, env, msg_info_headers);
+    }
+
+    msg_uuid = axutil_uuid_gen(env);
+    axis2_msg_info_headers_set_message_id(msg_info_headers, env, msg_uuid);
+    if(msg_uuid)
+    {
+        AXIS2_FREE(env->allocator, msg_uuid);
+        msg_uuid = NULL;
+    }
+    reply_to = axis2_msg_info_headers_get_reply_to(old_msg_info_headers, env);
+    axis2_msg_info_headers_set_to(msg_info_headers, env, reply_to);
+
+    fault_to = axis2_msg_info_headers_get_fault_to(old_msg_info_headers, env);
+    axis2_msg_info_headers_set_fault_to(msg_info_headers, env, fault_to);
+
+    to = axis2_msg_info_headers_get_to(old_msg_info_headers, env);
+    axis2_msg_info_headers_set_from(msg_info_headers, env, to);
+
+    msg_id = axis2_msg_info_headers_get_message_id(old_msg_info_headers, env);
+
+    /* we can create with default Relates to namespace. 
+     Actual namespace based on addressing version will be created in addressing out handler */
+    relates_to = axis2_relates_to_create(env, msg_id,
+        AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE);
+    axis2_msg_info_headers_set_relates_to(msg_info_headers, env, relates_to);
+
+    action = axis2_msg_info_headers_get_action(old_msg_info_headers, env);
+    axis2_msg_info_headers_set_action(msg_info_headers, env, action);
+
+    op_ctx = axis2_msg_ctx_get_op_ctx(in_msg_ctx, env);
+    axis2_msg_ctx_set_op_ctx(new_msg_ctx, env, op_ctx);
+
+    svc_ctx = axis2_msg_ctx_get_svc_ctx(in_msg_ctx, env);
+    axis2_msg_ctx_set_svc_ctx(new_msg_ctx, env, svc_ctx);
+
+    ctx = axis2_msg_ctx_get_base(in_msg_ctx, env);
+    if(ctx)
+    {
+        axis2_ctx_t *new_ctx = axis2_msg_ctx_get_base(new_msg_ctx, env);
+        if(new_ctx)
+        {
+            axis2_ctx_set_property_map(new_ctx, env, axis2_ctx_get_property_map(ctx, env));
+        }
+    }
+
+    out_stream = axis2_msg_ctx_get_transport_out_stream(in_msg_ctx, env);
+    axis2_msg_ctx_set_transport_out_stream(new_msg_ctx, env, out_stream);
+    axis2_msg_ctx_set_out_transport_info(new_msg_ctx, env, axis2_msg_ctx_get_out_transport_info(
+        in_msg_ctx, env));
+
+    /* Setting the character set encoding */
+    doing_rest = axis2_msg_ctx_get_doing_rest(in_msg_ctx, env);
+    axis2_msg_ctx_set_doing_rest(new_msg_ctx, env, doing_rest);
+
+    doing_mtom = axis2_msg_ctx_get_doing_mtom(in_msg_ctx, env);
+    axis2_msg_ctx_set_doing_mtom(new_msg_ctx, env, doing_mtom);
+
+    server_side = axis2_msg_ctx_get_server_side(in_msg_ctx, env);
+    axis2_msg_ctx_set_server_side(new_msg_ctx, env, server_side);
+
+    svc_grp_ctx = axis2_msg_ctx_get_svc_grp_ctx(in_msg_ctx, env);
+    axis2_msg_ctx_set_svc_grp_ctx(new_msg_ctx, env, svc_grp_ctx);
+
+    axis2_msg_ctx_set_is_soap_11(new_msg_ctx, env, axis2_msg_ctx_get_is_soap_11(in_msg_ctx, env));
+    axis2_msg_ctx_set_keep_alive(new_msg_ctx, env, axis2_msg_ctx_is_keep_alive(in_msg_ctx, env));
+
+    axis2_msg_ctx_set_charset_encoding(new_msg_ctx, env, axis2_msg_ctx_get_charset_encoding(
+        in_msg_ctx, env));
+
+    return new_msg_ctx;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_core_utils_reset_out_msg_ctx(
+    const axutil_env_t * env,
+    axis2_msg_ctx_t * out_msg_ctx)
+{
+    axis2_msg_info_headers_t *msg_info_headers = NULL;
+    if(!out_msg_ctx)
+        return;
+
+    msg_info_headers = axis2_msg_ctx_get_msg_info_headers(out_msg_ctx, env);
+    if(msg_info_headers)
+    {
+        axis2_msg_info_headers_set_to(msg_info_headers, env, NULL);
+        axis2_msg_info_headers_set_fault_to(msg_info_headers, env, NULL);
+        axis2_msg_info_headers_set_from(msg_info_headers, env, NULL);
+        axis2_msg_info_headers_set_reply_to(msg_info_headers, env, NULL);
+    }
+
+    axis2_msg_ctx_set_op_ctx(out_msg_ctx, env, NULL);
+    axis2_msg_ctx_set_svc_ctx(out_msg_ctx, env, NULL);
+    axis2_msg_ctx_reset_transport_out_stream(out_msg_ctx, env);
+    axis2_msg_ctx_reset_out_transport_info(out_msg_ctx, env);
+    axis2_msg_ctx_set_svc_grp_ctx(out_msg_ctx, env, NULL);
+
+    return;
+}
+
+AXIS2_EXTERN axutil_qname_t *AXIS2_CALL
+axis2_core_utils_get_module_qname(
+    const axutil_env_t * env,
+    const axis2_char_t * name,
+    const axis2_char_t * version)
+{
+    axutil_qname_t *ret_qname = NULL;
+    AXIS2_PARAM_CHECK(env->error, name, NULL);
+
+    if(version && 0 != axutil_strlen(version))
+    {
+        axis2_char_t *mod_name1 = NULL;
+        axis2_char_t *mod_name = NULL;
+        mod_name1 = axutil_stracat(env, name, "-");
+        if(!mod_name1)
+        {
+            return NULL;
+        }
+        mod_name = axutil_stracat(env, mod_name1, version);
+        if(!mod_name)
+        {
+            AXIS2_FREE(env->allocator, mod_name1);
+            mod_name1 = NULL;
+            return NULL;
+        }
+        ret_qname = axutil_qname_create(env, mod_name, NULL, NULL);
+        AXIS2_FREE(env->allocator, mod_name);
+        AXIS2_FREE(env->allocator, mod_name1);
+        return ret_qname;
+    }
+    ret_qname = axutil_qname_create(env, name, NULL, NULL);
+    return ret_qname;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_core_utils_calculate_default_module_version(
+    const axutil_env_t * env,
+    axutil_hash_t * modules_map,
+    axis2_conf_t * axis_conf)
+{
+    axutil_hash_t *default_modules = NULL;
+    axutil_hash_index_t *hi = NULL;
+    void *val = NULL;
+
+    AXIS2_PARAM_CHECK(env->error, modules_map, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, axis_conf, AXIS2_FAILURE);
+
+    default_modules = axutil_hash_make(env);
+    if(!default_modules)
+    {
+        return AXIS2_FAILURE;
+    }
+    for(hi = axutil_hash_first(modules_map, env); hi; hi = axutil_hash_next(env, hi))
+    {
+        axis2_module_desc_t *mod_desc = NULL;
+
+        axutil_hash_this(hi, NULL, NULL, &val);
+        mod_desc = (axis2_module_desc_t *)val;
+        if(mod_desc)
+        {
+            const axutil_qname_t *module_qname = NULL;
+            module_qname = axis2_module_desc_get_qname(mod_desc, env);
+            if(module_qname)
+            {
+                axis2_char_t *mod_name_with_ver = NULL;
+                mod_name_with_ver = axutil_qname_get_localpart(module_qname, env);
+                if(mod_name_with_ver)
+                {
+                    axis2_char_t *module_name_str = NULL;
+                    axis2_char_t *module_ver_str = NULL;
+                    axis2_char_t *current_def_ver = NULL;
+
+                    module_name_str = axis2_core_utils_get_module_name(env, mod_name_with_ver);
+                    if(!module_name_str)
+                    {
+                        return AXIS2_FAILURE;
+                    }
+                    module_ver_str = axis2_core_utils_get_module_version(env, mod_name_with_ver);
+                    current_def_ver = axutil_hash_get(default_modules, module_name_str,
+                        AXIS2_HASH_KEY_STRING);
+                    if(current_def_ver)
+                    {
+                        if(module_ver_str && AXIS2_TRUE == axis2_core_utils_is_latest_mod_ver(env,
+                            module_ver_str, current_def_ver))
+                        {
+                            axutil_hash_set(default_modules, module_name_str,
+                                AXIS2_HASH_KEY_STRING, module_ver_str);
+                        }
+                        else
+                        {
+                            if(module_name_str)
+                            {
+                                AXIS2_FREE(env->allocator, module_name_str);
+                            }
+                            if(module_ver_str)
+                            {
+                                AXIS2_FREE(env->allocator, module_ver_str);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        axutil_hash_set(default_modules, module_name_str, AXIS2_HASH_KEY_STRING,
+                            module_ver_str);
+                    }
+
+                    if(module_name_str)
+                    {
+                        AXIS2_FREE(env->allocator, module_name_str);
+                    }
+                }
+            }
+        }
+        val = NULL;
+    }
+
+    hi = NULL;
+    val = NULL;
+    for(hi = axutil_hash_first(default_modules, env); hi; hi = axutil_hash_next(env, hi))
+    {
+        void *key_string = NULL;
+        axutil_hash_this(hi, (const void **)&key_string, NULL, &val);
+        if(key_string && NULL != val)
+        {
+            axis2_conf_add_default_module_version(axis_conf, env, (axis2_char_t *)key_string,
+                (axis2_char_t *)val);
+            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Added default module"
+                " version : %s for module : %s", (axis2_char_t *)val, (axis2_char_t *)key_string);
+        }
+    }
+
+    if(default_modules)
+    {
+        axutil_hash_free(default_modules, env);
+        default_modules = NULL;
+    }
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+axis2_core_utils_get_module_name(
+    const axutil_env_t * env,
+    axis2_char_t * module_name)
+{
+    axis2_char_t version_seperator = '-';
+    axis2_char_t *name = NULL;
+    axis2_char_t *version_sep_loc = NULL;
+
+    AXIS2_PARAM_CHECK(env->error, module_name, NULL);
+
+    name = axutil_strdup(env, module_name);
+    if(!name)
+    {
+        return NULL;
+    }
+    version_sep_loc = axutil_rindex(name, version_seperator);
+    if(version_sep_loc)
+    {
+        *version_sep_loc = '\0';
+    }
+    return name;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+axis2_core_utils_get_module_version(
+    const axutil_env_t * env,
+    axis2_char_t * module_name)
+{
+    axis2_char_t version_seperator = '-';
+    axis2_char_t *version_sep_loc = NULL;
+
+    AXIS2_PARAM_CHECK(env->error, module_name, NULL);
+
+    version_sep_loc = axutil_rindex(module_name, version_seperator);
+    if(version_sep_loc)
+    {
+        return axutil_strdup(env, version_sep_loc + sizeof(axis2_char_t));
+    }
+    return NULL;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_core_utils_is_latest_mod_ver(
+    const axutil_env_t * env,
+    axis2_char_t * module_ver,
+    axis2_char_t * current_def_ver)
+{
+    double cur_ver = 0.0;
+    double mod_ver = 0.0;
+    AXIS2_PARAM_CHECK(env->error, module_ver, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, current_def_ver, AXIS2_FALSE);
+    cur_ver = atof(current_def_ver);
+    mod_ver = atof(module_ver);
+    if(mod_ver > cur_ver)
+    {
+        return AXIS2_TRUE;
+    }
+    return AXIS2_FAILURE;
+}
+
+/* build the rest map - external function */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_core_utils_prepare_rest_mapping(
+    const axutil_env_t * env,
+    axis2_char_t * url,
+    axutil_hash_t *rest_map,
+    axis2_op_t *op_desc)
+{
+
+    axis2_char_t *first_delimitter = NULL;
+    axis2_char_t *next_level_url = NULL;
+    axis2_char_t *mapping_key = NULL;
+    axutil_core_utils_map_internal_t *mapping_struct = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+    axis2_char_t *bracket_start = NULL;
+
+    first_delimitter = axutil_strchr(url, '/');
+
+    if(first_delimitter)
+    {
+        /* if there is another recursive level,
+         this will get the url of that level */
+        next_level_url = first_delimitter + 1;
+        *first_delimitter = '\0';
+    }
+
+    if((bracket_start = axutil_strchr(url, '{')))
+    {
+        /* we support multiple param per url component,
+         but we validate only one param */
+        if(axutil_strchr(bracket_start, '}'))
+        {
+            /* this is validated */
+        }
+
+        else
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "Invalid URL Format, no closing bracket in declaring parameters");
+            return AXIS2_FAILURE;
+        }
+    }
+
+    /* only constants are allowed in this level, so here url become the mapping_key */
+    mapping_key = url;
+
+    if(*mapping_key == '\0') /* empty mapping key */
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid URL Format: empty mapping key");
+        return AXIS2_FAILURE;
+    }
+
+    /* retrieve or create the mapping structure for the key*/
+    mapping_struct = axutil_hash_get(rest_map, mapping_key, AXIS2_HASH_KEY_STRING);
+    if(!mapping_struct)
+    {
+        mapping_struct = (axutil_core_utils_map_internal_t*)AXIS2_MALLOC(env->allocator,
+            sizeof(axutil_core_utils_map_internal_t));
+        if(!mapping_struct)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "No memory. Cannot create internal rest mapping structure");
+            return AXIS2_FAILURE;
+
+        }
+        memset(mapping_struct, 0, sizeof(axutil_core_utils_map_internal_t));
+
+        mapping_key = axutil_strdup(env, mapping_key);
+        axutil_hash_set(rest_map, mapping_key, AXIS2_HASH_KEY_STRING, mapping_struct);
+    }
+
+    if(!next_level_url)
+    {
+        /* if no next level url, put the op_desc in right this level */
+        if(mapping_struct->op_desc)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DUPLICATE_URL_REST_MAPPING, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Duplicate URL Mapping found");
+            return AXIS2_FAILURE;
+        }
+        mapping_struct->op_desc = op_desc;
+    }
+    else
+    {
+        /* we have to build the map_internal structure recursively */
+        status = axis2_core_utils_internal_build_rest_map_recursively(env, next_level_url,
+            mapping_struct, op_desc);
+    }
+
+    return status;
+
+}
+
+/* build the restmap recursively - internal function*/
+axis2_status_t AXIS2_CALL
+axis2_core_utils_internal_build_rest_map_recursively(
+    const axutil_env_t * env,
+    axis2_char_t * url,
+    axutil_core_utils_map_internal_t *parent_mapping_struct,
+    axis2_op_t *op_desc)
+{
+
+    /* Here url is expected to be in the form
+     {student}/marks/{subject} or
+     marks/{subject}
+     */
+
+    axis2_char_t *first_delimitter = NULL;
+    axis2_char_t *next_level_url = NULL;
+    axis2_char_t *mapping_key = NULL;
+    axutil_core_utils_map_internal_t *mapping_struct = NULL;
+    axutil_hash_t *cur_level_rest_map = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+    axis2_char_t *bracket_start = NULL;
+
+    axis2_bool_t is_key_a_param = AXIS2_FALSE;
+
+    first_delimitter = axutil_strchr(url, '/');
+
+    if(first_delimitter)
+    {
+        /* if there is another recurisive level,
+         this will get the url of that level */
+        next_level_url = first_delimitter + 1;
+        *first_delimitter = '\0';
+    }
+
+    if((bracket_start = axutil_strchr(url, '{')))
+    {
+        /* we support multiple param per url component,
+         but we validate only one param */
+        if(axutil_strchr(bracket_start, '}'))
+        {
+            is_key_a_param = AXIS2_TRUE;
+        }
+
+        else
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "Invalid URL Format, no closing bracket in declaring parameters");
+            return AXIS2_FAILURE;
+        }
+    }
+
+    /* here the url become the mapping_key */
+    mapping_key = url;
+
+    if(*mapping_key == '\0') /* empty mappng key */
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid URL Format: empty mapping key");
+        return AXIS2_FAILURE;
+    }
+
+    if(is_key_a_param)
+    {
+        /* set the rest map as the params_map */
+        if(parent_mapping_struct->params_map == NULL)
+        {
+            parent_mapping_struct->params_map = axutil_hash_make(env);
+            if(!parent_mapping_struct->params_map)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "No memory. Cannot create internal rest mapping structure");
+                return AXIS2_FAILURE;
+            }
+        }
+        cur_level_rest_map = parent_mapping_struct->params_map;
+    }
+    else
+    {
+        /* set the rest map as the consts_map */
+        if(parent_mapping_struct->consts_map == NULL)
+        {
+            parent_mapping_struct->consts_map = axutil_hash_make(env);
+            if(!parent_mapping_struct->consts_map)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "No memory. Cannot create internal rest mapping structure");
+                return AXIS2_FAILURE;
+            }
+        }
+        cur_level_rest_map = parent_mapping_struct->consts_map;
+    }
+
+    /* retrieve or create the maping structure for the key*/
+    mapping_struct = axutil_hash_get(cur_level_rest_map, mapping_key, AXIS2_HASH_KEY_STRING);
+    if(!mapping_struct)
+    {
+        mapping_struct = (axutil_core_utils_map_internal_t*)AXIS2_MALLOC(env->allocator,
+            sizeof(axutil_core_utils_map_internal_t));
+        if(!mapping_struct)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "No memory. Cannot create internal rest mapping structure");
+            return AXIS2_FAILURE;
+
+        }
+        memset(mapping_struct, 0, sizeof(axutil_core_utils_map_internal_t));
+
+        mapping_key = axutil_strdup(env, mapping_key);
+        axutil_hash_set(cur_level_rest_map, mapping_key, AXIS2_HASH_KEY_STRING, mapping_struct);
+    }
+
+    if(!next_level_url)
+    {
+        /* if no next level url, put the op_desc in right this level */
+        if(mapping_struct->op_desc)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DUPLICATE_URL_REST_MAPPING, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Duplicate URL Mapping found");
+            return AXIS2_FAILURE;
+        }
+        mapping_struct->op_desc = op_desc;
+    }
+    else
+    {
+        /* we have to build the map_internal structure recursively */
+        status = axis2_core_utils_internal_build_rest_map_recursively(env, next_level_url,
+            mapping_struct, op_desc);
+    }
+
+    return status;
+}
+
+/* free the rest map recursively */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axis2_core_utils_free_rest_map(
+    const axutil_env_t *env,
+    axutil_hash_t *rest_map)
+{
+
+    axutil_hash_index_t *hi = NULL;
+    const void *key = NULL;
+    void *val = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+
+    for(hi = axutil_hash_first(rest_map, env); hi; hi = axutil_hash_next(env, hi))
+    {
+        axutil_hash_this(hi, &key, NULL, &val);
+
+        if(val)
+        {
+            axutil_core_utils_map_internal_t *mapping_struct = NULL;
+            mapping_struct = (axutil_core_utils_map_internal_t*)val;
+
+            /* freeing the consts_map and params_map */
+            if(mapping_struct->consts_map)
+            {
+                axis2_core_utils_free_rest_map(env, mapping_struct->consts_map);
+            }
+
+            if(mapping_struct->params_map)
+            {
+                axis2_core_utils_free_rest_map(env, mapping_struct->params_map);
+            }
+            AXIS2_FREE(env->allocator, mapping_struct);
+        }
+
+        if(key)
+        {
+            AXIS2_FREE(env->allocator, (axis2_char_t *)key);
+            key = NULL;
+        }
+    }
+    axutil_hash_free(rest_map, env);
+    return status;
+}
+
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+axis2_core_utils_get_rest_op_with_method_and_location(
+    axis2_svc_t *svc,
+    const axutil_env_t *env,
+    const axis2_char_t *method,
+    const axis2_char_t *location,
+    axutil_array_list_t *param_keys,
+    axutil_array_list_t *param_values)
+{
+    axis2_char_t *addition_params_str = NULL;
+    axis2_char_t *adjusted_local_url = NULL;
+
+    axis2_char_t *live_mapping_url = NULL;
+    axis2_char_t *local_url = NULL;
+
+    axis2_op_t *op = NULL;
+
+    int key_len = 0;
+
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Checking for operation using "
+        "REST HTTP Location fragment : %s", location);
+
+    /* we are creating a dup of the location */
+    local_url = (axis2_char_t*)axutil_strdup(env, location);
+    if(!local_url)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "No memory. Cannot create the live rest mapping url");
+        return NULL;
+    }
+
+    /* checking the existence of the addition parameters
+     after the question mark '?' */
+    addition_params_str = strchr(local_url, '?');
+    if(addition_params_str)
+    {
+        *addition_params_str = '\0';
+        addition_params_str++;
+    }
+
+    /* if the first character is '/' ignore that */
+    if(*local_url == '/')
+    {
+        adjusted_local_url = local_url + 1;
+    }
+    else
+    {
+        adjusted_local_url = local_url;
+    }
+
+    /* now create the mapping url */
+    key_len = axutil_strlen(method) + axutil_strlen(adjusted_local_url) + 2;
+
+    live_mapping_url
+        = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * key_len));
+
+    if(!live_mapping_url)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "No memory. Cannot create the live rest mapping url");
+        AXIS2_FREE(env->allocator, local_url);
+        return NULL;
+    }
+
+    sprintf(live_mapping_url, "%s:%s", method, adjusted_local_url);
+
+    op = axis2_core_utils_infer_op_from_parent_rest_map(env, axis2_svc_get_rest_map(svc, env),
+        live_mapping_url, param_keys, param_values);
+
+    if(op)
+    {
+        axis2_char_t *params_str;
+
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+            "Operation found using target endpoint uri fragment");
+
+        /* here we are going to extract out the additional parameters 
+         * put after '?' mark */
+        params_str = addition_params_str;
+        while(params_str && *params_str != '\0')
+        {
+            axis2_char_t *next_params_str = NULL;
+            axis2_char_t *key_value_seperator = NULL;
+
+            axis2_char_t *key = NULL;
+            axis2_char_t *value = NULL;
+
+            /* we take one parameter pair to the params_str */
+            next_params_str = strchr(params_str, '&');
+            if(next_params_str)
+            {
+                *next_params_str = '\0';
+            }
+
+            key_value_seperator = strchr(params_str, '=');
+            if(key_value_seperator)
+            {
+                /* devide the key value pair */
+                *key_value_seperator = '\0';
+                key = params_str;
+                value = key_value_seperator + 1;
+            }
+            else
+            {
+                /* there is no '=' symbol, that mean only the key exist */
+                key = params_str;
+            }
+            if(key)
+            {
+                key = axutil_strdup(env, key);
+                axutil_array_list_add(param_keys, env, key);
+            }
+            if(value)
+            {
+                value = axutil_strdup(env, value);
+                axutil_array_list_add(param_values, env, value);
+            }
+
+            if(next_params_str)
+            {
+                /* if there was an '&' character then */
+                params_str = next_params_str + 1;
+            }
+            else
+            {
+                params_str = NULL; /* just to end the loop */
+            }
+        }
+    }
+
+    if(live_mapping_url)
+    {
+        AXIS2_FREE(env->allocator, live_mapping_url);
+    }
+    if(local_url)
+    {
+        AXIS2_FREE(env->allocator, local_url);
+    }
+    return op;
+}
+
+/* infer op from the live url */
+axis2_op_t *
+axis2_core_utils_infer_op_from_parent_rest_map(
+    const axutil_env_t *env,
+    axutil_hash_t *rest_map,
+    axis2_char_t *live_url,
+    axutil_array_list_t *param_keys,
+    axutil_array_list_t *param_values)
+{
+    axis2_char_t *first_delimitter = NULL;
+    axis2_char_t *next_level_url = NULL;
+    axis2_char_t *url_component = NULL;
+
+    axis2_op_t *op_desc = NULL;
+    axutil_core_utils_map_internal_t *mapping_struct = NULL;
+
+    first_delimitter = axutil_strchr(live_url, '/');
+
+    if(first_delimitter)
+    {
+        /* if there is another recursive level,
+         this will get the url of that level */
+        next_level_url = first_delimitter + 1;
+        *first_delimitter = '\0';
+    }
+
+    /* so live url is the url_component */
+    url_component = live_url;
+
+    /* check it in the hash map */
+    mapping_struct = (axutil_core_utils_map_internal_t*)axutil_hash_get(rest_map, url_component,
+        AXIS2_HASH_KEY_STRING);
+
+    if(mapping_struct)
+    {
+        if(!next_level_url)
+        {
+            /* if no level exists, find it here */
+            op_desc = mapping_struct->op_desc;
+        }
+        else
+        {
+
+            op_desc = axis2_core_utils_internal_infer_op_from_rest_map_recursively(env,
+                mapping_struct, next_level_url, param_keys, param_values);
+        }
+    }
+    if(!op_desc)
+    {
+        /* if the url is not mapped to the given constant url 
+         * we have to match it with the url pattern */
+
+        axutil_hash_index_t *hi = NULL;
+        const void *key = NULL;
+        void *val = NULL;
+        axis2_status_t matched_status = AXIS2_FAILURE;
+
+        for(hi = axutil_hash_first(rest_map, env); hi; hi = axutil_hash_next(env, hi))
+        {
+            axutil_hash_this(hi, &key, NULL, &val);
+
+            if(key == url_component)
+            {
+                continue; /* skip the already checked key */
+            }
+            if(key && val)
+            {
+                axis2_char_t *hash_key = (axis2_char_t*)key;
+                axis2_char_t *dup_url_component = NULL;
+                axis2_char_t *dup_pattern = NULL;
+
+                /* temporary param keys and values for each entry */
+                axutil_array_list_t *tmp_param_keys = NULL;
+                axutil_array_list_t *tmp_param_values = NULL;
+
+                tmp_param_keys = axutil_array_list_create(env, 10);
+                if(!tmp_param_keys)
+                {
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "No memory. Cannot create internal rest mapping structure");
+
+                    return NULL;
+                }
+                tmp_param_values = axutil_array_list_create(env, 10);
+                if(!tmp_param_values)
+                {
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "No memory. Cannot create internal rest mapping structure");
+                    axutil_array_list_free(tmp_param_keys, env);
+                    return NULL;
+                }
+
+                dup_url_component = axutil_strdup(env, url_component);
+                if(!dup_url_component)
+                {
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "No memory. Cannot create internal rest mapping structure");
+                    axutil_array_list_free(tmp_param_keys, env);
+                    axutil_array_list_free(tmp_param_values, env);
+                    return NULL;
+                }
+                dup_pattern = axutil_strdup(env, hash_key);
+                if(!dup_pattern)
+                {
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "No memory. Cannot create internal rest mapping structure");
+                    axutil_array_list_free(tmp_param_keys, env);
+                    axutil_array_list_free(tmp_param_values, env);
+                    AXIS2_FREE(env->allocator, dup_url_component);
+                    return NULL;
+                }
+
+                matched_status = axis2_core_utils_match_url_component_with_pattern(env,
+                    dup_pattern, dup_url_component, tmp_param_keys, tmp_param_values);
+
+                AXIS2_FREE(env->allocator, dup_url_component);
+                AXIS2_FREE(env->allocator, dup_pattern);
+
+                if(matched_status == AXIS2_SUCCESS && val)
+                {
+                    mapping_struct = (axutil_core_utils_map_internal_t*)val;
+
+                    if(!next_level_url)
+                    {
+                        op_desc = mapping_struct->op_desc;
+                    }
+                    else
+                    {
+
+                        op_desc = axis2_core_utils_internal_infer_op_from_rest_map_recursively(env,
+                            mapping_struct, next_level_url, tmp_param_keys, tmp_param_values);
+                    }
+                    if(op_desc)
+                    {
+                        /* we are done, the url is matched with a pattern */
+                        /* but before leaving should merge the param arrays */
+
+                        int i = 0;
+                        void *param_key = NULL;
+                        void *param_value = NULL;
+
+                        for(i = 0; i < axutil_array_list_size(tmp_param_keys, env); i++)
+                        {
+                            /* size(tmp_param_keys) == size(tmp_param_values) */
+                            param_key = axutil_array_list_get(tmp_param_keys, env, i);
+                            param_value = axutil_array_list_get(tmp_param_values, env, i);
+
+                            /* add it to original array */
+                            axutil_array_list_add(param_keys, env, param_key);
+                            axutil_array_list_add(param_values, env, param_value);
+
+                        }
+                        /* since of is found, no more searches needed */
+                        break;
+                    }
+                }
+                /* freeing the temporary arrays */
+                axutil_array_list_free(tmp_param_keys, env);
+                axutil_array_list_free(tmp_param_values, env);
+            }
+        }
+    }
+
+    if(!op_desc)
+    {
+        /* no more to look up */
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "REST maping structure is NULL for the accessed URL");
+        return NULL;
+    }
+
+    return op_desc;
+}
+
+/* infer op from the live url recursively */
+axis2_op_t *AXIS2_CALL
+axis2_core_utils_internal_infer_op_from_rest_map_recursively(
+    const axutil_env_t *env,
+    const axutil_core_utils_map_internal_t *parent_mapping_struct,
+    axis2_char_t *live_url,
+    axutil_array_list_t *param_keys,
+    axutil_array_list_t *param_values)
+{
+
+    axis2_char_t *first_delimitter = NULL;
+    axis2_char_t *next_level_url = NULL;
+    axis2_char_t *url_component = NULL;
+
+    axis2_op_t *op_desc = NULL;
+    axutil_core_utils_map_internal_t *child_mapping_struct = NULL;
+
+    axutil_hash_index_t *hi = NULL;
+    const void *key = NULL;
+    void *val = NULL;
+
+    first_delimitter = axutil_strchr(live_url, '/');
+
+    if(first_delimitter)
+    {
+        /* if there is another recurisive level,
+         this will get the url of that level */
+        next_level_url = first_delimitter + 1;
+        *first_delimitter = '\0';
+    }
+
+    /* so live url is the url_component */
+    url_component = live_url;
+
+    /* first check the url component in the constants array list */
+    if(parent_mapping_struct->consts_map)
+    {
+        child_mapping_struct = axutil_hash_get(parent_mapping_struct->consts_map, url_component,
+            AXIS2_HASH_KEY_STRING);
+    }
+
+    /* if the url component exists in the consts_map, go through it inside */
+
+    if(child_mapping_struct)
+    {
+        if(!next_level_url)
+        {
+            /* there is no another level, so the op should be here */
+
+            op_desc = child_mapping_struct->op_desc;
+
+            if(!op_desc)
+            {
+                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+                    "The operation descriptor not found constant given in the url");
+            }
+            /* rather than returning NULL we continue to search params_map */
+
+        }
+        else
+        {
+
+            op_desc = axis2_core_utils_internal_infer_op_from_rest_map_recursively(env,
+                child_mapping_struct, next_level_url, param_keys, param_values);
+        }
+    }
+
+    if(op_desc)
+    {
+        /* if the op for the accessed url found, no further searching is needed */
+        return op_desc;
+    }
+
+    /* if it is not found in the consts_map we have to assume it is in a params_map */
+
+    if(!parent_mapping_struct->params_map)
+    {
+        /* wrong operation, abort to continue to let calling function to check other operations */
+        if(first_delimitter)
+        {
+            /* restore the delimmiters */
+            *first_delimitter = '/';
+        }
+        return NULL;
+    }
+
+    for(hi = axutil_hash_first(parent_mapping_struct->params_map, env); hi; hi = axutil_hash_next(
+        env, hi))
+    {
+        axutil_hash_this(hi, &key, NULL, &val);
+
+        if(key && val)
+        {
+            int i = 0;
+            axis2_char_t *hash_key = (axis2_char_t*)key;
+            axis2_status_t matched_status = AXIS2_SUCCESS;
+            axis2_char_t *dup_url_component = NULL;
+            axis2_char_t *dup_pattern = NULL;
+
+            /* temporary param keys and values for each entry */
+            axutil_array_list_t *tmp_param_keys;
+            axutil_array_list_t *tmp_param_values;
+
+            tmp_param_keys = axutil_array_list_create(env, 10);
+            if(!tmp_param_keys)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "No memory. Cannot create internal rest mapping structure");
+
+                return NULL;
+            }
+            tmp_param_values = axutil_array_list_create(env, 10);
+            if(!tmp_param_values)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "No memory. Cannot create internal rest mapping structure");
+                axutil_array_list_free(tmp_param_keys, env);
+                return NULL;
+            }
+
+            dup_url_component = axutil_strdup(env, url_component);
+            if(!dup_url_component)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "No memory. Cannot create internal rest mapping structure");
+                axutil_array_list_free(tmp_param_keys, env);
+                axutil_array_list_free(tmp_param_values, env);
+                return NULL;
+            }
+            dup_pattern = axutil_strdup(env, hash_key);
+            if(!dup_pattern)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "No memory. Cannot create internal rest mapping structure");
+                axutil_array_list_free(tmp_param_keys, env);
+                axutil_array_list_free(tmp_param_values, env);
+                AXIS2_FREE(env->allocator, dup_url_component);
+                return NULL;
+            }
+
+            matched_status = axis2_core_utils_match_url_component_with_pattern(env, dup_pattern,
+                dup_url_component, tmp_param_keys, tmp_param_values);
+
+            AXIS2_FREE(env->allocator, dup_url_component);
+            AXIS2_FREE(env->allocator, dup_pattern);
+
+            if(matched_status == AXIS2_SUCCESS)
+            {
+                child_mapping_struct = (axutil_core_utils_map_internal_t*)val;
+
+                if(!next_level_url)
+                {
+                    /* there is no another level, so the op should be here */
+                    op_desc = child_mapping_struct->op_desc;
+
+                }
+                else
+                {
+
+                    /* if there is next level, we should check that level too */
+                    op_desc = axis2_core_utils_internal_infer_op_from_rest_map_recursively(env,
+                        child_mapping_struct, next_level_url, tmp_param_keys, tmp_param_values);
+                }
+
+                if(op_desc)
+                {
+                    /* the operation is found */
+                    /* but before leaving should merge the param arrays */
+
+                    int i = 0;
+                    void *param_key = NULL;
+                    void *param_value = NULL;
+                    for(i = 0; i < axutil_array_list_size(tmp_param_keys, env); i++)
+                    {
+                        /* size(tmp_param_keys) == size(tmp_param_values) */
+                        param_key = axutil_array_list_get(tmp_param_keys, env, i);
+                        param_value = axutil_array_list_get(tmp_param_values, env, i);
+
+                        /* add it to original array */
+                        axutil_array_list_add(param_keys, env, param_key);
+                        axutil_array_list_add(param_values, env, param_value);
+
+                    }
+
+                    /* freeing the temporary arrays */
+                    axutil_array_list_free(tmp_param_keys, env);
+                    axutil_array_list_free(tmp_param_values, env);
+                    /* since of is found, no more searches needed */
+                    break;
+                }
+            }
+
+            /* if we come here => op is not yet found */
+            /* just freeing the temp key and value arrays */
+            for(i = 0; i < axutil_array_list_size(tmp_param_keys, env); i++)
+            {
+                void *value = axutil_array_list_get(tmp_param_keys, env, i);
+                if(value)
+                {
+                    AXIS2_FREE(env->allocator, value);
+                }
+            }
+            for(i = 0; i < axutil_array_list_size(tmp_param_values, env); i++)
+            {
+                void *value = axutil_array_list_get(tmp_param_values, env, i);
+                if(value)
+                {
+                    AXIS2_FREE(env->allocator, value);
+                }
+            }
+            axutil_array_list_free(tmp_param_keys, env);
+            axutil_array_list_free(tmp_param_values, env);
+        }
+    }
+
+    if(!op_desc)
+    {
+        /* this is not an error, since the calling function
+         may find another opertion match with the url */
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+            "The operation descriptor not found for the accessed URL");
+
+        if(first_delimitter)
+        {
+            /* restore the delimmiters */
+            *first_delimitter = '/';
+        }
+    }
+    return op_desc;
+}
+
+/* match a pattern with a url component */
+axis2_status_t
+axis2_core_utils_match_url_component_with_pattern(
+    const axutil_env_t *env,
+    axis2_char_t *pattern,
+    axis2_char_t *url_component,
+    axutil_array_list_t *param_keys,
+    axutil_array_list_t *param_values)
+{
+    axutil_array_list_t *const_components = NULL;
+    axis2_char_t *c = NULL;
+    axis2_char_t *url_c = NULL;
+    axis2_char_t *pattern_c = NULL;
+    axis2_char_t *const_part = NULL;
+    axis2_char_t *param_part = NULL;
+    axis2_char_t *param_value = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+    /* here the state can have following values
+     0 - inside a constant
+     1 - inside a param
+     */
+    int loop_state = 0;
+    int i = 0;
+    int pattern_ending_with_param = 0;
+
+    /* the constant that undergoing matching */
+    int matching_constant_index = 0;
+    axis2_char_t *matching_constant = NULL;
+
+    /* dividing the pattern to consts */
+    const_components = axutil_array_list_create(env, 10);
+    if(!const_components)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "No memory. Cannot create internal rest mapping structure");
+    }
+    /* check whether the pattern ending with a param */
+    if(*(pattern + axutil_strlen(pattern) - 1) == '}')
+    {
+        pattern_ending_with_param = 1;
+    }
+
+    const_part = pattern;
+    /* a parse to fil the const array and key array */
+    for(c = pattern; c && *c != '\0'; c++)
+    {
+        if(loop_state == 0)
+        {
+            /* inside a constant */
+            if(*c == '{')
+            {
+                if(const_part == c)
+                {
+                    /* no const part */
+                }
+                else
+                {
+                    /* add the constant */
+                    *c = '\0';
+                    const_part = axutil_strdup(env, const_part);
+                    if(!const_part)
+                    {
+                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "No memory. Cannot create internal rest mapping structure");
+
+                        status = AXIS2_FAILURE;
+                        break;
+
+                    }
+                    axutil_array_list_add(const_components, env, const_part);
+
+                }
+                param_part = c + 1; /* start the param */
+                loop_state = 1; /* moving to the param from next iteration */
+            }
+            else if(*c == '}')
+            {
+                /* invalid state */
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing the url for %s",
+                    url_component);
+
+                status = AXIS2_FAILURE;
+                break;
+            }
+        }
+        else
+        {
+            /* inside a param */
+            if(*c == '}')
+            {
+                if(*(c + 1) == '{') /* you can not have two params without a constant in between */
+                {
+                    /* invalid state */
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(
+                        env->log,
+                        AXIS2_LOG_SI,
+                        "Error in parsing the url for %s, Please put constant between 2 parameters",
+                        url_component);
+
+                    status = AXIS2_FAILURE;
+                    break;
+                }
+                if(param_part == c)
+                {
+                    /* no param part */
+                }
+                else
+                {
+                    /* add the param */
+                    *c = '\0';
+                    param_part = axutil_strdup(env, param_part);
+
+                    if(param_part == NULL)
+                    {
+                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "No memory. Cannot create internal rest mapping structure");
+                        status = AXIS2_FAILURE;
+                        break;
+                    }
+                    axutil_array_list_add(param_keys, env, param_part);
+
+                    const_part = c + 1; /* start the const */
+                }
+                loop_state = 0; /* moving to the const from next iteration */
+            }
+            else if(*c == '{')
+            {
+                /* invalid state */
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing the url for %s",
+                    url_component);
+
+                status = AXIS2_FAILURE;
+                break;
+
+            }
+        }
+    }
+    /* loop should stop in state 0 */
+    if(loop_state != 0)
+    {
+        status = AXIS2_FAILURE;
+    }
+
+    if(const_part != c)
+    {
+        /* add the tailing const */
+        const_part = axutil_strdup(env, const_part);
+        if(!const_part)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "No memory. Cannot create internal rest mapping structure");
+            status = AXIS2_FAILURE;
+        }
+        axutil_array_list_add(const_components, env, const_part);
+    }
+
+    if(axutil_array_list_size(const_components, env) == 0 && status == AXIS2_SUCCESS)
+    {
+        /* no constants mean, the url componenent itself is the value */
+        url_component = axutil_strdup(env, url_component);
+        if(url_component)
+        {
+            axutil_array_list_add(param_values, env, url_component);
+
+            /* free the empty const array */
+
+            axutil_array_list_free(const_components, env);
+            return AXIS2_SUCCESS;
+        }
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "No memory. Cannot create internal rest mapping structure");
+        status = AXIS2_FAILURE;
+
+    }
+
+    if(status == AXIS2_FAILURE)
+    {
+        /* invalid state */
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing the url for %s", url_component);
+
+        /* free the const array */
+        for(i = 0; i < axutil_array_list_size(const_components, env); i++)
+        {
+            void *value;
+            value = axutil_array_list_get(const_components, env, i);
+
+            AXIS2_FREE(env->allocator, value);
+        }
+
+        axutil_array_list_free(const_components, env);
+
+        return status;
+    }
+
+    /* we are tracking the loop_state here too - this is useful only to track start*/
+    /* we are using the param_value part to track the matching param value */
+    if(*pattern != '{')
+    {
+        /* starting_with_constant  */
+        loop_state = 0;
+        param_value = NULL;
+    }
+    else
+    {
+        /* starting_with_param  */
+        loop_state = 1;
+        param_value = url_component;
+
+    }
+
+    matching_constant_index = 0;
+    matching_constant = axutil_array_list_get(const_components, env, 0);
+
+    /* now parse the url component */
+    for(url_c = url_component; *url_c != '\0' && status == AXIS2_SUCCESS && matching_constant
+        != NULL; url_c++)
+    {
+        axis2_char_t *tmp_url_c = url_c;
+        pattern_c = matching_constant;
+
+        while(*tmp_url_c == *pattern_c && *tmp_url_c != '\0' && *pattern_c != '\0')
+        {
+            tmp_url_c++;
+            pattern_c++;
+        }
+
+        if(*pattern_c == '\0')
+        {
+            /* we finised matching the constant pattern successfuly*/
+            if(loop_state == 0)
+            {
+                /* loop_state => we expected there is a constant */
+            }
+            else
+            {
+                /* we expected a param, but the constant is found => 
+                 url_c should mark the end of the param */
+                if(param_value == NULL)
+                {
+                    /* unexpected invalid state */
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing the url for %s",
+                        url_component);
+                    status = AXIS2_FAILURE;
+                }
+                *url_c = '\0';
+                param_value = axutil_strdup(env, param_value);
+
+                if(param_value == NULL)
+                {
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "No memory. Cannot create internal rest mapping structure");
+                    status = AXIS2_FAILURE;
+                    break;
+                }
+                axutil_array_list_add(param_values, env, param_value);
+
+            }
+            /* next the param part is starting */
+            param_value = tmp_url_c;
+
+            loop_state = 1; /* the end of the constant expects, start of a variable */
+
+            /* so we found one constant, go for the other */
+            matching_constant_index++;
+            matching_constant = axutil_array_list_get(const_components, env,
+                matching_constant_index);
+
+            tmp_url_c--;
+            /* increment the url_c to tmp_url_c */
+            url_c = tmp_url_c;
+        }
+        else
+        {
+            /* pattern not matched */
+            if(loop_state == 0)
+            {
+                /* we are expected this to be a constant, but it has not happend
+                 * mean: the pattern match failed 
+                 */
+                status = AXIS2_FAILURE;
+                break;
+            }
+        }
+
+    }
+
+    if(matching_constant_index != axutil_array_list_size(const_components, env))
+    {
+        status = AXIS2_FAILURE;
+    }
+
+    if(pattern_ending_with_param)
+    {
+        if(param_value)
+        {
+            param_value = axutil_strdup(env, param_value);
+
+            if(param_value == NULL)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "No memory. Cannot create internal rest mapping structure");
+                status = AXIS2_FAILURE;
+            }
+            else
+            {
+                axutil_array_list_add(param_values, env, param_value);
+            }
+        }
+    }
+    else if(*url_c != '\0')
+    {
+        /* here the pattern ending is a constant (not a param), and matches all are already made
+         * but some url part left => this is a not mach */
+        status = AXIS2_FAILURE;
+    }
+
+    /* finally freeing the const array */
+    for(i = 0; i < axutil_array_list_size(const_components, env); i++)
+    {
+        void *value;
+        value = axutil_array_list_get(const_components, env, i);
+
+        AXIS2_FREE(env->allocator, value);
+    }
+    axutil_array_list_free(const_components, env);
+
+    return status;
+}