ws-sandesha-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r690127 [9/11] - in /webservices/sandesha/trunk/c: ./ build/win32/ config/ ides/vc8/sandesha2/sandesha2/ include/ include/sandesha2/ samples/ samples/RMSampleService/ samples/rm_echo_1_0/ samples/rm_echo_1_0_large_sequence/ samples/rm_echo_...
Date Fri, 29 Aug 2008 06:56:38 GMT
Modified: webservices/sandesha/trunk/c/src/util/property_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/property_mgr.c?rev=690127&r1=690126&r2=690127&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/util/property_mgr.c (original)
+++ webservices/sandesha/trunk/c/src/util/property_mgr.c Thu Aug 28 23:56:29 2008
@@ -75,27 +75,29 @@
     const axutil_env_t *env)
 {
     sandesha2_property_bean_t *property_bean = NULL;
+
     property_bean = sandesha2_property_bean_create(env);
 
-    sandesha2_property_bean_set_exp_backoff(property_bean, env,
-        SANDESHA2_DEF_VAL_EXP_BACKOFF);
-    sandesha2_property_bean_set_retrans_interval(property_bean, env,
-        SANDESHA2_DEF_VAL_RETR_COUNT);
-    sandesha2_property_bean_set_ack_interval(property_bean, env, 
-        SANDESHA2_DEF_VAL_ACK_INTERVAL);
-    sandesha2_property_bean_set_inactive_timeout_interval_with_units(
-        property_bean, env, SANDESHA2_DEF_VAL_INACTIVETIMEOUT,
-        SANDESHA2_DEF_VAL_INACTIVETIMEOUT_MEASURE);
-    sandesha2_property_bean_set_in_order(property_bean, env,
-        SANDESHA2_DEF_VAL_INORDER_INVOCATION);
+    sandesha2_property_bean_set_exp_backoff(property_bean, env, SANDESHA2_DEF_VAL_EXP_BACKOFF);
+    sandesha2_property_bean_set_retrans_interval(property_bean, env, SANDESHA2_DEF_VAL_RETR_COUNT);
+    sandesha2_property_bean_set_ack_interval(property_bean, env, SANDESHA2_DEF_VAL_ACK_INTERVAL);
+    sandesha2_property_bean_set_inactive_timeout_interval_with_units(property_bean, env, 
+            SANDESHA2_DEF_VAL_INACTIVETIMEOUT, SANDESHA2_DEF_VAL_INACTIVETIMEOUT_MEASURE);
+
+    sandesha2_property_bean_set_in_order(property_bean, env, SANDESHA2_DEF_VAL_INORDER_INVOCATION);
     sandesha2_property_bean_set_msg_types_to_drop(property_bean, env, NULL);
+
     /* will be useful when we are loading libraries */
-    sandesha2_property_bean_set_max_retrans_count(property_bean, env,
-        SANDESHA2_DEF_VAL_MAX_RETR_COUNT);
-    sandesha2_property_mgr_load_msg_types_to_drop(env, 
-        SANDESHA2_DEF_VAL_MSG_TYPES_TO_DROP, property_bean);
-    sandesha2_property_bean_set_terminate_delay(property_bean, env,
-        SANDESHA2_TERMINATE_DELAY);
+    sandesha2_property_bean_set_max_retrans_count(property_bean, env, 
+            SANDESHA2_DEF_VAL_MAX_RETR_COUNT);
+
+    sandesha2_property_mgr_load_msg_types_to_drop(env, SANDESHA2_DEF_VAL_MSG_TYPES_TO_DROP, 
+            property_bean);
+
+    sandesha2_property_bean_set_terminate_delay(property_bean, env, SANDESHA2_TERMINATE_DELAY);
+    
+    sandesha2_property_bean_set_polling_delay(property_bean, env, SANDESHA2_POLLING_DELAY);
+
     return property_bean;
 }
 
@@ -117,35 +119,30 @@
     
     property_bean = sandesha2_property_bean_create(env);
 
-    param = axis2_module_desc_get_param(module_desc, env, 
-        SANDESHA2_PROPERTIES_EXP_BACKOFF);
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_EXP_BACKOFF);
     if(param)
     {
         exp_backoff_str = axutil_param_get_value(param, env);
-        sandesha2_property_mgr_load_exp_backoff(env, exp_backoff_str, 
-            property_bean);
+        sandesha2_property_mgr_load_exp_backoff(env, exp_backoff_str, property_bean);
     }
 
     param = axis2_module_desc_get_param(module_desc, env, 
-        SANDESHA2_PROPERTIES_RETRANSMISSION_INTERVAL);
+            SANDESHA2_PROPERTIES_RETRANSMISSION_INTERVAL);
+
     if(param)
     {
         retrans_int_str = axutil_param_get_value(param, env);
-        sandesha2_property_mgr_load_retrans_int(env, retrans_int_str, 
-            property_bean);
+        sandesha2_property_mgr_load_retrans_int(env, retrans_int_str, property_bean);
     }
 
-    param = axis2_module_desc_get_param(module_desc, env, 
-       SANDESHA2_PROPERTIES_ACK_INTERVAL);
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_ACK_INTERVAL);
     if(param)
     {
         ack_int_str = axutil_param_get_value(param, env);
-        sandesha2_property_mgr_load_ack_int(env, ack_int_str, 
-            property_bean);
+        sandesha2_property_mgr_load_ack_int(env, ack_int_str, property_bean);
     }
 
-    param = axis2_module_desc_get_param(module_desc, env, 
-        SANDESHA2_PROPERTIES_INACTIVETIMEOUT);
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_INACTIVETIMEOUT);
     if(param)
     {
         axis2_char_t *inactive_to_measure_str = NULL;
@@ -154,34 +151,34 @@
         param = axis2_module_desc_get_param(module_desc, env, 
             SANDESHA2_PROPERTIES_INACTIVETIMEOUT_MEASURE);
         if(param)
+        {
             inactive_to_measure_str = axutil_param_get_value(param, env);
-        if(NULL == inactive_to_measure_str)
+        }
+
+        if(!inactive_to_measure_str)
+        {
             inactive_to_measure_str = SANDESHA2_DEF_VAL_INACTIVETIMEOUT_MEASURE;
+        }
         
         sandesha2_property_mgr_load_inactive_timeout(env, inactive_timeout_str, 
-            inactive_to_measure_str, property_bean);
+                inactive_to_measure_str, property_bean);
     }
 
-    param = axis2_module_desc_get_param(module_desc, env, 
-        SANDESHA2_PROPERTIES_INORDER_INVOCATION);
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_INORDER_INVOCATION);
     if(param)
     {
         in_order_invoker_str = axutil_param_get_value(param, env);
-        sandesha2_property_mgr_load_in_order_invocation(env, 
-            in_order_invoker_str, property_bean);        
+        sandesha2_property_mgr_load_in_order_invocation(env, in_order_invoker_str, property_bean);        
     }
 
-    param = axis2_module_desc_get_param(module_desc, env, 
-        SANDESHA2_PROPERTIES_MSG_TYPES_TO_DROP);
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_MSG_TYPES_TO_DROP);
     if(param)
     {
         msg_types_str = axutil_param_get_value(param, env);
-        sandesha2_property_mgr_load_msg_types_to_drop(env, msg_types_str, 
-            property_bean);        
+        sandesha2_property_mgr_load_msg_types_to_drop(env, msg_types_str, property_bean);        
     }
     
-    param = axis2_module_desc_get_param(module_desc, env, 
-        SANDESHA2_PROPERTIES_STORAGE_MGR);
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_STORAGE_MGR);
     if(param)
     {
         axis2_char_t *storage_mgr = NULL;
@@ -189,39 +186,82 @@
         sandesha2_property_bean_set_storage_mgr(property_bean, env, storage_mgr);        
     }
     
-    param = axis2_module_desc_get_param(module_desc, env, 
-        SANDESHA2_PROPERTIES_MAX_RETRANS_COUNT);
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_MAX_RETRANS_COUNT);
     if(param)
     {
         int max_retrans_count = -1;
         axis2_char_t *max_retrans_count_str = axutil_param_get_value(param, env);
         axis2_char_t *str = sandesha2_utils_trim_string(env, max_retrans_count_str);
         if(str)
+        {
             max_retrans_count = atoi(str);
+        }
+
         if(0 < max_retrans_count)
-            sandesha2_property_bean_set_max_retrans_count(property_bean, env, 
-                max_retrans_count);
+        {
+            sandesha2_property_bean_set_max_retrans_count(property_bean, env, max_retrans_count);
+        }
+
         if(str)
+        {
             AXIS2_FREE(env->allocator, str);
+        }
     }
 
-    param = axis2_module_desc_get_param(module_desc, env, 
-        SANDESHA2_PROPERTIES_TERMINATE_DELAY);
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_TERMINATE_DELAY);
     if(param)
     {
         int terminate_delay = -1;
+
         axis2_char_t *terminate_delay_str = axutil_param_get_value(param, env);
         axis2_char_t *str = sandesha2_utils_trim_string(env, terminate_delay_str);
         if(str)
+        {
             terminate_delay = atoi(str);
+        }
         else
+        {
             terminate_delay = SANDESHA2_TERMINATE_DELAY;
+        }
+
         if(0 < terminate_delay)
-            sandesha2_property_bean_set_terminate_delay(property_bean, env, 
-                terminate_delay);
+        {
+            sandesha2_property_bean_set_terminate_delay(property_bean, env, terminate_delay);
+        }
+
+        if(str)
+        {
+            AXIS2_FREE(env->allocator, str);
+        }
+    }
+
+    param = axis2_module_desc_get_param(module_desc, env, SANDESHA2_PROPERTIES_POLLING_DELAY);
+    if(param)
+    {
+        int polling_delay = -1;
+
+        axis2_char_t *polling_delay_str = axutil_param_get_value(param, env);
+        axis2_char_t *str = sandesha2_utils_trim_string(env, polling_delay_str);
+        if(str)
+        {
+            polling_delay = axutil_atoi(str);
+        }
+        else
+        {
+            polling_delay = SANDESHA2_POLLING_DELAY;
+        }
+
+        if(0 < polling_delay)
+        {
+            sandesha2_property_bean_set_polling_delay(property_bean, env, polling_delay);
+        }
+
         if(str)
+        {
             AXIS2_FREE(env->allocator, str);
+        }
     }
+
     return property_bean;
 }
 
@@ -233,18 +273,24 @@
 {
     axis2_char_t *str = NULL;
     
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, property_bean, AXIS2_FAILURE);
     
     str = sandesha2_utils_trim_string(env, value);
-    if(0 == axutil_strcmp(str, AXIS2_VALUE_TRUE))
+    if(!axutil_strcmp(str, AXIS2_VALUE_TRUE))
+    {
         sandesha2_property_bean_set_exp_backoff(property_bean, env, AXIS2_TRUE);
+    }
     else
-        sandesha2_property_bean_set_exp_backoff(property_bean, env, 
-            AXIS2_FALSE);
+    {
+        sandesha2_property_bean_set_exp_backoff(property_bean, env, AXIS2_FALSE);
+    }
+
     if(str)
+    {
         AXIS2_FREE(env->allocator, str);
+    }
+
     return AXIS2_SUCCESS;
 }
                         
@@ -257,18 +303,26 @@
     axis2_char_t *str = NULL;
     int retrans_int = -1;
     
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, property_bean, AXIS2_FAILURE);
     
     str = sandesha2_utils_trim_string(env, value);
+
     if(str)
+    {
         retrans_int = atoi(str);
+    }
+
     if(0 < retrans_int)
-        sandesha2_property_bean_set_retrans_interval(property_bean, env, 
-                    retrans_int);
+    {
+        sandesha2_property_bean_set_retrans_interval(property_bean, env, retrans_int);
+    }
+
     if(str)
+    {
         AXIS2_FREE(env->allocator, str);
+    }
+
     return AXIS2_SUCCESS;
 }
                         
@@ -281,17 +335,25 @@
     axis2_char_t *str = NULL;
     int ack_int = -1;
     
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, property_bean, AXIS2_FAILURE);
     
     str = sandesha2_utils_trim_string(env, value);
     if(str)
+    {
         ack_int = atoi(str);
+    }
+
     if(0 < ack_int)
+    {
         sandesha2_property_bean_set_ack_interval(property_bean, env, ack_int);
+    }
+
     if(str)
+    {
         AXIS2_FREE(env->allocator, str);
+    }
+
     return AXIS2_SUCCESS;
 }
 
@@ -314,20 +376,33 @@
     str2 = sandesha2_utils_trim_string(env, measure);
     
     if(str)
-        timeout = atoi(str);
+    {
+        timeout = axutil_atoi(str);
+    }
+
     if(0 < timeout)
     {
         if(str2)
-            sandesha2_property_bean_set_inactive_timeout_interval_with_units(
-                property_bean, env, timeout, str2);
+        {
+            sandesha2_property_bean_set_inactive_timeout_interval_with_units(property_bean, env, 
+                    timeout, str2);
+        }
         else
-            sandesha2_property_bean_set_inactive_timeout_interval(property_bean,
-                env, timeout);
+        {
+            sandesha2_property_bean_set_inactive_timeout_interval(property_bean, env, timeout);
+        }
     }
+
     if(str)
+    {
         AXIS2_FREE(env->allocator, str);
+    }
+
     if(str2)
+    {
         AXIS2_FREE(env->allocator, str2);
+    }
+
     return AXIS2_SUCCESS;
 }
 
@@ -343,12 +418,20 @@
     AXIS2_PARAM_CHECK(env->error, property_bean, AXIS2_FAILURE);
     
     str = sandesha2_utils_trim_string(env, value);
-    if(0 == axutil_strcmp(str, AXIS2_VALUE_TRUE))
+    if(!axutil_strcmp(str, AXIS2_VALUE_TRUE))
+    {
         sandesha2_property_bean_set_in_order(property_bean, env, AXIS2_TRUE);
+    }
     else
+    {
         sandesha2_property_bean_set_in_order(property_bean, env, AXIS2_FALSE);
+    }
+
     if(str)
+    {
         AXIS2_FREE(env->allocator, str);
+    }
+
     return AXIS2_SUCCESS;
 }
 
@@ -360,12 +443,11 @@
 {
     axis2_char_t *str = NULL;
     
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, property_bean, AXIS2_FAILURE);
     
     str = sandesha2_utils_trim_string(env, value);
-    if(str && 0 != axutil_strcmp(str, SANDESHA2_VALUE_NONE))
+    if(str && axutil_strcmp(str, SANDESHA2_VALUE_NONE))
     {
         axis2_char_t *str2 = NULL;
         axutil_array_list_t *list = NULL;
@@ -375,17 +457,21 @@
         if(list)
         {
             int i = 0;
+
             for(i = 0; i < axutil_array_list_size(list, env); i++)
             {
                 axis2_char_t *val = NULL;
                 val = axutil_array_list_get(list, env, i);
-                sandesha2_property_bean_add_msg_type_to_drop(property_bean, env,
-                    atoi(val));
+                sandesha2_property_bean_add_msg_type_to_drop(property_bean, env, axutil_atoi(val));
             }
         }
     }
+
     if(str)
+    {
         AXIS2_FREE(env->allocator, str);
+    }
+
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/sandesha/trunk/c/src/util/sandesha2_utils.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/sandesha2_utils.c?rev=690127&r1=690126&r2=690127&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/util/sandesha2_utils.c (original)
+++ webservices/sandesha/trunk/c/src/util/sandesha2_utils.c Thu Aug 28 23:56:29 2008
@@ -30,6 +30,7 @@
 #include <sandesha2_permanent_storage_mgr.h>
 #include <axutil_string.h>
 #include <axis2_conf.h>
+#include <axis2_const.h>
 #include <axutil_property.h>
 #include <axutil_uuid_gen.h>
 #include <axiom_soap_body.h>
@@ -67,8 +68,10 @@
     axis2_msg_ctx_t *in_msg_ctx);
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-sandesha2_utils_remove_soap_body_part(const axutil_env_t *env, 
-                        axiom_soap_envelope_t *envelope, axutil_qname_t *qname)
+sandesha2_utils_remove_soap_body_part(
+    const axutil_env_t *env, 
+    axiom_soap_envelope_t *envelope, 
+    axutil_qname_t *qname)
 {
     axiom_soap_body_t *soap_body = NULL;
     axiom_node_t *body_node = NULL;
@@ -83,29 +86,39 @@
     if(!soap_body)
     {
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[sandesha2]Soap envelope does not have a soap body");
+                "[sandesha2] Soap envelope does not have a soap body");
         return AXIS2_FAILURE;
     }
+
     body_node = axiom_soap_body_get_base_node(soap_body, env);
     if(!body_node)
     {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[sandesha2]Soap body does not have a base node");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Soap body does not have a base node");
         return AXIS2_FAILURE;
     }
+
     body_element = axiom_node_get_data_element(body_node, env);
     if(!body_element)
     {
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[sandesha2]Soap body node does not have a node element");
+                "[sandesha2] Soap body node does not have a node element");
         return AXIS2_FAILURE;
     }
-    body_rm_element = axiom_element_get_first_child_with_qname(body_element,
-                            env, qname, body_node, &body_rm_node);
+
+    body_rm_element = axiom_element_get_first_child_with_qname(body_element, env, qname, body_node, 
+            &body_rm_node);
+
     if(body_rm_element)
     {
-        axiom_node_detach(body_rm_node, env);
+        axiom_node_t *temp_node = NULL;
+
+        temp_node = axiom_node_detach(body_rm_node, env);
+        if(temp_node)
+        {
+            axiom_node_free_tree(temp_node, env);
+        }
     }
+
     return AXIS2_SUCCESS;
 }
 
@@ -178,8 +191,8 @@
 AXIS2_EXTERN axis2_char_t* AXIS2_CALL
 sandesha2_utils_get_seq_property(
     const axutil_env_t *env,
-    axis2_char_t *incoming_seq_id,
-    axis2_char_t *name,
+    const axis2_char_t *incoming_seq_id,
+    const axis2_char_t *name,
     sandesha2_seq_property_mgr_t *seq_prop_mgr)
 {
     axis2_char_t *value = NULL;
@@ -189,13 +202,13 @@
     AXIS2_PARAM_CHECK(env->error, name, NULL);
     AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, NULL);
     
-    seq_prop_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr,
-        env, incoming_seq_id, name);
+    seq_prop_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, incoming_seq_id, name);
     if(!seq_prop_bean)
+    {
         return NULL;
+    }
 
-    value = axutil_strdup(env, sandesha2_seq_property_bean_get_value(
-        seq_prop_bean, env));
+    value = axutil_strdup(env, sandesha2_seq_property_bean_get_value(seq_prop_bean, env));
     sandesha2_seq_property_bean_free(seq_prop_bean, env);
     return value;
 }
@@ -356,57 +369,18 @@
     AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE);
     
-    return sandesha2_sender_run_for_seq(env, conf_ctx, seq_id, 
-        persistent);
+    /*return sandesha2_sender_run_for_seq(env, conf_ctx, seq_id, persistent);*/
+    return AXIS2_SUCCESS;
 }
  
-AXIS2_EXTERN axis2_status_t AXIS2_CALL                        
-sandesha2_utils_start_polling_mgr(
-    const axutil_env_t *env,
-    axis2_conf_ctx_t *conf_ctx,
-    const axis2_char_t *internal_seq_id)
-{
-    sandesha2_polling_mgr_t *polling_mgr = NULL;
-    axutil_property_t *property = NULL;
-    axis2_status_t status = AXIS2_FAILURE;
-    
-    AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
-    
-    axutil_allocator_switch_to_global_pool(env->allocator);
-    property = axis2_ctx_get_property(axis2_conf_ctx_get_base(conf_ctx, env),
-        env, SANDESHA2_POLLING_MGR);
-    if(property)
-        polling_mgr = axutil_property_get_value(property, env);
-       
-    /* Assumes that if someone has set the polling_mgr, he must have already 
-     * started it 
-     */
-    if(!polling_mgr)
-    {
-        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
-            "[sandesha2]Starting the polling manager");
-        polling_mgr = sandesha2_polling_mgr_create(env);
-        property = axutil_property_create_with_args(env, 0, AXIS2_FALSE,
-            (void *)sandesha2_polling_mgr_free_void_arg, polling_mgr);
-        axis2_ctx_set_property(axis2_conf_ctx_get_base(conf_ctx, env),
-            env, SANDESHA2_POLLING_MGR, property);
-    }
-    status = sandesha2_polling_mgr_start(polling_mgr, env, conf_ctx, 
-        internal_seq_id);
-    axutil_allocator_switch_to_local_pool(env->allocator);
-    return status;
-}
-                   
-                        
 AXIS2_EXTERN axis2_char_t* AXIS2_CALL
-sandesha2_utils_get_outgoing_internal_seq_id(
+sandesha2_utils_get_internal_sequence_id(
     const axutil_env_t *env,
-    axis2_char_t *seq_id)
+    axis2_char_t *rmd_sequence_id)
 {
-    AXIS2_PARAM_CHECK(env->error, seq_id, NULL);
+    AXIS2_PARAM_CHECK(env->error, rmd_sequence_id, NULL);
     
-    return axutil_strcat(env, SANDESHA2_INTERNAL_SEQ_PREFIX, ":",
-        seq_id, NULL);
+    return axutil_strcat(env, SANDESHA2_INTERNAL_SEQ_PREFIX, ":", rmd_sequence_id, NULL);
 }
 
 AXIS2_EXTERN axis2_transport_out_desc_t* AXIS2_CALL
@@ -433,20 +407,21 @@
 }
 
 AXIS2_EXTERN axis2_char_t* AXIS2_CALL                       
-sandesha2_utils_get_svr_side_incoming_seq_id(const axutil_env_t *env,
-                        axis2_char_t *incoming_seq_id)
+sandesha2_utils_get_rmd_seq_id(
+        const axutil_env_t *env,
+        axis2_char_t *internal_sequence_id)
 {
     axis2_char_t *start_str = NULL;
     axis2_char_t *ret = NULL;
     int start_len = 0;
     
-    AXIS2_PARAM_CHECK(env->error, incoming_seq_id, NULL);
+    AXIS2_PARAM_CHECK(env->error, internal_sequence_id, NULL);
     
     start_str = axutil_strcat(env, SANDESHA2_INTERNAL_SEQ_PREFIX, ":", NULL);
     start_len = axutil_strlen(start_str);
-    if(0 != axutil_strncmp(incoming_seq_id, start_str, start_len))
+    if(0 != axutil_strncmp(internal_sequence_id, start_str, start_len))
         return NULL;
-    ret = axutil_strdup(env, (incoming_seq_id + start_len * sizeof(axis2_char_t)));
+    ret = axutil_strdup(env, (internal_sequence_id + start_len * sizeof(axis2_char_t)));
     
     return ret;    
 }
@@ -475,7 +450,7 @@
 }
 
 AXIS2_EXTERN axis2_char_t* AXIS2_CALL
-sandesha2_utils_get_internal_seq_id(
+sandesha2_utils_get_client_internal_sequence_id(
     const axutil_env_t *env,
     axis2_char_t *to,
     axis2_char_t *seq_key)
@@ -506,10 +481,8 @@
 AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL
 sandesha2_utils_create_new_related_msg_ctx(
     const axutil_env_t *env,
-    sandesha2_msg_ctx_t *ref_rm_msg,
-    axis2_op_t *op)
+    sandesha2_msg_ctx_t *ref_rm_msg)
 {
-    axis2_ctx_t *ctx = NULL;
     axis2_msg_ctx_t *ref_msg = NULL;
     axis2_msg_ctx_t *new_msg = NULL;
     axis2_conf_ctx_t *conf_ctx = NULL;
@@ -526,7 +499,6 @@
     axis2_char_t *transport_to = NULL;
     
     AXIS2_PARAM_CHECK(env->error, ref_rm_msg, NULL);
-    AXIS2_PARAM_CHECK(env->error, op, NULL);
     
     ref_msg = sandesha2_msg_ctx_get_msg_ctx(ref_rm_msg, env);
     conf_ctx = axis2_msg_ctx_get_conf_ctx(ref_msg, env);
@@ -539,108 +511,23 @@
     svc_grp = axis2_msg_ctx_get_svc_grp(ref_msg, env); 
     if(svc_grp)
     {
-        axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
-        axis2_msg_ctx_set_svc_grp(new_msg, env, svc_grp);
-        svc_grp_ctx = axis2_msg_ctx_get_svc_grp_ctx(ref_msg, env);
-        if(svc_grp_ctx)
-        {
-            axis2_msg_ctx_set_svc_grp_ctx(new_msg, env, svc_grp_ctx); 
-        }
-        else
-        {
-            axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
-            svc_grp_ctx = axis2_svc_grp_ctx_create(env, 
-                axis2_msg_ctx_get_svc_grp(ref_msg, env), conf_ctx);
-            axis2_msg_ctx_set_svc_grp_ctx(new_msg, env, svc_grp_ctx);
-        }
-    }
-    else
-    {
-        axis2_svc_grp_t *svc_grp = NULL;
-        axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
-        
-        svc_grp = axis2_svc_grp_create_with_conf(env, conf);
-        svc_grp_ctx = axis2_svc_grp_ctx_create(env, svc_grp, conf_ctx);
         axis2_msg_ctx_set_svc_grp(new_msg, env, svc_grp);
-        axis2_msg_ctx_set_svc_grp_ctx(new_msg, env, svc_grp_ctx);
     }
 
     if(axis2_msg_ctx_get_svc(ref_msg, env))
     {
-        axis2_msg_ctx_set_svc_grp(new_msg, env, (axis2_svc_grp_t *)
-            axis2_msg_ctx_get_svc(ref_msg, env));
-        if(axis2_msg_ctx_get_svc_ctx(ref_msg, env))
-        {
-            axis2_msg_ctx_set_svc_ctx(new_msg, env, 
-                axis2_msg_ctx_get_svc_ctx(ref_msg, env));
-            axis2_msg_ctx_set_svc_ctx_id(new_msg, env, 
-                axis2_msg_ctx_get_svc_ctx_id(ref_msg, env));
-        }
-        else
-        {
-            axis2_svc_ctx_t *svc_ctx =  NULL;
-            svc_ctx = axis2_svc_ctx_create(env, 
-                axis2_msg_ctx_get_svc(ref_msg, env),
-                axis2_msg_ctx_get_svc_grp_ctx(new_msg, env));
-            axis2_msg_ctx_set_svc_ctx(new_msg, env, svc_ctx);
-        }
+        axis2_msg_ctx_set_svc(new_msg, env, axis2_msg_ctx_get_svc(ref_msg, env));
     }
-    else
-    {
-        axis2_svc_t *axis_svc = NULL;
-        axutil_qname_t *svc_qname = NULL;
-        axis2_svc_grp_t *svc_grp = NULL;
-        axis2_svc_ctx_t *svc_ctx = NULL;
-        axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
-        
-        svc_qname = axutil_qname_create(env, "AnonymousRMService", NULL, NULL);
-        axis_svc = axis2_svc_create_with_qname(env, svc_qname);
-        if(svc_qname)
-            axutil_qname_free(svc_qname, env);
-        
-        svc_grp = axis2_msg_ctx_get_svc_grp(new_msg, env);
-        axis2_svc_set_parent(axis_svc, env, axis2_msg_ctx_get_svc_grp(new_msg,
-            env));
-        axis2_svc_grp_add_svc(svc_grp, env, axis_svc);
-        svc_grp_ctx = axis2_msg_ctx_get_svc_grp_ctx(new_msg, env);
-        svc_ctx = axis2_svc_ctx_create(env, axis_svc, svc_grp_ctx);
-    }
-    /*op_ctx = axis2_op_ctx_create(env, op, axis2_msg_ctx_get_svc_ctx(new_msg, env));*/
+
     op_ctx = axis2_msg_ctx_get_op_ctx(ref_msg, env);
-    axis2_op_ctx_increment_ref(op_ctx, env);
+    /*axis2_op_ctx_increment_ref(op_ctx, env);*/
     axis2_msg_ctx_set_op_ctx(new_msg, env, op_ctx);
-    
-    ctx = axis2_msg_ctx_get_base(ref_msg, env);
-    if (ctx)
-    {
-        axis2_ctx_t *new_ctx = axis2_msg_ctx_get_base(new_msg, env);
-        if (new_ctx)
-        {
-            axutil_hash_index_t *hi = NULL;
-            axutil_hash_t *ht = NULL;
-            axutil_hash_t *ht2 = NULL;
-            void *val = NULL;
-            const void *val2 = NULL;
-            axutil_property_t *prop = NULL;
-            axutil_property_t *prop_clone = NULL;
-            axis2_char_t *prop_name = NULL;
-
-            ht = axis2_ctx_get_property_map(ctx, env);
-            ht2 = axis2_ctx_get_property_map(new_ctx, env);
-            for (hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) {
-                axutil_hash_this(hi, &val2, NULL, &val);
-                prop = (axutil_property_t*)val;
-                prop_name = (axis2_char_t*)val2;
-                prop_clone = axutil_property_clone(prop, env);
-                axis2_ctx_set_property(new_ctx, env, prop_name, prop_clone);
-                axutil_property_set_free_func(prop, env, sandesha2_util_dummy_prop_free);
-            }
-        }
-    }
+    axis2_msg_ctx_set_svc_ctx(new_msg, env, axis2_msg_ctx_get_svc_ctx(ref_msg, env));
+    axis2_msg_ctx_set_svc_grp_ctx(new_msg, env, axis2_msg_ctx_get_svc_grp_ctx(ref_msg, env));
 
     soap_env = axiom_soap_envelope_create_default_soap_envelope(env, 
-        sandesha2_utils_get_soap_version(env, 
-        axis2_msg_ctx_get_soap_envelope(ref_msg, env)));
+            sandesha2_utils_get_soap_version(env, axis2_msg_ctx_get_soap_envelope(ref_msg, env)));
+
     axis2_msg_ctx_set_soap_envelope(new_msg, env, soap_env);
     
     transport_to = axis2_msg_ctx_get_transport_url(ref_msg, env);
@@ -648,47 +535,60 @@
     {
         axis2_msg_ctx_set_transport_url(new_msg, env, transport_to);
     }
+
     property = axis2_msg_ctx_get_property(ref_msg, env, AXIS2_WSA_VERSION);
     if(!property)
     {
         axis2_msg_ctx_t *req_msg = NULL;
-        axis2_op_ctx_t *op_ctx = axis2_msg_ctx_get_op_ctx(ref_msg, env);
+        axis2_op_ctx_t *temp_op_ctx = NULL;
         
-        req_msg =  axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
+        temp_op_ctx = axis2_msg_ctx_get_op_ctx(ref_msg, env);
+        if(temp_op_ctx)
+        {
+            req_msg =  axis2_op_ctx_get_msg_ctx(temp_op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
+        }
+
         if(req_msg)
         {
-            property = axis2_msg_ctx_get_property(req_msg, env, 
-                AXIS2_WSA_VERSION);
+            property = axis2_msg_ctx_get_property(req_msg, env, AXIS2_WSA_VERSION);
             if(property)
-                addr_ver = axutil_property_get_value(property, env);
+            {
+                addr_ver = axutil_strdup(env, axutil_property_get_value(property, env));
+            }
         }
     }
     else
     {
-        addr_ver = axutil_property_get_value(property, env);
+        addr_ver = axutil_strdup(env, axutil_property_get_value(property, env));
     }
-    property = axutil_property_create_with_args(env, 0, 0, 0, addr_ver);
+
+    property = axutil_property_create_with_args(env, 0, AXIS2_TRUE, 0, addr_ver);
     axis2_msg_ctx_set_property(new_msg, env, AXIS2_WSA_VERSION, property);
     
-    out_stream = axis2_msg_ctx_get_transport_out_stream(ref_msg, 
-        env);
+    out_stream = axis2_msg_ctx_get_transport_out_stream(ref_msg, env);
     axis2_msg_ctx_set_transport_out_stream(new_msg, env, out_stream);
-    property = axis2_msg_ctx_get_property(ref_msg, env, 
-        AXIS2_TRANSPORT_IN);
+    property = axis2_msg_ctx_get_property(ref_msg, env, AXIS2_TRANSPORT_IN);
     if(property)
-        axis2_msg_ctx_set_property(new_msg, env, AXIS2_TRANSPORT_IN, 
-            axutil_property_clone(property, env));
-    axis2_msg_ctx_set_out_transport_info(new_msg, env, 
-        axis2_msg_ctx_get_out_transport_info(ref_msg, env));
-    axis2_msg_ctx_set_charset_encoding(new_msg, env,
-        axis2_msg_ctx_get_charset_encoding(ref_msg, env));
-    property = axis2_msg_ctx_get_property(ref_msg, env, 
-        AXIS2_TRANSPORT_HEADERS);
+    {
+        axis2_msg_ctx_set_property(new_msg, env, AXIS2_TRANSPORT_IN, sandesha2_util_property_clone(
+                    env, property));
+    }
+
+    axis2_msg_ctx_set_out_transport_info(new_msg, env, axis2_msg_ctx_get_out_transport_info(ref_msg, 
+                env));
+
+    axis2_msg_ctx_set_charset_encoding(new_msg, env, axis2_msg_ctx_get_charset_encoding(ref_msg, 
+                env));
+
+    property = axis2_msg_ctx_get_property(ref_msg, env, AXIS2_TRANSPORT_HEADERS);
     if(property)
-        axis2_msg_ctx_set_property(new_msg, env, AXIS2_TRANSPORT_HEADERS, 
-            axutil_property_clone(property, env));
-    paused_phase_name = (axis2_char_t*)axis2_msg_ctx_get_paused_phase_name(
-        ref_msg, env);
+    {
+        axis2_msg_ctx_set_property(new_msg, env, AXIS2_TRANSPORT_HEADERS, sandesha2_util_property_clone(
+                    env, property));
+    }
+
+    paused_phase_name = (axis2_char_t*)axis2_msg_ctx_get_paused_phase_name(ref_msg, env);
+
     axis2_msg_ctx_set_paused_phase_name(new_msg, env, paused_phase_name);
 
     return new_msg;
@@ -749,7 +649,7 @@
         
     if(0 == axutil_strcmp(action, SANDESHA2_SPEC_2005_02_ACTION_CREATE_SEQ))
         ret = AXIS2_TRUE;
-    else if(0 == axutil_strcmp(action, SANDESHA2_SPEC_2006_08_ACTION_CREATE_SEQ))
+    else if(0 == axutil_strcmp(action, SANDESHA2_SPEC_2007_02_ACTION_CREATE_SEQ))
         ret = AXIS2_TRUE;
         
     return ret;
@@ -797,7 +697,7 @@
         if(!seq_element)
         {
             qname = axutil_qname_create(env, SANDESHA2_WSRM_COMMON_SEQ,
-                        SANDESHA2_SPEC_2006_08_NS_URI, NULL);
+                        SANDESHA2_SPEC_2007_02_NS_URI, NULL);
             seq_element = axiom_element_get_first_child_with_qname(
                         header_element, env, qname, header_node, &seq_node);
             if(qname)
@@ -819,14 +719,14 @@
         is_global_msg = AXIS2_TRUE;    
         
     if(0 == axutil_strcmp(action, 
-                        SANDESHA2_SPEC_2006_08_ACTION_SEQ_ACKNOWLEDGEMENT))
+                        SANDESHA2_SPEC_2007_02_ACTION_SEQ_ACKNOWLEDGEMENT))
         is_global_msg = AXIS2_TRUE;
         
     if(0 == axutil_strcmp(action, 
-                        SANDESHA2_SPEC_2006_08_ACTION_CREATE_SEQ_RESPONSE))
+                        SANDESHA2_SPEC_2007_02_ACTION_CREATE_SEQ_RESPONSE))
         is_global_msg = AXIS2_TRUE;
         
-    if(0 == axutil_strcmp(action, SANDESHA2_SPEC_2006_08_ACTION_TERMINATE_SEQ))
+    if(0 == axutil_strcmp(action, SANDESHA2_SPEC_2007_02_ACTION_TERMINATE_SEQ))
         is_global_msg = AXIS2_TRUE;    
     
     return is_global_msg;
@@ -907,28 +807,6 @@
     return AXIS2_SUCCESS;
 }
  
-AXIS2_EXTERN axis2_status_t AXIS2_CALL                        
-sandesha2_utils_stop_polling_mgr(
-    const axutil_env_t *env,
-    axis2_conf_ctx_t *conf_ctx)
-{
-    sandesha2_polling_mgr_t *polling_mgr = NULL;
-    axutil_property_t *property = NULL;
-    
-    AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
-    
-    property = axis2_ctx_get_property(axis2_conf_ctx_get_base(conf_ctx, env),
-                        env, SANDESHA2_POLLING_MGR);
-    if(property)
-        polling_mgr = axutil_property_get_value(property, env);
-       
-    if(polling_mgr)
-    {
-        sandesha2_polling_mgr_stop_polling(polling_mgr, env);
-    }
-    return AXIS2_SUCCESS;
-}
-                 
 /**
  * Used to convert a message number list (a comma seperated list of message
  * numbers) into a set of Acknowledgement Ranges. This breaks the list, sort
@@ -980,6 +858,10 @@
              upper = *temp;
              completed = AXIS2_FALSE;
         }
+        if(temp)
+        {
+            AXIS2_FREE(env->allocator, temp);
+        }
     }
     if(!completed)
     {
@@ -1023,6 +905,17 @@
     sorted_msg_no_list = sandesha2_utils_sort(env, msg_numbers);
     if(msg_numbers)
     {
+        int i = 0;
+        int size = 0;
+
+        size = axutil_array_list_size(msg_numbers, env);
+        for(i = 0; i < size; i++)
+        {
+            long *temp_long = NULL;
+
+            temp_long = (long *) axutil_array_list_get(msg_numbers, env, i);
+            AXIS2_FREE(env->allocator, temp_long);
+        }
         axutil_array_list_free(msg_numbers, env);
     }
     AXIS2_FREE(env->allocator, dup_str);
@@ -1041,15 +934,21 @@
     
     sorted_list = axutil_array_list_create(env, 0);
     if(list)
+    {
         size = axutil_array_list_size(list, env);
+    }
+
     for(i = 0; i < size; i++)
     {
         long *temp_long = NULL;
 
         temp_long = (long *) axutil_array_list_get(list, env, i);
         if(*temp_long > max)
+        {
             max = *temp_long;
+        }
     }
+
     for(j = 1; j <= max; j++)
     {
         long *temp = AXIS2_MALLOC(env->allocator, sizeof(long));
@@ -1066,6 +965,7 @@
                 break;
             }
         }
+
         if(contains)
         {
             axutil_array_list_add(sorted_list, env, temp);
@@ -1085,28 +985,40 @@
     axutil_array_list_t *acked_msgs_list = NULL;
     long smallest_msg_no = 1;
     long temp_msg_no = 0;
+    axis2_bool_t ret = AXIS2_TRUE;
+
+    client_completed_msgs = sandesha2_utils_get_seq_property(env, internal_seq_id, 
+            SANDESHA2_SEQ_PROP_CLIENT_COMPLETED_MESSAGES, seq_prop_mgr);
+
+    if(client_completed_msgs)
+    {
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Client_completed_msgs:%s", 
+            client_completed_msgs);
+
+        acked_msgs_list = sandesha2_utils_get_array_list_from_string(env, client_completed_msgs);
+        AXIS2_FREE(env->allocator, client_completed_msgs);
+    }
 
-    client_completed_msgs = sandesha2_utils_get_seq_property(env, 
-        internal_seq_id, SANDESHA2_SEQ_PROP_CLIENT_COMPLETED_MESSAGES, 
-        seq_prop_mgr);
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
-        "[sandesha2]client_completed_msgs:%s", client_completed_msgs);
-    acked_msgs_list = sandesha2_utils_get_array_list_from_string(env, 
-        client_completed_msgs);
     if(!acked_msgs_list)
+    {
         return AXIS2_FALSE;
-    for(temp_msg_no = smallest_msg_no; temp_msg_no <= highest_in_msg_no; 
-        temp_msg_no++)
+    }
+
+    for(temp_msg_no = smallest_msg_no; temp_msg_no <= highest_in_msg_no; temp_msg_no++)
     {
         axis2_char_t str_msg_no[32];
+
         sprintf(str_msg_no, "%ld", temp_msg_no);
-        if(!sandesha2_utils_array_list_contains(env, acked_msgs_list, 
-            str_msg_no))
+        if(!sandesha2_utils_array_list_contains(env, acked_msgs_list, str_msg_no))
         {
-            return AXIS2_FALSE;
+            ret = AXIS2_FALSE;
+            break;
         }
     }
-    return AXIS2_TRUE; /* All messages upto the highest have been acked */
+    
+    axutil_array_list_free(acked_msgs_list, env);
+
+    return ret; /* All messages upto the highest have been acked */
 }
 
 axis2_status_t AXIS2_CALL
@@ -1125,24 +1037,22 @@
 
     msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
     if(msg_ctx)
+    {
         conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
-    sandesha2_msg_ctx_set_msg_type(rm_msg_ctx, env, 
-        SANDESHA2_MSG_TYPE_CREATE_SEQ);
+    }
+
+    sandesha2_msg_ctx_set_msg_type(rm_msg_ctx, env, SANDESHA2_MSG_TYPE_CREATE_SEQ);
     /* Message will be stored in the sandesha2_transport_sender */
-    property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST,
-        AXIS2_TRUE, 0, storage_key);
-    axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_MESSAGE_STORE_KEY, 
-        property);
+    property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_TRUE, 0, storage_key);
+    axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_MESSAGE_STORE_KEY, property);
     
     transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx, env);
     property = axutil_property_create_with_args(env, 3, 0, 
         axis2_transport_out_desc_free_void_arg, transport_out);
-    axis2_msg_ctx_set_property(msg_ctx, env, 
-        SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property);
+    axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property);
     
-    property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
-    axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_SET_SEND_TO_TRUE, 
-        property);
+    /*property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
+    axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_SET_SEND_TO_TRUE, property);*/
     sandesha2_transport_out = sandesha2_utils_get_transport_out(env);
     axis2_msg_ctx_set_transport_out_desc(msg_ctx, env, sandesha2_transport_out);
     /*Sending the message once through the sandesha2_transport_sender */
@@ -1157,8 +1067,12 @@
     {
         status = axis2_engine_send(engine, env, msg_ctx);
     }
+
     if(engine)
+    {
         axis2_engine_free(engine, env);
+    }
+
     return status;
 }
 
@@ -1180,19 +1094,33 @@
     const axutil_env_t *env,
     const axis2_char_t *address)
 {
+    axis2_bool_t ret = AXIS2_FALSE;
+
     axis2_char_t *address_l = NULL;
     if(!address)
+    {
         return AXIS2_TRUE;
+    }
+
     address_l = axutil_strtrim(env, address, NULL);
 
-    if(0 == axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL, address_l))
-        return AXIS2_TRUE;
-    if(0 == axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL_SUBMISSION, address_l))
-        return AXIS2_TRUE;
+    if(!axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL, address_l))
+    {
+        ret = AXIS2_TRUE;
+    }
+
+    if(!axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL_SUBMISSION, address_l))
+    {
+        ret = AXIS2_TRUE;
+    }
     else if (sandesha2_utils_is_wsrm_anon_reply_to(env, (axis2_char_t *) address))
-        return AXIS2_TRUE;
+    {
+        ret = AXIS2_TRUE;
+    }
 
-    return AXIS2_FALSE;
+    AXIS2_FREE(env->allocator, address_l);
+
+    return ret;
 }
 
 axutil_array_list_t *AXIS2_CALL
@@ -1205,31 +1133,43 @@
     axis2_char_t *ptr = NULL;
     axis2_char_t *value = NULL;
     ptr = axutil_strstr(str, pattern);
+
     while(ptr)
     {
         ptr[0] = AXIS2_EOLN;
-        value = axutil_strdup(env, str);
-        if(value && 0 != axutil_strcmp(value, ""))
+        /*value = axutil_strdup(env, str);*/
+        value = str;
+        if(value && axutil_strcmp(value, ""))
+        {
             axutil_array_list_add(list, env, value);
+        }
+
         str = ptr + 3;
         ptr = axutil_strstr(str, pattern);
     }
-    value = axutil_strdup(env, str);
-    if(value && 0 != axutil_strcmp(value, ""))
+
+    /*value = axutil_strdup(env, str);*/
+    value = str;
+    if(value && axutil_strcmp(value, ""))
+    {
         axutil_array_list_add(list, env, value);
+    }
 
     return list;
 }
 
 axis2_bool_t AXIS2_CALL
-sandesha2_utils_is_single_channel(
+sandesha2_utils_is_rm_1_0_anonymous_acks_to(
     const axutil_env_t *env,
     const axis2_char_t *rm_version,
     const axis2_char_t *acks_to_addr)
 {
     if(sandesha2_utils_is_anon_uri(env, acks_to_addr) &&
-        (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_0, rm_version)))
+        (!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_0, rm_version)))
+    {
         return AXIS2_TRUE;
+    }
+
     else return AXIS2_FALSE;
 }
 
@@ -1293,11 +1233,13 @@
         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);
+    axis2_msg_info_headers_set_fault_to(msg_info_headers, env, sandesha2_util_endpoint_ref_clone(
+                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);
@@ -1322,28 +1264,7 @@
         axis2_ctx_t *new_ctx = axis2_msg_ctx_get_base(new_msg_ctx, env);
         if (new_ctx)
         {
-            axutil_hash_index_t *hi = NULL;
-            axutil_hash_t *ht = NULL;
-            axutil_hash_t *ht2 = NULL;
-            void *val = NULL;
-            const void *val2 = NULL;
-            axutil_property_t *prop = NULL;
-            axutil_property_t *prop_clone = NULL;
-            axis2_char_t *prop_name = NULL;
-
-            ht = axis2_ctx_get_property_map(ctx, env);
-            ht2 = axis2_ctx_get_property_map(new_ctx, env);
-            for (hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) {
-                axutil_hash_this(hi, &val2, NULL, &val);
-                prop = (axutil_property_t*)val;
-                prop_name = (axis2_char_t*)val2;
-                prop_clone = axutil_property_clone(prop, env);
-                axis2_ctx_set_property(new_ctx, env, prop_name, prop_clone);
-                axutil_property_set_free_func(prop, env, sandesha2_util_dummy_prop_free);
-            }
-            /* axis2_ctx_set_property_map(new_ctx, env,
-             *  axis2_ctx_get_property_map(ctx, env));
-             */
+            axis2_ctx_set_property_map(new_ctx, env, axis2_ctx_get_property_map(ctx, env));
         }
     }
 
@@ -1413,3 +1334,79 @@
     return dbname;
 }
 
+axis2_bool_t AXIS2_CALL
+sandesha2_util_is_fault_envelope(
+    const axutil_env_t *env, 
+    axiom_soap_envelope_t *soap_envelope)
+{
+    axiom_soap_fault_t *fault = NULL;
+
+    AXIS2_PARAM_CHECK(env->error, soap_envelope, AXIS2_FAILURE);
+    
+    fault = axiom_soap_body_get_fault(axiom_soap_envelope_get_body(soap_envelope, env), env);
+    if(fault)
+    {
+        return AXIS2_TRUE;
+    }
+        
+    return AXIS2_FALSE;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_util_is_ack_already_piggybacked(
+    const axutil_env_t *env, 
+    sandesha2_msg_ctx_t *rm_msg_ctx)
+{
+    AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
+    
+    if(sandesha2_msg_ctx_get_seq_ack(rm_msg_ctx, env))
+    {
+        return AXIS2_TRUE;
+    }
+    
+    return AXIS2_FALSE;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_util_is_piggybackable_msg_type(
+    const axutil_env_t *env, 
+    int msg_type)
+{
+    if(SANDESHA2_MSG_TYPE_ACK == msg_type)
+    {
+        return AXIS2_FALSE;
+    }
+
+    return AXIS2_TRUE;
+}
+
+axutil_property_t *AXIS2_CALL
+sandesha2_util_property_clone(
+    const axutil_env_t * env,
+    axutil_property_t * property)
+{
+    axutil_property_t *new_property = NULL;
+
+    new_property = axutil_property_clone(property, env);
+    axutil_property_set_own_value(new_property, env, 0);
+
+    return new_property;
+}
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_util_endpoint_ref_clone(
+    const axutil_env_t * env,
+    axis2_endpoint_ref_t * endpoint_ref)
+{
+    axis2_endpoint_ref_t *new_endpoint_ref = NULL;
+    const axis2_char_t *address = NULL;
+
+    if(endpoint_ref)
+    {
+        address = axis2_endpoint_ref_get_address(endpoint_ref, env);
+        new_endpoint_ref = axis2_endpoint_ref_create(env, address);
+    }
+
+    return new_endpoint_ref;
+}
+

Modified: webservices/sandesha/trunk/c/src/util/seq_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/seq_mgr.c?rev=690127&r1=690126&r2=690127&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/util/seq_mgr.c (original)
+++ webservices/sandesha/trunk/c/src/util/seq_mgr.c Thu Aug 28 23:56:29 2008
@@ -40,28 +40,20 @@
 #include <axis2_listener_manager.h>
 #include <axis2_ctx.h>
 
-/******************************************************************************/
 long AXIS2_CALL
 sandesha2_seq_mgr_get_last_activated_time(
     const axutil_env_t *env,
     axis2_char_t *property_key,
     sandesha2_seq_property_mgr_t *seq_prop_mgr);
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-sandesha2_seq_mgr_update_client_side_listener_if_needed(
-    const axutil_env_t *env,
-    axis2_msg_ctx_t *msg_ctx, 
-    axis2_char_t *addr_anon_uri);
-/******************************************************************************/
-
 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-sandesha2_seq_mgr_setup_new_seq(
+sandesha2_seq_mgr_setup_new_rmd_sequence(
     const axutil_env_t *env,
     sandesha2_msg_ctx_t *create_seq_msg, 
     sandesha2_seq_property_mgr_t *seq_prop_mgr,
     sandesha2_next_msg_mgr_t *next_msg_mgr)
 {
-    axis2_char_t *seq_id = NULL;
+    axis2_char_t *rmd_sequence_id = NULL;
     axis2_endpoint_ref_t *to = NULL;
     axis2_endpoint_ref_t *reply_to = NULL;
     axis2_endpoint_ref_t *acks_to = NULL;
@@ -84,121 +76,171 @@
     axis2_char_t *spec_version = NULL;
     axis2_char_t *address = NULL;
     axis2_char_t *reply_to_addr = NULL;
-    axis2_char_t *internal_seq_id = NULL;
 
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, 
-        "[sandesha2]Entry:sandesha2_seq_mgr_setup_new_seq");
-    seq_id = axutil_uuid_gen(env);
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Entry:sandesha2_seq_mgr_setup_new_rmd_sequence");
+
+    rmd_sequence_id = axutil_uuid_gen(env);
     to = sandesha2_msg_ctx_get_to(create_seq_msg, env);
     if(!to)
     {
-        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "To is NULL");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "To is NULL");
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_TO_IS_NULL, AXIS2_FAILURE);
         return NULL; 
     }
+
     reply_to = sandesha2_msg_ctx_get_reply_to(create_seq_msg, env);
     create_seq = sandesha2_msg_ctx_get_create_seq(create_seq_msg, env);
     if(!create_seq)
     {
-        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Create Sequence Part is NULL");
-        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CREATE_SEQ_PART_IS_NULL, 
-                AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Create Sequence Part is NULL");
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CREATE_SEQ_PART_IS_NULL, AXIS2_FAILURE);
         return NULL; 
     }
+
     temp_acks_to = sandesha2_create_seq_get_acks_to(create_seq, env);
     temp_address = sandesha2_acks_to_get_address(temp_acks_to, env);
     acks_to = sandesha2_address_get_epr(temp_address, env);
     if(!acks_to)
     {
-        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Acks To is NULL");
-        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_ACKS_TO_IS_NULL, 
-                AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Acks To is NULL");
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_ACKS_TO_IS_NULL, AXIS2_FAILURE);
         return NULL; 
     }
+
     msg_ctx = sandesha2_msg_ctx_get_msg_ctx(create_seq_msg, env);
     conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
-    received_msg_bean = sandesha2_seq_property_bean_create_with_data(env, seq_id, 
-            SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES, "");
+
     /* Setting the addressing version */
     addressing_ns_value = sandesha2_msg_ctx_get_addr_ns_val(create_seq_msg, env);
-    addressing_ns_bean = sandesha2_seq_property_bean_create_with_data(env, seq_id, 
+    addressing_ns_bean = sandesha2_seq_property_bean_create_with_data(env, rmd_sequence_id, 
             SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE, addressing_ns_value);
-    sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, addressing_ns_bean);
-    anonymous_uri = sandesha2_spec_specific_consts_get_anon_uri(env, 
-            addressing_ns_value); 
+    if(addressing_ns_bean)
+    {
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, addressing_ns_bean);
+        sandesha2_seq_property_bean_free(addressing_ns_bean, env);
+    }
+    anonymous_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addressing_ns_value); 
+
     /* If no replyTo value. Send responses as sync. */
     if(reply_to)
     {
         reply_to_addr = (axis2_char_t*)axis2_endpoint_ref_get_address(reply_to, env);
-        to_bean = sandesha2_seq_property_bean_create_with_data(env, seq_id, 
+        to_bean = sandesha2_seq_property_bean_create_with_data(env, rmd_sequence_id, 
                 SANDESHA2_SEQ_PROP_TO_EPR, reply_to_addr);
     }
     else
     {
-        to_bean = sandesha2_seq_property_bean_create_with_data(env, seq_id, 
+        to_bean = sandesha2_seq_property_bean_create_with_data(env, rmd_sequence_id, 
                 SANDESHA2_SEQ_PROP_TO_EPR, anonymous_uri);
     }
+
+    if(to_bean)
+    {
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, to_bean);
+        sandesha2_seq_property_bean_free(to_bean, env);
+    }
+
     address = (axis2_char_t*)axis2_endpoint_ref_get_address(to, env);
-    reply_to_bean = sandesha2_seq_property_bean_create_with_data(env, seq_id, 
+    reply_to_bean = sandesha2_seq_property_bean_create_with_data(env, rmd_sequence_id, 
         SANDESHA2_SEQ_PROP_REPLY_TO_EPR, address);
+    if(reply_to_bean)
+    {
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, reply_to_bean);
+        sandesha2_seq_property_bean_free(reply_to_bean, env);
+    }
+
     address = (axis2_char_t*)axis2_endpoint_ref_get_address(acks_to, env);
-    acks_to_bean = sandesha2_seq_property_bean_create_with_data(env, seq_id, 
+    acks_to_bean = sandesha2_seq_property_bean_create_with_data(env, rmd_sequence_id, 
         SANDESHA2_SEQ_PROP_ACKS_TO_EPR, address);
-    sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, received_msg_bean);
-    sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, reply_to_bean);
-    sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, acks_to_bean);
-    if(to_bean)
+
+    if(acks_to_bean)
     {
-        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, to_bean);
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, acks_to_bean);
+        sandesha2_seq_property_bean_free(acks_to_bean, env);
+    }
+
+    received_msg_bean = sandesha2_seq_property_bean_create_with_data(env, rmd_sequence_id, 
+            SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES, "");
+    if(received_msg_bean)
+    {
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, received_msg_bean);
+        sandesha2_seq_property_bean_free(received_msg_bean, env);
     }
-    next_msg_bean = sandesha2_next_msg_bean_create_with_data(env, seq_id, 1); 
+
+
+    next_msg_bean = sandesha2_next_msg_bean_create_with_data(env, rmd_sequence_id, 1); 
                                                     /* 1 will be the next */
-    internal_seq_id = sandesha2_utils_get_outgoing_internal_seq_id(env, seq_id);
-    sandesha2_next_msg_bean_set_internal_seq_id(next_msg_bean, env, 
-        internal_seq_id);
-    sandesha2_next_msg_mgr_insert(next_msg_mgr, env, next_msg_bean);
+    if(next_msg_bean)
+    {
+        axis2_char_t *internal_sequence_id = NULL;
+
+        internal_sequence_id = sandesha2_utils_get_internal_sequence_id(env, rmd_sequence_id);
+        if(internal_sequence_id)
+        {
+            sandesha2_next_msg_bean_set_internal_seq_id(next_msg_bean, env, internal_sequence_id);
+            AXIS2_FREE(env->allocator, internal_sequence_id);
+        }
+
+        sandesha2_next_msg_mgr_insert(next_msg_mgr, env, next_msg_bean);
+        sandesha2_next_msg_bean_free(next_msg_bean, env);
+    }
 
     /* Message to invoke. This will apply for only in-order invocations */
-    /*if(!axis2_msg_ctx_get_server_side(msg_ctx, env) || 
-        !sandesha2_utils_is_anon_uri(env, reply_to_addr))
-            sandesha2_utils_start_sender_for_seq(env, conf_ctx, seq_id);*/
+    /*if(!axis2_msg_ctx_get_server_side(msg_ctx, env) || !sandesha2_utils_is_anon_uri(env, 
+     * reply_to_addr))
+     * {
+     *   sandesha2_utils_start_sender_for_seq(env, conf_ctx, rmd_sequence_id);
+     *}*/
+
     /* Setting the RM Spec version for this sequence */
-    create_seq_msg_action = sandesha2_msg_ctx_get_wsa_action(create_seq_msg, 
-        env);
-    if(create_seq_msg_action == NULL)
+    create_seq_msg_action = sandesha2_msg_ctx_get_wsa_action(create_seq_msg, env);
+    if(!create_seq_msg_action)
     {
-        AXIS2_ERROR_SET(env->error, 
-            SANDESHA2_ERROR_CREATE_SEQ_MSG_DOES_NOT_HAVE_WSA_ACTION_VALUE, 
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CREATE_SEQ_MSG_DOES_NOT_HAVE_WSA_ACTION_VALUE, 
             AXIS2_FAILURE);
+
         return NULL;
     }
+
     msg_rm_ns = sandesha2_create_seq_get_namespace_value(create_seq, env);
-    if(0 == axutil_strcmp(SANDESHA2_SPEC_2005_02_NS_URI, msg_rm_ns))
+
+    if(!axutil_strcmp(SANDESHA2_SPEC_2005_02_NS_URI, msg_rm_ns))
     {
         spec_version = axutil_strdup(env, SANDESHA2_SPEC_VERSION_1_0);
     }
-    else if(0 == axutil_strcmp(SANDESHA2_SPEC_2006_08_NS_URI, msg_rm_ns))
+    else if(!axutil_strcmp(SANDESHA2_SPEC_2007_02_NS_URI, msg_rm_ns))
     {
         spec_version = axutil_strdup(env, SANDESHA2_SPEC_VERSION_1_1);
     }
     else
     {
-        AXIS2_ERROR_SET(env->error, 
-            SANDESHA2_ERROR_CREATE_SEQ_MSG_DOES_NOT_HAVE_VALID_RM_NS_VALUE,
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CREATE_SEQ_MSG_DOES_NOT_HAVE_VALID_RM_NS_VALUE,
             AXIS2_FAILURE);
+
         return NULL;
     }
+
     spec_version_bean = sandesha2_seq_property_bean_create(env);
-    sandesha2_seq_property_bean_set_seq_id(spec_version_bean, env, seq_id);
-    sandesha2_seq_property_bean_set_name(spec_version_bean, env, 
-            SANDESHA2_SEQ_PROP_RM_SPEC_VERSION);
-    sandesha2_seq_property_bean_set_value(spec_version_bean, env, spec_version);
+    if(spec_version_bean)
+    {
+        sandesha2_seq_property_bean_set_seq_id(spec_version_bean, env, rmd_sequence_id);
+        sandesha2_seq_property_bean_set_name(spec_version_bean, env, SANDESHA2_SEQ_PROP_RM_SPEC_VERSION);
+        sandesha2_seq_property_bean_set_value(spec_version_bean, env, spec_version);
    
-    sandesha2_seq_property_mgr_insert(seq_prop_mgr,env, spec_version_bean);
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr,env, spec_version_bean);
+        sandesha2_seq_property_bean_free(spec_version_bean, env);
+    }
+
+    if(spec_version)
+    {
+        AXIS2_FREE(env->allocator, spec_version);
+    }
+
     /* TODO Get the SOAP version from the creaet sequence message */
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, 
-        "[sandesha2]Entry:sandesha2_seq_mgr_setup_new_seq");
-    return seq_id;
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Entry:sandesha2_seq_mgr_setup_new_rmd_sequence");
+
+    return rmd_sequence_id;
 }
        
 /**
@@ -219,15 +261,16 @@
     
     last_activated_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, 
             property_key, SANDESHA2_SEQ_PROP_LAST_ACTIVATED_TIME);
+
     if(!last_activated_bean)
     {
         added = AXIS2_TRUE;
         last_activated_bean = sandesha2_seq_property_bean_create(env);
-        sandesha2_seq_property_bean_set_seq_id(last_activated_bean, env, 
-                property_key);
+        sandesha2_seq_property_bean_set_seq_id(last_activated_bean, env, property_key);
         sandesha2_seq_property_bean_set_name(last_activated_bean, env, 
                 SANDESHA2_SEQ_PROP_LAST_ACTIVATED_TIME);
     }
+
     current_time = sandesha2_utils_get_current_time_in_millis(env);
     sprintf(current_time_str, "%ld", current_time);
     sandesha2_seq_property_bean_set_value(last_activated_bean, env, current_time_str); 
@@ -250,7 +293,6 @@
 sandesha2_seq_mgr_has_seq_timedout(
     const axutil_env_t *env,
     axis2_char_t *property_key,
-    sandesha2_msg_ctx_t *rm_msg_ctx,
     sandesha2_seq_property_mgr_t *seq_prop_mgr,
     axis2_conf_ctx_t *conf_ctx)
 {
@@ -260,42 +302,35 @@
     long current_time = -1;
     long timeout_interval = -1;
     
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, 
-        "[sandesha2]Entry:sandesha2_seq_mgr_has_seq_timedout");
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_seq_mgr_has_seq_timedout");
+
     AXIS2_PARAM_CHECK(env->error, property_key, AXIS2_FALSE);
-    AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FALSE);
     AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, AXIS2_FALSE);
     
-    /* Avoid retrieving property bean from operation until it is availbale */
-    /*property_bean = sandesha2_utils_get_property_bean_from_op(env, 
-        axis2_msg_ctx_get_op(sandesha2_msg_ctx_get_msg_ctx(
-        rm_msg_ctx, env), env));*/
-    property_bean = sandesha2_utils_get_property_bean(env, 
-        axis2_conf_ctx_get_conf(conf_ctx, env));
-    timeout_interval = sandesha2_property_bean_get_inactive_timeout_interval(
-        property_bean, env);
+    property_bean = sandesha2_utils_get_property_bean(env, axis2_conf_ctx_get_conf(conf_ctx, env));
+    timeout_interval = sandesha2_property_bean_get_inactive_timeout_interval(property_bean, env);
     if(timeout_interval <= 0)
+    {
         return AXIS2_FALSE;
-    last_activated_time = sandesha2_seq_mgr_get_last_activated_time(env, 
-        property_key, seq_prop_mgr);
+    }
+
+    last_activated_time = sandesha2_seq_mgr_get_last_activated_time(env, property_key, seq_prop_mgr);
     current_time = sandesha2_utils_get_current_time_in_millis(env);
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]timeout_interval:%ld", 
-        timeout_interval);
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]last_activated_time:%ld", 
-        last_activated_time);
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]current_time:%ld", 
-        current_time);
-    if(last_activated_time > 0 && ((last_activated_time + timeout_interval) < 
-        current_time))
+
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]timeout_interval:%ld", timeout_interval);
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]last_activated_time:%ld", last_activated_time);
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]current_time:%ld", current_time);
+
+    if(last_activated_time > 0 && ((last_activated_time + timeout_interval) < current_time))
     {
         seq_timedout = AXIS2_TRUE;
     }
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, 
-        "[sandesha2]Exit:sandesha2_seq_mgr_has_seq_timedout");
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Exit:sandesha2_seq_mgr_has_seq_timedout");
+
     return seq_timedout;
 }
 
-
 long AXIS2_CALL
 sandesha2_seq_mgr_get_last_activated_time(
     const axutil_env_t *env,
@@ -323,13 +358,12 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-sandesha2_seq_mgr_setup_new_client_seq(
+sandesha2_seq_mgr_setup_new_rms_sequence(
     const axutil_env_t *env,
     axis2_msg_ctx_t *first_app_msg,
-    axis2_char_t *int_seq_id,
+    axis2_char_t *internal_sequence_id,
     axis2_char_t *spec_version,
-    sandesha2_seq_property_mgr_t *seq_prop_mgr,
-    const axis2_bool_t persistent)
+    sandesha2_seq_property_mgr_t *seq_prop_mgr)
 {
     axis2_conf_ctx_t *conf_ctx = NULL;
     axis2_char_t *addr_ns_val = NULL;
@@ -341,21 +375,16 @@
     sandesha2_seq_property_bean_t *to_bean = NULL;
     sandesha2_seq_property_bean_t *reply_to_bean = NULL;
     sandesha2_seq_property_bean_t *acks_to_bean = NULL;
-    axis2_ctx_t *ctx = NULL;
-    /*axis2_options_t *options = NULL;*/
-    AXIS2_TRANSPORT_ENUMS transport_in_protocol = -1;
-    axis2_listener_manager_t *listener_manager = NULL;
     sandesha2_seq_property_bean_t *msgs_bean = NULL;
     axis2_char_t *transport_to = NULL;
     sandesha2_seq_property_bean_t *spec_version_bean = NULL;
     axis2_endpoint_ref_t *reply_to_epr = NULL;
-    axis2_char_t *addr = NULL;
-    axis2_endpoint_ref_t *epr = NULL;
+    axis2_bool_t is_svr_side = AXIS2_FALSE;
    
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, 
-        "Entry:sandesha2_seq_mgr_setup_new_client_seq");
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:sandesha2_seq_mgr_setup_new_rms_sequence");
+
     AXIS2_PARAM_CHECK(env->error, first_app_msg, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, int_seq_id, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, internal_sequence_id, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, spec_version, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, AXIS2_FAILURE);
     
@@ -363,194 +392,164 @@
     
     property = axis2_msg_ctx_get_property(first_app_msg, env, AXIS2_WSA_VERSION);
     if(property)
+    {
         addr_ns_val = axutil_property_get_value(property, env);
+    }
+
     if(!addr_ns_val)
     {
         axis2_op_ctx_t *op_ctx = NULL;
         axis2_msg_ctx_t *req_msg_ctx = NULL;
+
         op_ctx = axis2_msg_ctx_get_op_ctx(first_app_msg, env);
-        req_msg_ctx =  axis2_op_ctx_get_msg_ctx(op_ctx, env, 
-            AXIS2_WSDL_MESSAGE_LABEL_IN);
+        req_msg_ctx =  axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
+
         if(req_msg_ctx)
         {
-            property = axis2_msg_ctx_get_property(req_msg_ctx, env, 
-                        AXIS2_WSA_VERSION);
+            property = axis2_msg_ctx_get_property(req_msg_ctx, env, AXIS2_WSA_VERSION);
             if(property)
+            {
                 addr_ns_val = axutil_property_get_value(property, env);
+            }
         }
     }
+
     if(!addr_ns_val)
+    {
         addr_ns_val = AXIS2_WSA_NAMESPACE;
+    }
         
-    addr_ns_bean = sandesha2_seq_property_bean_create_with_data(env, 
-                        int_seq_id, 
-                        SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE,
-                        addr_ns_val);
+    addr_ns_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, 
+            SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE, addr_ns_val);
+
     sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, addr_ns_bean);
+    if(addr_ns_bean)
+    {
+        sandesha2_seq_property_bean_free(addr_ns_bean, env);
+    }
+
     anon_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addr_ns_val);
     
     to_epr = axis2_msg_ctx_get_to(first_app_msg, env);
-    property = axis2_msg_ctx_get_property(first_app_msg, env, 
-                        SANDESHA2_CLIENT_ACKS_TO);
+    property = axis2_msg_ctx_get_property(first_app_msg, env, SANDESHA2_CLIENT_ACKS_TO);
     if(property)
-        acks_to_str = axutil_property_get_value(property, env);
-    /*if(!to_epr)
     {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] WSA To is NULL");
-        return AXIS2_FAILURE;
-    }*/
-   
+        acks_to_str = axutil_property_get_value(property, env);
+    }
+
     if (to_epr)
     {
-        to_bean = sandesha2_seq_property_bean_create_with_data(env, int_seq_id,
-                       SANDESHA2_SEQ_PROP_TO_EPR, 
-                       (axis2_char_t*)axis2_endpoint_ref_get_address(to_epr, 
+        to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, 
+                SANDESHA2_SEQ_PROP_TO_EPR, (axis2_char_t*)axis2_endpoint_ref_get_address(to_epr, 
                        env));
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, to_bean);
+        sandesha2_seq_property_bean_free(to_bean, env);
     }
     
-    if(axis2_msg_ctx_get_server_side(first_app_msg, env))
+    is_svr_side = axis2_msg_ctx_get_server_side(first_app_msg, env);
+
+    if(is_svr_side)
     {
         axis2_op_ctx_t *op_ctx = NULL;
         axis2_msg_ctx_t *req_msg_ctx = NULL;
         
         op_ctx = axis2_msg_ctx_get_op_ctx(first_app_msg, env);
-        req_msg_ctx =  axis2_op_ctx_get_msg_ctx(op_ctx, env, 
-            AXIS2_WSDL_MESSAGE_LABEL_IN);
+
+        req_msg_ctx =  axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
         if(!req_msg_ctx)
         {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Cannot find"
-                        " the request message from the operation context");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
+                    "[sandesha2] Cannot find the request message from the operation context");
             return AXIS2_FAILURE;
         }
+
         reply_to_epr = axis2_msg_ctx_get_to(req_msg_ctx, env);
-        /*ctx = axis2_op_ctx_get_base(op_ctx, env);
-        property = axis2_ctx_get_property(ctx, env, 
-                SANDESHA2_SEQ_PROP_REPLY_TO_EPR, AXIS2_FALSE);
-        reply_to_epr = axutil_property_get_value(property, env);*/
+
         if(reply_to_epr)
-            reply_to_bean = sandesha2_seq_property_bean_create_with_data(env,
-                        int_seq_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR,
-                        (axis2_char_t*)axis2_endpoint_ref_get_address(
-                        reply_to_epr, env));
+        {
+            const axis2_char_t *temp_epr_addr = axis2_endpoint_ref_get_address(reply_to_epr, env);
+            
+            if(temp_epr_addr)
+            {
+                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "temp_epr_address:%s", temp_epr_addr);
+                acks_to_str = (axis2_char_t *) temp_epr_addr;
+                reply_to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, 
+                    SANDESHA2_SEQ_PROP_REPLY_TO_EPR, (axis2_char_t*) temp_epr_addr);
+                sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, reply_to_bean);
+                sandesha2_seq_property_bean_free(reply_to_bean, env);
+            }
+        }
         else
         {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Cannot get"\
-                " request message from the operation context");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
+                    "[sandesha2] Cannot get request message from the operation context");
+
             return AXIS2_FAILURE;
         }        
     }
-    else
+    else /* Not server side */
     {
         reply_to_epr = axis2_msg_ctx_get_reply_to(first_app_msg, env);
-        /* Set replyTo bean */
+
         if(reply_to_epr)
         {
-            reply_to_bean = sandesha2_seq_property_bean_create_with_data(env,
-                        int_seq_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR,
-                        (axis2_char_t*)axis2_endpoint_ref_get_address(
-                        reply_to_epr, env));
-
+            const axis2_char_t *temp_epr_addr = axis2_endpoint_ref_get_address(reply_to_epr, env);
+            if(temp_epr_addr)
+            {
+                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "temp_epr_address:%s", temp_epr_addr);
+                reply_to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, 
+                    SANDESHA2_SEQ_PROP_REPLY_TO_EPR, (axis2_char_t*) temp_epr_addr);
+                sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, reply_to_bean);
+                sandesha2_seq_property_bean_free(reply_to_bean, env);
+            }
         } 
     }
+
     if(!acks_to_str)
+    {
         acks_to_str = anon_uri;
-    
-    acks_to_bean = sandesha2_seq_property_bean_create_with_data(env,
-                        int_seq_id, SANDESHA2_SEQ_PROP_ACKS_TO_EPR,
-                        acks_to_str);
-    if(!axis2_msg_ctx_get_server_side(first_app_msg, env) && 
-        !sandesha2_utils_is_anon_uri(env, acks_to_str))
-    {
-        ctx = axis2_msg_ctx_get_base(first_app_msg, env);
-        /* TODO currently axis2 doesn't expose the *options* at msg ctx level.
-         * Once it is finished change to get from there
-         */
-        /*options = AXIS2_CTX_GET_OPTIONS(ctx, env);
-        transport_in_protocol = axis2_options_get_transport_in_protocol(options, env);*/
-        transport_in_protocol = AXIS2_TRANSPORT_ENUM_HTTP;
-            
-        axis2_listener_manager_make_sure_started(listener_manager, env, 
-                        transport_in_protocol, conf_ctx);
     }
     
-    msgs_bean = sandesha2_seq_property_bean_create_with_data(env, int_seq_id, 
+    acks_to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, 
+            SANDESHA2_SEQ_PROP_ACKS_TO_EPR, acks_to_str);
+
+    msgs_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, 
                         SANDESHA2_SEQ_PROP_CLIENT_COMPLETED_MESSAGES, "");
-    sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, msgs_bean);
-    if (to_bean)
+    if(msgs_bean)
     {
-        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, to_bean);
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, msgs_bean);
+        sandesha2_seq_property_bean_free(msgs_bean, env);
     }
     
     if(acks_to_bean)
+    {
         sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, acks_to_bean);
-    if(reply_to_bean)
-        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, reply_to_bean);
-        
-    
+        sandesha2_seq_property_bean_free(acks_to_bean, env);
+    }
+
     transport_to = axis2_msg_ctx_get_transport_url(first_app_msg, env);
     
     if(transport_to)
     {
         sandesha2_seq_property_bean_t *transport_to_bean = NULL;
-        transport_to_bean = sandesha2_seq_property_bean_create_with_data(env,
-                        int_seq_id, SANDESHA2_SEQ_PROP_TRANSPORT_TO,
-                        transport_to);
+        transport_to_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, 
+                SANDESHA2_SEQ_PROP_TRANSPORT_TO, transport_to);
+
         sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, transport_to_bean);
     }
-    spec_version_bean = sandesha2_seq_property_bean_create_with_data(env,
-                        int_seq_id, SANDESHA2_SEQ_PROP_RM_SPEC_VERSION,
-                        spec_version);
-    sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, spec_version_bean);
-    sandesha2_seq_mgr_update_last_activated_time(env, int_seq_id, seq_prop_mgr);
-    epr = axis2_msg_ctx_get_to(first_app_msg, env);
-    if(epr)
-        addr = (axis2_char_t*)axis2_endpoint_ref_get_address(
-            epr, env);
-    if(!axis2_msg_ctx_get_server_side(first_app_msg, env) ||
-        !sandesha2_utils_is_anon_uri(env, addr))
-    {
-        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
-            "[sandesha2] Calling function sandesha2_utils_start_sender_for_seq()");
-        sandesha2_utils_start_sender_for_seq(env, conf_ctx, int_seq_id, 
-            persistent);
-    }
-    sandesha2_seq_mgr_update_client_side_listener_if_needed(env, first_app_msg,
-        anon_uri);
-    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, 
-        "Exit:sandesha2_seq_mgr_setup_new_client_seq");
-    return AXIS2_SUCCESS;
-}
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-sandesha2_seq_mgr_update_client_side_listener_if_needed(
-    const axutil_env_t *env,
-    axis2_msg_ctx_t *msg_ctx, 
-    axis2_char_t *addr_anon_uri)
-{
-    axis2_char_t *transport_in_protocol = NULL;
-    axis2_ctx_t *ctx = NULL;
-    /*axis2_options_t *options = NULL;*/
-    axis2_char_t *acks_to = NULL;
-    axutil_property_t *property = NULL;
-    
-    AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, addr_anon_uri, AXIS2_FAILURE);
-    
-    if(!axis2_msg_ctx_get_server_side(msg_ctx, env))
-        return AXIS2_SUCCESS;
-    
-    ctx = axis2_msg_ctx_get_base(msg_ctx, env);
-    /* TODO currently axis2 doesn't expose the *options* at msg ctx level.
-     * Once it is finished change to get from there
-     */
-    /* options = AXIS2_CTX_GET_OPTIONS(ctx, env);
-    transport_in_protocol = axis2_options_get_transport_in_protocol(options, env);*/
-    transport_in_protocol = AXIS2_TRANSPORT_HTTP;
-    property = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_CLIENT_ACKS_TO);
-    if(property)
-        acks_to = axutil_property_get_value(property, env);
-    
-    
+    spec_version_bean = sandesha2_seq_property_bean_create_with_data(env, internal_sequence_id, 
+            SANDESHA2_SEQ_PROP_RM_SPEC_VERSION, spec_version);
+    if(spec_version_bean)
+    {
+        sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, spec_version_bean);
+        sandesha2_seq_property_bean_free(spec_version_bean, env);
+    }
+
+    sandesha2_seq_mgr_update_last_activated_time(env, internal_sequence_id, seq_prop_mgr);
+
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:sandesha2_seq_mgr_setup_new_rms_sequence");
+
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/sandesha/trunk/c/src/util/spec_specific_consts.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/spec_specific_consts.c?rev=690127&r1=690126&r2=690127&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/util/spec_specific_consts.c (original)
+++ webservices/sandesha/trunk/c/src/util/spec_specific_consts.c Thu Aug 28 23:56:29 2008
@@ -32,7 +32,7 @@
     {
         return SANDESHA2_SPEC_VERSION_1_0;
     }
-    else if(0 == axutil_strcmp(ns_val, SANDESHA2_SPEC_2006_08_NS_URI))
+    else if(0 == axutil_strcmp(ns_val, SANDESHA2_SPEC_2007_02_NS_URI))
     {
         return SANDESHA2_SPEC_VERSION_1_1;
     }
@@ -58,7 +58,7 @@
     }
     if(0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_ver))
     {
-        return SANDESHA2_SPEC_2006_08_NS_URI;
+        return SANDESHA2_SPEC_2007_02_NS_URI;
     }
     return NULL;
 }
@@ -125,7 +125,7 @@
     if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_0, spec_version)) 
         return SANDESHA2_SPEC_2005_02_ACTION_TERMINATE_SEQ;
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_TERMINATE_SEQ;
+        return SANDESHA2_SPEC_2007_02_ACTION_TERMINATE_SEQ;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);
@@ -142,7 +142,7 @@
         return SANDESHA2_SPEC_2005_02_ACTION_CREATE_SEQ;
     }
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_CREATE_SEQ;
+        return SANDESHA2_SPEC_2007_02_ACTION_CREATE_SEQ;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);
@@ -159,7 +159,7 @@
         return SANDESHA2_SPEC_2005_02_ACTION_CREATE_SEQ_RESPONSE;
     }
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_CREATE_SEQ_RESPONSE;
+        return SANDESHA2_SPEC_2007_02_ACTION_CREATE_SEQ_RESPONSE;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);
@@ -178,7 +178,7 @@
         return NULL;
     }
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_CLOSE_SEQ;
+        return SANDESHA2_SPEC_2007_02_ACTION_CLOSE_SEQ;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);
@@ -197,7 +197,7 @@
         return NULL;
     }
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_CLOSE_SEQ_RESPONSE;
+        return SANDESHA2_SPEC_2007_02_ACTION_CLOSE_SEQ_RESPONSE;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);
@@ -218,7 +218,7 @@
         return NULL;
     }
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_ACK_REQUEST;
+        return SANDESHA2_SPEC_2007_02_ACTION_ACK_REQUEST;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
             AXIS2_FAILURE);
@@ -268,7 +268,7 @@
     if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_0, spec_version)) 
         return SANDESHA2_SPEC_2005_02_SOAP_ACTION_TERMINATE_SEQ;
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_SOAP_ACTION_TERMINATE_SEQ;
+        return SANDESHA2_SPEC_2007_02_SOAP_ACTION_TERMINATE_SEQ;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);
@@ -289,7 +289,7 @@
     }
     else if(0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version))
     {
-        return SANDESHA2_SPEC_2006_08_SOAP_ACTION_ACK_REQUEST;
+        return SANDESHA2_SPEC_2007_02_SOAP_ACTION_ACK_REQUEST;
     }
     else
     {
@@ -323,11 +323,10 @@
         const axutil_env_t *env,
         axis2_char_t *spec_version)
 {
-    AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, spec_version, NULL);
     
     if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_TERMINATE_SEQ_RESPONSE;
+        return SANDESHA2_SPEC_2007_02_ACTION_TERMINATE_SEQ_RESPONSE;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);
@@ -345,7 +344,7 @@
         return SANDESHA2_SPEC_2005_02_ACTION_SEQ_ACKNOWLEDGEMENT;
     }
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_SEQ_ACKNOWLEDGEMENT;
+        return SANDESHA2_SPEC_2007_02_ACTION_SEQ_ACKNOWLEDGEMENT;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);
@@ -363,7 +362,7 @@
     }
     else if(0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version))
     {
-        return SANDESHA2_SPEC_2006_08_SOAP_ACTION_SEQ_ACKNOWLEDGEMENT;
+        return SANDESHA2_SPEC_2007_02_SOAP_ACTION_SEQ_ACKNOWLEDGEMENT;
     }
     else
     {
@@ -385,7 +384,7 @@
                 AXIS2_FAILURE);
     }
     else if (0 == axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) 
-        return SANDESHA2_SPEC_2006_08_ACTION_MAKE_CONNECTION;
+        return SANDESHA2_SPEC_2007_02_ACTION_MAKE_CONNECTION;
     else
         AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE, 
                 AXIS2_FAILURE);



---------------------------------------------------------------------
To unsubscribe, e-mail: sandesha-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: sandesha-dev-help@ws.apache.org


Mime
View raw message