You are viewing a plain text version of this content. The canonical link for it is here.
Posted to rampart-dev@ws.apache.org by ka...@apache.org on 2007/03/28 12:22:20 UTC

svn commit: r523261 [1/2] - in /webservices/rampart/trunk/c/src/omxmlsec: ./ c14n/

Author: kaushalye
Date: Wed Mar 28 03:21:59 2007
New Revision: 523261

URL: http://svn.apache.org/viewvc?view=rev&rev=523261
Log:
Code formatting in OMXMLSecurity and C14N

Modified:
    webservices/rampart/trunk/c/src/omxmlsec/asym_ctx.c
    webservices/rampart/trunk/c/src/omxmlsec/axiom.c
    webservices/rampart/trunk/c/src/omxmlsec/buffer.c
    webservices/rampart/trunk/c/src/omxmlsec/c14n/c14n.c
    webservices/rampart/trunk/c/src/omxmlsec/c14n/sorted_list.c
    webservices/rampart/trunk/c/src/omxmlsec/cipher.c
    webservices/rampart/trunk/c/src/omxmlsec/ctx.c
    webservices/rampart/trunk/c/src/omxmlsec/encryption.c
    webservices/rampart/trunk/c/src/omxmlsec/error.c
    webservices/rampart/trunk/c/src/omxmlsec/iv.c
    webservices/rampart/trunk/c/src/omxmlsec/key.c
    webservices/rampart/trunk/c/src/omxmlsec/key_mgr.c
    webservices/rampart/trunk/c/src/omxmlsec/sign_ctx.c
    webservices/rampart/trunk/c/src/omxmlsec/sign_part.c
    webservices/rampart/trunk/c/src/omxmlsec/signature.c
    webservices/rampart/trunk/c/src/omxmlsec/transform.c
    webservices/rampart/trunk/c/src/omxmlsec/transforms_factory.c
    webservices/rampart/trunk/c/src/omxmlsec/utility.c
    webservices/rampart/trunk/c/src/omxmlsec/x509_cert.c
    webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c
    webservices/rampart/trunk/c/src/omxmlsec/xml_key_info_builder.c
    webservices/rampart/trunk/c/src/omxmlsec/xml_key_processor.c
    webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c

Modified: webservices/rampart/trunk/c/src/omxmlsec/asym_ctx.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/asym_ctx.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/asym_ctx.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/asym_ctx.c Wed Mar 28 03:21:59 2007
@@ -28,8 +28,8 @@
     axis2_char_t *password;
     axis2_char_t *algorithm;
     axis2_char_t *st_ref_pattern;
-    oxs_asym_ctx_operation_t operation;   
-    oxs_asym_ctx_format_t format;   
+    oxs_asym_ctx_operation_t operation;
+    oxs_asym_ctx_format_t format;
     oxs_x509_cert_t *certificate;
     openssl_pkey_t *private_key;
 
@@ -263,7 +263,7 @@
 }
 
 
-AXIS2_EXTERN 
+AXIS2_EXTERN
 oxs_asym_ctx_t *AXIS2_CALL
 oxs_asym_ctx_create(const axis2_env_t *env)
 {
@@ -286,7 +286,7 @@
     asym_ctx->st_ref_pattern = NULL;
     asym_ctx->operation = -1;
     asym_ctx->certificate = NULL;
-    
+
     return asym_ctx;
 }
 
@@ -294,7 +294,7 @@
 AXIS2_EXTERN
 axis2_status_t AXIS2_CALL
 oxs_asym_ctx_free(oxs_asym_ctx_t *asym_ctx,
-        const axis2_env_t *env)
+                  const axis2_env_t *env)
 {
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

Modified: webservices/rampart/trunk/c/src/omxmlsec/axiom.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/axiom.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/axiom.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/axiom.c Wed Mar 28 03:21:59 2007
@@ -31,11 +31,11 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 oxs_axiom_add_attribute(const axis2_env_t *env,
-    axiom_node_t* node,
-    axis2_char_t* attribute_ns,
-    axis2_char_t* attribute_ns_uri,
-    axis2_char_t* attribute,
-    axis2_char_t* value)
+                        axiom_node_t* node,
+                        axis2_char_t* attribute_ns,
+                        axis2_char_t* attribute_ns_uri,
+                        axis2_char_t* attribute,
+                        axis2_char_t* value)
 {
     axiom_attribute_t *attr = NULL;
     axiom_element_t *ele = NULL;
@@ -47,7 +47,7 @@
     ele =  AXIOM_NODE_GET_DATA_ELEMENT(node, env);
     attr =  axiom_attribute_create(env, attribute , value, ns);
     status = axiom_element_add_attribute(ele, env, attr, node);
-    
+
     return status;
 }
 
@@ -70,7 +70,7 @@
     if (!parent_ele)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "Cannot find %s element", local_name);
+                  "Cannot find %s element", local_name);
         return -1;
     }
 
@@ -90,13 +90,13 @@
  * */
 AXIS2_EXTERN axiom_node_t* AXIS2_CALL
 oxs_axiom_get_node_by_local_name(const axis2_env_t *env,
-    axiom_node_t *node,
-    axis2_char_t *local_name)
+                                 axiom_node_t *node,
+                                 axis2_char_t *local_name)
 {
     axis2_char_t *temp_name = NULL;
-    
+
     if(!node){return NULL;}
-    
+
     if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT){return NULL;}
 
     temp_name = axiom_util_get_localname(node, env);
@@ -106,20 +106,20 @@
         /*Gottcha.. return this node*/
         return node;
     }else{
-        /*Doesn't match? Get the first child*/    
+        /*Doesn't match? Get the first child*/
         axiom_node_t *temp_node = NULL;
 
         temp_node = axiom_node_get_first_element(node, env);
         while (temp_node)
         {
-            axiom_node_t *res_node = NULL;       
+            axiom_node_t *res_node = NULL;
             res_node = oxs_axiom_get_node_by_local_name(env, temp_node, local_name);
             if(res_node){
                 return res_node;
             }
             temp_node = AXIOM_NODE_GET_NEXT_SIBLING(temp_node, env);
-        } 
-    
+        }
+
     }
     return NULL;
 }
@@ -129,15 +129,15 @@
  * */
 AXIS2_EXTERN axiom_node_t* AXIS2_CALL
 oxs_axiom_get_node_by_id(const axis2_env_t *env,
-    axiom_node_t *node,
-    axis2_char_t *attr,
-    axis2_char_t *val)
+                         axiom_node_t *node,
+                         axis2_char_t *attr,
+                         axis2_char_t *val)
 {
     axis2_char_t *attribute_value = NULL;
     axis2_char_t *localname = NULL;
-    
+
     if(!node){return NULL;}
-    
+
     if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT){return NULL;}
 
     localname = axiom_util_get_localname(node, env);
@@ -148,20 +148,20 @@
         /*Gottcha.. return this node*/
         return node;
     }else{
-        /*Doesn't match? Get the first child*/    
+        /*Doesn't match? Get the first child*/
         axiom_node_t *temp_node = NULL;
 
         temp_node = axiom_node_get_first_element(node, env);
         while (temp_node)
         {
-            axiom_node_t *res_node = NULL;       
+            axiom_node_t *res_node = NULL;
             res_node = oxs_axiom_get_node_by_id(env, temp_node, attr, val);
             if(res_node){
                 return res_node;
             }
             temp_node = AXIOM_NODE_GET_NEXT_SIBLING(temp_node, env);
-        } 
-    
+        }
+
     }
     return NULL;
 }
@@ -169,24 +169,24 @@
 
 AXIS2_EXTERN axis2_char_t* AXIS2_CALL
 oxs_axiom_get_attribute_value_of_node_by_name(const axis2_env_t *env,
-    axiom_node_t *node,
-    axis2_char_t *attribute_name)
+        axiom_node_t *node,
+        axis2_char_t *attribute_name)
 {
     axis2_char_t *attribute_value = NULL;
     axiom_element_t *ele = NULL;
-    
+
     ele = AXIOM_NODE_GET_DATA_ELEMENT(node, env);
     attribute_value = axiom_element_get_attribute_value_by_name(ele, env, attribute_name);
-    
+
     return attribute_value;
 }
 
 AXIS2_EXTERN axiom_node_t* AXIS2_CALL
 oxs_axiom_get_first_child_node_by_name(const axis2_env_t *env,
-        axiom_node_t* parent,
-        axis2_char_t* local_name,
-        axis2_char_t* ns_uri,
-        axis2_char_t* prefix)
+                                       axiom_node_t* parent,
+                                       axis2_char_t* local_name,
+                                       axis2_char_t* ns_uri,
+                                       axis2_char_t* prefix)
 {
     axis2_qname_t *qname = NULL;
     axiom_node_t *node = NULL;
@@ -199,7 +199,7 @@
     if (!parent_ele)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "Cannot find %s element", local_name);
+                  "Cannot find %s element", local_name);
         return NULL;
     }
     /*Get the child*/
@@ -212,7 +212,7 @@
     if (!node)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "Cannot find child %s of %s", local_name, parent_name);
+                  "Cannot find child %s of %s", local_name, parent_name);
         return NULL;
     }
     return node;
@@ -246,16 +246,16 @@
     if (!buffer)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "buffer is NULL");
+                  "buffer is NULL");
         return NULL;
     }
     reader = axiom_xml_reader_create_for_memory(env,
-            (void*)buffer, axis2_strlen(buffer), "utf-8", AXIS2_XML_PARSER_TYPE_BUFFER);
+             (void*)buffer, axis2_strlen(buffer), "utf-8", AXIS2_XML_PARSER_TYPE_BUFFER);
 
     if (!reader)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "axiom_xml_reader is NULL");
+                  "axiom_xml_reader is NULL");
         return NULL;
     }
 
@@ -263,7 +263,7 @@
     if (!builder)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "axiom_stax_builder is NULL");
+                  "axiom_stax_builder is NULL");
         return NULL;
     }
 
@@ -271,14 +271,14 @@
     if (!doc)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "axiom_document is NULL");
+                  "axiom_document is NULL");
         return NULL;
     }
     node = axiom_document_build_all(doc, env);
     if (!node)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "Building node failed");
+                  "Building node failed");
         return NULL;
     }
 

Modified: webservices/rampart/trunk/c/src/omxmlsec/buffer.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/buffer.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/buffer.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/buffer.c Wed Mar 28 03:21:59 2007
@@ -60,9 +60,9 @@
     if (status == AXIS2_FAILURE)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_DEFAULT,
-                "oxs_buffer_set_max_size");
+                  "oxs_buffer_set_max_size");
         return NULL;
-    }    
+    }
 
     return buffer;
 
@@ -73,7 +73,7 @@
     oxs_buffer_t *buffer,
     const axis2_env_t *env
 )
-{    
+{
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
     if (buffer->data)
@@ -103,7 +103,7 @@
         if (!buffer->data)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "oxs_buffer_remove_head failed. data is NULL");
+                      "oxs_buffer_remove_head failed. data is NULL");
             return  AXIS2_FAILURE;
         }
         buffer->size -= size;
@@ -120,7 +120,7 @@
         if (!buffer->data)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "oxs_buffer_remove_head failed");
+                      "oxs_buffer_remove_head failed");
             return  AXIS2_FAILURE;
         }
         memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
@@ -151,7 +151,7 @@
         if (buffer->data)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "");
+                      "");
             return  AXIS2_FAILURE;
         }
         memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
@@ -177,7 +177,7 @@
         if (!data)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "data is NULL");
+                      "data is NULL");
             return AXIS2_FAILURE;
         }
 
@@ -204,7 +204,7 @@
         if (!data)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "data is NULL");
+                      "data is NULL");
             return AXIS2_FAILURE;
         }
 
@@ -230,7 +230,7 @@
         if (!data)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "Passed data is NULL");
+                      "Passed data is NULL");
             return AXIS2_FAILURE;
         }
 
@@ -262,7 +262,7 @@
     if (f == NULL)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "");
+                  "");
         return AXIS2_FAILURE;
     }
 
@@ -283,7 +283,7 @@
         {
             fclose(f);
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "");
+                      "");
             return AXIS2_FAILURE;
         }
 
@@ -311,7 +311,7 @@
     if (status == AXIS2_FAILURE)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "oxs_buffer_set_max_size failed");
+                  "oxs_buffer_set_max_size failed");
         return AXIS2_FAILURE;
     }
     /*Now set the size*/
@@ -339,12 +339,12 @@
 
     switch (buffer->alloc_mode)
     {
-        case oxs_alloc_mode_exact:
-            new_size = size + 8;
-            break;
-        case oxs_alloc_mode_double:
-            new_size = 2 * size + 32;
-            break;
+    case oxs_alloc_mode_exact:
+        new_size = size + 8;
+        break;
+    case oxs_alloc_mode_double:
+        new_size = 2 * size + 32;
+        break;
     }
 
     if (new_size < OXS_BUFFER_INITIAL_SIZE)
@@ -355,16 +355,16 @@
     /*If there are data already then use realloc instead of malloc*/
     if (buffer->data)
     {
-#if 0        
+#if 0
         new_data = (unsigned char*)AXIS2_REALLOC(env->allocator, buffer_impl->data, new_size);
 #else
 
         /*Assign extra amnt of memory*/
         new_data = (unsigned char*)AXIS2_MALLOC(env->allocator, new_size + buffer->max_size);
-        
+
         /*Copy to newdata*/
         new_data = memcpy(new_data, buffer->data, buffer->size);
-    
+
 #endif
     }
     else
@@ -375,7 +375,7 @@
     if (new_data == NULL)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "");
+                  "");
         return AXIS2_FAILURE;
     }
 
@@ -387,7 +387,7 @@
         if (buffer->data == NULL)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "");
+                      "");
             return AXIS2_FAILURE;
         }
         memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);

Modified: webservices/rampart/trunk/c/src/omxmlsec/c14n/c14n.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/c14n/c14n.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/c14n/c14n.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/c14n/c14n.c Wed Mar 28 03:21:59 2007
@@ -35,8 +35,8 @@
 
 #define N_C14N_DEBUG
 
-#define DEFAULT_STACK_SIZE 16 
-#define INIT_BUFFER_SIZE 256 
+#define DEFAULT_STACK_SIZE 16
+#define INIT_BUFFER_SIZE 256
 
 #define c14n_ns_stack_push(save_stack, ctx) \
         (save_stack)->head = (ctx)->ns_stack->head; \
@@ -54,7 +54,7 @@
 
 #define C14N_GET_ROOT_NODE_FROM_DOC_OR_NODE(doc, node, ctx) \
     ((doc) ? axiom_document_get_root_element((axiom_document_t *)(doc), \
-        (ctx)->env) : c14n_get_root_node((node), (ctx))) 
+        (ctx)->env) : c14n_get_root_node((node), (ctx)))
 
 typedef enum {
     C14N_XML_C14N = 1,
@@ -74,7 +74,7 @@
     const axis2_env_t *env;
     const axiom_document_t *doc;
     axis2_bool_t comments;
-    axis2_char_t **outbuf; 
+    axis2_char_t **outbuf;
     axis2_stream_t *outstream;
     axis2_bool_t exclusive;
     axis2_bool_t use_stream;
@@ -88,44 +88,44 @@
 static c14n_ns_stack_t*
 c14n_ns_stack_create(
     const c14n_ctx_t *ctx
-    );
+);
 
 static void
 c14n_ns_stack_free(
     c14n_ctx_t *ctx
-    );
+);
 
-static axis2_status_t 
+static axis2_status_t
 c14n_ns_stack_find(
     const axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_status_t
 c14n_ns_stack_find_with_prefix_uri(
     const axis2_char_t *prefix,
     const axis2_char_t *uri,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_status_t
 c14n_ns_stack_add(
-    axiom_namespace_t *ns,  
+    axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    );
+);
 
 /*ns stack implementation*/
 
 static c14n_ns_stack_t*
 c14n_ns_stack_create(
     const c14n_ctx_t *ctx
-    )
+)
 {
     c14n_ns_stack_t *ns_stack = NULL;
 
-    ns_stack = (c14n_ns_stack_t *)(AXIS2_MALLOC(ctx->env->allocator, 
-                sizeof(c14n_ns_stack_t)));
-   
+    ns_stack = (c14n_ns_stack_t *)(AXIS2_MALLOC(ctx->env->allocator,
+                                   sizeof(c14n_ns_stack_t)));
+
     if (ns_stack)
     {
         ns_stack->head = 0;
@@ -141,21 +141,21 @@
 
 static axis2_status_t
 c14n_ns_stack_add(
-    axiom_namespace_t *ns,  
+    axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    )
+)
 {
     c14n_ns_stack_t *ns_stack = ctx->ns_stack;
 
     if (!ns_stack->stack)
     {
         ns_stack->stack = (axiom_namespace_t **)(AXIS2_MALLOC(
-                ctx->env->allocator, 
-                sizeof(axiom_namespace_t*) * DEFAULT_STACK_SIZE));
+                              ctx->env->allocator,
+                              sizeof(axiom_namespace_t*) * DEFAULT_STACK_SIZE));
         if (!ns_stack->stack)
         {
-            AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY, 
-                    AXIS2_FAILURE);
+            AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY,
+                            AXIS2_FAILURE);
             return AXIS2_FAILURE;
         }
         else ns_stack->size = DEFAULT_STACK_SIZE;
@@ -164,15 +164,15 @@
     {
         int size = 2 * ns_stack->size;
         axiom_namespace_t **tmp_stack = (axiom_namespace_t **)(AXIS2_MALLOC(
-                ctx->env->allocator, sizeof(axiom_namespace_t*) * size));
+                                            ctx->env->allocator, sizeof(axiom_namespace_t*) * size));
         if (tmp_stack)
         {
             /*int i = 0;*/
             /* TODO:DONE use memcpy for this.*/
             /*for (i=0; i<ns_stack->size; i++)
                 tmp_stack[i] = (ns_stack->stack)[i];*/
-            memcpy(tmp_stack, ns_stack, 
-                    sizeof(axiom_namespace_t*) * ns_stack->size);
+            memcpy(tmp_stack, ns_stack,
+                   sizeof(axiom_namespace_t*) * ns_stack->size);
 
             ns_stack->size = size;
 
@@ -181,8 +181,8 @@
         }
         else
         {
-            AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY, 
-                    AXIS2_FAILURE);
+            AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY,
+                            AXIS2_FAILURE);
             return AXIS2_FAILURE;
         }
     }
@@ -208,7 +208,7 @@
     const axis2_char_t *prefix,
     const axis2_char_t *uri,
     const c14n_ctx_t *ctx
-    )
+)
 {
     int i;
     c14n_ns_stack_t *ns_stack = ctx->ns_stack;
@@ -217,12 +217,12 @@
         for (i = ns_stack->head-1; i>=0; i--)
         {
             axis2_char_t *prefix_i = axiom_namespace_get_prefix(
-                    (ns_stack->stack)[i], ctx->env);
+                                         (ns_stack->stack)[i], ctx->env);
 
             if (axis2_strcmp(prefix_i, prefix) == 0)
             {
                 axis2_char_t *uri_i = axiom_namespace_get_uri((ns_stack->stack)[i],
-                        ctx->env);
+                                      ctx->env);
                 if (axis2_strcmp(uri_i, uri) == 0)
                     return AXIS2_SUCCESS;
                 else
@@ -230,28 +230,28 @@
             }
             else
                 continue;
-                
+
         }
     }
     return AXIS2_FAILURE;
 }
 
-static axis2_status_t 
+static axis2_status_t
 c14n_ns_stack_find(
     const axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    )
-{ 
+)
+{
     return (c14n_ns_stack_find_with_prefix_uri(
-            axiom_namespace_get_prefix((axiom_namespace_t *)ns, ctx->env),
-            axiom_namespace_get_uri((axiom_namespace_t *)ns, ctx->env), ctx)
-            );
+                axiom_namespace_get_prefix((axiom_namespace_t *)ns, ctx->env),
+                axiom_namespace_get_uri((axiom_namespace_t *)ns, ctx->env), ctx)
+           );
 }
 
-static void 
+static void
 c14n_ns_stack_free(
     c14n_ctx_t *ctx
-    )
+)
 {
     if (ctx->ns_stack->stack)
     {
@@ -273,90 +273,90 @@
 c14n_apply_on_node(
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_status_t
 c14n_apply_on_element(
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_status_t
 c14n_apply_on_namespace_axis(
     const axiom_element_t *ele,
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_status_t
 c14n_apply_on_namespace_axis_exclusive(
     const axiom_element_t *ele,
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_status_t
 c14n_apply_on_attribute_axis(
     const axiom_element_t *ele,
     const c14n_ctx_t *ctx
-    );
+);
 
-static axis2_status_t 
+static axis2_status_t
 c14n_apply_on_node (
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    );
+);
 
-static void 
+static void
 c14n_apply_on_comment (
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    );
+);
 
-static void 
+static void
 c14n_output(
-    const axis2_char_t *str, 
+    const axis2_char_t *str,
     const c14n_ctx_t *ctx
-    );
+);
 
 static int
 attr_compare(
     const void *a1,
     const void *a2,
     const void *context
-    );
+);
 
 static int
 ns_prefix_compare(
     const void *ns1,
     const void *ns2,
     const void *context
-    );
+);
 
 static int
 ns_uri_compare(
     const void *ns1,
     const void *ns2,
     const void *context
-    );
+);
 
 static axis2_char_t*
 c14n_normalize_attribute(
     axis2_char_t *attval,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_char_t*
 c14n_normalize_text(
     axis2_char_t *text,
     const c14n_ctx_t *ctx
-    );
+);
 
-static void 
+static void
 c14n_apply_on_namespace(
     const void *ns,
     const void *ctx
-    );
+);
 
 static axis2_bool_t
 c14n_need_to_declare_ns(
@@ -364,7 +364,7 @@
     const axiom_node_t *node,
     const axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_bool_t
 c14n_ns_visibly_utilized(
@@ -372,7 +372,7 @@
     const axiom_node_t *node,
     const axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axis2_bool_t
 c14n_no_output_ancestor_uses_prefix(
@@ -380,18 +380,18 @@
     const axiom_node_t *node,
     const axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    );
+);
 
 static axiom_node_t*
 c14n_get_root_node(
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    );
+);
 
-static c14n_algo_t 
+static c14n_algo_t
 c14n_get_algorithm(
     const axis2_char_t* algo
-    );
+);
 
 /*static axis2_bool_t
 c14n_in_nodeset(
@@ -405,17 +405,17 @@
 static void
 c14n_ctx_free(
     c14n_ctx_t *ctx
-    )
+)
 {
     if (ctx)
     {
         c14n_ns_stack_free(ctx);
     }
-    
+
     AXIS2_FREE(ctx->env->allocator, ctx);
 }
 
-static c14n_ctx_t* 
+static c14n_ctx_t*
 c14n_init(
     const axis2_env_t *env,
     const axiom_document_t *doc,
@@ -426,10 +426,10 @@
     const axis2_array_list_t *ns_prefixes,
     const axis2_bool_t use_stream,
     const axiom_node_t *node
-    )
+)
 {
-    c14n_ctx_t *ctx = (c14n_ctx_t *)(AXIS2_MALLOC(env->allocator, 
-                sizeof(c14n_ctx_t)));
+    c14n_ctx_t *ctx = (c14n_ctx_t *)(AXIS2_MALLOC(env->allocator,
+                                     sizeof(c14n_ctx_t)));
     if (ctx)
     {
         ctx->env = env;
@@ -466,7 +466,7 @@
 c14n_get_root_node(
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    )
+)
 {
     const axiom_node_t *parent = NULL;
     const axiom_node_t *prv_parent = NULL;
@@ -480,24 +480,24 @@
     return (axiom_node_t *)prv_parent;
 }
 
-static c14n_algo_t 
+static c14n_algo_t
 c14n_get_algorithm(
     const axis2_char_t* algo
-    )
+)
 {
-   if (axis2_strcmp(algo, OXS_HREF_XML_C14N) == 0)
-            return C14N_XML_C14N;
+    if (axis2_strcmp(algo, OXS_HREF_XML_C14N) == 0)
+        return C14N_XML_C14N;
 
-   if (axis2_strcmp(algo, OXS_HREF_XML_C14N_WITH_COMMENTS) == 0)
-            return C14N_XML_C14N_WITH_COMMENTS;
+    if (axis2_strcmp(algo, OXS_HREF_XML_C14N_WITH_COMMENTS) == 0)
+        return C14N_XML_C14N_WITH_COMMENTS;
 
-   if (axis2_strcmp(algo, OXS_HREF_XML_EXC_C14N) == 0)
-            return C14N_XML_EXC_C14N;
+    if (axis2_strcmp(algo, OXS_HREF_XML_EXC_C14N) == 0)
+        return C14N_XML_EXC_C14N;
 
-   if (axis2_strcmp(algo, OXS_HREF_XML_EXC_C14N_WITH_COMMENTS) == 0)
-            return C14N_XML_EXC_C14N_WITH_COMMENTS;
+    if (axis2_strcmp(algo, OXS_HREF_XML_EXC_C14N_WITH_COMMENTS) == 0)
+        return C14N_XML_EXC_C14N_WITH_COMMENTS;
 
-   return 0; /*c14n_algo_t enum starts with 1*/
+    return 0; /*c14n_algo_t enum starts with 1*/
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
@@ -508,26 +508,26 @@
     const axis2_array_list_t *ns_prefixes,
     const axiom_node_t *node,
     const axis2_char_t* algo
-    )
+)
 {
     switch (c14n_get_algorithm(algo))
     {
-        case C14N_XML_C14N:
-            return oxs_c14n_apply_stream(env, doc, AXIS2_FALSE, stream, AXIS2_FALSE,
-                    ns_prefixes, node);
-        case C14N_XML_C14N_WITH_COMMENTS:
-            return oxs_c14n_apply_stream(env, doc, AXIS2_TRUE, stream, AXIS2_FALSE,
-                    ns_prefixes, node);
-        case C14N_XML_EXC_C14N:
-            return oxs_c14n_apply_stream(env, doc, AXIS2_FALSE, stream, AXIS2_TRUE,
-                    ns_prefixes, node);
-        case C14N_XML_EXC_C14N_WITH_COMMENTS:
-            return oxs_c14n_apply_stream(env, doc, AXIS2_TRUE, stream, AXIS2_TRUE,
-                    ns_prefixes, node);
-        default:
-            /*TODO: set the error*/
-            return AXIS2_FAILURE;
-     }
+    case C14N_XML_C14N:
+        return oxs_c14n_apply_stream(env, doc, AXIS2_FALSE, stream, AXIS2_FALSE,
+                                     ns_prefixes, node);
+    case C14N_XML_C14N_WITH_COMMENTS:
+        return oxs_c14n_apply_stream(env, doc, AXIS2_TRUE, stream, AXIS2_FALSE,
+                                     ns_prefixes, node);
+    case C14N_XML_EXC_C14N:
+        return oxs_c14n_apply_stream(env, doc, AXIS2_FALSE, stream, AXIS2_TRUE,
+                                     ns_prefixes, node);
+    case C14N_XML_EXC_C14N_WITH_COMMENTS:
+        return oxs_c14n_apply_stream(env, doc, AXIS2_TRUE, stream, AXIS2_TRUE,
+                                     ns_prefixes, node);
+    default:
+        /*TODO: set the error*/
+        return AXIS2_FAILURE;
+    }
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
@@ -538,26 +538,26 @@
     const axis2_array_list_t *ns_prefixes,
     const axiom_node_t *node,
     const axis2_char_t *algo
-    )
+)
 {
     switch (c14n_get_algorithm(algo))
     {
-        case C14N_XML_C14N:
-            return oxs_c14n_apply(env, doc, AXIS2_FALSE, outbuf, AXIS2_FALSE,
-                    ns_prefixes, node);
-        case C14N_XML_C14N_WITH_COMMENTS:
-            return oxs_c14n_apply(env, doc, AXIS2_TRUE, outbuf, AXIS2_FALSE,
-                    ns_prefixes, node);
-        case C14N_XML_EXC_C14N:
-            return oxs_c14n_apply(env, doc, AXIS2_FALSE, outbuf, AXIS2_TRUE,
-                    ns_prefixes, node);
-        case C14N_XML_EXC_C14N_WITH_COMMENTS:
-            return oxs_c14n_apply(env, doc, AXIS2_TRUE, outbuf, AXIS2_TRUE,
-                    ns_prefixes, node);
-        default:
-            /*TODO:set the error*/
-            return AXIS2_FAILURE;
-     }
+    case C14N_XML_C14N:
+        return oxs_c14n_apply(env, doc, AXIS2_FALSE, outbuf, AXIS2_FALSE,
+                              ns_prefixes, node);
+    case C14N_XML_C14N_WITH_COMMENTS:
+        return oxs_c14n_apply(env, doc, AXIS2_TRUE, outbuf, AXIS2_FALSE,
+                              ns_prefixes, node);
+    case C14N_XML_EXC_C14N:
+        return oxs_c14n_apply(env, doc, AXIS2_FALSE, outbuf, AXIS2_TRUE,
+                              ns_prefixes, node);
+    case C14N_XML_EXC_C14N_WITH_COMMENTS:
+        return oxs_c14n_apply(env, doc, AXIS2_TRUE, outbuf, AXIS2_TRUE,
+                              ns_prefixes, node);
+    default:
+        /*TODO:set the error*/
+        return AXIS2_FAILURE;
+    }
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
@@ -569,17 +569,17 @@
     const axis2_bool_t exclusive,
     const axis2_array_list_t *ns_prefixes,
     const axiom_node_t *node
-    )
+)
 {
     c14n_ctx_t *ctx = NULL;
     axiom_node_t *root_node = NULL;
-    axis2_status_t status = AXIS2_SUCCESS;    
+    axis2_status_t status = AXIS2_SUCCESS;
     axiom_element_t *root_ele = NULL;
     /*axiom_children_iterator_t *child_itr = NULL;*/
     axis2_stream_t *outstream = NULL;
 
     ctx = c14n_init(env, doc, comments, NULL, stream, exclusive, ns_prefixes,
-            AXIS2_TRUE, node);
+                    AXIS2_TRUE, node);
 
     if (ctx && ctx->outstream)
     {
@@ -591,7 +591,7 @@
 
         root_ele = AXIOM_NODE_GET_DATA_ELEMENT(root_node, env);
         status = c14n_apply_on_node((node ? node : root_node), ctx);
-        
+
         if (!status)
         {
             AXIS2_STREAM_FREE(ctx->outstream, env);
@@ -600,7 +600,7 @@
 
         outstream = ctx->outstream;
 
-#ifdef TEST 
+#ifdef TEST
         printf("--------------\n");
         axiom_namespace_t *ns1 = NULL;
         axiom_namespace_t *ns2 = NULL;
@@ -611,33 +611,33 @@
             char uri[10], pfx[10];
             sprintf(uri, "urn:ns%d", i);
             sprintf(pfx, "ns%d", i);
-            ns1 = axiom_namespace_create(ctx->env, uri, pfx); 
+            ns1 = axiom_namespace_create(ctx->env, uri, pfx);
             c14n_ns_stack_add(ns1, ctx);
         }
         for (i=0; i<ctx->ns_stack->head; i++)
         {
             ns1 = ctx->ns_stack->stack[i];
-            printf("%s:%s\n", axiom_namespace_get_prefix(ns1, env), 
-                    axiom_namespace_get_uri(ns1, env));
+            printf("%s:%s\n", axiom_namespace_get_prefix(ns1, env),
+                   axiom_namespace_get_uri(ns1, env));
         }
         printf("%d\n", ctx->ns_stack->size);
-        
+
         ns1 = axiom_namespace_create(ctx->env, "urn:ns0", "ns0");
         ns2 = axiom_namespace_create(ctx->env, "urn:ns10", "ns10");
         ns3 = axiom_namespace_create(ctx->env, "urn:ns2", "ns3");
-        
+
         if (c14n_ns_stack_find(ns1, ctx)) printf("ns1 found\n");
         if (c14n_ns_stack_find(ns2, ctx)) printf("ns2 found\n");
         if (c14n_ns_stack_find(ns3, ctx)) printf("ns3 found\n");
 #endif
-        
+
         c14n_ctx_free(ctx);
         ctx = NULL;
     }
     else
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        
+
         if (ctx)
         {
             c14n_ctx_free(ctx);
@@ -664,11 +664,11 @@
     const axis2_bool_t exclusive,
     const axis2_array_list_t *ns_prefixes,
     const axiom_node_t *node
-    )
+)
 {
     axis2_stream_t *stream = axis2_stream_create_basic(env);
-    axis2_status_t ret = oxs_c14n_apply_stream(env, doc, comments, 
-            stream, exclusive, ns_prefixes, node);
+    axis2_status_t ret = oxs_c14n_apply_stream(env, doc, comments,
+                         stream, exclusive, ns_prefixes, node);
 
     *outbuf = NULL;
 
@@ -681,8 +681,8 @@
         int len = AXIS2_STREAM_BASIC_GET_LEN(stream, env)+1;
         if (len>0)
         {
-            *outbuf = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, 
-                        sizeof(axis2_char_t)*len));
+            *outbuf = (axis2_char_t *)(AXIS2_MALLOC(env->allocator,
+                                                    sizeof(axis2_char_t)*len));
             AXIS2_STREAM_READ(stream, env, *outbuf, len);
             AXIS2_STREAM_FREE(stream, env);
             stream = NULL;
@@ -697,16 +697,16 @@
     }
 }
 
-static axis2_status_t 
+static axis2_status_t
 c14n_apply_on_text (
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    )
-{   
+)
+{
     axiom_text_t *text = NULL;
     text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT((axiom_node_t *)node,
             ctx->env);
-    
+
     if (text)
     {
         axis2_char_t *textval = (axis2_char_t*)axiom_text_get_value(text, ctx->env);
@@ -718,36 +718,37 @@
             textval = NULL;
         }
     }
-    
+
     return AXIS2_SUCCESS;
 }
 
-static axis2_status_t 
+static axis2_status_t
 c14n_apply_on_node (
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    )
+)
 {
-/*    printf("%d %d %d\n", AXIOM_NODE_GET_NODE_TYPE((axiom_node_t *)node, ctx->env), AXIOM_COMMENT, AXIOM_ELEMENT); */
+    /*    printf("%d %d %d\n", AXIOM_NODE_GET_NODE_TYPE((axiom_node_t *)node, ctx->env), AXIOM_COMMENT, AXIOM_ELEMENT); */
     switch (AXIOM_NODE_GET_NODE_TYPE((axiom_node_t *)node, ctx->env))
     {
-        case AXIOM_ELEMENT:
-            c14n_apply_on_element(node, ctx);
-            break;
-        case AXIOM_TEXT:
-            c14n_apply_on_text(node, ctx);
+    case AXIOM_ELEMENT:
+        c14n_apply_on_element(node, ctx);
+        break;
+    case AXIOM_TEXT:
+        c14n_apply_on_text(node, ctx);
+        break;
+    case AXIOM_COMMENT:
+        if (ctx->comments)
+        {
+            c14n_apply_on_comment(node, ctx);
             break;
-        case AXIOM_COMMENT:
-            if (ctx->comments)
-            {
-                c14n_apply_on_comment(node, ctx);
-                break;
-            }
-        case AXIOM_DOCTYPE:
-        case AXIOM_PROCESSING_INSTRUCTION:
-        default:;
+        }
+    case AXIOM_DOCTYPE:
+    case AXIOM_PROCESSING_INSTRUCTION:
+    default:
+        ;
     }
-    
+
     return AXIS2_SUCCESS;
 }
 
@@ -755,12 +756,12 @@
 c14n_apply_on_comment (
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    )
+)
 {
     /*TODO: HACK*/
     c14n_output("<!--", ctx);
     c14n_output(axiom_comment_get_value(
-                        (axiom_comment_t*)AXIOM_NODE_GET_DATA_ELEMENT(
+                    (axiom_comment_t*)AXIOM_NODE_GET_DATA_ELEMENT(
                         (axiom_node_t*)node, ctx->env),ctx->env), ctx);
     c14n_output("-->", ctx);
 }
@@ -769,7 +770,7 @@
 c14n_apply_on_element(
     const axiom_node_t const *node,
     const c14n_ctx_t *ctx
-    )
+)
 {
     axis2_status_t res = AXIS2_SUCCESS;
     axiom_element_t *ele = NULL;
@@ -778,19 +779,19 @@
     c14n_ns_stack_t *save_stack = NULL;
     axiom_node_t *child_node = NULL;
 
-    ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT((axiom_node_t *)node, 
+    ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT((axiom_node_t *)node,
             ctx->env);
 
     if (!ele) return AXIS2_FAILURE; /*should it be failure?*/
-    
+
     ns = axiom_element_get_namespace(ele, ctx->env, (axiom_node_t *)node);
-    
+
     save_stack = c14n_ns_stack_create(ctx);
     c14n_ns_stack_push(save_stack, ctx); /*save current ns stack*/
-    
+
     /*print qname*/
     c14n_output("<", ctx);
-    
+
     if (ns)
     {
         axis2_char_t *prefix = axiom_namespace_get_prefix(ns, ctx->env);
@@ -807,14 +808,14 @@
         res = c14n_apply_on_namespace_axis_exclusive(ele, node, ctx);
     else
         res = c14n_apply_on_namespace_axis(ele, node, ctx);
-    
+
     /*
      * edited the code so that the same fn does both exc and non-exc.
      * have to be careful here!
      */
-    
+
     if (!res) return res;
-    
+
     res = c14n_apply_on_attribute_axis(ele, ctx);
 
     if (!res) return res;
@@ -826,7 +827,7 @@
 #endif
 
     /*process child elements*/
-    
+
     child_node = AXIOM_NODE_GET_FIRST_CHILD((axiom_node_t *)node, ctx->env);
 
     while (child_node)
@@ -852,11 +853,11 @@
             }
         }
     }*/
-    
+
 
     /*print qname*/
     c14n_output("</", ctx);
-    
+
     if (ns)
     {
         axis2_char_t *prefix = axiom_namespace_get_prefix(ns, ctx->env);
@@ -875,7 +876,7 @@
     /*TODO:DONE??? save_stack free*/
     /*since save_stack is used just to memorize the head of the stack,
      * we don't have to worry about freeing its members*/
-    
+
     /**/
     AXIS2_FREE(ctx->env->allocator, save_stack);
     save_stack = NULL;
@@ -892,7 +893,7 @@
     const void *ns1,
     const void *ns2,
     const void *context
-    )
+)
 {
     c14n_ctx_t *ctx = (c14n_ctx_t *)context;
 
@@ -901,10 +902,10 @@
     if (!ns2) return 1;
 
     return (axis2_strcmp(
-            (const axis2_char_t *)axiom_namespace_get_uri(
-                (axiom_namespace_t *)ns1, ctx->env),
-            (const axis2_char_t *)axiom_namespace_get_uri(
-                (axiom_namespace_t *)ns2, ctx->env)));
+                (const axis2_char_t *)axiom_namespace_get_uri(
+                    (axiom_namespace_t *)ns1, ctx->env),
+                (const axis2_char_t *)axiom_namespace_get_uri(
+                    (axiom_namespace_t *)ns2, ctx->env)));
 }
 
 static int
@@ -912,7 +913,7 @@
     const void *ns1,
     const void *ns2,
     const void *context
-    )
+)
 {
     c14n_ctx_t *ctx = (c14n_ctx_t *)context;
 
@@ -921,10 +922,10 @@
     if (!ns2) return 1;
 
     return (axis2_strcmp(
-            (const axis2_char_t *)axiom_namespace_get_prefix(
-                (axiom_namespace_t *)ns1, ctx->env),
-            (const axis2_char_t *)axiom_namespace_get_prefix(
-                (axiom_namespace_t *)ns2, ctx->env)));
+                (const axis2_char_t *)axiom_namespace_get_prefix(
+                    (axiom_namespace_t *)ns1, ctx->env),
+                (const axis2_char_t *)axiom_namespace_get_prefix(
+                    (axiom_namespace_t *)ns2, ctx->env)));
 }
 
 static int
@@ -932,7 +933,7 @@
     const void *a1,
     const void *a2,
     const void *context
-    )
+)
 {
     c14n_ctx_t *ctx = (c14n_ctx_t *)context;
     axiom_attribute_t *attr1 = NULL;
@@ -944,7 +945,7 @@
     if (a1 == a2) return 0;
     if (!a1) return -1;
     if (!a2) return 1;
-    
+
     attr1 = (axiom_attribute_t *)a1;
     attr2 = (axiom_attribute_t *)a2;
     ns1 = axiom_attribute_get_namespace((axiom_attribute_t *)a1, ctx->env);
@@ -952,27 +953,27 @@
 
     if (ns1 == ns2)
         return axis2_strcmp(
-                (const axis2_char_t *)axiom_attribute_get_localname(
-                    (axiom_attribute_t *)a1, ctx->env),
-                (const axis2_char_t *)axiom_attribute_get_localname(
-                    (axiom_attribute_t *)a2, ctx->env));
-    
+                   (const axis2_char_t *)axiom_attribute_get_localname(
+                       (axiom_attribute_t *)a1, ctx->env),
+                   (const axis2_char_t *)axiom_attribute_get_localname(
+                       (axiom_attribute_t *)a2, ctx->env));
+
     if (!ns1) return -1;
     if (!ns2) return 1;
 
     res = axis2_strcmp(
-            axiom_namespace_get_uri(ns1, ctx->env),
-            axiom_namespace_get_uri(ns2, ctx->env));
+              axiom_namespace_get_uri(ns1, ctx->env),
+              axiom_namespace_get_uri(ns2, ctx->env));
 
     if (res == 0)
         return axis2_strcmp(
-                (const axis2_char_t *)axiom_attribute_get_localname(
-                    (axiom_attribute_t *)a1, ctx->env),
-                (const axis2_char_t *)axiom_attribute_get_localname(
-                    (axiom_attribute_t *)a2, ctx->env));
+                   (const axis2_char_t *)axiom_attribute_get_localname(
+                       (axiom_attribute_t *)a1, ctx->env),
+                   (const axis2_char_t *)axiom_attribute_get_localname(
+                       (axiom_attribute_t *)a2, ctx->env));
     else
         return res;
-    
+
 }
 
 
@@ -981,7 +982,7 @@
 c14n_apply_on_attribute(
     const void *attribute,
     const void *context
-    )
+)
 {
     c14n_ctx_t *ctx = (c14n_ctx_t *) context;
     axiom_attribute_t *attr = (axiom_attribute_t *) attribute;
@@ -1001,15 +1002,15 @@
     }
     c14n_output(axiom_attribute_get_localname(attr, ctx->env), ctx);
     c14n_output("=\"", ctx);
-    
+
     /* TODO:DONE Normalize the text before output */
     attvalue = axiom_attribute_get_value(attr, ctx->env);
     attvalue = c14n_normalize_attribute(attvalue, (c14n_ctx_t const *)context);
 
     c14n_output(attvalue, ctx);
-    
-    c14n_output("\"", ctx); 
-    
+
+    c14n_output("\"", ctx);
+
     if (attvalue)
     {
         AXIS2_FREE(ctx->env->allocator, attvalue);
@@ -1021,37 +1022,37 @@
 c14n_apply_on_attribute_axis(
     const axiom_element_t *ele,
     const c14n_ctx_t *ctx
-    )
+)
 {
     axis2_hash_t *attr_ht = NULL;
     axis2_hash_index_t *hi = NULL;
     c14n_sorted_list_t *attr_list = c14n_sorted_list_create(ctx->env);
- 
-    attr_ht = axiom_element_get_all_attributes((axiom_element_t *)ele, 
-            ctx->env);
-    
+
+    attr_ht = axiom_element_get_all_attributes((axiom_element_t *)ele,
+              ctx->env);
+
     if(attr_ht)
     {
-        for (hi = axis2_hash_first(attr_ht, ctx->env); hi; 
-                hi = axis2_hash_next(ctx->env, hi)) 
+        for (hi = axis2_hash_first(attr_ht, ctx->env); hi;
+                hi = axis2_hash_next(ctx->env, hi))
         {
             void *v = NULL;
             axis2_hash_this(hi, NULL, NULL, &v);
-    
+
             if (v)
             {
-                C14N_SORTED_LIST_INSERT(&attr_list, v, ctx, attr_compare, 
-                        ctx->env);
+                C14N_SORTED_LIST_INSERT(&attr_list, v, ctx, attr_compare,
+                                        ctx->env);
             }
         }
 
-        C14N_SORTED_LIST_ITERATE(attr_list, ctx, c14n_apply_on_attribute, 
-                ctx->env);
+        C14N_SORTED_LIST_ITERATE(attr_list, ctx, c14n_apply_on_attribute,
+                                 ctx->env);
     }
-    
+
     /*TODO:DONE C14N_SORTED_LIST_FREE();*/
     C14N_SORTED_LIST_FREE_CONTAINER(attr_list, ctx->env);
-    
+
     return AXIS2_SUCCESS;
 
     /* TODO: Still need to add the "xml" attrs of the parents in case of doc subsets
@@ -1063,7 +1064,7 @@
 c14n_normalize_text(
     axis2_char_t *text,
     const c14n_ctx_t *ctx
-    )
+)
 {
     axis2_char_t *buf = NULL;
     axis2_char_t *endpivot = NULL;
@@ -1072,18 +1073,18 @@
     int bufsz = INIT_BUFFER_SIZE;
 
     /* TODO:DONE a better buffer implementation */
-    buf = (axis2_char_t *)(AXIS2_MALLOC(ctx->env->allocator, 
-                (sizeof(axis2_char_t) * bufsz) + 10));
+    buf = (axis2_char_t *)(AXIS2_MALLOC(ctx->env->allocator,
+                                        (sizeof(axis2_char_t) * bufsz) + 10));
     if (!buf)
     {
-        AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY, 
-                AXIS2_FAILURE);
+        AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY,
+                        AXIS2_FAILURE);
         return buf;
     }
 
     p = buf;
     endpivot = p + bufsz;
-   
+
     old = text;
 
     while (*old !='\0')
@@ -1092,68 +1093,68 @@
         {
             int size = bufsz * 2;
             axis2_char_t *temp_buf = (axis2_char_t *)(AXIS2_MALLOC(
-                        ctx->env->allocator, sizeof(axis2_char_t) * size + 10));
-            
+                                         ctx->env->allocator, sizeof(axis2_char_t) * size + 10));
+
             if (!temp_buf)
             {
-                AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY, 
-                        AXIS2_FAILURE);
+                AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY,
+                                AXIS2_FAILURE);
                 return buf;
             }
 
             memcpy(temp_buf, buf, sizeof(axis2_char_t) * bufsz + 10);
-            
+
             p = temp_buf + (p - buf);
-            
+
             AXIS2_FREE(ctx->env->allocator, buf);
             buf = temp_buf;
             bufsz = size;
             endpivot = buf + bufsz;
         }
-        
+
         switch (*old)
         {
-            case '&':
-                *p++ = '&'; 
-                *p++ = 'a'; 
-                *p++ = 'm'; 
-                *p++ = 'p'; 
-                *p++ = ';'; 
-                break;
-            case '>':
-                *p++ = '&'; 
-                *p++ = 'g'; 
-                *p++ = 't'; 
-                *p++ = ';'; 
-                break;
-            case '<':
-                *p++ = '&'; 
-                *p++ = 'l'; 
-                *p++ = 't'; 
-                *p++ = ';'; 
-                break;
-            case '\x0D':
-                *p++ = '&';
-                *p++ = '#'; 
-                *p++ = 'x'; 
-                *p++ = 'D'; 
-                *p++ = ';'; 
-                break;
-            default:
-                *p++ = *old;
+        case '&':
+            *p++ = '&';
+            *p++ = 'a';
+            *p++ = 'm';
+            *p++ = 'p';
+            *p++ = ';';
+            break;
+        case '>':
+            *p++ = '&';
+            *p++ = 'g';
+            *p++ = 't';
+            *p++ = ';';
+            break;
+        case '<':
+            *p++ = '&';
+            *p++ = 'l';
+            *p++ = 't';
+            *p++ = ';';
+            break;
+        case '\x0D':
+            *p++ = '&';
+            *p++ = '#';
+            *p++ = 'x';
+            *p++ = 'D';
+            *p++ = ';';
+            break;
+        default:
+            *p++ = *old;
         }
         old ++;
     }
     *p++ = '\0';
     return buf;
 }
- 
+
 static axis2_char_t*
 c14n_normalize_attribute(
     axis2_char_t *attval,
     const c14n_ctx_t *ctx
-    )
-{   
+)
+{
     axis2_char_t *buf = NULL;
     axis2_char_t *endpivot = NULL;
     axis2_char_t *p = NULL;
@@ -1161,12 +1162,12 @@
     int bufsz = INIT_BUFFER_SIZE;
 
     /* TODO:DONE a better buffer implementation */
-    buf = (axis2_char_t *)(AXIS2_MALLOC(ctx->env->allocator, 
-                sizeof(axis2_char_t) * INIT_BUFFER_SIZE + 10));
+    buf = (axis2_char_t *)(AXIS2_MALLOC(ctx->env->allocator,
+                                        sizeof(axis2_char_t) * INIT_BUFFER_SIZE + 10));
     if (!buf)
     {
-        AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY, 
-                AXIS2_FAILURE);
+        AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY,
+                        AXIS2_FAILURE);
         return buf;
     }
 
@@ -1181,19 +1182,19 @@
         {
             int size = bufsz * 2;
             axis2_char_t *temp_buf = (axis2_char_t *)(AXIS2_MALLOC(
-                        ctx->env->allocator, sizeof(axis2_char_t) * size + 10));
-            
+                                         ctx->env->allocator, sizeof(axis2_char_t) * size + 10));
+
             if (!temp_buf)
             {
-                AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY, 
-                        AXIS2_FAILURE);
+                AXIS2_ERROR_SET(ctx->env->error, AXIS2_ERROR_NO_MEMORY,
+                                AXIS2_FAILURE);
                 return buf;
             }
 
             memcpy(temp_buf, buf, sizeof(axis2_char_t) * bufsz + 10);
-            
+
             p = temp_buf + (p - buf);
-            
+
             AXIS2_FREE(ctx->env->allocator, buf);
             buf = temp_buf;
             bufsz = size;
@@ -1202,50 +1203,50 @@
 
         switch (*old)
         {
-            case '&':
-                *p++ = '&'; 
-                *p++ = 'a'; 
-                *p++ = 'm'; 
-                *p++ = 'p'; 
-                *p++ = ';'; 
-                break;
-            case '<':
-                *p++ = '&'; 
-                *p++ = 'l'; 
-                *p++ = 't'; 
-                *p++ = ';'; 
-                break;
-            case '"':
-                *p++ = '&'; 
-                *p++ = 'q'; 
-                *p++ = 'u'; 
-                *p++ = 'o'; 
-                *p++ = 't'; 
-                *p++ = ';'; 
-                break;
-            case '\x09':
-                *p++ = '&'; 
-                *p++ = '#'; 
-                *p++ = 'x'; 
-                *p++ = '9'; 
-                *p++ = ';'; 
-                break;
-            case '\x0A':
-                *p++ = '&'; 
-                *p++ = '#'; 
-                *p++ = 'x'; 
-                *p++ = 'A'; 
-                *p++ = ';'; 
-                break;
-            case '\x0D':
-                *p++ = '&'; 
-                *p++ = '#'; 
-                *p++ = 'x'; 
-                *p++ = 'D'; 
-                *p++ = ';'; 
-                break;
-            default:
-                *p++ = *old;
+        case '&':
+            *p++ = '&';
+            *p++ = 'a';
+            *p++ = 'm';
+            *p++ = 'p';
+            *p++ = ';';
+            break;
+        case '<':
+            *p++ = '&';
+            *p++ = 'l';
+            *p++ = 't';
+            *p++ = ';';
+            break;
+        case '"':
+            *p++ = '&';
+            *p++ = 'q';
+            *p++ = 'u';
+            *p++ = 'o';
+            *p++ = 't';
+            *p++ = ';';
+            break;
+        case '\x09':
+            *p++ = '&';
+            *p++ = '#';
+            *p++ = 'x';
+            *p++ = '9';
+            *p++ = ';';
+            break;
+        case '\x0A':
+            *p++ = '&';
+            *p++ = '#';
+            *p++ = 'x';
+            *p++ = 'A';
+            *p++ = ';';
+            break;
+        case '\x0D':
+            *p++ = '&';
+            *p++ = '#';
+            *p++ = 'x';
+            *p++ = 'D';
+            *p++ = ';';
+            break;
+        default:
+            *p++ = *old;
         }
         old ++;
     }
@@ -1259,61 +1260,61 @@
     const axiom_element_t *ele,
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    )
-{   
+)
+{
     axis2_hash_t *ns_ht = NULL;
     axis2_hash_index_t *hi = NULL;
-    
+
     c14n_sorted_list_t *out_list = c14n_sorted_list_create(ctx->env);
 
 
     ns_ht = axiom_element_get_namespaces((axiom_element_t *)ele, ctx->env);
-    
+
     if(ns_ht)
     {
-        for (hi = axis2_hash_first(ns_ht, ctx->env); hi; 
-                hi = axis2_hash_next(ctx->env, hi)) 
+        for (hi = axis2_hash_first(ns_ht, ctx->env); hi;
+                hi = axis2_hash_next(ctx->env, hi))
         {
             void *v = NULL;
             axis2_hash_this(hi, NULL, NULL, &v);
-    
+
             if (v)
             {
                 axiom_namespace_t *ns = (axiom_namespace_t *) v;
-                 
+
                 axis2_char_t *pfx = axiom_namespace_get_prefix(ns, ctx->env);
                 axis2_char_t *uri = axiom_namespace_get_uri(ns, ctx->env);
-                
+
                 if (axis2_strlen(pfx) == 0)
                 {
                     /*process for default namespace*/
-                    /*int nsc = ns_prefix_compare(c14n_ns_stack_get_default(ctx), ns, ctx); 
+                    /*int nsc = ns_prefix_compare(c14n_ns_stack_get_default(ctx), ns, ctx);
                     int len = axis2_strlen(uri);*/
 
-                    if (axis2_strlen(uri) == 0) 
+                    if (axis2_strlen(uri) == 0)
                     {
                         if (c14n_ns_stack_get_default(ctx)!=NULL)
                         {
                             c14n_ns_stack_set_default(ns, ctx);
                             C14N_SORTED_LIST_INSERT(&out_list, (void *)ns, ctx,
-                                    ns_prefix_compare, ctx->env);
+                                                    ns_prefix_compare, ctx->env);
                         }
-                             
+
                     }
                     else
                     {
-                        axiom_namespace_t *prev_def = 
+                        axiom_namespace_t *prev_def =
                             c14n_ns_stack_get_default(ctx);
 
-                        axis2_char_t *prev_def_uri = ((prev_def) ? 
-                            axiom_namespace_get_uri(prev_def, ctx->env) : NULL);
-                        
+                        axis2_char_t *prev_def_uri = ((prev_def) ?
+                                                      axiom_namespace_get_uri(prev_def, ctx->env) : NULL);
+
 
                         if (!prev_def_uri || axis2_strcmp(prev_def_uri, uri) != 0)
                         {
                             c14n_ns_stack_set_default(ns, ctx);
                             C14N_SORTED_LIST_INSERT(&out_list, (void *)ns, ctx,
-                                    ns_prefix_compare, ctx->env);
+                                                    ns_prefix_compare, ctx->env);
                         }
                     }
                 }
@@ -1322,16 +1323,16 @@
                     /*non-default namespace*/
                     c14n_ns_stack_add(ns, ctx);
                     C14N_SORTED_LIST_INSERT(&out_list, (void *)ns, ctx,
-                            ns_prefix_compare, ctx->env);
+                                            ns_prefix_compare, ctx->env);
                 }
             }
         }
     }
-    
+
     C14N_SORTED_LIST_ITERATE(out_list, ctx, c14n_apply_on_namespace, ctx->env);
-    
+
     C14N_SORTED_LIST_FREE_CONTAINER(out_list, ctx->env);
-    
+
     /*TODO:DONE C14N_SORTED_LIST_FREE();*/
     return AXIS2_SUCCESS;
 }
@@ -1341,8 +1342,8 @@
     const axiom_element_t *ele,
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    )
-{   
+)
+{
     axis2_hash_t *ns_ht = NULL;
     axis2_hash_index_t *hi = NULL;
     axiom_node_t *pnode = NULL;
@@ -1350,29 +1351,29 @@
     axiom_namespace_t *ns = NULL;
 
     c14n_sorted_list_t *out_list = c14n_sorted_list_create(ctx->env);
-    
-    pele = (axiom_element_t *)ele; 
+
+    pele = (axiom_element_t *)ele;
     pnode = (axiom_node_t *)node;
 
     /*treat the default namespace specially*/
 
     ns = axiom_element_get_namespace(pele, ctx->env,
-            pnode);
+                                     pnode);
 
     if (ns)
     {
         if (axis2_strlen(axiom_namespace_get_prefix((axiom_namespace_t *)ns,
-                        ctx->env)) == 0)
+                         ctx->env)) == 0)
         {
             axiom_namespace_t *def_ns = c14n_ns_stack_get_default(ctx);
             if (def_ns || axis2_strlen(axiom_namespace_get_uri(
-                            (axiom_namespace_t *)ns, ctx->env)) != 0)
+                                           (axiom_namespace_t *)ns, ctx->env)) != 0)
             {
                 if (ns_uri_compare(ns, def_ns, ctx) != 0)
                 {
                     c14n_ns_stack_set_default(ns, ctx);
                     C14N_SORTED_LIST_INSERT(&out_list, (void *)ns,
-                            ctx, ns_prefix_compare, ctx->env);
+                                            ctx, ns_prefix_compare, ctx->env);
                 }
             }
         }
@@ -1382,26 +1383,26 @@
     {
         pele = AXIOM_NODE_GET_DATA_ELEMENT((axiom_node_t *)pnode, ctx->env);
         ns_ht = axiom_element_get_namespaces((axiom_element_t *)pele, ctx->env);
-        
+
         if (ns_ht)
         {
-            for (hi = axis2_hash_first(ns_ht, ctx->env); hi; 
-                    hi = axis2_hash_next(ctx->env, hi)) 
+            for (hi = axis2_hash_first(ns_ht, ctx->env); hi;
+                    hi = axis2_hash_next(ctx->env, hi))
             {
                 void *v = NULL;
                 axis2_hash_this(hi, NULL, NULL, &v);
-        
+
                 if (v)
                 {
                     axis2_char_t *pfx = NULL;
                     ns = (axiom_namespace_t *) v;
-                     
+
                     pfx = axiom_namespace_get_prefix(ns, ctx->env);
                     /*axis2_char_t *uri = axiom_namespace_get_uri(ns, ctx->env);*/
-                    
+
                     if (axis2_strlen(pfx) == 0)
                     {
-                        /* process for default namespace. 
+                        /* process for default namespace.
                          * NOTE: This part was taken out of here due to the 
                          * search thruogh parent-axis
                          * */
@@ -1413,7 +1414,7 @@
                         {
                             c14n_ns_stack_add(ns, ctx);
                             C14N_SORTED_LIST_INSERT(&out_list, (void *)ns, ctx,
-                                    ns_prefix_compare, ctx->env);
+                                                    ns_prefix_compare, ctx->env);
                         }
                     }
                 }
@@ -1422,7 +1423,7 @@
         pnode = AXIOM_NODE_GET_PARENT((axiom_node_t *)pnode, ctx->env);
     } /*while*/
     C14N_SORTED_LIST_ITERATE(out_list, ctx, c14n_apply_on_namespace , ctx->env);
-    
+
     C14N_SORTED_LIST_FREE_CONTAINER(out_list, ctx->env);
 
     /*TODO:DONE C14N_SORTED_LIST_FREE();*/
@@ -1433,14 +1434,14 @@
 c14n_apply_on_namespace(
     const void *namespace,
     const void *context
-    )
+)
 {
     axiom_namespace_t *ns = (axiom_namespace_t *)namespace;
     c14n_ctx_t *ctx = (c14n_ctx_t *)context;
- 
+
     axis2_char_t *pfx = axiom_namespace_get_prefix(ns, ctx->env);
     axis2_char_t *uri = axiom_namespace_get_uri(ns, ctx->env);
-    
+
     /*c14n_output(" *", ctx);
     c14n_output(axiom_namespace_to_string(ns, ctx->env), ctx);
     c14n_output("*", ctx);*/
@@ -1452,20 +1453,20 @@
     }
     else
         c14n_output(" xmlns", ctx);
-    
+
     c14n_output("=\"", ctx);
-    
+
     if (axis2_strlen(uri) > 0)
         c14n_output(uri, ctx);
     c14n_output("\"", ctx);
-    
+
 }
 
-static void 
+static void
 c14n_output(
-    const axis2_char_t *str, 
+    const axis2_char_t *str,
     const c14n_ctx_t *ctx
-    )
+)
 {
 #ifdef C14N_DEBUG
     printf("%s", str);
@@ -1473,7 +1474,7 @@
     if (ctx->use_stream)
     {
         AXIS2_STREAM_WRITE(ctx->outstream, ctx->env, str,
-                axis2_strlen(str)*sizeof(axis2_char_t));
+                           axis2_strlen(str)*sizeof(axis2_char_t));
     }
 #endif
 }
@@ -1484,14 +1485,14 @@
     const axiom_node_t *node,
     const axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    )
+)
 {
     axis2_bool_t vu = c14n_ns_visibly_utilized(ele, node, ns, ctx);
 
     if (vu || (ctx->ns_prefixes && axis2_array_list_contains(
-                (axis2_array_list_t*)(ctx->ns_prefixes), ctx->env, 
-                (void*)(axiom_namespace_get_prefix((axiom_namespace_t*)ns,
-                        ctx->env)))))
+                   (axis2_array_list_t*)(ctx->ns_prefixes), ctx->env,
+                   (void*)(axiom_namespace_get_prefix((axiom_namespace_t*)ns,
+                                                      ctx->env)))))
         return c14n_no_output_ancestor_uses_prefix(ele, node, ns, ctx);
 
     return AXIS2_FALSE;
@@ -1503,20 +1504,20 @@
     const axiom_node_t *node,
     const axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    )
+)
 {
     axis2_bool_t vu = AXIS2_FALSE;
     axiom_namespace_t *ns_ele = NULL;
 
-    axis2_char_t *pfx = axiom_namespace_get_prefix((axiom_namespace_t*)ns, 
-            ctx->env);
-    axis2_char_t *uri = axiom_namespace_get_uri((axiom_namespace_t *)ns, 
-            ctx->env);
+    axis2_char_t *pfx = axiom_namespace_get_prefix((axiom_namespace_t*)ns,
+                        ctx->env);
+    axis2_char_t *uri = axiom_namespace_get_uri((axiom_namespace_t *)ns,
+                        ctx->env);
     axis2_char_t *pfx_ele = NULL;
     axis2_char_t *uri_ele = NULL;
     ns_ele = axiom_element_get_namespace((axiom_element_t*)ele, ctx->env,
-            (axiom_node_t *)node);
-    
+                                         (axiom_node_t *)node);
+
     if (ns_ele)  /* return AXIS2_FALSE; TODO:check */
     {
         pfx_ele = axiom_namespace_get_prefix(ns_ele, ctx->env);
@@ -1527,27 +1528,27 @@
     else
     {
         axis2_hash_t *attr_ht = axiom_element_get_all_attributes(
-                (axiom_element_t *)ele, ctx->env);
+                                    (axiom_element_t *)ele, ctx->env);
         axis2_hash_index_t *hi = NULL;
         if (attr_ht)
         {
-            for (hi = axis2_hash_first(attr_ht, ctx->env); hi; 
-                    hi = axis2_hash_next(ctx->env, hi)) 
+            for (hi = axis2_hash_first(attr_ht, ctx->env); hi;
+                    hi = axis2_hash_next(ctx->env, hi))
             {
                 void *v = NULL;
                 axis2_hash_this(hi, NULL, NULL, &v);
-        
+
                 if (v)
                 {
                     axiom_attribute_t *attr = (axiom_attribute_t*)v;
                     axiom_namespace_t *ns_attr = axiom_attribute_get_namespace(
-                            attr, ctx->env);
+                                                     attr, ctx->env);
                     axis2_char_t *attr_pfx = NULL;
-                    
+
                     /*if in_nodelist(attr) {*/
                     if (ns_attr)
                         attr_pfx = axiom_namespace_get_prefix(
-                                ns_attr, ctx->env);
+                                       ns_attr, ctx->env);
 
                     if (axis2_strcmp(attr_pfx, pfx) == 0)
                     {
@@ -1558,7 +1559,7 @@
                 }
             }
         }
-     
+
     }
 
     return vu;
@@ -1568,11 +1569,11 @@
 in_nodeset(
     const axiom_node_t *node,
     const c14n_ctx_t *ctx
-    )
+)
 {
     axiom_node_t *pnode = NULL;
     pnode = AXIOM_NODE_GET_PARENT((axiom_node_t *)node, ctx->env);
-    
+
     while (pnode)
     {
         if (ctx->node == pnode) return AXIS2_TRUE;
@@ -1588,26 +1589,26 @@
     const axiom_node_t *node,
     const axiom_namespace_t *ns,
     const c14n_ctx_t *ctx
-    )
+)
 {
-    axis2_char_t *pfx = axiom_namespace_get_prefix((axiom_namespace_t*)ns, 
-            ctx->env);
-    axis2_char_t *uri = axiom_namespace_get_uri((axiom_namespace_t *)ns, 
-            ctx->env);
-    
-    axiom_node_t *parent_node = AXIOM_NODE_GET_PARENT((axiom_node_t *)node, 
-            ctx->env);
-    axiom_element_t *parent_element = NULL; 
+    axis2_char_t *pfx = axiom_namespace_get_prefix((axiom_namespace_t*)ns,
+                        ctx->env);
+    axis2_char_t *uri = axiom_namespace_get_uri((axiom_namespace_t *)ns,
+                        ctx->env);
+
+    axiom_node_t *parent_node = AXIOM_NODE_GET_PARENT((axiom_node_t *)node,
+                                ctx->env);
+    axiom_element_t *parent_element = NULL;
     axiom_namespace_t *parent_ns = NULL;
     axis2_char_t *parent_pfx = NULL;
     axis2_char_t *parent_uri = NULL;
 
     /* assuming the parent  of an element is always an element node in AXIOM*/
-    while (parent_node) 
+    while (parent_node)
     {
         axis2_hash_index_t *hi = NULL;
         axis2_hash_t *attr_ht = NULL;
-       
+
         /* TODO:
          * HACK: since we only use a single node as the subset
          * the following hack should work instead of a more
@@ -1619,60 +1620,60 @@
              * so the prefix is not used*/
             return AXIS2_TRUE;
         }
-        
+
         /* if (in_nodeset(parent)){*/
         parent_element = AXIOM_NODE_GET_DATA_ELEMENT(
-                (axiom_node_t *)parent_node, ctx->env);
-        parent_ns = axiom_element_get_namespace((axiom_element_t *) 
-                parent_element, ctx->env, (axiom_node_t *)parent_node);
-        
-        if (parent_ns)  
+                             (axiom_node_t *)parent_node, ctx->env);
+        parent_ns = axiom_element_get_namespace((axiom_element_t *)
+                                                parent_element, ctx->env, (axiom_node_t *)parent_node);
+
+        if (parent_ns)
         {
             parent_pfx = axiom_namespace_get_prefix((axiom_namespace_t *)parent_ns,
-                    ctx->env);
+                                                    ctx->env);
             if (axis2_strcmp(pfx, parent_pfx) == 0)
             {
                 parent_uri = axiom_namespace_get_uri((axiom_namespace_t*)parent_ns,
-                        ctx->env);
+                                                     ctx->env);
                 return (!(axis2_strcmp(uri, parent_uri) == 0));
             }
         }
 
         attr_ht = axiom_element_get_all_attributes(
-                (axiom_element_t *)parent_element, ctx->env);
+                      (axiom_element_t *)parent_element, ctx->env);
         if (attr_ht)
         {
-            for (hi = axis2_hash_first(attr_ht, ctx->env); hi; 
-                    hi = axis2_hash_next(ctx->env, hi)) 
+            for (hi = axis2_hash_first(attr_ht, ctx->env); hi;
+                    hi = axis2_hash_next(ctx->env, hi))
             {
                 void *v = NULL;
                 axis2_hash_this(hi, NULL, NULL, &v);
-                
+
                 if (v)
                 {
                     axiom_attribute_t *attr = (axiom_attribute_t*)v;
                     axiom_namespace_t *attr_ns = axiom_attribute_get_namespace(
-                            attr, ctx->env);
+                                                     attr, ctx->env);
                     axis2_char_t *attr_pfx = NULL;
                     axis2_char_t *attr_uri = NULL;
 
                     if (attr_ns)
                     {
                         attr_pfx = axiom_namespace_get_prefix(
-                                attr_ns, ctx->env);
-                        attr_uri = axiom_namespace_get_uri(attr_ns, 
-                                ctx->env);
+                                       attr_ns, ctx->env);
+                        attr_uri = axiom_namespace_get_uri(attr_ns,
+                                                           ctx->env);
 
                         if (axis2_strcmp(attr_pfx, pfx) == 0)
-                            return (!(axis2_strcmp(attr_uri, uri) == 0)); 
-                            /*test for this case*/
-                   }
+                            return (!(axis2_strcmp(attr_uri, uri) == 0));
+                        /*test for this case*/
+                    }
                 }
             }
         }
         /*}*/
-        parent_node = AXIOM_NODE_GET_PARENT((axiom_node_t *)parent_node, 
-                ctx->env);
+        parent_node = AXIOM_NODE_GET_PARENT((axiom_node_t *)parent_node,
+                                            ctx->env);
     }
 
     return AXIS2_TRUE;

Modified: webservices/rampart/trunk/c/src/omxmlsec/c14n/sorted_list.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/c14n/sorted_list.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/c14n/sorted_list.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/c14n/sorted_list.c Wed Mar 28 03:21:59 2007
@@ -29,13 +29,13 @@
  * reimplemented
  * */
 
-void 
+void
 sorted_list_iterate(
     c14n_sorted_list_t *root,
     const void *ctx,
     void(*perform)(const void *, const void *),
     const axis2_env_t *env
-    )
+)
 {
     if (!root) return;
     if(root->left) sorted_list_iterate(root->left, ctx, perform, env);
@@ -49,30 +49,30 @@
     void *val,
     const void *ctx,
     int(*compar)(const void *, const void *, const void *)
-    ) 
+)
 {
-   if(!(*node)) {
-      *node = (c14n_sorted_list_t *) malloc(sizeof(node));
-      (*node)->left = (*node)->right = NULL;
-      (*node)->val = val;
-      return;
-   }
+    if(!(*node)) {
+        *node = (c14n_sorted_list_t *) malloc(sizeof(node));
+        (*node)->left = (*node)->right = NULL;
+        (*node)->val = val;
+        return;
+    }
 
-   if(compar(val, (*node)->val, ctx)<0)
-      sorted_list_insert(&(*node)->left, val, ctx, compar);
-   else if(compar(val, (*node)->val, ctx)>0)
-      sorted_list_insert(&(*node)->right, val, ctx, compar);
-   else; /*neglect if the same ns*/
+    if(compar(val, (*node)->val, ctx)<0)
+        sorted_list_insert(&(*node)->left, val, ctx, compar);
+    else if(compar(val, (*node)->val, ctx)>0)
+        sorted_list_insert(&(*node)->right, val, ctx, compar);
+    else; /*neglect if the same ns*/
 }
 
 void
 sorted_list_free_container(
     c14n_sorted_list_t *root,
     const axis2_env_t *env
-    )
+)
 {
     if (!root) return;
-    if (root->left) 
+    if (root->left)
     {
         sorted_list_free_container(root->left, env);
         AXIS2_FREE(env->allocator, root->left);
@@ -85,12 +85,12 @@
     /*if (root) AXIS2_FREE(env->allocator, root);*/
 }
 
-void 
+void
 sorted_list_free(
     c14n_sorted_list_t *root,
     void(*free)(const void *, const void *),
     const axis2_env_t *env
-    )
+)
 {
     sorted_list_iterate(root, NULL, free, env);
 }
@@ -99,12 +99,12 @@
 {
     printf("%s\n", (char *)p);
 }
-
+ 
 void printout(c14n_sorted_list_t * sorted_list) 
 {
     sorted_list_iterate(sorted_list, print_str);
 }
-
+ 
 static int
 cmpstringp(
     const void *p1,
@@ -113,11 +113,11 @@
 {
     return strcmp((char *) p1, (char *) p2);
 }
-
-
+ 
+ 
 int main() {
    c14n_sorted_list_t * curr, * root;
-
+ 
    root = c14n_sorted_list_create(curr);
    char *c1 = "aaa";
    char *c2 = "bac";
@@ -125,7 +125,7 @@
    char *c4 = "bab";
    char *c5 = "aca";
    char *c6 = "babaaa";
-
+ 
    AXIS2_SORTED_LIST_INSERT(&root, (void *) c1, cmpstringp, env);
    AXIS2_SORTED_LIST_INSERT(&root, (void *) c2, cmpstringp, env);
    AXIS2_SORTED_LIST_INSERT(&root, (void *) c3, cmpstringp, env);
@@ -135,5 +135,5 @@
    printout(root);
    return 0;
 }
-
+ 
 */

Modified: webservices/rampart/trunk/c/src/omxmlsec/cipher.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/cipher.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/cipher.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/cipher.c Wed Mar 28 03:21:59 2007
@@ -25,7 +25,7 @@
 
 AXIS2_EXTERN openssl_cipher_property_t *AXIS2_CALL
 oxs_get_cipher_property_for_url(const axis2_env_t *env,
-        axis2_char_t *url)
+                                axis2_char_t *url)
 {
     openssl_cipher_property_t *cprop = NULL;
     axis2_char_t *cipher_name = NULL;
@@ -37,7 +37,7 @@
     cipher_name = oxs_get_cipher_name_for_url(env, url);
     if((!cipher_name) || (0 == axis2_strcmp(cipher_name, ""))){
         oxs_error(env, ERROR_LOCATION,
-                        OXS_ERROR_INVALID_DATA, "Cannot populate cipher property");
+                  OXS_ERROR_INVALID_DATA, "Cannot populate cipher property");
         return NULL;
     }
     ret = openssl_cipher_property_set_name(cprop, env , cipher_name);
@@ -46,7 +46,7 @@
     if (ret == AXIS2_FAILURE)
     {
         oxs_error(env, ERROR_LOCATION,
-                OXS_ERROR_INVALID_DATA, "Cannot populate cipher property");
+                  OXS_ERROR_INVALID_DATA, "Cannot populate cipher property");
         return NULL;
 
     }
@@ -55,7 +55,7 @@
 
 AXIS2_EXTERN axis2_char_t* AXIS2_CALL
 oxs_get_cipher_name_for_url(const axis2_env_t *env,
-        axis2_char_t *url)
+                            axis2_char_t *url)
 {
 
     axis2_char_t *cipher_name = NULL;
@@ -83,7 +83,7 @@
     else
     {
         oxs_error(env, ERROR_LOCATION,
-                OXS_ERROR_UNSUPPORTED_ALGO, "Algorithm not supported");
+                  OXS_ERROR_UNSUPPORTED_ALGO, "Algorithm not supported");
         return NULL;
     }
 
@@ -92,7 +92,7 @@
 
 AXIS2_EXTERN axis2_char_t* AXIS2_CALL
 oxs_get_cipher_url_for_name(const axis2_env_t *env,
-        axis2_char_t *name)
+                            axis2_char_t *name)
 {
 
     axis2_char_t *cipher_url = NULL;
@@ -120,7 +120,7 @@
     else
     {
         oxs_error(env, ERROR_LOCATION,
-                OXS_ERROR_INVALID_DATA, "Name not supported");
+                  OXS_ERROR_INVALID_DATA, "Name not supported");
         return NULL;
     }
 

Modified: webservices/rampart/trunk/c/src/omxmlsec/ctx.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/ctx.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/ctx.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/ctx.c Wed Mar 28 03:21:59 2007
@@ -22,7 +22,7 @@
 
 
 struct oxs_ctx_t
-{    
+{
     /*Encryption mode*/
     oxs_ctx_mode_t mode;
 
@@ -81,7 +81,7 @@
 /*public functions*/
 axis2_status_t AXIS2_CALL
 oxs_ctx_free(oxs_ctx_t *ctx,
-        const axis2_env_t *env
+             const axis2_env_t *env
             )
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

Modified: webservices/rampart/trunk/c/src/omxmlsec/encryption.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/encryption.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/encryption.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/encryption.c Wed Mar 28 03:21:59 2007
@@ -34,36 +34,36 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 oxs_encryption_symmetric_crypt(const axis2_env_t *env,
-    oxs_ctx_t * enc_ctx,
-    oxs_buffer_t *input,
-    oxs_buffer_t *result)
+                               oxs_ctx_t * enc_ctx,
+                               oxs_buffer_t *input,
+                               oxs_buffer_t *result)
 {
     openssl_cipher_ctx_t *oc_ctx = NULL;
     openssl_cipher_property_t *cprop = NULL;
     axis2_char_t *iv = NULL;
     axis2_char_t *cipher_name = NULL;
     axis2_status_t ret = AXIS2_FAILURE;
-    
+
     /*Get cipher property*/
     cprop =  oxs_get_cipher_property_for_url(env, oxs_ctx_get_enc_mtd_algorithm(enc_ctx, env));
     if(!cprop){
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "Cipher property is NULL");
+                  "Cipher property is NULL");
         return AXIS2_FAILURE;
     }
     /*Get the IV*/
     iv = axis2_strndup((axis2_char_t*)oxs_iv_generate_for_algo(
-                env,
-                oxs_ctx_get_enc_mtd_algorithm(enc_ctx, env)),
-            openssl_cipher_property_get_iv_size(cprop, env),
-            env);
+                           env,
+                           oxs_ctx_get_enc_mtd_algorithm(enc_ctx, env)),
+                       openssl_cipher_property_get_iv_size(cprop, env),
+                       env);
 
     /*Create the openssl context*/
     oc_ctx = openssl_cipher_ctx_create(env);
     if (!oc_ctx)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "openssl_cipher_ctx_create failed");
+                  "openssl_cipher_ctx_create failed");
         return AXIS2_FAILURE;
     }
 
@@ -78,17 +78,17 @@
     if (!cipher_name)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "oxs_get_cipher failed");
+                  "oxs_get_cipher failed");
 
         return AXIS2_FAILURE;
     }
     ret = openssl_cipher_ctx_set_cipher(oc_ctx,
-            env,
-            (EVP_CIPHER*)openssl_get_evp_cipher_by_name(
-                env, (axis2_char_t*)cipher_name)
-            );
-    
-    /*Now everything is ready for the en/decryption*/ 
+                                        env,
+                                        (EVP_CIPHER*)openssl_get_evp_cipher_by_name(
+                                            env, (axis2_char_t*)cipher_name)
+                                       );
+
+    /*Now everything is ready for the en/decryption*/
     /*ENCRYPTION*/
     if (oxs_ctx_get_operation(enc_ctx, env) == OXS_CTX_OPERATION_ENCRYPT)
     {
@@ -103,7 +103,7 @@
         enclen = openssl_bc_crypt(env, oc_ctx, input, output, OPENSSL_ENCRYPT);
         if(enclen < 0){
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
-                    "openssl_block_cipher_crypt FAILED");
+                      "openssl_block_cipher_crypt FAILED");
             return AXIS2_FAILURE;
         }
 
@@ -113,20 +113,20 @@
         if (ret < 0)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                    "axis2_base64_encode_binary failed");
+                      "axis2_base64_encode_binary failed");
             return AXIS2_FAILURE;
         }
 
         /*Attach the result to the result buf*/
         ret = oxs_buffer_populate(result, env, (unsigned char*)axis2_strdup(encoded_str, env), encodedlen);
-        
+
         /*Free*/
         oxs_buffer_free(output, env);
         output = NULL;
         AXIS2_FREE(env->allocator, encoded_str);
         encoded_str = NULL;
 
-    /*DECRYPTION*/
+        /*DECRYPTION*/
     }else if(oxs_ctx_get_operation(enc_ctx, env) == OXS_CTX_OPERATION_DECRYPT){
         unsigned char *decoded_data = NULL;/*Can be binary*/
         int decoded_len = -1;
@@ -141,17 +141,17 @@
         if (decoded_len < 0)
         {
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_DECRYPT_FAILED,
-                    "axis2_base64_decode_binary failed");
+                      "axis2_base64_decode_binary failed");
             return AXIS2_FAILURE;
         }
         /*Populate decoded (input to the crypto function) buffer*/
         ret = oxs_buffer_populate(decoded_buf, env, decoded_data, decoded_len);
         /*Then we decrypt*/
         enclen = openssl_bc_crypt(env, oc_ctx, decoded_buf, result, OPENSSL_DECRYPT);
-       
+
         if(enclen < 0){
             oxs_error(env, ERROR_LOCATION, OXS_ERROR_DECRYPT_FAILED,
-                    "openssl_block_cipher_crypt FAILED");
+                      "openssl_block_cipher_crypt FAILED");
             return AXIS2_FAILURE;
         }
         /*Free*/
@@ -162,10 +162,10 @@
 
     }else{
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                "Invalid operation type %d", oxs_ctx_get_operation(enc_ctx, env));
+                  "Invalid operation type %d", oxs_ctx_get_operation(enc_ctx, env));
         return AXIS2_FAILURE;
     }
- 
+
     /*Free*/
     AXIS2_FREE(env->allocator, iv);
     iv = NULL;
@@ -177,9 +177,9 @@
 
 AXIS2_EXTERN  axis2_status_t AXIS2_CALL
 oxs_encryption_asymmetric_crypt(const axis2_env_t *env,
-    oxs_asym_ctx_t *ctx,
-    oxs_buffer_t *input,
-    oxs_buffer_t *result)
+                                oxs_asym_ctx_t *ctx,
+                                oxs_buffer_t *input,
+                                oxs_buffer_t *result)
 {
     openssl_pkey_t *pkey = NULL;
     oxs_asym_ctx_operation_t operation = -1;
@@ -193,7 +193,7 @@
     if(0 != (axis2_strcmp(OXS_HREF_RSA_PKCS1, algorithm ))) {
         oxs_asym_ctx_set_algorithm(ctx, env, OXS_HREF_RSA_PKCS1);
     }*/
-    
+
     /*Set the proper padding for the algorithm*/
     if(0 == (axis2_strcmp(OXS_HREF_RSA_OAEP, algorithm))){
         padding = OPENSSL_RSA_PKCS1_OAEP_PADDING;
@@ -207,7 +207,7 @@
     if(AXIS2_FAILURE == status){
         return AXIS2_FAILURE;
     }
-        
+
     /*Check for the operation and call appropriate method*/
     operation = oxs_asym_ctx_get_operation(ctx, env);
     if(   OXS_ASYM_CTX_OPERATION_PUB_ENCRYPT == operation ){
@@ -217,7 +217,7 @@
         int enclen = -1;
         int encodedlen = -1;
         int ret = -1;
-       
+
         /*Operation is PUB ENCRYPT; Get the public key from the context*/
         x509_cert = oxs_asym_ctx_get_certificate(ctx, env);
         pkey = oxs_x509_cert_get_public_key(x509_cert, env);
@@ -227,9 +227,9 @@
         enclen = openssl_rsa_pub_encrypt(env, pkey, padding, input, out_buf);
         encodedlen = axis2_base64_encode_len(enclen);
         encoded_str = AXIS2_MALLOC(env->allocator, encodedlen);
-        ret = axis2_base64_encode(encoded_str, (const char *)oxs_buffer_get_data(out_buf, env), enclen); 
+        ret = axis2_base64_encode(encoded_str, (const char *)oxs_buffer_get_data(out_buf, env), enclen);
         status = oxs_buffer_populate(result, env, (unsigned char*)axis2_strdup(encoded_str, env), encodedlen);
-        
+
         /*Free*/
         oxs_buffer_free(out_buf, env);
         out_buf = NULL;
@@ -241,7 +241,7 @@
         oxs_buffer_t *dec_enc_buf = NULL;
         int ret = -1;
         int  declen = -1;
-        
+
         /*Operation id PRV DECRYPT; Get the private key from the context*/
         pkey = oxs_asym_ctx_get_private_key(ctx, env);
         /*Base64 decode first. Then do the decryption and populate the buffer*/
@@ -250,7 +250,7 @@
         dec_enc_buf = oxs_buffer_create(env);
         oxs_buffer_populate(dec_enc_buf, env, decoded_encrypted_str, ret);
         declen = openssl_rsa_prv_decrypt(env, pkey, padding,  dec_enc_buf, result);
-   
+
         /*Free*/
         AXIS2_FREE(env->allocator, decoded_encrypted_str);
         decoded_encrypted_str = NULL;
@@ -262,6 +262,6 @@
     }
 
     /*TODO Set certificate information taken from the PEM file */
-    
+
     return AXIS2_SUCCESS;
 }

Modified: webservices/rampart/trunk/c/src/omxmlsec/error.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/error.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/error.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/error.c Wed Mar 28 03:21:59 2007
@@ -79,7 +79,7 @@
 
 AXIS2_EXTERN void   AXIS2_CALL
 oxs_error(const axis2_env_t *env, const char* file, int line, const char* func,
-        int code, const char* msg, ...)
+          int code, const char* msg, ...)
 {
     const char* error_msg = NULL;
     char value[AXIS2_LEN_VALUE+1];
@@ -91,6 +91,6 @@
     AXIS2_VSNPRINTF(value, AXIS2_LEN_VALUE, msg, ap);
     va_end(ap);
 
-    AXIS2_LOG_INFO(env->log, "OXS ERROR [%s:%d in %s] %s , %s", file, line, func, error_msg, value);     
+    AXIS2_LOG_INFO(env->log, "OXS ERROR [%s:%d in %s] %s , %s", file, line, func, error_msg, value);
     printf("\nOXS ERROR [%s:%d in %s] %s , %s\n", file, line, func, error_msg, value);
 }

Modified: webservices/rampart/trunk/c/src/omxmlsec/iv.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/iv.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/iv.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/iv.c Wed Mar 28 03:21:59 2007
@@ -26,7 +26,7 @@
 
 AXIS2_EXTERN axis2_char_t* AXIS2_CALL
 oxs_iv_generate_for_algo(const axis2_env_t *env,
-        axis2_char_t *key_algo)
+                         axis2_char_t *key_algo)
 {
     axis2_char_t* iv = NULL;
     openssl_cipher_property_t *cprop = NULL;
@@ -35,7 +35,7 @@
     if (!cprop)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
-                "openssl_get_cipher_property failed");
+                  "openssl_get_cipher_property failed");
         return NULL;
     }
     size = openssl_cipher_property_get_iv_size(cprop, env);

Modified: webservices/rampart/trunk/c/src/omxmlsec/key.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/key.c?view=diff&rev=523261&r1=523260&r2=523261
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/key.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/key.c Wed Mar 28 03:21:59 2007
@@ -37,8 +37,8 @@
 oxs_key_get_data(
     const oxs_key_t *key,
     const axis2_env_t *env)
-{    
-    AXIS2_ENV_CHECK(env, NULL);    
+{
+    AXIS2_ENV_CHECK(env, NULL);
 
     return oxs_buffer_get_data(key->buf, env);
 }
@@ -48,7 +48,7 @@
     const oxs_key_t *key,
     const axis2_env_t *env)
 {
-    AXIS2_ENV_CHECK(env, NULL);    
+    AXIS2_ENV_CHECK(env, NULL);
 
     return key->name;
 
@@ -60,7 +60,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     return oxs_buffer_get_size(key->buf, env);
 }
 
@@ -114,7 +114,7 @@
 AXIS2_EXTERN oxs_key_t *AXIS2_CALL
 oxs_key_create(const axis2_env_t *env)
 {
-	oxs_key_t *key = NULL;
+    oxs_key_t *key = NULL;
     AXIS2_ENV_CHECK(env, NULL);
 
     key = (oxs_key_t*)AXIS2_MALLOC(env->allocator, sizeof(oxs_key_t));
@@ -128,7 +128,7 @@
     key->buf = NULL;
     key->name = NULL;
     key->usage = -1;
-    
+
     /*additionally we need to create a buffer to keep data*/
     key->buf = oxs_buffer_create(env);
 
@@ -138,7 +138,7 @@
 
 axis2_status_t AXIS2_CALL
 oxs_key_free(oxs_key_t *key,
-        const axis2_env_t *env)
+             const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
@@ -155,11 +155,11 @@
 
 axis2_status_t AXIS2_CALL
 oxs_key_populate(oxs_key_t *key,
-        const axis2_env_t *env,
-        unsigned char *data,
-        axis2_char_t *name,
-        int size,
-        int usage)
+                 const axis2_env_t *env,
+                 unsigned char *data,
+                 axis2_char_t *name,
+                 int size,
+                 int usage)
 {
     int ret;
 
@@ -176,8 +176,8 @@
 
 axis2_status_t AXIS2_CALL
 oxs_key_read_from_file(oxs_key_t *key,
-        const axis2_env_t *env,
-        axis2_char_t *file_name)
+                       const axis2_env_t *env,
+                       axis2_char_t *file_name)
 {
     oxs_buffer_t *buf = NULL;
     axis2_status_t status = AXIS2_FAILURE;
@@ -186,8 +186,8 @@
     status = oxs_buffer_read_file(buf, env, file_name);
 
     status = oxs_key_populate(key, env,
-            oxs_buffer_get_data(buf, env), file_name,
-            oxs_buffer_get_size(buf, env), OXS_KEY_USAGE_NONE);
+                              oxs_buffer_get_data(buf, env), file_name,
+                              oxs_buffer_get_size(buf, env), OXS_KEY_USAGE_NONE);
 
     return status;
 
@@ -195,8 +195,8 @@
 
 axis2_status_t AXIS2_CALL
 oxs_key_for_algo(oxs_key_t *key,
-        const axis2_env_t *env,
-        axis2_char_t *key_algo)
+                 const axis2_env_t *env,
+                 axis2_char_t *key_algo)
 {
     oxs_buffer_t *key_buf = NULL;
     openssl_cipher_property_t * cprop = NULL;
@@ -209,7 +209,7 @@
     if (!cprop)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
-                "openssl_get_cipher_property failed");
+                  "openssl_get_cipher_property failed");
         return AXIS2_FAILURE;
     }
 
@@ -221,7 +221,7 @@
     if (ret == AXIS2_FAILURE)
     {
         oxs_error(env, ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
-                "generate_random_data failed");
+                  "generate_random_data failed");
         return AXIS2_FAILURE;
     }
 
@@ -229,8 +229,8 @@
     temp_str = oxs_buffer_get_data(key_buf, env);
 
     ret = oxs_key_populate(key, env,
-            oxs_buffer_get_data(key_buf, env), NULL,
-            oxs_buffer_get_size(key_buf, env), OXS_KEY_USAGE_NONE);
+                           oxs_buffer_get_data(key_buf, env), NULL,
+                           oxs_buffer_get_size(key_buf, env), OXS_KEY_USAGE_NONE);
 
     /* Duplicate key data and free key_buf*/
     return ret;