axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r580289 [12/20] - in /webservices/axis2/trunk/c: guththila/include/ guththila/samples/ guththila/src/ guththila/tests/ neethi/include/ neethi/src/ neethi/src/secpolicy/builder/ neethi/src/secpolicy/model/ neethi/test/ samples/client/echo/ s...
Date Fri, 28 Sep 2007 10:29:43 GMT
Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/secpolicy.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/secpolicy.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/secpolicy.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/secpolicy.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,8 +16,6 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_secpolicy.h>
 
 struct rp_secpolicy_t
@@ -32,22 +31,23 @@
     rp_signed_encrypted_elements_t *signed_elements;
     rp_signed_encrypted_elements_t *encrypted_elements;
     rp_signed_encrypted_items_t *signed_items;
-    rp_signed_encrypted_items_t *encrypted_items;    
+    rp_signed_encrypted_items_t *encrypted_items;
     rp_rampart_config_t *rampart_config;
-    
+
 };
 
-AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL 
-rp_secpolicy_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL
+rp_secpolicy_create(
+    const axutil_env_t * env)
 {
     rp_secpolicy_t *secpolicy = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    secpolicy =  (rp_secpolicy_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (rp_secpolicy_t));
+    secpolicy = (rp_secpolicy_t *) AXIS2_MALLOC(env->allocator,
+                                                sizeof(rp_secpolicy_t));
 
-    if(secpolicy == NULL)
+    if (secpolicy == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -69,397 +69,401 @@
     return secpolicy;
 }
 
-AXIS2_EXTERN void AXIS2_CALL 
+AXIS2_EXTERN void AXIS2_CALL
 rp_secpolicy_free(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-    if(secpolicy)
+
+    if (secpolicy)
     {
-        if(secpolicy->binding)
+        if (secpolicy->binding)
         {
             rp_property_free(secpolicy->binding, env);
             secpolicy->binding = NULL;
         }
-        if(secpolicy->wss)
+        if (secpolicy->wss)
         {
-            rp_property_free(secpolicy->wss, env);            
+            rp_property_free(secpolicy->wss, env);
             secpolicy->wss = NULL;
         }
-        if(secpolicy->supporting_tokens)
+        if (secpolicy->supporting_tokens)
         {
             rp_supporting_tokens_free(secpolicy->supporting_tokens, env);
             secpolicy->supporting_tokens = NULL;
         }
-        if(secpolicy->signed_supporting_tokens)
+        if (secpolicy->signed_supporting_tokens)
         {
             rp_supporting_tokens_free(secpolicy->signed_supporting_tokens, env);
             secpolicy->signed_supporting_tokens = NULL;
         }
-        if(secpolicy->endorsing_supporting_tokens)
+        if (secpolicy->endorsing_supporting_tokens)
         {
-            rp_supporting_tokens_free(secpolicy->endorsing_supporting_tokens, env);
+            rp_supporting_tokens_free(secpolicy->endorsing_supporting_tokens,
+                                      env);
             secpolicy->endorsing_supporting_tokens = NULL;
         }
-        if(secpolicy->signed_endorsing_supporting_tokens)
+        if (secpolicy->signed_endorsing_supporting_tokens)
         {
-            rp_supporting_tokens_free(secpolicy->signed_endorsing_supporting_tokens, env);
+            rp_supporting_tokens_free(secpolicy->
+                                      signed_endorsing_supporting_tokens, env);
             secpolicy->signed_endorsing_supporting_tokens = NULL;
         }
-        if(secpolicy->signed_parts)
+        if (secpolicy->signed_parts)
         {
             rp_signed_encrypted_parts_free(secpolicy->signed_parts, env);
             secpolicy->signed_parts = NULL;
         }
-        if(secpolicy->encrypted_parts)
+        if (secpolicy->encrypted_parts)
         {
             rp_signed_encrypted_parts_free(secpolicy->encrypted_parts, env);
             secpolicy->encrypted_parts = NULL;
-        }            
-        if(secpolicy->signed_elements)
+        }
+        if (secpolicy->signed_elements)
         {
             rp_signed_encrypted_elements_free(secpolicy->signed_elements, env);
             secpolicy->signed_elements = NULL;
-        }            
-        if(secpolicy->encrypted_elements)
+        }
+        if (secpolicy->encrypted_elements)
         {
-            rp_signed_encrypted_elements_free(secpolicy->encrypted_elements, env);
+            rp_signed_encrypted_elements_free(secpolicy->encrypted_elements,
+                                              env);
             secpolicy->encrypted_elements = NULL;
         }
-        if(secpolicy->signed_items)
+        if (secpolicy->signed_items)
         {
             rp_signed_encrypted_items_free(secpolicy->signed_items, env);
             secpolicy->signed_items = NULL;
-        }            
-        if(secpolicy->encrypted_items)
+        }
+        if (secpolicy->encrypted_items)
         {
             rp_signed_encrypted_items_free(secpolicy->encrypted_items, env);
             secpolicy->encrypted_items = NULL;
         }
-        if(secpolicy->rampart_config)
+        if (secpolicy->rampart_config)
         {
             rp_rampart_config_free(secpolicy->rampart_config, env);
             secpolicy->rampart_config = NULL;
-        }            
-        AXIS2_FREE(env->allocator, secpolicy);           
+        }
+        AXIS2_FREE(env->allocator, secpolicy);
     }
 
     return;
 }
 
-
 /* Implementations */
 AXIS2_EXTERN rp_property_t *AXIS2_CALL
 rp_secpolicy_get_binding(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return secpolicy->binding;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_binding(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_property_t *binding)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_property_t * binding)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, binding, AXIS2_FAILURE);
     rp_property_increment_ref(binding, env);
-    secpolicy->binding = binding; 
+    secpolicy->binding = binding;
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_supporting_tokens(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_supporting_tokens_t *supporting_tokens)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_supporting_tokens_t * supporting_tokens)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,supporting_tokens,AXIS2_FAILURE);
-   
+    AXIS2_PARAM_CHECK(env->error, supporting_tokens, AXIS2_FAILURE);
+
     rp_supporting_tokens_increment_ref(supporting_tokens, env);
-    secpolicy->supporting_tokens = supporting_tokens; 
+    secpolicy->supporting_tokens = supporting_tokens;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
 rp_secpolicy_get_supporting_tokens(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return secpolicy->supporting_tokens;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_signed_supporting_tokens(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_supporting_tokens_t *signed_supporting_tokens)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_supporting_tokens_t * signed_supporting_tokens)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,signed_supporting_tokens,AXIS2_FAILURE);
-    
+    AXIS2_PARAM_CHECK(env->error, signed_supporting_tokens, AXIS2_FAILURE);
+
     rp_supporting_tokens_increment_ref(signed_supporting_tokens, env);
-    secpolicy->signed_supporting_tokens = signed_supporting_tokens; 
+    secpolicy->signed_supporting_tokens = signed_supporting_tokens;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
 rp_secpolicy_get_signed_supporting_tokens(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return secpolicy->signed_supporting_tokens;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_endorsing_supporting_tokens(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_supporting_tokens_t *endorsing_supporting_tokens)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_supporting_tokens_t * endorsing_supporting_tokens)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, endorsing_supporting_tokens, AXIS2_FAILURE);   
-    
+    AXIS2_PARAM_CHECK(env->error, endorsing_supporting_tokens, AXIS2_FAILURE);
+
     rp_supporting_tokens_increment_ref(endorsing_supporting_tokens, env);
-    secpolicy->endorsing_supporting_tokens = endorsing_supporting_tokens; 
+    secpolicy->endorsing_supporting_tokens = endorsing_supporting_tokens;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
 rp_secpolicy_get_endorsing_supporting_tokens(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return secpolicy->endorsing_supporting_tokens;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_signed_endorsing_supporting_tokens(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_supporting_tokens_t *signed_endorsing_supporting_tokens)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_supporting_tokens_t * signed_endorsing_supporting_tokens)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, signed_endorsing_supporting_tokens, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_endorsing_supporting_tokens,
+                      AXIS2_FAILURE);
 
     rp_supporting_tokens_increment_ref(signed_endorsing_supporting_tokens, env);
-    secpolicy->signed_endorsing_supporting_tokens = signed_endorsing_supporting_tokens; 
+    secpolicy->signed_endorsing_supporting_tokens =
+        signed_endorsing_supporting_tokens;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
 rp_secpolicy_get_signed_endorsing_supporting_tokens(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return secpolicy->signed_endorsing_supporting_tokens;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_signed_parts(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_signed_encrypted_parts_t *signed_parts)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_signed_encrypted_parts_t * signed_parts)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, signed_parts, AXIS2_FAILURE);    
+    AXIS2_PARAM_CHECK(env->error, signed_parts, AXIS2_FAILURE);
     rp_signed_encrypted_parts_increment_ref(signed_parts, env);
-    secpolicy->signed_parts = signed_parts; 
+    secpolicy->signed_parts = signed_parts;
 
     return AXIS2_SUCCESS;
-    
+
 }
 
 AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
 rp_secpolicy_get_signed_parts(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return secpolicy->signed_parts;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_encrypted_parts(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_signed_encrypted_parts_t *encrypted_parts)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_signed_encrypted_parts_t * encrypted_parts)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, encrypted_parts, AXIS2_FAILURE);    
+    AXIS2_PARAM_CHECK(env->error, encrypted_parts, AXIS2_FAILURE);
 
     rp_signed_encrypted_parts_increment_ref(encrypted_parts, env);
-    secpolicy->encrypted_parts = encrypted_parts; 
+    secpolicy->encrypted_parts = encrypted_parts;
     return AXIS2_SUCCESS;
-    
+
 }
 
 AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
 rp_secpolicy_get_encrypted_parts(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return secpolicy->encrypted_parts;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_signed_elements(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_signed_encrypted_elements_t *signed_elements)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_signed_encrypted_elements_t * signed_elements)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, signed_elements, AXIS2_FAILURE);
 
     rp_signed_encrypted_elements_increment_ref(signed_elements, env);
-    secpolicy->signed_elements = signed_elements; 
+    secpolicy->signed_elements = signed_elements;
     return AXIS2_SUCCESS;
-    
+
 }
 
 AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL
 rp_secpolicy_get_signed_elements(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return secpolicy->signed_elements;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_encrypted_elements(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_signed_encrypted_elements_t *encrypted_elements)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_signed_encrypted_elements_t * encrypted_elements)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, encrypted_elements, AXIS2_FAILURE);   
+    AXIS2_PARAM_CHECK(env->error, encrypted_elements, AXIS2_FAILURE);
 
     rp_signed_encrypted_elements_increment_ref(encrypted_elements, env);
-    secpolicy->encrypted_elements = encrypted_elements; 
+    secpolicy->encrypted_elements = encrypted_elements;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL
 rp_secpolicy_get_encrypted_elements(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return secpolicy->encrypted_elements;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_signed_items(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_signed_encrypted_items_t *signed_items)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_signed_encrypted_items_t * signed_items)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,signed_items,AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_items, AXIS2_FAILURE);
 
-    secpolicy->signed_items = signed_items; 
+    secpolicy->signed_items = signed_items;
     return AXIS2_SUCCESS;
-    
+
 }
 
 AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL
 rp_secpolicy_get_signed_items(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return secpolicy->signed_items;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_encrypted_items(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_signed_encrypted_items_t *encrypted_items)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_signed_encrypted_items_t * encrypted_items)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,encrypted_items,AXIS2_FAILURE);   
+    AXIS2_PARAM_CHECK(env->error, encrypted_items, AXIS2_FAILURE);
 
-    secpolicy->encrypted_items = encrypted_items; 
+    secpolicy->encrypted_items = encrypted_items;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL
 rp_secpolicy_get_encrypted_items(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return secpolicy->encrypted_items;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_wss(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_property_t *wss)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_property_t * wss)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, wss, AXIS2_FAILURE);
-    
+
     rp_property_increment_ref(wss, env);
-    secpolicy->wss = wss; 
+    secpolicy->wss = wss;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_property_t *AXIS2_CALL
 rp_secpolicy_get_wss(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return secpolicy->wss;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_secpolicy_set_rampart_config(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env,
-    rp_rampart_config_t *rampart_config)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env,
+    rp_rampart_config_t * rampart_config)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, rampart_config, AXIS2_FAILURE);   
-    
+    AXIS2_PARAM_CHECK(env->error, rampart_config, AXIS2_FAILURE);
+
     rp_rampart_config_increment_ref(rampart_config, env);
-    secpolicy->rampart_config = rampart_config; 
+    secpolicy->rampart_config = rampart_config;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_rampart_config_t *AXIS2_CALL
 rp_secpolicy_get_rampart_config(
-    rp_secpolicy_t *secpolicy,
-    const axutil_env_t *env)
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return secpolicy->rampart_config;
 }

Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/security_context_token.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/security_context_token.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/security_context_token.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/security_context_token.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,8 +16,6 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_security_context_token.h>
 
 struct rp_security_context_token_t
@@ -28,17 +27,20 @@
     int ref;
 };
 
-AXIS2_EXTERN rp_security_context_token_t *AXIS2_CALL 
-rp_security_context_token_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_security_context_token_t *AXIS2_CALL
+rp_security_context_token_create(
+    const axutil_env_t * env)
 {
     rp_security_context_token_t *security_context_token = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    security_context_token =  (rp_security_context_token_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (rp_security_context_token_t));
+    security_context_token =
+        (rp_security_context_token_t *) AXIS2_MALLOC(env->allocator,
+                                                     sizeof
+                                                     (rp_security_context_token_t));
 
-    if(security_context_token == NULL)
+    if (security_context_token == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -53,66 +55,65 @@
 
 }
 
-AXIS2_EXTERN void AXIS2_CALL 
+AXIS2_EXTERN void AXIS2_CALL
 rp_security_context_token_free(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env)
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-    if(security_context_token)
+
+    if (security_context_token)
     {
         if (--(security_context_token->ref) > 0)
         {
             return;
         }
-        
+
         AXIS2_FREE(env->allocator, security_context_token);
         security_context_token = NULL;
     }
     return;
 }
 
-
 /* Implementations */
 
-AXIS2_EXTERN axis2_char_t *AXIS2_CALL 
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
 rp_security_context_token_get_inclusion(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env)
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return security_context_token->inclusion;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_security_context_token_set_inclusion(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env,
-    axis2_char_t *inclusion)
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env,
+    axis2_char_t * inclusion)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, inclusion, AXIS2_FAILURE);    
+    AXIS2_PARAM_CHECK(env->error, inclusion, AXIS2_FAILURE);
 
     security_context_token->inclusion = inclusion;
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
 rp_security_context_token_get_derivedkeys(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env)
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return security_context_token->derivedkeys;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_security_context_token_set_derivedkeys(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env,
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env,
     axis2_bool_t derivedkeys)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -122,63 +123,61 @@
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
 rp_security_context_token_get_require_external_uri_ref(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env)
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return security_context_token->require_external_uri_ref;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_security_context_token_set_require_external_uri_ref(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env,
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env,
     axis2_bool_t require_external_uri_ref)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, require_external_uri_ref, AXIS2_FAILURE);
 
-    security_context_token->require_external_uri_ref = 
-            require_external_uri_ref;
+    security_context_token->require_external_uri_ref = require_external_uri_ref;
 
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
 rp_security_context_token_get_sc10_security_context_token(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env)
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return security_context_token->require_external_uri_ref;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_security_context_token_set_sc10_security_context_token(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env,
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env,
     axis2_bool_t sc10_security_context_token)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, sc10_security_context_token, AXIS2_FAILURE);
 
-    security_context_token->sc10_security_context_token = 
-            sc10_security_context_token;
+    security_context_token->sc10_security_context_token =
+        sc10_security_context_token;
 
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_security_context_token_increment_ref(
-    rp_security_context_token_t *security_context_token,
-    const axutil_env_t *env)
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     security_context_token->ref++;
     return AXIS2_SUCCESS;
 }
-

Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_elements.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_elements.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_elements.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_elements.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,8 +16,6 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_signed_encrypted_elements.h>
 
 struct rp_signed_encrypted_elements_t
@@ -28,31 +27,35 @@
 
 };
 
-AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL 
-rp_signed_encrypted_elements_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL
+rp_signed_encrypted_elements_create(
+    const axutil_env_t * env)
 {
     rp_signed_encrypted_elements_t *signed_encrypted_elements = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    signed_encrypted_elements =  (rp_signed_encrypted_elements_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (rp_signed_encrypted_elements_t));
+    signed_encrypted_elements =
+        (rp_signed_encrypted_elements_t *) AXIS2_MALLOC(env->allocator,
+                                                        sizeof
+                                                        (rp_signed_encrypted_elements_t));
 
-    if(signed_encrypted_elements == NULL)
+    if (signed_encrypted_elements == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     signed_encrypted_elements->xpath_expressions = NULL;
 
-    signed_encrypted_elements->xpath_expressions = axutil_array_list_create(env, 0);
+    signed_encrypted_elements->xpath_expressions =
+        axutil_array_list_create(env, 0);
     if (!(signed_encrypted_elements->xpath_expressions))
     {
         rp_signed_encrypted_elements_free(signed_encrypted_elements, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    
+
     signed_encrypted_elements->xpath_version = NULL;
     signed_encrypted_elements->ref = 0;
 
@@ -60,62 +63,68 @@
 
 }
 
-AXIS2_EXTERN void AXIS2_CALL 
-rp_signed_encrypted_elements_free(rp_signed_encrypted_elements_t *signed_encrypted_elements,
-        const axutil_env_t *env)
+AXIS2_EXTERN void AXIS2_CALL
+rp_signed_encrypted_elements_free(
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-    if(signed_encrypted_elements)
+
+    if (signed_encrypted_elements)
     {
         if (--(signed_encrypted_elements->ref) > 0)
         {
             return;
         }
-        
-        if(signed_encrypted_elements->xpath_expressions)
+
+        if (signed_encrypted_elements->xpath_expressions)
         {
             int i = 0;
-            for (i = 0; i < axutil_array_list_size(signed_encrypted_elements->xpath_expressions,
-                env); i++)
+            for (i = 0;
+                 i <
+                 axutil_array_list_size(signed_encrypted_elements->
+                                        xpath_expressions, env); i++)
             {
                 axis2_char_t *expression = NULL;
                 expression = (axis2_char_t *)
-                    axutil_array_list_get(signed_encrypted_elements->xpath_expressions,env, i);
+                    axutil_array_list_get(signed_encrypted_elements->
+                                          xpath_expressions, env, i);
                 if (expression)
-                    AXIS2_FREE(env->allocator,expression);
+                    AXIS2_FREE(env->allocator, expression);
 
                 expression = NULL;
             }
-            axutil_array_list_free(signed_encrypted_elements->xpath_expressions, env);
+            axutil_array_list_free(signed_encrypted_elements->xpath_expressions,
+                                   env);
             signed_encrypted_elements->xpath_expressions = NULL;
 
         }
-        AXIS2_FREE(env->allocator,signed_encrypted_elements);
+        AXIS2_FREE(env->allocator, signed_encrypted_elements);
         signed_encrypted_elements = NULL;
     }
     return;
 }
 
-
 /* Implementations */
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
-rp_signed_encrypted_elements_get_signedelements(rp_signed_encrypted_elements_t *signed_encrypted_elements,
-            const axutil_env_t *env)
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_signed_encrypted_elements_get_signedelements(
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-     return signed_encrypted_elements->signedelements;
+
+    return signed_encrypted_elements->signedelements;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-rp_signed_encrypted_elements_set_signedelements(rp_signed_encrypted_elements_t *signed_encrypted_elements,
-            const axutil_env_t *env,
-            axis2_bool_t signedelements)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_signed_encrypted_elements_set_signedelements(
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env,
+    axis2_bool_t signedelements)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,signedelements,AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signedelements, AXIS2_FAILURE);
 
     signed_encrypted_elements->signedelements = signedelements;
     return AXIS2_SUCCESS;
@@ -123,30 +132,32 @@
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
 rp_signed_encrypted_elements_get_xpath_expressions(
-    rp_signed_encrypted_elements_t *signed_encrypted_elements,
-    const axutil_env_t *env)
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return signed_encrypted_elements->xpath_expressions;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-rp_signed_encrypted_elements_add_expression(rp_signed_encrypted_elements_t *signed_encrypted_elements,
-            const axutil_env_t *env,
-            axis2_char_t *expression)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_signed_encrypted_elements_add_expression(
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env,
+    axis2_char_t * expression)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,expression,AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, expression, AXIS2_FAILURE);
 
-    axutil_array_list_add(signed_encrypted_elements->xpath_expressions,env,expression);    
+    axutil_array_list_add(signed_encrypted_elements->xpath_expressions, env,
+                          expression);
     return AXIS2_SUCCESS;
 }
 
-
 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-rp_signed_encrypted_elements_get_xpath_version(rp_signed_encrypted_elements_t *signed_encrypted_elements,
-            const axutil_env_t *env)
+rp_signed_encrypted_elements_get_xpath_version(
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
@@ -154,13 +165,14 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-rp_signed_encrypted_elements_set_xpath_version(rp_signed_encrypted_elements_t *signed_encrypted_elements,
-            const axutil_env_t *env,
-            axis2_char_t *xpath_version)
+rp_signed_encrypted_elements_set_xpath_version(
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env,
+    axis2_char_t * xpath_version)
 {
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,xpath_version,AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, xpath_version, AXIS2_FAILURE);
 
     signed_encrypted_elements->xpath_version = xpath_version;
     return AXIS2_SUCCESS;
@@ -168,11 +180,10 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_signed_encrypted_elements_increment_ref(
-    rp_signed_encrypted_elements_t *signed_encrypted_elements,
-    const axutil_env_t *env)
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     signed_encrypted_elements->ref++;
     return AXIS2_SUCCESS;
 }
-

Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_items.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_items.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_items.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_items.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,8 +16,6 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_signed_encrypted_items.h>
 
 struct rp_signed_encrypted_items_t
@@ -26,17 +25,20 @@
 
 };
 
-AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL 
-rp_signed_encrypted_items_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL
+rp_signed_encrypted_items_create(
+    const axutil_env_t * env)
 {
     rp_signed_encrypted_items_t *signed_encrypted_items = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    signed_encrypted_items =  (rp_signed_encrypted_items_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (rp_signed_encrypted_items_t));
+    signed_encrypted_items =
+        (rp_signed_encrypted_items_t *) AXIS2_MALLOC(env->allocator,
+                                                     sizeof
+                                                     (rp_signed_encrypted_items_t));
 
-    if(signed_encrypted_items == NULL)
+    if (signed_encrypted_items == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -44,7 +46,7 @@
     signed_encrypted_items->elements = NULL;
 
     signed_encrypted_items->elements = axutil_array_list_create(env, 0);
-    if (!(signed_encrypted_items->elements) )
+    if (!(signed_encrypted_items->elements))
     {
         rp_signed_encrypted_items_free(signed_encrypted_items, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -55,24 +57,27 @@
 
 }
 
-AXIS2_EXTERN void AXIS2_CALL 
-rp_signed_encrypted_items_free(rp_signed_encrypted_items_t *signed_encrypted_items,
-        const axutil_env_t *env)
+AXIS2_EXTERN void AXIS2_CALL
+rp_signed_encrypted_items_free(
+    rp_signed_encrypted_items_t * signed_encrypted_items,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-    if(signed_encrypted_items)
+
+    if (signed_encrypted_items)
     {
-        
-        if(signed_encrypted_items->elements)
+
+        if (signed_encrypted_items->elements)
         {
             int i = 0;
-            for (i = 0; i < axutil_array_list_size(signed_encrypted_items->elements,
-                env); i++)
+            for (i = 0;
+                 i < axutil_array_list_size(signed_encrypted_items->elements,
+                                            env); i++)
             {
                 rp_element_t *element = NULL;
                 element = (rp_element_t *)
-                    axutil_array_list_get(signed_encrypted_items->elements,env, i);
+                    axutil_array_list_get(signed_encrypted_items->elements, env,
+                                          i);
                 if (element)
                     rp_element_free(element, env);
 
@@ -82,31 +87,32 @@
             signed_encrypted_items->elements = NULL;
 
         }
-        AXIS2_FREE(env->allocator,signed_encrypted_items);
+        AXIS2_FREE(env->allocator, signed_encrypted_items);
         signed_encrypted_items = NULL;
     }
     return;
 }
 
-
 /* Implementations */
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
-rp_signed_encrypted_items_get_signeditems(rp_signed_encrypted_items_t *signed_encrypted_items,
-            const axutil_env_t *env)
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_signed_encrypted_items_get_signeditems(
+    rp_signed_encrypted_items_t * signed_encrypted_items,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return signed_encrypted_items->signeditems;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-rp_signed_encrypted_items_set_signeditems(rp_signed_encrypted_items_t *signed_encrypted_items,
-            const axutil_env_t *env,
-            axis2_bool_t signeditems)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_signed_encrypted_items_set_signeditems(
+    rp_signed_encrypted_items_t * signed_encrypted_items,
+    const axutil_env_t * env,
+    axis2_bool_t signeditems)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,signeditems,AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signeditems, AXIS2_FAILURE);
     signed_encrypted_items->signeditems = signeditems;
 
     return AXIS2_SUCCESS;
@@ -114,23 +120,23 @@
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
 rp_signed_encrypted_items_get_elements(
-    rp_signed_encrypted_items_t *signed_encrypted_items,
-    const axutil_env_t *env)
+    rp_signed_encrypted_items_t * signed_encrypted_items,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return signed_encrypted_items->elements;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-rp_signed_encrypted_items_add_element(rp_signed_encrypted_items_t *signed_encrypted_items,
-            const axutil_env_t *env,
-            rp_element_t *element)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_signed_encrypted_items_add_element(
+    rp_signed_encrypted_items_t * signed_encrypted_items,
+    const axutil_env_t * env,
+    rp_element_t * element)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,element,AXIS2_FAILURE);
-        
-    axutil_array_list_add(signed_encrypted_items->elements,env,element);    
+    AXIS2_PARAM_CHECK(env->error, element, AXIS2_FAILURE);
+
+    axutil_array_list_add(signed_encrypted_items->elements, env, element);
     return AXIS2_SUCCESS;
 }
-

Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_parts.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_parts.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_parts.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/signed_encrypted_parts.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,8 +16,6 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_signed_encrypted_parts.h>
 
 struct rp_signed_encrypted_parts_t
@@ -27,17 +26,20 @@
     int ref;
 };
 
-AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL 
-rp_signed_encrypted_parts_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
+rp_signed_encrypted_parts_create(
+    const axutil_env_t * env)
 {
     rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    signed_encrypted_parts =  (rp_signed_encrypted_parts_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (rp_signed_encrypted_parts_t));
+    signed_encrypted_parts =
+        (rp_signed_encrypted_parts_t *) AXIS2_MALLOC(env->allocator,
+                                                     sizeof
+                                                     (rp_signed_encrypted_parts_t));
 
-    if(signed_encrypted_parts == NULL)
+    if (signed_encrypted_parts == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -45,7 +47,7 @@
     signed_encrypted_parts->headers = NULL;
 
     signed_encrypted_parts->headers = axutil_array_list_create(env, 0);
-    if (!(signed_encrypted_parts->headers) )
+    if (!(signed_encrypted_parts->headers))
     {
         rp_signed_encrypted_parts_free(signed_encrypted_parts, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -60,27 +62,30 @@
 
 }
 
-AXIS2_EXTERN void AXIS2_CALL 
-rp_signed_encrypted_parts_free(rp_signed_encrypted_parts_t *signed_encrypted_parts,
-        const axutil_env_t *env)
+AXIS2_EXTERN void AXIS2_CALL
+rp_signed_encrypted_parts_free(
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-    if(signed_encrypted_parts)
+
+    if (signed_encrypted_parts)
     {
         if (--(signed_encrypted_parts->ref) > 0)
         {
             return;
         }
-        if(signed_encrypted_parts->headers)
+        if (signed_encrypted_parts->headers)
         {
             int i = 0;
-            for (i = 0; i < axutil_array_list_size(signed_encrypted_parts->headers,
-                env); i++)
+            for (i = 0;
+                 i < axutil_array_list_size(signed_encrypted_parts->headers,
+                                            env); i++)
             {
                 rp_header_t *header = NULL;
                 header = (rp_header_t *)
-                    axutil_array_list_get(signed_encrypted_parts->headers,env, i);
+                    axutil_array_list_get(signed_encrypted_parts->headers, env,
+                                          i);
                 if (header)
                     rp_header_free(header, env);
 
@@ -90,52 +95,55 @@
             signed_encrypted_parts->headers = NULL;
 
         }
-        AXIS2_FREE(env->allocator,signed_encrypted_parts);
+        AXIS2_FREE(env->allocator, signed_encrypted_parts);
         signed_encrypted_parts = NULL;
     }
     return;
 }
 
-
 /* Implementations */
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
-rp_signed_encrypted_parts_get_body(rp_signed_encrypted_parts_t *signed_encrypted_parts,
-            const axutil_env_t *env)
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_signed_encrypted_parts_get_body(
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return signed_encrypted_parts->body;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-rp_signed_encrypted_parts_set_body(rp_signed_encrypted_parts_t *signed_encrypted_parts,
-            const axutil_env_t *env,
-            axis2_bool_t body)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_signed_encrypted_parts_set_body(
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env,
+    axis2_bool_t body)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,body,AXIS2_FAILURE);    
+    AXIS2_PARAM_CHECK(env->error, body, AXIS2_FAILURE);
     signed_encrypted_parts->body = body;
 
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
-rp_signed_encrypted_parts_get_signedparts(rp_signed_encrypted_parts_t *signed_encrypted_parts,
-            const axutil_env_t *env)
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_signed_encrypted_parts_get_signedparts(
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return signed_encrypted_parts->signedparts;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-rp_signed_encrypted_parts_set_signedparts(rp_signed_encrypted_parts_t *signed_encrypted_parts,
-            const axutil_env_t *env,
-            axis2_bool_t signedparts)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_signed_encrypted_parts_set_signedparts(
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env,
+    axis2_bool_t signedparts)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    /*AXIS2_PARAM_CHECK(env->error,signedparts,AXIS2_FAILURE);*/
+    /*AXIS2_PARAM_CHECK(env->error,signedparts,AXIS2_FAILURE); */
     signed_encrypted_parts->signedparts = signedparts;
 
     return AXIS2_SUCCESS;
@@ -143,31 +151,31 @@
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
 rp_signed_encrypted_parts_get_headers(
-    rp_signed_encrypted_parts_t *signed_encrypted_parts,
-    const axutil_env_t *env)
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return signed_encrypted_parts->headers;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-rp_signed_encrypted_parts_add_header(rp_signed_encrypted_parts_t *signed_encrypted_parts,
-            const axutil_env_t *env,
-            rp_header_t *header)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_signed_encrypted_parts_add_header(
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env,
+    rp_header_t * header)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,header,AXIS2_FAILURE);
-        
-    axutil_array_list_add(signed_encrypted_parts->headers,env,header);    
+    AXIS2_PARAM_CHECK(env->error, header, AXIS2_FAILURE);
+
+    axutil_array_list_add(signed_encrypted_parts->headers, env, header);
     return AXIS2_SUCCESS;
 }
 
-
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_signed_encrypted_parts_increment_ref(
-    rp_signed_encrypted_parts_t *signed_encrypted_parts,
-    const axutil_env_t *env)
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     signed_encrypted_parts->ref++;

Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/supporting_tokens.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/supporting_tokens.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/supporting_tokens.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/supporting_tokens.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,8 +16,6 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_supporting_tokens.h>
 
 struct rp_supporting_tokens_t
@@ -31,30 +30,32 @@
     int ref;
 };
 
-AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL 
-rp_supporting_tokens_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
+rp_supporting_tokens_create(
+    const axutil_env_t * env)
 {
     rp_supporting_tokens_t *supporting_tokens = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    supporting_tokens =  (rp_supporting_tokens_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (rp_supporting_tokens_t));
+    supporting_tokens = (rp_supporting_tokens_t *) AXIS2_MALLOC(env->allocator,
+                                                                sizeof
+                                                                (rp_supporting_tokens_t));
 
-    if(supporting_tokens == NULL)
+    if (supporting_tokens == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     supporting_tokens->tokens = NULL;
-    supporting_tokens->tokens = axutil_array_list_create(env,0);
+    supporting_tokens->tokens = axutil_array_list_create(env, 0);
     if (!(supporting_tokens->tokens))
     {
         rp_supporting_tokens_free(supporting_tokens, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    
+
     supporting_tokens->algorithmsuite = NULL;
     supporting_tokens->signed_parts = NULL;
     supporting_tokens->signed_elements = NULL;
@@ -66,28 +67,29 @@
 }
 
 AXIS2_EXTERN void AXIS2_CALL
-rp_supporting_tokens_free(rp_supporting_tokens_t *supporting_tokens,
-        const axutil_env_t *env)
+rp_supporting_tokens_free(
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    if(supporting_tokens)
+    if (supporting_tokens)
     {
 
         if (--(supporting_tokens->ref) > 0)
         {
             return;
         }
-        
-        if(supporting_tokens->tokens)
+
+        if (supporting_tokens->tokens)
         {
             int i = 0;
             for (i = 0; i < axutil_array_list_size(supporting_tokens->tokens,
-                env); i++)
+                                                   env); i++)
             {
                 rp_property_t *token = NULL;
                 token = (rp_property_t *)
-                    axutil_array_list_get(supporting_tokens->tokens,env, i);
+                    axutil_array_list_get(supporting_tokens->tokens, env, i);
                 if (token)
                     rp_property_free(token, env);
 
@@ -97,44 +99,47 @@
             supporting_tokens->tokens = NULL;
 
         }
-        if(supporting_tokens->algorithmsuite)
+        if (supporting_tokens->algorithmsuite)
         {
-            rp_algorithmsuite_free(supporting_tokens->algorithmsuite,env);
+            rp_algorithmsuite_free(supporting_tokens->algorithmsuite, env);
             supporting_tokens->algorithmsuite = NULL;
-        }            
-        if(supporting_tokens->signed_parts)
+        }
+        if (supporting_tokens->signed_parts)
         {
-            rp_signed_encrypted_parts_free(supporting_tokens->signed_parts,env);
+            rp_signed_encrypted_parts_free(supporting_tokens->signed_parts,
+                                           env);
             supporting_tokens->signed_parts = NULL;
-        }    
-        if(supporting_tokens->signed_elements)
+        }
+        if (supporting_tokens->signed_elements)
         {
-            rp_signed_encrypted_elements_free(supporting_tokens->signed_elements,env);
+            rp_signed_encrypted_elements_free(supporting_tokens->
+                                              signed_elements, env);
             supporting_tokens->signed_elements = NULL;
         }
-        if(supporting_tokens->encrypted_parts)
+        if (supporting_tokens->encrypted_parts)
         {
-            rp_signed_encrypted_parts_free(supporting_tokens->encrypted_parts,env);
+            rp_signed_encrypted_parts_free(supporting_tokens->encrypted_parts,
+                                           env);
             supporting_tokens->encrypted_parts = NULL;
         }
-        if(supporting_tokens->encrypted_elements)
+        if (supporting_tokens->encrypted_elements)
         {
-            rp_signed_encrypted_elements_free(supporting_tokens->encrypted_elements,env);
+            rp_signed_encrypted_elements_free(supporting_tokens->
+                                              encrypted_elements, env);
             supporting_tokens->encrypted_elements = NULL;
         }
-        AXIS2_FREE(env->allocator,supporting_tokens);
+        AXIS2_FREE(env->allocator, supporting_tokens);
         supporting_tokens = NULL;
     }
     return;
 }
 
-
 /* Implementations */
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
 rp_supporting_tokens_get_tokens(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
@@ -142,24 +147,23 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-rp_supporting_tokens_add_token(rp_supporting_tokens_t *supporting_tokens,
-            const axutil_env_t *env,
-            rp_property_t *token)
+rp_supporting_tokens_add_token(
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env,
+    rp_property_t * token)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, token, AXIS2_FAILURE);
-    
+
     rp_property_increment_ref(token, env);
     axutil_array_list_add(supporting_tokens->tokens, env, token);
     return AXIS2_SUCCESS;
 }
 
-
-
 AXIS2_EXTERN rp_algorithmsuite_t *AXIS2_CALL
 rp_supporting_tokens_get_algorithmsuite(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -168,9 +172,9 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_supporting_tokens_set_algorithmsuite(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env,
-    rp_algorithmsuite_t *algorithmsuite)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env,
+    rp_algorithmsuite_t * algorithmsuite)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, algorithmsuite, AXIS2_FAILURE);
@@ -180,34 +184,33 @@
     return AXIS2_SUCCESS;
 }
 
-
 AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
 rp_supporting_tokens_get_signed_parts(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-        
+
     return supporting_tokens->signed_parts;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_supporting_tokens_set_signed_parts(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env,
-    rp_signed_encrypted_parts_t *signed_parts)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env,
+    rp_signed_encrypted_parts_t * signed_parts)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, signed_parts, AXIS2_FAILURE);
-        
+
     supporting_tokens->signed_parts = signed_parts;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL
 rp_supporting_tokens_get_signed_elements(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -216,21 +219,21 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_supporting_tokens_set_signed_elements(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env,
-    rp_signed_encrypted_elements_t *signed_elements)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env,
+    rp_signed_encrypted_elements_t * signed_elements)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, signed_elements, AXIS2_FAILURE);
-        
+
     supporting_tokens->signed_elements = signed_elements;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
 rp_supporting_tokens_get_encrypted_parts(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -239,9 +242,9 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_supporting_tokens_set_encrypted_parts(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env,
-    rp_signed_encrypted_parts_t *encrypted_parts)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env,
+    rp_signed_encrypted_parts_t * encrypted_parts)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, encrypted_parts, AXIS2_FAILURE);
@@ -252,41 +255,41 @@
 
 AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL
 rp_supporting_tokens_get_encrypted_elements(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return supporting_tokens->encrypted_elements;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_supporting_tokens_set_encrypted_elements(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env,
-    rp_signed_encrypted_elements_t *encrypted_elements)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env,
+    rp_signed_encrypted_elements_t * encrypted_elements)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, encrypted_elements, AXIS2_FAILURE);
-        
+
     supporting_tokens->encrypted_elements = encrypted_elements;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN int AXIS2_CALL
 rp_supporting_tokens_get_type(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-        
+
     return supporting_tokens->type;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_supporting_tokens_set_type(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env,
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env,
     int type)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -296,11 +299,10 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_supporting_tokens_increment_ref(
-    rp_supporting_tokens_t *supporting_tokens,
-    const axutil_env_t *env)
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     supporting_tokens->ref++;
     return AXIS2_SUCCESS;
 }
-

Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/symmetric_asymmetric_binding_commons.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/symmetric_asymmetric_binding_commons.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/symmetric_asymmetric_binding_commons.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/symmetric_asymmetric_binding_commons.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,8 +16,6 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_symmetric_asymmetric_binding_commons.h>
 
 struct rp_symmetric_asymmetric_binding_commons_t
@@ -29,115 +28,127 @@
 
 };
 
-AXIS2_EXTERN rp_symmetric_asymmetric_binding_commons_t *AXIS2_CALL 
-rp_symmetric_asymmetric_binding_commons_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_symmetric_asymmetric_binding_commons_t *AXIS2_CALL
+rp_symmetric_asymmetric_binding_commons_create(
+    const axutil_env_t * env)
 {
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons = NULL;
+    rp_symmetric_asymmetric_binding_commons_t
+        *symmetric_asymmetric_binding_commons = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    symmetric_asymmetric_binding_commons =  (rp_symmetric_asymmetric_binding_commons_t *)
-        AXIS2_MALLOC (env->allocator,sizeof (rp_symmetric_asymmetric_binding_commons_t));
+    symmetric_asymmetric_binding_commons =
+        (rp_symmetric_asymmetric_binding_commons_t *) AXIS2_MALLOC(env->
+                                                                   allocator,
+                                                                   sizeof
+                                                                   (rp_symmetric_asymmetric_binding_commons_t));
 
-    if(symmetric_asymmetric_binding_commons == NULL)
+    if (symmetric_asymmetric_binding_commons == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     symmetric_asymmetric_binding_commons->binding_commons = NULL;
-    symmetric_asymmetric_binding_commons->protection_order = RP_SIGN_BEFORE_ENCRYPTING;
+    symmetric_asymmetric_binding_commons->protection_order =
+        RP_SIGN_BEFORE_ENCRYPTING;
     symmetric_asymmetric_binding_commons->signature_protection = AXIS2_FALSE;
     symmetric_asymmetric_binding_commons->token_protection = AXIS2_FALSE;
-    symmetric_asymmetric_binding_commons->entire_headers_and_body_signatures = AXIS2_FALSE;
+    symmetric_asymmetric_binding_commons->entire_headers_and_body_signatures =
+        AXIS2_FALSE;
 
     return symmetric_asymmetric_binding_commons;
 }
 
-AXIS2_EXTERN void AXIS2_CALL 
+AXIS2_EXTERN void AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_free(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env)
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-    if(symmetric_asymmetric_binding_commons)
+
+    if (symmetric_asymmetric_binding_commons)
     {
-        if(symmetric_asymmetric_binding_commons->binding_commons)
+        if (symmetric_asymmetric_binding_commons->binding_commons)
         {
-            rp_binding_commons_free(symmetric_asymmetric_binding_commons->binding_commons,env);
+            rp_binding_commons_free(symmetric_asymmetric_binding_commons->
+                                    binding_commons, env);
             symmetric_asymmetric_binding_commons->binding_commons = NULL;
-        }            
-        AXIS2_FREE(env->allocator,symmetric_asymmetric_binding_commons);
+        }
+        AXIS2_FREE(env->allocator, symmetric_asymmetric_binding_commons);
         symmetric_asymmetric_binding_commons = NULL;
     }
     return;
 }
 
-
 /* Implementations */
 AXIS2_EXTERN rp_binding_commons_t *AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_get_binding_commons(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env)
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-        
+
     return symmetric_asymmetric_binding_commons->binding_commons;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_set_binding_commons(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env,
-    rp_binding_commons_t *binding_commons)
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env,
+    rp_binding_commons_t * binding_commons)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, binding_commons, AXIS2_FAILURE);   
-        
-    symmetric_asymmetric_binding_commons->binding_commons = 
-        binding_commons;    
+    AXIS2_PARAM_CHECK(env->error, binding_commons, AXIS2_FAILURE);
+
+    symmetric_asymmetric_binding_commons->binding_commons = binding_commons;
     return AXIS2_SUCCESS;
 }
 
-
-
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_get_signature_protection(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env)
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
-    
+
     return symmetric_asymmetric_binding_commons->signature_protection;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_set_signature_protection(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env,
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env,
     axis2_bool_t signature_protection)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,signature_protection,AXIS2_FAILURE);    
-    symmetric_asymmetric_binding_commons->signature_protection = signature_protection;
+    AXIS2_PARAM_CHECK(env->error, signature_protection, AXIS2_FAILURE);
+    symmetric_asymmetric_binding_commons->signature_protection =
+        signature_protection;
 
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_get_token_protection(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env)
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
-    
+
     return symmetric_asymmetric_binding_commons->token_protection;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_set_token_protection(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env,
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env,
     axis2_bool_t token_protection)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -147,26 +158,30 @@
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_get_entire_headers_and_body_signatures(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env)
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
-    
-    return symmetric_asymmetric_binding_commons->entire_headers_and_body_signatures;
+
+    return symmetric_asymmetric_binding_commons->
+        entire_headers_and_body_signatures;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_set_entire_headers_and_body_signatures(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env,
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env,
     axis2_bool_t entire_headers_and_body_signatures)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, entire_headers_and_body_signatures, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, entire_headers_and_body_signatures,
+                      AXIS2_FAILURE);
 
-    symmetric_asymmetric_binding_commons->entire_headers_and_body_signatures = 
+    symmetric_asymmetric_binding_commons->entire_headers_and_body_signatures =
         entire_headers_and_body_signatures;
 
     return AXIS2_SUCCESS;
@@ -174,25 +189,25 @@
 
 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_get_protection_order(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env)
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    
+
     return symmetric_asymmetric_binding_commons->protection_order;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_asymmetric_binding_commons_set_protection_order(
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons,
-    const axutil_env_t *env,
-    axis2_char_t *protection_order)
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons,
+    const axutil_env_t * env,
+    axis2_char_t * protection_order)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, protection_order, AXIS2_FAILURE);
-    
-    symmetric_asymmetric_binding_commons->protection_order = 
-        protection_order;    
+
+    symmetric_asymmetric_binding_commons->protection_order = protection_order;
     return AXIS2_SUCCESS;
 }
-

Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/symmetric_binding.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/symmetric_binding.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/symmetric_binding.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/symmetric_binding.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,30 +16,31 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_symmetric_binding.h>
 
 struct rp_symmetric_binding_t
 {
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons;
+    rp_symmetric_asymmetric_binding_commons_t
+        *symmetric_asymmetric_binding_commons;
     rp_property_t *protection_token;
     rp_property_t *signature_token;
     rp_property_t *encryption_token;
     int ref;
 };
 
-AXIS2_EXTERN rp_symmetric_binding_t *AXIS2_CALL 
-rp_symmetric_binding_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_symmetric_binding_t *AXIS2_CALL
+rp_symmetric_binding_create(
+    const axutil_env_t * env)
 {
     rp_symmetric_binding_t *symmetric_binding = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    symmetric_binding =  (rp_symmetric_binding_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (rp_symmetric_binding_t));
+    symmetric_binding = (rp_symmetric_binding_t *) AXIS2_MALLOC(env->allocator,
+                                                                sizeof
+                                                                (rp_symmetric_binding_t));
 
-    if(symmetric_binding == NULL)
+    if (symmetric_binding == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -52,174 +54,168 @@
     return symmetric_binding;
 }
 
-AXIS2_EXTERN void AXIS2_CALL 
+AXIS2_EXTERN void AXIS2_CALL
 rp_symmetric_binding_free(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-    if(symmetric_binding)
+
+    if (symmetric_binding)
     {
         if (--(symmetric_binding->ref) > 0)
         {
             return;
         }
 
-        if(symmetric_binding->symmetric_asymmetric_binding_commons)
+        if (symmetric_binding->symmetric_asymmetric_binding_commons)
         {
-            rp_symmetric_asymmetric_binding_commons_free(
-                symmetric_binding->symmetric_asymmetric_binding_commons,
-                env);
-            symmetric_binding->symmetric_asymmetric_binding_commons=NULL;
+            rp_symmetric_asymmetric_binding_commons_free(symmetric_binding->
+                                                         symmetric_asymmetric_binding_commons,
+                                                         env);
+            symmetric_binding->symmetric_asymmetric_binding_commons = NULL;
         }
-        if(symmetric_binding->protection_token)
+        if (symmetric_binding->protection_token)
         {
-            rp_property_free(symmetric_binding->protection_token,env);
+            rp_property_free(symmetric_binding->protection_token, env);
             symmetric_binding->protection_token = NULL;
         }
-        if(symmetric_binding->encryption_token)
+        if (symmetric_binding->encryption_token)
         {
-            rp_property_free(symmetric_binding->encryption_token,env);            
+            rp_property_free(symmetric_binding->encryption_token, env);
             symmetric_binding->encryption_token = NULL;
         }
-        if(symmetric_binding->signature_token)
+        if (symmetric_binding->signature_token)
         {
-            rp_property_free(symmetric_binding->signature_token,env);            
+            rp_property_free(symmetric_binding->signature_token, env);
             symmetric_binding->signature_token = NULL;
         }
-        AXIS2_FREE(env->allocator,symmetric_binding);           
+        AXIS2_FREE(env->allocator, symmetric_binding);
     }
 
     return;
 }
 
-
 /* Implementations */
 
 AXIS2_EXTERN rp_symmetric_asymmetric_binding_commons_t *AXIS2_CALL
 rp_symmetric_binding_get_symmetric_asymmetric_binding_commons(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-        
+
     return symmetric_binding->symmetric_asymmetric_binding_commons;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_binding_set_symmetric_asymmetric_binding_commons(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env,
-    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env,
+    rp_symmetric_asymmetric_binding_commons_t *
+    symmetric_asymmetric_binding_commons)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, symmetric_asymmetric_binding_commons,
-            AXIS2_FAILURE);
-        
+                      AXIS2_FAILURE);
+
     symmetric_binding->symmetric_asymmetric_binding_commons
-            =symmetric_asymmetric_binding_commons;
+        = symmetric_asymmetric_binding_commons;
 
     return AXIS2_SUCCESS;
 }
 
-
-
 AXIS2_EXTERN rp_property_t *AXIS2_CALL
 rp_symmetric_binding_get_protection_token(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-        
+
     return symmetric_binding->protection_token;
 }
 
-
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_binding_set_protection_token(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env,
-    rp_property_t *protection_token)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env,
+    rp_property_t * protection_token)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,protection_token,AXIS2_FAILURE);
-    if(symmetric_binding->signature_token ||
+    AXIS2_PARAM_CHECK(env->error, protection_token, AXIS2_FAILURE);
+    if (symmetric_binding->signature_token ||
         symmetric_binding->encryption_token)
     {
         return AXIS2_FAILURE;
     }
-    symmetric_binding->protection_token = 
-        protection_token; 
+    symmetric_binding->protection_token = protection_token;
 
     return AXIS2_SUCCESS;
-    
+
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_binding_set_encryption_token(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env,
-    rp_property_t *encryption_token)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env,
+    rp_property_t * encryption_token)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,encryption_token,AXIS2_FAILURE);
-    if(symmetric_binding->protection_token)
+    AXIS2_PARAM_CHECK(env->error, encryption_token, AXIS2_FAILURE);
+    if (symmetric_binding->protection_token)
     {
         return AXIS2_FAILURE;
     }
-    symmetric_binding->encryption_token = encryption_token; 
+    symmetric_binding->encryption_token = encryption_token;
 
     return AXIS2_SUCCESS;
-    
+
 }
 
 AXIS2_EXTERN rp_property_t *AXIS2_CALL
 rp_symmetric_binding_get_encryption_token(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    
+
     return symmetric_binding->encryption_token;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_binding_set_signature_token(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env,
-    rp_property_t *signature_token)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env,
+    rp_property_t * signature_token)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error,signature_token,AXIS2_FAILURE);
-    if(symmetric_binding->protection_token)
+    AXIS2_PARAM_CHECK(env->error, signature_token, AXIS2_FAILURE);
+    if (symmetric_binding->protection_token)
     {
         return AXIS2_FAILURE;
     }
-    symmetric_binding->signature_token = signature_token; 
+    symmetric_binding->signature_token = signature_token;
 
     return AXIS2_SUCCESS;
-    
+
 }
 
 AXIS2_EXTERN rp_property_t *AXIS2_CALL
 rp_symmetric_binding_get_signature_token(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    
+
     return symmetric_binding->signature_token;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_symmetric_binding_increment_ref(
-    rp_symmetric_binding_t *symmetric_binding,
-    const axutil_env_t *env)
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     symmetric_binding->ref++;
     return AXIS2_SUCCESS;
 }
-

Modified: webservices/axis2/trunk/c/neethi/src/secpolicy/model/transport_binding.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/neethi/src/secpolicy/model/transport_binding.c?rev=580289&r1=580288&r2=580289&view=diff
==============================================================================
--- webservices/axis2/trunk/c/neethi/src/secpolicy/model/transport_binding.c (original)
+++ webservices/axis2/trunk/c/neethi/src/secpolicy/model/transport_binding.c Fri Sep 28 03:29:16 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,8 +16,6 @@
  * limitations under the License.
  */
 
-
-
 #include <rp_transport_binding.h>
 
 struct rp_transport_binding_t
@@ -26,17 +25,19 @@
     int ref;
 };
 
-AXIS2_EXTERN rp_transport_binding_t *AXIS2_CALL 
-rp_transport_binding_create(const axutil_env_t *env)
+AXIS2_EXTERN rp_transport_binding_t *AXIS2_CALL
+rp_transport_binding_create(
+    const axutil_env_t * env)
 {
     rp_transport_binding_t *transport_binding = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    transport_binding =  (rp_transport_binding_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (rp_transport_binding_t));
+    transport_binding = (rp_transport_binding_t *) AXIS2_MALLOC(env->allocator,
+                                                                sizeof
+                                                                (rp_transport_binding_t));
 
-    if(transport_binding == NULL)
+    if (transport_binding == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -49,42 +50,41 @@
 
 }
 
-AXIS2_EXTERN void AXIS2_CALL 
+AXIS2_EXTERN void AXIS2_CALL
 rp_transport_binding_free(
-    rp_transport_binding_t *transport_binding,
-    const axutil_env_t *env)
+    rp_transport_binding_t * transport_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
-    if(transport_binding)
+
+    if (transport_binding)
     {
         if (--(transport_binding->ref) > 0)
-        { 
+        {
             return;
         }
-        if(transport_binding->binding_commons)
+        if (transport_binding->binding_commons)
         {
-            rp_binding_commons_free(transport_binding->binding_commons,env);
+            rp_binding_commons_free(transport_binding->binding_commons, env);
             transport_binding->binding_commons = NULL;
         }
-        if(transport_binding->transport_token)
+        if (transport_binding->transport_token)
         {
-            rp_property_free(transport_binding->transport_token,env);
+            rp_property_free(transport_binding->transport_token, env);
             transport_binding->transport_token = NULL;
         }
-        AXIS2_FREE(env->allocator,transport_binding);           
+        AXIS2_FREE(env->allocator, transport_binding);
     }
 
     return;
 }
 
-
 /* Implementations */
 
 AXIS2_EXTERN rp_binding_commons_t *AXIS2_CALL
 rp_transport_binding_get_binding_commons(
-    rp_transport_binding_t *transport_binding,
-    const axutil_env_t *env)
+    rp_transport_binding_t * transport_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -93,49 +93,46 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_transport_binding_set_binding_commons(
-    rp_transport_binding_t *transport_binding,
-    const axutil_env_t *env,
-    rp_binding_commons_t *binding_commons)
+    rp_transport_binding_t * transport_binding,
+    const axutil_env_t * env,
+    rp_binding_commons_t * binding_commons)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, binding_commons, AXIS2_FAILURE);
-        
-    transport_binding->binding_commons=binding_commons;
+
+    transport_binding->binding_commons = binding_commons;
     return AXIS2_SUCCESS;
 }
 
-
 AXIS2_EXTERN rp_property_t *AXIS2_CALL
 rp_transport_binding_get_transport_token(
-    rp_transport_binding_t *transport_binding,
-    const axutil_env_t *env)
+    rp_transport_binding_t * transport_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    
+
     return transport_binding->transport_token;
 }
 
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_transport_binding_set_transport_token(
-    rp_transport_binding_t *transport_binding,
-    const axutil_env_t *env,
-    rp_property_t *transport_token)
+    rp_transport_binding_t * transport_binding,
+    const axutil_env_t * env,
+    rp_property_t * transport_token)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, transport_token, AXIS2_FAILURE);
-    
-    transport_binding->transport_token = transport_token; 
+
+    transport_binding->transport_token = transport_token;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 rp_transport_binding_increment_ref(
-    rp_transport_binding_t *transport_binding,
-    const axutil_env_t *env)
+    rp_transport_binding_t * transport_binding,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     transport_binding->ref++;
     return AXIS2_SUCCESS;
 }
-



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


Mime
View raw message