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 sh...@apache.org on 2009/08/31 08:39:07 UTC

svn commit: r809469 - in /webservices/rampart/trunk/c/src/omxmlsec: axiom.c tokens/token_binary_security_token.c xml_encryption.c xml_signature.c

Author: shankar
Date: Mon Aug 31 06:39:07 2009
New Revision: 809469

URL: http://svn.apache.org/viewvc?rev=809469&view=rev
Log:
improving log messages, error checking

Modified:
    webservices/rampart/trunk/c/src/omxmlsec/axiom.c
    webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c
    webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c
    webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c

Modified: webservices/rampart/trunk/c/src/omxmlsec/axiom.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/axiom.c?rev=809469&r1=809468&r2=809469&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/axiom.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/axiom.c Mon Aug 31 06:39:07 2009
@@ -396,60 +396,7 @@
     const axutil_env_t *env,  
     axis2_char_t* buffer)
 {
-    axiom_document_t *doc = NULL;
-    axiom_stax_builder_t *builder = NULL;
-    axiom_xml_reader_t *reader = NULL;
-    axiom_node_t *node = NULL;
-
-    if(!buffer)
-    {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[rampart]Deserialise method called with invalid buffer.");
-        return NULL;
-    }
-    reader = axiom_xml_reader_create_for_memory(
-        env, (void*)buffer, axutil_strlen(buffer), NULL, AXIS2_XML_PARSER_TYPE_BUFFER);
-
-    if(!reader)
-    {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[rampart]Could not be able to create axiom_xml_reader.");
-        return NULL;
-    }
-
-    builder = axiom_stax_builder_create(env, reader);
-    if(!builder)
-    {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[rampart]Could not be able to create axiom_stax_builder.");
-        return NULL;
-    }
-
-    doc = axiom_document_create(env, NULL, builder);
-    if(!doc)
-    {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[rampart]Could not be able to create axiom_document.");
-        return NULL;
-    }
-
-    node = axiom_document_build_all(doc, env);
-    if(!node)
-    {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[rampart]Could not be able to deserialize the node.");
-		axiom_document_free(doc, env);
-        return NULL;
-    }
-
-    /* Free stax builder. The stax builder will free the reader. */
-    axiom_stax_builder_free_self(builder, env);
-    builder = NULL;
-
-	axiom_document_free_self(doc, env);
-	doc = NULL;
-
-    return node;
+    return axiom_util_string_to_node(env, buffer);
 }
 
 /**
@@ -680,23 +627,5 @@
     const axutil_env_t *env,
     axiom_node_t *node)
 {
-    axis2_char_t* node_string = NULL;
-    axiom_node_t *clone = NULL;
-
-    if(!node)
-    {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[rampart]Could not be able to clone the node. Given node is not valid.");
-        return NULL;
-    }
-
-    node_string = axiom_node_sub_tree_to_string(node, env);
-    clone = oxs_axiom_deserialize_node(env, node_string);
-
-    if(node_string)
-    {
-        AXIS2_FREE(env->allocator, node_string);
-    }
-
-    return clone;
+    return axiom_util_clone_node(env, node);
 }

Modified: webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c?rev=809469&r1=809468&r2=809469&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c Mon Aug 31 06:39:07 2009
@@ -40,14 +40,14 @@
     axiom_namespace_t *ns = NULL;
 
     ns_obj = axiom_namespace_create(env, OXS_WSSE_NS, OXS_WSSE);
-    ns = axiom_namespace_create(env,RAMPART_WSU_XMLNS,OXS_WSU);
+    ns = axiom_namespace_create(env, RAMPART_WSU_XMLNS, OXS_WSU);
 
-    binary_security_token_ele = axiom_element_create(
-        env, parent, OXS_NODE_BINARY_SECURITY_TOKEN, ns_obj, &binary_security_token_node);
-    if (!binary_security_token_ele)
+    binary_security_token_ele = axiom_element_create(env, parent, OXS_NODE_BINARY_SECURITY_TOKEN,
+        ns_obj, &binary_security_token_node);
+    if(!binary_security_token_ele)
     {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "[rampart]Error creating %s element.", OXS_NODE_BINARY_SECURITY_TOKEN);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s element.",
+            OXS_NODE_BINARY_SECURITY_TOKEN);
         axiom_namespace_free(ns_obj, env);
         axiom_namespace_free(ns, env);
         return NULL;
@@ -69,24 +69,24 @@
 
     if(!id)
     {
-        id = oxs_util_generate_id(env,(axis2_char_t*)OXS_CERT_ID);
+        id = oxs_util_generate_id(env, (axis2_char_t*)OXS_CERT_ID);
     }
 
-    id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id,ns);
-    encoding_type_att =  axiom_attribute_create(env, OXS_ATTR_ENCODING_TYPE, encoding_type, NULL);
-    value_type_att =  axiom_attribute_create(env, OXS_ATTR_VALUE_TYPE, value_type, NULL);
-
-    ret = axiom_element_add_attribute(
-        binary_security_token_ele, env, id_attr, binary_security_token_node);
-    ret = axiom_element_add_attribute(
-        binary_security_token_ele, env, encoding_type_att, binary_security_token_node);
-    ret = axiom_element_add_attribute(
-        binary_security_token_ele, env, value_type_att, binary_security_token_node);
+    id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id, ns);
+    encoding_type_att = axiom_attribute_create(env, OXS_ATTR_ENCODING_TYPE, encoding_type, NULL);
+    value_type_att = axiom_attribute_create(env, OXS_ATTR_VALUE_TYPE, value_type, NULL);
+
+    ret = axiom_element_add_attribute(binary_security_token_ele, env, id_attr,
+        binary_security_token_node);
+    ret = axiom_element_add_attribute(binary_security_token_ele, env, encoding_type_att,
+        binary_security_token_node);
+    ret = axiom_element_add_attribute(binary_security_token_ele, env, value_type_att,
+        binary_security_token_node);
 
     if(data)
     {
-        ret = axiom_element_set_text(
-            binary_security_token_ele, env, data, binary_security_token_node);
+        ret = axiom_element_set_text(binary_security_token_ele, env, data,
+            binary_security_token_node);
     }
 
     return binary_security_token_node;

Modified: webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c?rev=809469&r1=809468&r2=809469&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c Mon Aug 31 06:39:07 2009
@@ -47,10 +47,11 @@
 *   
 */
 static axis2_status_t
-oxs_xml_enc_populate_stref_with_key_identifier(const axutil_env_t *env,
-        oxs_asym_ctx_t *asym_ctx,
-        axiom_node_t *stref_node, 
-        axis2_bool_t is_thumbprint)
+oxs_xml_enc_populate_stref_with_key_identifier(
+    const axutil_env_t *env,
+    oxs_asym_ctx_t *asym_ctx,
+    axiom_node_t *stref_node,
+    axis2_bool_t is_thumbprint)
 {
     axiom_node_t *key_identifier_node = NULL;
     axis2_char_t *key_identifier = NULL;
@@ -58,20 +59,23 @@
     oxs_x509_cert_t *cert = NULL;
 
     cert = oxs_asym_ctx_get_certificate(asym_ctx, env);
-    if(is_thumbprint){
+    if(is_thumbprint)
+    {
         key_identifier = oxs_x509_cert_get_fingerprint(cert, env);
         val_type = OXS_X509_TUMBP_PRINT_SHA1;
-    }else{
+    }
+    else
+    {
         key_identifier = oxs_x509_cert_get_key_identifier(cert, env);
         val_type = OXS_X509_SUBJ_KI;
     }
-    if(!key_identifier){
+    if(!key_identifier)
+    {
         return AXIS2_FAILURE;
     }
     /*Build KeyIdentifier node*/
-    key_identifier_node = oxs_token_build_key_identifier_element(
-                              env, stref_node, OXS_ENCODING_BASE64BINARY,
-                              val_type, key_identifier);
+    key_identifier_node = oxs_token_build_key_identifier_element(env, stref_node,
+        OXS_ENCODING_BASE64BINARY, val_type, key_identifier);
     return AXIS2_SUCCESS;
 }
 
@@ -85,10 +89,11 @@
 *   </KeyInfo>
 */
 static axis2_status_t
-oxs_xml_enc_populate_stref_with_bst(const axutil_env_t *env,
-                                    oxs_asym_ctx_t *asym_ctx,
-                                    axiom_node_t *stref_node,
-                                    axiom_node_t *parent)
+oxs_xml_enc_populate_stref_with_bst(
+    const axutil_env_t *env,
+    oxs_asym_ctx_t *asym_ctx,
+    axiom_node_t *stref_node,
+    axiom_node_t *parent)
 {
     axiom_node_t *ref_node = NULL;
     axiom_node_t *bst_node = NULL;
@@ -100,14 +105,16 @@
     cert = oxs_asym_ctx_get_certificate(asym_ctx, env);
     bst_data = oxs_x509_cert_get_data(cert, env);
 
-    if(!bst_data){
+    if(!bst_data)
+    {
         return AXIS2_FAILURE;
     }
     /*Generate an ID for BST*/
-    id = oxs_util_generate_id(env,(axis2_char_t*)OXS_CERT_ID);
+    id = oxs_util_generate_id(env, (axis2_char_t*)OXS_CERT_ID);
 
     /*Build BinarySecurityToken as a child of parent(wsse:Security)*/
-    bst_node = oxs_token_build_binary_security_token_element(env, parent, id, OXS_ENCODING_BASE64BINARY, OXS_VALUE_X509V3, bst_data);
+    bst_node = oxs_token_build_binary_security_token_element(env, parent, id,
+        OXS_ENCODING_BASE64BINARY, OXS_VALUE_X509V3, bst_data);
 
     /*Build a Reference to above BST*/
     ref_id = axutil_stracat(env, OXS_LOCAL_REFERENCE_PREFIX, id);
@@ -125,9 +132,10 @@
 *   </KeyInfo>
 */
 static axis2_status_t
-oxs_xml_enc_populate_stref_with_embedded(const axutil_env_t *env,
-        oxs_asym_ctx_t *asym_ctx,
-        axiom_node_t *stref_node)
+oxs_xml_enc_populate_stref_with_embedded(
+    const axutil_env_t *env,
+    oxs_asym_ctx_t *asym_ctx,
+    axiom_node_t *stref_node)
 {
     axiom_node_t *embedded_node = NULL;
     axiom_node_t *bst_node = NULL;
@@ -137,13 +145,15 @@
     cert = oxs_asym_ctx_get_certificate(asym_ctx, env);
     bst_data = oxs_x509_cert_get_data(cert, env);
 
-    if(!bst_data){
+    if(!bst_data)
+    {
         return AXIS2_FAILURE;
     }
     /*Build embedded token*/
     embedded_node = oxs_token_build_embedded_element(env, stref_node, NULL);
     /*Build BinarySecurityToken*/
-    bst_node = oxs_token_build_binary_security_token_element(env, embedded_node, NULL, OXS_ENCODING_BASE64BINARY, OXS_VALUE_X509V3, bst_data);
+    bst_node = oxs_token_build_binary_security_token_element(env, embedded_node, NULL,
+        OXS_ENCODING_BASE64BINARY, OXS_VALUE_X509V3, bst_data);
 
     return AXIS2_SUCCESS;
 }
@@ -161,9 +171,10 @@
 *   </KeyInfo>
 */
 static axis2_status_t
-oxs_xml_enc_populate_stref_with_issuer_serial(const axutil_env_t *env,
-        oxs_asym_ctx_t *asym_ctx,
-        axiom_node_t *stref_node)
+oxs_xml_enc_populate_stref_with_issuer_serial(
+    const axutil_env_t *env,
+    oxs_asym_ctx_t *asym_ctx,
+    axiom_node_t *stref_node)
 {
     axiom_node_t *x509_data_node = NULL;
     axiom_node_t *issuer_serial_node = NULL;
@@ -175,15 +186,17 @@
     cert = oxs_asym_ctx_get_certificate(asym_ctx, env);
 
     issuer_name = oxs_x509_cert_get_issuer(cert, env);
-    serial =  oxs_x509_cert_get_serial_number(cert, env);
-    if((!issuer_name) || (serial<0)){
+    serial = oxs_x509_cert_get_serial_number(cert, env);
+    if((!issuer_name) || (serial < 0))
+    {
         return AXIS2_FAILURE;
     }
 
     sprintf(serial_number, "%d", serial);
     /*Build x509Data*/
     x509_data_node = oxs_token_build_x509_data_element(env, stref_node);
-    issuer_serial_node = oxs_token_build_x509_issuer_serial_with_data(env, x509_data_node, issuer_name, serial_number);
+    issuer_serial_node = oxs_token_build_x509_issuer_serial_with_data(env, x509_data_node,
+        issuer_name, serial_number);
     return AXIS2_SUCCESS;
 }
 
@@ -196,21 +209,21 @@
 {
     axiom_node_t *st_ref_node = NULL;
 
-    st_ref_node =  oxs_axiom_get_first_child_node_by_name(
-        env, key_info_node, OXS_NODE_SECURITY_TOKEN_REFRENCE, OXS_WSSE_XMLNS, OXS_WSSE);
+    st_ref_node = oxs_axiom_get_first_child_node_by_name(env, key_info_node,
+        OXS_NODE_SECURITY_TOKEN_REFRENCE, OXS_WSSE_XMLNS, OXS_WSSE);
     if(!st_ref_node)
     {
         return AXIS2_FAILURE;
     }
     /*
-        WSS-Core specification suggests
-        1. Resolve any <wsse:Reference> elements (specified within
-           <wsse:SecurityTokenReference>).
-        2. Resolve any <wsse:KeyIdentifier> elements (specified within
-           <wsse:SecurityTokenReference>).
-        3. Resolve any <ds:KeyName> elements. NOT PERMITTED by WS-i
-        4. Resolve any other <ds:KeyInfo> elements. NOT PERMITTED by WS-i
-    */
+     WSS-Core specification suggests
+     1. Resolve any <wsse:Reference> elements (specified within
+     <wsse:SecurityTokenReference>).
+     2. Resolve any <wsse:KeyIdentifier> elements (specified within
+     <wsse:SecurityTokenReference>).
+     3. Resolve any <ds:KeyName> elements. NOT PERMITTED by WS-i
+     4. Resolve any other <ds:KeyInfo> elements. NOT PERMITTED by WS-i
+     */
 
     /*
      * TODO: This method should get the key from the key_node. Currently key is taken from 
@@ -222,27 +235,31 @@
 
 /*public functions*/
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_encrypt_node(const axutil_env_t *env,
-                         oxs_ctx_t * enc_ctx,
-                         axiom_node_t *node,
-                         axiom_node_t **enc_type_node, 
-                         axiom_node_t *security_token_reference)
+oxs_xml_enc_encrypt_node(
+    const axutil_env_t *env,
+    oxs_ctx_t * enc_ctx,
+    axiom_node_t *node,
+    axiom_node_t **enc_type_node,
+    axiom_node_t *security_token_reference)
 {
     axis2_char_t *serialized_data = NULL;
-    oxs_buffer_t *serialized_buf= NULL;
+    oxs_buffer_t *serialized_buf = NULL;
     axis2_status_t ret = AXIS2_FAILURE;
 
     /*Serialize node*/
     /*serialized_data = axiom_node_to_string(node, env);*/
     serialized_data = axiom_node_to_string_non_optimized(node, env);
     serialized_buf = oxs_buffer_create(env);
-    ret =  oxs_buffer_populate(serialized_buf, env, (unsigned char *)serialized_data, axutil_strlen(serialized_data));
+    ret = oxs_buffer_populate(serialized_buf, env, (unsigned char *)serialized_data, axutil_strlen(
+        serialized_data));
 
     /*We call encrypt_data*/
-    ret = oxs_xml_enc_encrypt_data(env, enc_ctx, serialized_buf, enc_type_node, security_token_reference);
+    ret = oxs_xml_enc_encrypt_data(env, enc_ctx, serialized_buf, enc_type_node,
+        security_token_reference);
 
     /*Remove the node from the parent*/
-    if(AXIS2_SUCCESS == ret){
+    if(AXIS2_SUCCESS == ret)
+    {
         axiom_node_detach(node, env);
         axiom_node_free_tree(node, env);
         node = NULL;
@@ -260,13 +277,14 @@
 
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_encrypt_data(const axutil_env_t *env,
-                         oxs_ctx_t * enc_ctx,
-                         oxs_buffer_t *content_buf,
-                         axiom_node_t **enc_type_node, 
-                         axiom_node_t *security_token_reference_node)
+oxs_xml_enc_encrypt_data(
+    const axutil_env_t *env,
+    oxs_ctx_t * enc_ctx,
+    oxs_buffer_t *content_buf,
+    axiom_node_t **enc_type_node,
+    axiom_node_t *security_token_reference_node)
 {
-    oxs_buffer_t *result_buf= NULL;
+    oxs_buffer_t *result_buf = NULL;
     oxs_key_t *sym_key = NULL;
     axis2_char_t *sym_algo = NULL;
     axiom_node_t *enc_mtd_node = NULL;
@@ -309,12 +327,14 @@
 
         key_info_node = oxs_token_build_key_info_element(env, *enc_type_node);
         str_node = oxs_token_build_security_token_reference_element(env, key_info_node);
-        ref_node = oxs_token_build_reference_element(env, str_node, oxs_ctx_get_ref_key_name(enc_ctx, env), NULL);
+        ref_node = oxs_token_build_reference_element(env, str_node, oxs_ctx_get_ref_key_name(
+            enc_ctx, env), NULL);
     }
 
     /*Create CipherData element and populate*/
     cd_node = oxs_token_build_cipher_data_element(env, *enc_type_node);
-    cv_node = oxs_token_build_cipher_value_element(env, cd_node, (axis2_char_t*)oxs_buffer_get_data(result_buf, env));
+    cv_node = oxs_token_build_cipher_value_element(env, cd_node,
+        (axis2_char_t*)oxs_buffer_get_data(result_buf, env));
 
     /*Free buffers*/
     oxs_buffer_free(result_buf, env);
@@ -324,10 +344,11 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_decrypt_node(const axutil_env_t *env,
-                         oxs_ctx_t * enc_ctx,
-                         axiom_node_t *enc_type_node,
-                         axiom_node_t **decrypted_node)
+oxs_xml_enc_decrypt_node(
+    const axutil_env_t *env,
+    oxs_ctx_t * enc_ctx,
+    axiom_node_t *enc_type_node,
+    axiom_node_t **decrypted_node)
 {
     axiom_node_t *deserialized_node = NULL;
     axiom_node_t *parent_of_enc_node = NULL;
@@ -340,15 +361,19 @@
 
     /*Decrypt*/
     status = oxs_xml_enc_decrypt_data(env, enc_ctx, enc_type_node, result_buf);
-    if(AXIS2_FAILURE == status){
+    if(AXIS2_FAILURE == status)
+    {
         oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED, "Data encryption failed");
         return AXIS2_FAILURE;
     }
-    decrypted_data = axutil_strmemdup(oxs_buffer_get_data(result_buf, env), oxs_buffer_get_size(result_buf, env), env);
+    decrypted_data = axutil_strmemdup(oxs_buffer_get_data(result_buf, env), oxs_buffer_get_size(
+        result_buf, env), env);
     /*De-serialize the decrypted content to build the node*/
     deserialized_node = (axiom_node_t*)oxs_axiom_deserialize_node(env, decrypted_data);
-    if(!deserialized_node){
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,"Cannot deserialize a node from the content.\n%s", decrypted_data);
+    if(!deserialized_node)
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
+            "Cannot deserialize a node from the content.\n%s", decrypted_data);
         return AXIS2_FAILURE;
     }
     /*Assign deserialized_node to the reference passed*/
@@ -360,7 +385,6 @@
     axiom_node_insert_sibling_after(enc_type_node, env, deserialized_node);
     axiom_node_detach(enc_type_node, env);
 
-
     axiom_node_free_tree(enc_type_node, env);
     enc_type_node = NULL;
 
@@ -376,10 +400,11 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_decrypt_data(const axutil_env_t *env,
-                         oxs_ctx_t * enc_ctx,
-                         axiom_node_t *enc_type_node,
-                         oxs_buffer_t *result_buf)
+oxs_xml_enc_decrypt_data(
+    const axutil_env_t *env,
+    oxs_ctx_t * enc_ctx,
+    axiom_node_t *enc_type_node,
+    oxs_buffer_t *result_buf)
 {
     axiom_node_t *enc_mtd_node = NULL;
     axiom_node_t *cd_node = NULL;
@@ -392,46 +417,70 @@
     oxs_buffer_t *input_buf = NULL;
     axis2_status_t status = AXIS2_FAILURE;
 
-    /*Get the symmetric encryption algorithm*/
-    enc_mtd_node = oxs_axiom_get_first_child_node_by_name(env, enc_type_node, OXS_NODE_ENCRYPTION_METHOD,OXS_ENC_NS,OXS_XENC);
+    /* Get the symmetric encryption algorithm */
+    enc_mtd_node = oxs_axiom_get_first_child_node_by_name(env, enc_type_node,
+        OXS_NODE_ENCRYPTION_METHOD, OXS_ENC_NS, OXS_XENC);
+    if(!enc_mtd_node)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find encryption method node");
+        return AXIS2_FAILURE;
+    }
+
     sym_algo = oxs_token_get_encryption_method(env, enc_mtd_node);
-    if(!sym_algo){
+    if(!sym_algo)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find encryption method");
         return AXIS2_FAILURE;
     }
-    /*Get ID, Type, MimeType attributes from the EncryptedDataNode*/
+
+    /* Get ID, Type, MimeType attributes from the EncryptedDataNode */
     id = oxs_axiom_get_attribute_value_of_node_by_name(env, enc_type_node, OXS_ATTR_ID, NULL);
     type = oxs_axiom_get_attribute_value_of_node_by_name(env, enc_type_node, OXS_ATTR_TYPE, NULL);
 
-    /*Populate the context for future use*/
+    /* Populate the context for future use */
     oxs_ctx_set_enc_mtd_algorithm(enc_ctx, env, sym_algo);
     oxs_ctx_set_id(enc_ctx, env, id);
     oxs_ctx_set_type(enc_ctx, env, type);
 
-    /*Get the cipher value*/
-    cd_node = oxs_axiom_get_first_child_node_by_name(env, enc_type_node, OXS_NODE_CIPHER_DATA,OXS_ENC_NS,OXS_XENC);
-    cv_node = oxs_axiom_get_first_child_node_by_name(env, cd_node, OXS_NODE_CIPHER_VALUE,OXS_ENC_NS,OXS_XENC);
+    /* Get the cipher value */
+    cd_node = oxs_axiom_get_first_child_node_by_name(env, enc_type_node, OXS_NODE_CIPHER_DATA,
+        OXS_ENC_NS, OXS_XENC);
+    if(!cd_node)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find cipher data node");
+        return AXIS2_FAILURE;
+    }
+
+    cv_node = oxs_axiom_get_first_child_node_by_name(env, cd_node, OXS_NODE_CIPHER_VALUE,
+        OXS_ENC_NS, OXS_XENC);
+    if(!cv_node)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find cipher value node");
+        return AXIS2_FAILURE;
+    }
+
     cipher_val = oxs_token_get_cipher_value(env, cv_node);
+    if(!cipher_val)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find cipher value");
+        return AXIS2_FAILURE;
+    }
 
-    /*We need to remove new lines if any*/
+    /* We need to remove new lines if any */
     new_cipher_val = oxs_util_get_newline_removed_string(env, cipher_val);
 
-    /*eof NEW CODE*/
-    /*Create input buffer with cipher data obtained*/
+    /* Create input buffer with cipher data obtained */
     input_buf = oxs_buffer_create(env);
-    oxs_buffer_populate(input_buf, env, (unsigned char*)new_cipher_val, axutil_strlen(new_cipher_val) );
+    oxs_buffer_populate(input_buf, env, (unsigned char*)new_cipher_val,
+        axutil_strlen(new_cipher_val));
 
-    /*Decrypt*/
+    /* Decrypt */
     oxs_ctx_set_operation(enc_ctx, env, OXS_CTX_OPERATION_DECRYPT);
-    status =  oxs_encryption_symmetric_crypt(env, enc_ctx, input_buf, result_buf);
+    status = oxs_encryption_symmetric_crypt(env, enc_ctx, input_buf, result_buf);
 
     /*Free*/
-
     oxs_buffer_free(input_buf, env);
     input_buf = NULL;
-
-    /*AXIS2_FREE(env->allocator, cipher_val);
-    cipher_val = NULL;*/
-
     AXIS2_FREE(env->allocator, new_cipher_val);
     new_cipher_val = NULL;
 
@@ -440,11 +489,12 @@
 
 /*For SOAP this parent is the wsse:Security node*/
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_encrypt_key(const axutil_env_t *env,
-                        oxs_asym_ctx_t * asym_ctx,
-                        axiom_node_t *parent,
-                        oxs_key_t *sym_key,
-                        axutil_array_list_t *id_list)
+oxs_xml_enc_encrypt_key(
+    const axutil_env_t *env,
+    oxs_asym_ctx_t * asym_ctx,
+    axiom_node_t *parent,
+    oxs_key_t *sym_key,
+    axutil_array_list_t *id_list)
 {
     axis2_char_t *algorithm = NULL;
     axis2_char_t *encrypted_key_data = NULL;
@@ -475,9 +525,10 @@
     oxs_buffer_free(input, env);
     input = NULL;
 
-    if(AXIS2_FAILURE == status){
+    if(AXIS2_FAILURE == status)
+    {
         oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
-                  "Assymmetric key encryption failed");
+            "Assymmetric key encryption failed");
         return AXIS2_FAILURE;
     }
     /*Get the encrypted key*/
@@ -492,33 +543,46 @@
     stref_node = oxs_token_build_security_token_reference_element(env, key_info_node);
     /*Get the ST REF pattern. If not set the default*/
     st_ref_pattern = oxs_asym_ctx_get_st_ref_pattern(asym_ctx, env);
-    if((!st_ref_pattern) || (0 == axutil_strcmp(st_ref_pattern, ""))){
+    if((!st_ref_pattern) || (0 == axutil_strcmp(st_ref_pattern, "")))
+    {
         st_ref_pattern = OXS_STR_DEFAULT;
     }
 
-    if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_ISSUER_SERIAL)){
+    if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_ISSUER_SERIAL))
+    {
         status = oxs_xml_enc_populate_stref_with_issuer_serial(env, asym_ctx, stref_node);
-    }else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_EMBEDDED)){
+    }
+    else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_EMBEDDED))
+    {
         status = oxs_xml_enc_populate_stref_with_embedded(env, asym_ctx, stref_node);
-    }else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_DIRECT_REFERENCE)){
+    }
+    else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_DIRECT_REFERENCE))
+    {
         status = oxs_xml_enc_populate_stref_with_bst(env, asym_ctx, stref_node, parent);
-    }else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_KEY_IDENTIFIER)){
-        status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node, AXIS2_FALSE);
-    }else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_THUMB_PRINT)){
+    }
+    else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_KEY_IDENTIFIER))
+    {
+        status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node,
+            AXIS2_FALSE);
+    }
+    else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_THUMB_PRINT))
+    {
         /*TODO: Need to support Thumbprint Ref*/
-        status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node, AXIS2_TRUE);
+        status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node,
+            AXIS2_TRUE);
     }
     cd_node = oxs_token_build_cipher_data_element(env, encrypted_key_node);
-    cv_node = oxs_token_build_cipher_value_element(env, cd_node,  encrypted_key_data);
+    cv_node = oxs_token_build_cipher_value_element(env, cd_node, encrypted_key_data);
     /*If and only if the id_list the present, we create the reference list*/
-    if(id_list){
+    if(id_list)
+    {
         oxs_token_build_data_reference_list(env, encrypted_key_node, id_list);
     }
 
     /*calculate the EncryptedKeySHA1 and set as the key_sha*/
     decoded_len = axutil_base64_decode_len(encrypted_key_data);
     decoded_enc_sec = AXIS2_MALLOC(env->allocator, decoded_len);
-	axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, encrypted_key_data);
+    axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, encrypted_key_data);
     encrypted_key_hash = openssl_sha1(env, decoded_enc_sec, decoded_len);
     oxs_key_set_key_sha(sym_key, env, encrypted_key_hash);
     AXIS2_FREE(env->allocator, decoded_enc_sec);
@@ -534,11 +598,12 @@
 * Inspect the key node. Then populate the sym_key
 */
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_decrypt_key(const axutil_env_t *env,
-                        oxs_asym_ctx_t * asym_ctx,
-                        axiom_node_t *parent,
-                        axiom_node_t *encrypted_key_node,
-                        oxs_key_t *key)
+oxs_xml_enc_decrypt_key(
+    const axutil_env_t *env,
+    oxs_asym_ctx_t * asym_ctx,
+    axiom_node_t *parent,
+    axiom_node_t *encrypted_key_node,
+    oxs_key_t *key)
 {
     axiom_node_t *enc_mtd_node = NULL;
     axiom_node_t *key_info_node = NULL;
@@ -556,33 +621,40 @@
     axis2_char_t *decoded_enc_sec = NULL;
 
     /*Get encryption method algorithm*/
-    enc_mtd_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node, OXS_NODE_ENCRYPTION_METHOD,OXS_ENC_NS,OXS_XENC);
+    enc_mtd_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node,
+        OXS_NODE_ENCRYPTION_METHOD, OXS_ENC_NS, OXS_XENC);
     enc_mtd_algo = oxs_token_get_encryption_method(env, enc_mtd_node);
-    if(!enc_mtd_algo){
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED, "Cannot find the Encryption method");
+    if(!enc_mtd_algo)
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
+            "Cannot find the Encryption method");
         return AXIS2_FAILURE;
     }
     /*Get cipher data*/
-    cd_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node, OXS_NODE_CIPHER_DATA,OXS_ENC_NS,OXS_XENC);
+    cd_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node, OXS_NODE_CIPHER_DATA,
+        OXS_ENC_NS, OXS_XENC);
     cipher_val = oxs_token_get_cipher_value_from_cipher_data(env, cd_node);
-    if(!cipher_val){
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED, "Cannot find the cipher value for key decryption");
+    if(!cipher_val)
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
+            "Cannot find the cipher value for key decryption");
         return AXIS2_FAILURE;
     }
 
     new_cipher_val = oxs_util_get_newline_removed_string(env, cipher_val);
 
     /*Get key used to encrypt*/
-    key_info_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node, OXS_NODE_KEY_INFO,OXS_DSIG_NS,OXS_DS);
+    key_info_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node,
+        OXS_NODE_KEY_INFO, OXS_DSIG_NS, OXS_DS);
     status = oxs_xml_enc_process_key_info(env, asym_ctx, key_info_node, parent);
     /*Right now we support KeyInfo -> SecurityTokenReference -> Reference
-                           KeyInfo -> SecurityTokenReference -> X509IssuerSerial */
-
+     KeyInfo -> SecurityTokenReference -> X509IssuerSerial */
 
     /*Get the pkey used to decrypt the session key. If found set it to the asym_ctx*/
     /*Create the input buffer*/
     input_buf = oxs_buffer_create(env);
-    oxs_buffer_populate(input_buf, env, (unsigned char*)new_cipher_val, axutil_strlen(new_cipher_val));
+    oxs_buffer_populate(input_buf, env, (unsigned char*)new_cipher_val, axutil_strlen(
+        new_cipher_val));
 
     /*Create a results buffer*/
     result_buf = oxs_buffer_create(env);
@@ -593,28 +665,26 @@
     oxs_buffer_free(input_buf, env);
     input_buf = NULL;
 
-     /*calculate the EncryptedKeySHA1 and set as the key_sha*/
+    /*calculate the EncryptedKeySHA1 and set as the key_sha*/
     decoded_len = axutil_base64_decode_len(new_cipher_val);
     decoded_enc_sec = AXIS2_MALLOC(env->allocator, decoded_len);
-	axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, new_cipher_val);
+    axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, new_cipher_val);
     encrypted_key_hash = openssl_sha1(env, decoded_enc_sec, decoded_len);
     AXIS2_FREE(env->allocator, decoded_enc_sec);
 
     AXIS2_FREE(env->allocator, new_cipher_val);
     new_cipher_val = NULL;
 
-
-    if(AXIS2_FAILURE == status){
+    if(AXIS2_FAILURE == status)
+    {
         return AXIS2_FAILURE;
     }
 
-    key_name = oxs_axiom_get_attribute_value_of_node_by_name(env, encrypted_key_node, OXS_ATTR_ID, NULL);
+    key_name = oxs_axiom_get_attribute_value_of_node_by_name(env, encrypted_key_node, OXS_ATTR_ID,
+        NULL);
     /*Populate the key with the data in the result buffer*/
-    oxs_key_populate(key, env,
-                     oxs_buffer_get_data(result_buf, env),
-                     key_name,
-                     oxs_buffer_get_size(result_buf, env),
-                     OXS_KEY_USAGE_SESSION  );
+    oxs_key_populate(key, env, oxs_buffer_get_data(result_buf, env), key_name, oxs_buffer_get_size(
+        result_buf, env), OXS_KEY_USAGE_SESSION);
     oxs_key_set_key_sha(key, env, encrypted_key_hash);
 
     /*Free*/

Modified: webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c?rev=809469&r1=809468&r2=809469&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c Mon Aug 31 06:39:07 2009
@@ -34,31 +34,33 @@
 #include <oxs_transforms_factory.h>
 #include <oxs_tokens.h>
 #include <axiom_util.h>
-/*Private functions*/
 
 
-/*This method is common for both signing and verification*/
+/* This method is common for both signing and verification */
 static axis2_char_t *
-oxs_xml_sig_transform_n_digest(const axutil_env_t *env,
-                               axiom_node_t *node,
-                               axutil_array_list_t *transforms,
-                               axis2_char_t *digest_mtd)
+oxs_xml_sig_transform_n_digest(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axutil_array_list_t *transforms,
+    axis2_char_t *digest_mtd)
 {
     axis2_char_t *serialized_node = NULL;
     axis2_char_t *digest = NULL;
-	axiom_node_t *ori_node = NULL, *sig_node = NULL;
-	oxs_tr_dtype_t output_dtype = OXS_TRANSFORM_TYPE_UNKNOWN;/*This will always be the current dtype*/
+    axiom_node_t *ori_node = NULL, *sig_node = NULL;
+    oxs_tr_dtype_t output_dtype = OXS_TRANSFORM_TYPE_UNKNOWN;/*This will always be the current dtype*/
     void *tr_output = NULL;
     int i = 0;
 
-    if((transforms) && (0 < axutil_array_list_size(transforms, env))){
-       
+    if((transforms) && (0 < axutil_array_list_size(transforms, env)))
+    {
+
         output_dtype = OXS_TRANSFORM_TYPE_NODE; /*We always begin with a node*/
 
         tr_output = node; /*The first transformation is applied to the node*/
 
         /*LOOP: Apply transforms. For example exclusive C14N*/
-        for (i = 0; i < axutil_array_list_size(transforms, env); i++){
+        for(i = 0; i < axutil_array_list_size(transforms, env); i++)
+        {
             oxs_transform_t *tr = NULL;
             oxs_transform_tr_func tr_func = NULL;
             oxs_tr_dtype_t input_dtype = OXS_TRANSFORM_TYPE_UNKNOWN;
@@ -73,54 +75,83 @@
 
             /*Prepare the input*/
             /*If the required input type is CHAR and what we have is a NODE*/
-            if((input_dtype == OXS_TRANSFORM_TYPE_CHAR) && (output_dtype == OXS_TRANSFORM_TYPE_NODE)){
+            if((input_dtype == OXS_TRANSFORM_TYPE_CHAR)
+                && (output_dtype == OXS_TRANSFORM_TYPE_NODE))
+            {
                 /*Serialize*/
                 tr_input = axiom_node_to_string((axiom_node_t*)tr_output, env);
                 /*If the required input type is NODE and what we have is a CHAR*/
-            }else if((input_dtype == OXS_TRANSFORM_TYPE_NODE) && (output_dtype == OXS_TRANSFORM_TYPE_CHAR)){
+            }
+            else if((input_dtype == OXS_TRANSFORM_TYPE_NODE) && (output_dtype
+                == OXS_TRANSFORM_TYPE_CHAR))
+            {
                 /*De-serialize*/
-                tr_input =  oxs_axiom_deserialize_node(env, (axis2_char_t *)tr_output);
-			}else if((input_dtype == OXS_TRANSFORM_TYPE_NODE) && (output_dtype == OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST)){
-				ori_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
-				sig_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
-				tr_input = ori_node;				
-			}else if((input_dtype == OXS_TRANSFORM_TYPE_CHAR) && (output_dtype == OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST)){
-				ori_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
-				sig_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
-				tr_input = axiom_node_to_string(ori_node, env);
-            }else{
+                tr_input = oxs_axiom_deserialize_node(env, (axis2_char_t *)tr_output);
+            }
+            else if((input_dtype == OXS_TRANSFORM_TYPE_NODE) && (output_dtype
+                == OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST))
+            {
+                ori_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
+                sig_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
+                tr_input = ori_node;
+            }
+            else if((input_dtype == OXS_TRANSFORM_TYPE_CHAR) && (output_dtype
+                == OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST))
+            {
+                ori_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
+                sig_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
+                tr_input = axiom_node_to_string(ori_node, env);
+            }
+            else
+            {
                 /*Let it go as it is. */
                 tr_input = tr_output;
             }
             /*Apply transform*/
-            if(tr_func){
+            if(tr_func)
+            {
                 output_dtype = (*tr_func)(env, tr_input, input_dtype, &tr_output);
-            }else{
-                oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"Cannot get the transform implementation for %s", tr_id);
+            }
+            else
+            {
+                oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,
+                    "Cannot get the transform implementation for %s", tr_id);
             }
             /*If the output data type is unknown OR the output is NULL its an error*/
-            if((output_dtype == OXS_TRANSFORM_TYPE_UNKNOWN) || (!tr_output)){
-                oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"Transform failed for %s", tr_id);
+            if((output_dtype == OXS_TRANSFORM_TYPE_UNKNOWN) || (!tr_output))
+            {
+                oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,
+                    "Transform failed for %s", tr_id);
                 return NULL;
             }
-		}/*eof for loop*/
+        }/*eof for loop*/
         /*We have applied all our transforms now*/
         /*Serialize node*/
-        if(OXS_TRANSFORM_TYPE_NODE == output_dtype ){
+        if(OXS_TRANSFORM_TYPE_NODE == output_dtype)
+        {
             serialized_node = axiom_node_to_string((axiom_node_t*)tr_output, env);
-        }else if(OXS_TRANSFORM_TYPE_CHAR == output_dtype){
+        }
+        else if(OXS_TRANSFORM_TYPE_CHAR == output_dtype)
+        {
             serialized_node = (axis2_char_t*)tr_output;
         }
-		else if(OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST == output_dtype){
-			ori_node = (axiom_node_t*)axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
-			sig_node = (axiom_node_t*)axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
-			serialized_node = axiom_node_to_string(ori_node, env);
-		}
-		else{
+        else if(OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST == output_dtype)
+        {
+            ori_node
+                = (axiom_node_t*)axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
+            sig_node
+                = (axiom_node_t*)axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
+            serialized_node = axiom_node_to_string(ori_node, env);
+        }
+        else
+        {
             /*Error*/
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"Unsupported transform data type  %d", output_dtype);
+            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,
+                "Unsupported transform data type  %d", output_dtype);
         }
-	}else{
+    }
+    else
+    {
         /*No transforms defined. Thus we simply direct the node, to make the digest*/
         serialized_node = axiom_node_to_string(node, env);
     }
@@ -139,11 +170,13 @@
             "Unsupported digest method  %s", digest_mtd);
         return NULL;
     }
-	
-	if(ori_node && sig_node){			
-		axiom_node_add_child(ori_node, env, sig_node);
-	}
-    if(serialized_node){
+
+    if(ori_node && sig_node)
+    {
+        axiom_node_add_child(ori_node, env, sig_node);
+    }
+    if(serialized_node)
+    {
         AXIS2_FREE(env->allocator, serialized_node);
         serialized_node = NULL;
     }
@@ -152,16 +185,17 @@
 
 /*parent is ds:SignedInfo*/
 static axis2_status_t
-oxs_xml_sig_build_reference(const axutil_env_t *env,
-                            axiom_node_t *parent,
-                            oxs_sign_part_t *sign_part)
+oxs_xml_sig_build_reference(
+    const axutil_env_t *env,
+    axiom_node_t *parent,
+    oxs_sign_part_t *sign_part)
 {
     axis2_char_t *digest = NULL;
     axis2_char_t *digest_mtd = NULL;
     axis2_char_t *ref_id = NULL;
     axis2_char_t *id = NULL, *id_name = NULL;
-	axiom_namespace_t *ns = NULL;
-	axis2_char_t *ns_uri = NULL;
+    axiom_namespace_t *ns = NULL;
+    axis2_char_t *ns_uri = NULL;
     axutil_array_list_t *transforms = NULL;
     axiom_node_t *node = NULL;
     axiom_node_t *reference_node = NULL;
@@ -172,25 +206,24 @@
     /*Get the node to digest*/
     node = oxs_sign_part_get_node(sign_part, env);
 
-	id_name = oxs_sign_part_get_id_name(sign_part, env);
-	ns = oxs_sign_part_get_sign_namespace(sign_part, env);
+    id_name = oxs_sign_part_get_id_name(sign_part, env);
+    ns = oxs_sign_part_get_sign_namespace(sign_part, env);
 
-	if(ns)
-		ns_uri = axiom_namespace_get_uri(ns, env);
-	else if (!ns && !id_name) 
-		ns_uri = OXS_WSU_XMLNS;
+    if(ns)
+        ns_uri = axiom_namespace_get_uri(ns, env);
+    else if(!ns && !id_name)
+        ns_uri = OXS_WSU_XMLNS;
     else
         ns_uri = NULL;
 
-	if(!id_name)
-		id_name = OXS_ATTR_ID;
+    if(!id_name)
+        id_name = OXS_ATTR_ID;
 
     /*Get the reference ID from the node and hence to the ds:Reference node*/
-    id = oxs_axiom_get_attribute_value_of_node_by_name(env, node, id_name,
-													ns_uri);
+    id = oxs_axiom_get_attribute_value_of_node_by_name(env, node, id_name, ns_uri);
 
     ref_id = axutil_stracat(env, OXS_LOCAL_REFERENCE_PREFIX, id);/* <ds:Reference URI="#id">*/
-    reference_node = oxs_token_build_ds_reference_element(env, parent ,NULL, ref_id, NULL);
+    reference_node = oxs_token_build_ds_reference_element(env, parent, NULL, ref_id, NULL);
 
     AXIS2_FREE(env->allocator, ref_id);
     ref_id = NULL;
@@ -208,11 +241,13 @@
     }
 
     /*Build ds:Transforms node and its children*/
-    if((transforms) && (0 < axutil_array_list_size(transforms, env))){
+    if((transforms) && (0 < axutil_array_list_size(transforms, env)))
+    {
         axiom_node_t *transforms_node = NULL;
 
         transforms_node = oxs_token_build_transforms_element(env, reference_node);
-        for (i = 0; i < axutil_array_list_size(transforms, env); i++){
+        for(i = 0; i < axutil_array_list_size(transforms, env); i++)
+        {
             oxs_transform_t *tr = NULL;
             axis2_char_t *tr_id = NULL;
 
@@ -236,10 +271,11 @@
  *  C14N -> Serialize -> Sign the <SignedInfo> element
  */
 static axis2_status_t
-oxs_xml_sig_sign_signed_info(const axutil_env_t *env,
-                             axiom_node_t *signature_node,
-                             axiom_node_t *signed_info_node,
-                             oxs_sign_ctx_t *sign_ctx)
+oxs_xml_sig_sign_signed_info(
+    const axutil_env_t *env,
+    axiom_node_t *signature_node,
+    axiom_node_t *signed_info_node,
+    oxs_sign_ctx_t *sign_ctx)
 {
     axis2_char_t *signature_val = NULL;
     axis2_char_t *serialized_signed_info = NULL;
@@ -256,8 +292,8 @@
     doc = axiom_node_get_document(signed_info_node, env);
 
     /*oxs_c14n_apply(env, doc, AXIS2_FALSE, &c14nized, AXIS2_TRUE, NULL, signed_info_node); */
-    oxs_c14n_apply_algo(env, doc,  &c14nized, NULL, signed_info_node, c14n_algo);
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (sig)= %s ", c14nized );
+    oxs_c14n_apply_algo(env, doc, &c14nized, NULL, signed_info_node, c14n_algo);
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (sig)= %s ", c14nized);
 
     /*Then serialize <SignedInfo>*/
     serialized_signed_info = c14nized; /*axiom_node_to_string(signed_info_node, env);*/
@@ -266,17 +302,19 @@
     input_buf = oxs_buffer_create(env);
     output_buf = oxs_buffer_create(env);
 
-    oxs_buffer_populate(input_buf, env, (unsigned char *)serialized_signed_info, axutil_strlen(serialized_signed_info));
+    oxs_buffer_populate(input_buf, env, (unsigned char *)serialized_signed_info, axutil_strlen(
+        serialized_signed_info));
     /*Then sign... NOTE: The signature process includes making the digest. e.g. rsa-sha1 => RSA(SHA-1(contents))*/
     status = oxs_sig_sign(env, sign_ctx, input_buf, output_buf);
 
     signature_val = (axis2_char_t*)oxs_buffer_get_data(output_buf, env);
 
     /*Construct <SignatureValue>*/
-    signature_val_node = oxs_token_build_signature_value_element(env, signature_node, signature_val);
+    signature_val_node
+        = oxs_token_build_signature_value_element(env, signature_node, signature_val);
 
     /*Free*/
-    AXIS2_FREE(env->allocator , c14nized);
+    AXIS2_FREE(env->allocator, c14nized);
     c14nized = NULL;
     oxs_buffer_free(input_buf, env);
     input_buf = NULL;
@@ -288,10 +326,11 @@
 
 /*Public functions*/
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_sign(const axutil_env_t *env,
-                 oxs_sign_ctx_t *sign_ctx,
-                 axiom_node_t *parent,
-                 axiom_node_t **sig_node)
+oxs_xml_sig_sign(
+    const axutil_env_t *env,
+    oxs_sign_ctx_t *sign_ctx,
+    axiom_node_t *parent,
+    axiom_node_t **sig_node)
 {
     axiom_node_t *signed_info_node = NULL;
     axiom_node_t *signature_node = NULL;
@@ -302,7 +341,7 @@
     axis2_char_t *sig_id = NULL;
     axutil_array_list_t *sign_parts = NULL;
     axis2_status_t status = AXIS2_FAILURE;
-    int i=0;
+    int i = 0;
 
     /*Construct the <Signature> element*/
     sig_id = oxs_util_generate_id(env, OXS_SIG_ID);
@@ -323,11 +362,12 @@
     signature_mtd_node = oxs_token_build_signature_method_element(env, signed_info_node, sign_algo);
 
     /*Look for signature parts*/
-    sign_parts = oxs_sign_ctx_get_sign_parts(sign_ctx , env);
+    sign_parts = oxs_sign_ctx_get_sign_parts(sign_ctx, env);
 
     /*For each and every signature part in sig ctx,*/
-    for (i = 0; i < axutil_array_list_size(sign_parts, env); i++){
-        oxs_sign_part_t *sign_part =  NULL;
+    for(i = 0; i < axutil_array_list_size(sign_parts, env); i++)
+    {
+        oxs_sign_part_t *sign_part = NULL;
 
         /*Get ith sign_part*/
         sign_part = (oxs_sign_part_t*)axutil_array_list_get(sign_parts, env, i);
@@ -340,7 +380,7 @@
     }
     /*At this point we have a complete <SignedInfo> node. Now we need to sign it*/
     status = oxs_xml_sig_sign_signed_info(env, signature_node, signed_info_node, sign_ctx);
-	/*sig_id = axiom_node_to_string(parent, env);*/
+    /*sig_id = axiom_node_to_string(parent, env);*/
     *sig_node = signature_node;
     return status;
 }
@@ -349,135 +389,142 @@
 
 /*Populates a sign_part according to the <ds:Reference> node*/
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_process_ref_node(const axutil_env_t *env,
-                             oxs_sign_part_t *sign_part,
-                             axiom_node_t *ref_node,
-                             axiom_node_t *scope_node)
+oxs_xml_sig_process_ref_node(
+    const axutil_env_t *env,
+    oxs_sign_part_t *sign_part,
+    axiom_node_t *ref_node,
+    axiom_node_t *scope_node)
 {
     axis2_char_t *ref_id = NULL;
     axis2_char_t *ref_id2 = NULL;
     axis2_char_t *child_node_name = NULL;
     axiom_node_t *reffed_node = NULL;
     axiom_node_t *child_node = NULL, *cn = NULL;
-	
-	axis2_char_t *id_name = NULL;
-	axiom_namespace_t *ns = NULL;
-	axis2_char_t *ns_uri = NULL;
-	axiom_attribute_t *attr = NULL;
-	axutil_hash_t *attr_hash = NULL;
-	axutil_hash_index_t *hi = NULL;
-	axiom_element_t *element = NULL, *ce = NULL;
-	axiom_child_element_iterator_t *ci = NULL;
-    ref_id =  oxs_token_get_ds_reference(env, ref_node);
+
+    axis2_char_t *id_name = NULL;
+    axiom_namespace_t *ns = NULL;
+    axis2_char_t *ns_uri = NULL;
+    axiom_attribute_t *attr = NULL;
+    axutil_hash_t *attr_hash = NULL;
+    axutil_hash_index_t *hi = NULL;
+    axiom_element_t *element = NULL, *ce = NULL;
+    axiom_child_element_iterator_t *ci = NULL;
+    ref_id = oxs_token_get_ds_reference(env, ref_node);
     oxs_sign_part_set_id(sign_part, env, ref_id);
-	
+
     /*Remove the # from the id*/
-    ref_id2 =  axutil_string_substring_starting_at(axutil_strdup(env, ref_id), 1);	
-	/*Look for the attribute with the Reference URI value*/
-	if(scope_node)
-	{
-		element = axiom_node_get_data_element(scope_node, env);
-		if(element)
-			attr_hash = axiom_element_get_all_attributes(element, env);	
-		
-		if (attr_hash)
-		{
-			for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
-			{
-				void *v = NULL;
-				axutil_hash_this(hi, NULL, NULL, &v);
-				if (v)
-				{
-					axis2_char_t *attr_val = NULL;
-					axiom_attribute_t *attribute = (axiom_attribute_t*)v;			
-					attr_val = axiom_attribute_get_value(attribute, env);
-					if(!axutil_strcmp(attr_val, ref_id2))
-					{
-						attr = attribute;
-						break;
-					}
-				}
-			}
-		}
-	}
-	/* if we cannot find the Id in the scope node proceed to childs*/
-	if (!attr)
-	{
-		element = axiom_node_get_data_element(scope_node, env);		
-		if (element)
-		{
-			ci = axiom_element_get_child_elements(element, env, scope_node);
-			if (ci)
-			{
-				while (AXIS2_TRUE == axiom_child_element_iterator_has_next(ci, env))
-				{
-					cn = axiom_child_element_iterator_next(ci, env);
-					ce = axiom_node_get_data_element(cn, env);
-					if(ce)
-						attr_hash = axiom_element_get_all_attributes(ce, env);	
-					
-					if (attr_hash)
-					{
-						for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
-						{
-							void *v = NULL;
-							axutil_hash_this(hi, NULL, NULL, &v);
-							if (v)
-							{
-								axis2_char_t *attr_val = NULL;
-								axiom_attribute_t *attribute = (axiom_attribute_t*)v;			
-								attr_val = axiom_attribute_get_value(attribute, env);
-								if(!axutil_strcmp(attr_val, ref_id2))
-								{
-									attr = attribute;
-									if (env)
-										AXIS2_FREE(env->allocator, hi);
-									break;
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	if(attr)
-	{	
-		id_name = axiom_attribute_get_localname(attr, env);		
-		ns = axiom_attribute_get_namespace(attr, env);
-		if(ns)
-			ns_uri = axiom_namespace_get_uri(ns, env);
-		else
-			ns_uri = "";
-		reffed_node = oxs_axiom_get_node_by_id(env, scope_node, id_name, ref_id2, ns_uri);
-	}
-	else
-	{
-		reffed_node = oxs_axiom_get_node_by_id(env, scope_node, "Id", ref_id2, OXS_WSU_XMLNS );	
+    ref_id2 = axutil_string_substring_starting_at(axutil_strdup(env, ref_id), 1);
+    /*Look for the attribute with the Reference URI value*/
+    if(scope_node)
+    {
+        element = axiom_node_get_data_element(scope_node, env);
+        if(element)
+            attr_hash = axiom_element_get_all_attributes(element, env);
+
+        if(attr_hash)
+        {
+            for(hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
+            {
+                void *v = NULL;
+                axutil_hash_this(hi, NULL, NULL, &v);
+                if(v)
+                {
+                    axis2_char_t *attr_val = NULL;
+                    axiom_attribute_t *attribute = (axiom_attribute_t*)v;
+                    attr_val = axiom_attribute_get_value(attribute, env);
+                    if(!axutil_strcmp(attr_val, ref_id2))
+                    {
+                        attr = attribute;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    /* if we cannot find the Id in the scope node proceed to childs*/
+    if(!attr)
+    {
+        element = axiom_node_get_data_element(scope_node, env);
+        if(element)
+        {
+            ci = axiom_element_get_child_elements(element, env, scope_node);
+            if(ci)
+            {
+                while(AXIS2_TRUE == axiom_child_element_iterator_has_next(ci, env))
+                {
+                    cn = axiom_child_element_iterator_next(ci, env);
+                    ce = axiom_node_get_data_element(cn, env);
+                    if(ce)
+                        attr_hash = axiom_element_get_all_attributes(ce, env);
+
+                    if(attr_hash)
+                    {
+                        for(hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env,
+                            hi))
+                        {
+                            void *v = NULL;
+                            axutil_hash_this(hi, NULL, NULL, &v);
+                            if(v)
+                            {
+                                axis2_char_t *attr_val = NULL;
+                                axiom_attribute_t *attribute = (axiom_attribute_t*)v;
+                                attr_val = axiom_attribute_get_value(attribute, env);
+                                if(!axutil_strcmp(attr_val, ref_id2))
+                                {
+                                    attr = attribute;
+                                    if(env)
+                                        AXIS2_FREE(env->allocator, hi);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if(attr)
+    {
+        id_name = axiom_attribute_get_localname(attr, env);
+        ns = axiom_attribute_get_namespace(attr, env);
+        if(ns)
+            ns_uri = axiom_namespace_get_uri(ns, env);
+        else
+            ns_uri = "";
+        reffed_node = oxs_axiom_get_node_by_id(env, scope_node, id_name, ref_id2, ns_uri);
+    }
+    else
+    {
+        reffed_node = oxs_axiom_get_node_by_id(env, scope_node, "Id", ref_id2, OXS_WSU_XMLNS);
         /*for endorsing, we have to check "Id", not "wsu:Id"*/
         if(!reffed_node)
         {
-            reffed_node = oxs_axiom_get_node_by_id(env, scope_node, "Id", ref_id2, NULL );	
-        }		
-	}
+            reffed_node = oxs_axiom_get_node_by_id(env, scope_node, "Id", ref_id2, NULL);
+        }
+    }
     /*Find the node refered by this ref_id2 and set to the sign part*/
-	
-    if(reffed_node){
+
+    if(reffed_node)
+    {
         oxs_sign_part_set_node(sign_part, env, reffed_node);
-    }else{
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find node with Id=%s ", ref_id2 );
-		AXIS2_FREE(env->allocator, ref_id2);
-		ref_id2 = NULL;
+    }
+    else
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+            "Cannot find node with Id=%s ", ref_id2);
+        AXIS2_FREE(env->allocator, ref_id2);
+        ref_id2 = NULL;
         return AXIS2_FAILURE; /*No such node. Its an error*/
     }
-	AXIS2_FREE(env->allocator, ref_id2);
-	ref_id2 = NULL;
+    AXIS2_FREE(env->allocator, ref_id2);
+    ref_id2 = NULL;
 
     /*First child is optional Transforms element*/
     child_node = axiom_node_get_first_element(ref_node, env);
     child_node_name = axiom_util_get_localname(child_node, env);
-    if(0 == axutil_strcmp(child_node_name, OXS_NODE_TRANSFORMS)){
+    if(0 == axutil_strcmp(child_node_name, OXS_NODE_TRANSFORMS))
+    {
         /*Transforms found*/
         axiom_node_t *tr_node = NULL;
         axutil_array_list_t *tr_list = NULL;
@@ -491,30 +538,35 @@
             axis2_char_t *node_name = NULL;
 
             node_name = axiom_util_get_localname(tr_node, env);
-            if( 0 == axutil_strcmp(OXS_NODE_TRANSFORM, node_name)){
+            if(0 == axutil_strcmp(OXS_NODE_TRANSFORM, node_name))
+            {
                 axis2_char_t *tr_id = NULL;
                 oxs_transform_t *tr = NULL;
 
                 tr_id = oxs_token_get_transform(env, tr_node);
                 /*Get the transform given the id*/
                 tr = oxs_transforms_factory_produce_transform(env, tr_id);
-                if(!tr) {
+                if(!tr)
+                {
                     /*The transform not supported*/
-                    oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"Cannot produce the transform for %s", tr_id);
+                    oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,
+                        "Cannot produce the transform for %s", tr_id);
                     return AXIS2_FAILURE;
                 }
                 /*Add the transform to the list*/
                 axutil_array_list_add(tr_list, env, tr);
-            }else{
+            }
+            else
+            {
                 /*<ds:Transforms> cant have any other element*/
                 /*NOTE: Removed this check for interop testing*/
                 /*oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"<ds:Transforms> cannot have node %s ", node_name );
-                return AXIS2_FAILURE;*/
+                 return AXIS2_FAILURE;*/
             }
             /*Set the next node to be processed*/
             tr_node = axiom_node_get_next_sibling(tr_node, env);
             /*axiom_util_get_next_sibling_element(axiom_node_get_data_element(tr_node, env), env,
-                                                            tr_node, &tr_node);*/
+             tr_node, &tr_node);*/
         }/*eof while*/
         /*Set transforms for this signature part*/
         oxs_sign_part_set_transforms(sign_part, env, tr_list);
@@ -522,14 +574,17 @@
         /*At the end, set the next node as the child node*/
         /*child_node = axiom_node_get_next_sibling(child_node, env);*/
         axiom_util_get_next_sibling_element(axiom_node_get_data_element(child_node, env), env,
-                                            child_node, &child_node);
-    }else{
+            child_node, &child_node);
+    }
+    else
+    {
         /*There are no transforms for this sign part*/
     }
 
     /* Process mandatory ds:DigestMethod*/
     child_node_name = axiom_util_get_localname(child_node, env);
-    if(0 == axutil_strcmp(child_node_name, OXS_NODE_DIGEST_METHOD)){
+    if(0 == axutil_strcmp(child_node_name, OXS_NODE_DIGEST_METHOD))
+    {
         axis2_char_t *digest_mtd = NULL;
         /*ds:DigestMethod found*/
         digest_mtd = oxs_token_get_digest_method(env, child_node);
@@ -538,21 +593,28 @@
         /*At the end, set the next node as the child node*/
         /*child_node = axiom_node_get_next_sibling(child_node, env);*/
         axiom_util_get_next_sibling_element(axiom_node_get_data_element(child_node, env), env,
-                                            child_node, &child_node);
-    }else{
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find <ds:DigestMethod> " );
+            child_node, &child_node);
+    }
+    else
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+            "Cannot find <ds:DigestMethod> ");
         return AXIS2_FAILURE;
     }
 
     /* Process mandatory ds:DigestValue*/
     child_node_name = axiom_util_get_localname(child_node, env);
-    if(0 == axutil_strcmp(child_node_name, OXS_NODE_DIGEST_VALUE)){
+    if(0 == axutil_strcmp(child_node_name, OXS_NODE_DIGEST_VALUE))
+    {
         /*ds:DigestValue found*/
         axis2_char_t *digest_val = NULL;
         digest_val = oxs_token_get_digest_value(env, child_node);
         oxs_sign_part_set_digest_val(sign_part, env, digest_val);
-    }else{
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find <ds:DigestValue> " );
+    }
+    else
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+            "Cannot find <ds:DigestValue> ");
         return AXIS2_FAILURE;
     }
 
@@ -570,10 +632,11 @@
  *      3.3. Transforms*/
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_process_signature_node(const axutil_env_t *env,
-                                   oxs_sign_ctx_t *sign_ctx,
-                                   axiom_node_t *signature_node,
-                                   axiom_node_t *scope_node)
+oxs_xml_sig_process_signature_node(
+    const axutil_env_t *env,
+    oxs_sign_ctx_t *sign_ctx,
+    axiom_node_t *signature_node,
+    axiom_node_t *scope_node)
 {
     axiom_node_t *cur_node = NULL;
     axiom_node_t *signed_info_node = NULL;
@@ -582,57 +645,69 @@
     axutil_array_list_t *sign_part_list = NULL;
 
     signed_info_node = oxs_axiom_get_first_child_node_by_name(env, signature_node,
-                       OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS );
+        OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS);
 
     /*signed_info_node = oxs_axiom_get_first_child_node_by_name(env, signature_node,
-                            OXS_NODE_SIGNEDINFO, NULL,NULL);*/
+     OXS_NODE_SIGNEDINFO, NULL,NULL);*/
 
-    if(!signed_info_node){
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find <ds:SignedInfo> " );
+    if(!signed_info_node)
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+            "Cannot find <ds:SignedInfo> ");
         return AXIS2_FAILURE;
     }
     /*Create the list for sign parts*/
-    sign_part_list = axutil_array_list_create(env,5);
+    sign_part_list = axutil_array_list_create(env, 5);
 
     /*Process signed info element*/
     cur_node = axiom_node_get_first_element(signed_info_node, env);
     /*Iterate thru children of <SignedInfo>*/
-    while(cur_node){
-        axis2_char_t *localname =  NULL;
+    while(cur_node)
+    {
+        axis2_char_t *localname = NULL;
 
-        localname  = axiom_util_get_localname(cur_node, env);
+        localname = axiom_util_get_localname(cur_node, env);
 
-        if(0 == axutil_strcmp(localname, OXS_NODE_CANONICALIZATION_METHOD)){
+        if(0 == axutil_strcmp(localname, OXS_NODE_CANONICALIZATION_METHOD))
+        {
             axis2_char_t *c14n_mtd = NULL;
             c14n_mtd = oxs_token_get_c14n_method(env, cur_node);
             oxs_sign_ctx_set_c14n_mtd(sign_ctx, env, c14n_mtd);
 
-        }else if(0 == axutil_strcmp(localname, OXS_NODE_SIGNATURE_METHOD)){
+        }
+        else if(0 == axutil_strcmp(localname, OXS_NODE_SIGNATURE_METHOD))
+        {
             axis2_char_t *sig_mtd = NULL;
             sig_mtd = oxs_token_get_signature_method(env, cur_node);
             oxs_sign_ctx_set_sign_mtd_algo(sign_ctx, env, sig_mtd);
 
-        }else if(0 == axutil_strcmp(localname, OXS_NODE_REFERENCE)){
+        }
+        else if(0 == axutil_strcmp(localname, OXS_NODE_REFERENCE))
+        {
             oxs_sign_part_t *sign_part = NULL;
 
             /* There might be multiple references.
              * For each create a sign_part and add to sign_part_list in the sign_ctx*/
             sign_part = oxs_sign_part_create(env);
             status = oxs_xml_sig_process_ref_node(env, sign_part, cur_node, scope_node);
-            if(status == AXIS2_FAILURE){
-                oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"<ds:Reference> node processing failed " );
+            if(status == AXIS2_FAILURE)
+            {
+                oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+                    "<ds:Reference> node processing failed ");
                 return AXIS2_FAILURE;
             }
 
             /*Now we have a new sign_part. Add it to the list.*/
             axutil_array_list_add(sign_part_list, env, sign_part);
 
-        }else{
+        }
+        else
+        {
             /*We do not process*/
         }
         cur_node = axiom_node_get_next_sibling(cur_node, env);
         /*axiom_util_get_next_sibling_element(axiom_node_get_data_element(cur_node, env), env,
-                                                                            cur_node, &cur_node);*/
+         cur_node, &cur_node);*/
     }
 
     oxs_sign_ctx_set_sign_parts(sign_ctx, env, sign_part_list);
@@ -640,22 +715,25 @@
     /*The very next child of SignedInfo Should be the ds:SignatureValue*/
     /*sig_val_node = axiom_node_get_next_sibling(signed_info_node, env);*/
     axiom_util_get_next_sibling_element(axiom_node_get_data_element(signed_info_node, env), env,
-                                        signed_info_node, &sig_val_node);
-    if(0 == axutil_strcmp( OXS_NODE_SIGNATURE_VALUE, axiom_util_get_localname(sig_val_node, env))){
+        signed_info_node, &sig_val_node);
+    if(0 == axutil_strcmp(OXS_NODE_SIGNATURE_VALUE, axiom_util_get_localname(sig_val_node, env)))
+    {
         axis2_char_t *sig_val = NULL;
         axis2_char_t *newline_removed = NULL;
 
         sig_val = oxs_token_get_signature_value(env, sig_val_node);
         if(!sig_val)
         {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find signature value. " );
+            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+                "Cannot find signature value. ");
             return AXIS2_FAILURE;
         }
         /*We now remove \n in this text.Otherwise verifications failed.*/
-        newline_removed = oxs_util_get_newline_removed_string(env,sig_val);
+        newline_removed = oxs_util_get_newline_removed_string(env, sig_val);
         if(!newline_removed)
         {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot Remove new lines. " );
+            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+                "Cannot Remove new lines. ");
             return AXIS2_FAILURE;
         }
         oxs_sign_ctx_set_sig_val(sign_ctx, env, newline_removed);
@@ -663,9 +741,12 @@
         /*We can free newline_removed string as sign_ctx duplicates it*/
         AXIS2_FREE(env->allocator, newline_removed);
         newline_removed = NULL;
-    }else{
+    }
+    else
+    {
         /*Error the node should be the ds:SignatureValue*/
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find <ds:SignatureValue> " );
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+            "Cannot find <ds:SignatureValue> ");
         return AXIS2_FAILURE;
     }
 
@@ -673,8 +754,9 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_verify_sign_part(const axutil_env_t *env,
-                             oxs_sign_part_t *sign_part)
+oxs_xml_sig_verify_sign_part(
+    const axutil_env_t *env,
+    oxs_sign_part_t *sign_part)
 {
     axis2_char_t *id = NULL;
     axis2_char_t *digest_mtd = NULL;
@@ -684,24 +766,28 @@
     axutil_array_list_t *transforms = NULL;
     axis2_status_t status = AXIS2_FAILURE;
 
-    id =            oxs_sign_part_get_id(sign_part, env);
-    digest_mtd =    oxs_sign_part_get_digest_mtd(sign_part, env);
-    digest_val =    oxs_sign_part_get_digest_val(sign_part, env);
-    node =          oxs_sign_part_get_node(sign_part, env);
-    transforms =    oxs_sign_part_get_transforms(sign_part, env);
+    id = oxs_sign_part_get_id(sign_part, env);
+    digest_mtd = oxs_sign_part_get_digest_mtd(sign_part, env);
+    digest_val = oxs_sign_part_get_digest_val(sign_part, env);
+    node = oxs_sign_part_get_node(sign_part, env);
+    transforms = oxs_sign_part_get_transforms(sign_part, env);
 
-    AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Verifying signature part %s ", id );
+    AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Verifying signature part %s ", id);
 
     /*Do transforms to the node*/
     new_digest = oxs_xml_sig_transform_n_digest(env, node, transforms, digest_mtd);
 
     /*Compare values*/
-    if(0 == axutil_strcmp(new_digest, digest_val)){
-        AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Digest verification success for node Id= %s ", id );
+    if(0 == axutil_strcmp(new_digest, digest_val))
+    {
+        AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Digest verification success for node Id= %s ", id);
         status = AXIS2_SUCCESS;
-    }else{
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Digest verification failed for node Id= %s  ", id );
-        status =  AXIS2_FAILURE;
+    }
+    else
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+            "Digest verification failed for node Id= %s  ", id);
+        status = AXIS2_FAILURE;
     }
 
     /*FREE*/
@@ -712,23 +798,26 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_verify_digests(const axutil_env_t *env,
-                           oxs_sign_ctx_t *sign_ctx)
+oxs_xml_sig_verify_digests(
+    const axutil_env_t *env,
+    oxs_sign_ctx_t *sign_ctx)
 {
     axis2_status_t status = AXIS2_FAILURE;
     axutil_array_list_t *sign_parts = NULL;
-    int i = 0 ;
+    int i = 0;
 
     /*Get the sign_part list*/
-    sign_parts =  oxs_sign_ctx_get_sign_parts(sign_ctx, env);
+    sign_parts = oxs_sign_ctx_get_sign_parts(sign_ctx, env);
     /*For each and every signature part in sig ctx,*/
-    for (i = 0; i < axutil_array_list_size(sign_parts, env); i++){
-        oxs_sign_part_t *sign_part =  NULL;
+    for(i = 0; i < axutil_array_list_size(sign_parts, env); i++)
+    {
+        oxs_sign_part_t *sign_part = NULL;
 
         /*Get ith sign_part*/
         sign_part = (oxs_sign_part_t*)axutil_array_list_get(sign_parts, env, i);
         status = oxs_xml_sig_verify_sign_part(env, sign_part);
-        if(AXIS2_FAILURE == status){
+        if(AXIS2_FAILURE == status)
+        {
             return AXIS2_FAILURE;
         }
     }
@@ -738,10 +827,11 @@
 
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_verify(const axutil_env_t *env,
-                   oxs_sign_ctx_t *sign_ctx,
-                   axiom_node_t *signature_node,
-                   axiom_node_t *scope_node)
+oxs_xml_sig_verify(
+    const axutil_env_t *env,
+    oxs_sign_ctx_t *sign_ctx,
+    axiom_node_t *signature_node,
+    axiom_node_t *scope_node)
 {
     axis2_status_t status = AXIS2_FAILURE;
     axiom_node_t *signed_info_node = NULL;
@@ -749,16 +839,17 @@
     axis2_char_t *c14n_mtd = NULL;
     axis2_char_t *content = NULL;
     axis2_char_t *signature_val = NULL;
-	  axis2_char_t *signed_info_node_value = NULL;
 
     /*Set operation to verify*/
     oxs_sign_ctx_set_operation(sign_ctx, env, OXS_SIGN_OPERATION_VERIFY);
 
     /*Populate the sign_ctx by inspecting the ds:Signature node*/
     status = oxs_xml_sig_process_signature_node(env, sign_ctx, signature_node, scope_node);
-    if(status != AXIS2_SUCCESS){
+    if(status != AXIS2_SUCCESS)
+    {
         /*Something went wrong while processing the Signature node!!! :(*/
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"<ds:Signature> node processing failed " );
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+            "<ds:Signature> node processing failed ");
         return AXIS2_FAILURE;
     }
 
@@ -769,10 +860,13 @@
     /*Verify the integrity of the signed parts by comparing the digest values of each and every reference.*/
     status = oxs_xml_sig_verify_digests(env, sign_ctx);
 
-    if(AXIS2_FAILURE == status){
+    if(AXIS2_FAILURE == status)
+    {
         return AXIS2_FAILURE;
-    }else{
-        AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Digests verification SUCCESS " );
+    }
+    else
+    {
+        AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Digests verification SUCCESS ");
     }
 
     /*At this point we have compared the digest. Next step is to compare the Signature value */
@@ -781,36 +875,41 @@
 
     /*Then we apply the C14N for the ds:SignedInfo*/
     signed_info_node = oxs_axiom_get_first_child_node_by_name(env, signature_node,
-                       OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS );
+        OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS);
 
     /*signed_info_node = oxs_axiom_get_first_child_node_by_name(env, signature_node,
-                                OXS_NODE_SIGNEDINFO, NULL,NULL );*/
+     OXS_NODE_SIGNEDINFO, NULL,NULL );*/
 
     c14n_mtd = oxs_sign_ctx_get_c14n_mtd(sign_ctx, env);
     doc = axiom_node_get_document(signed_info_node, env);
 
-	  signed_info_node_value = axiom_node_to_string(signed_info_node, env);
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (verif1)= %s ", signed_info_node_value );
-	AXIS2_FREE(env->allocator, signed_info_node_value);
-	  signed_info_node_value = NULL;
-    /*    oxs_c14n_apply(env, doc, AXIS2_FALSE, &content, AXIS2_TRUE, NULL, signed_info_node);*/
+    IF_AXIS2_LOG_DEBUG_ENABLED(env->log)
+    {
+        axis2_char_t *node_value = NULL;
+        node_value = axiom_node_to_string(signed_info_node, env);
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart] C14N (verif1)= %s ", node_value);
+        AXIS2_FREE(env->allocator, node_value);
+    }
 
     oxs_c14n_apply_algo(env, doc, &content, NULL, signed_info_node, c14n_mtd);
 
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (verif2)=\n\n%s\n\n", content );
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (verif2)=\n\n%s\n\n", content);
 
     /*In the final step we Verify*/
-    status = oxs_sig_verify(env, sign_ctx, content , signature_val);
+    status = oxs_sig_verify(env, sign_ctx, content, signature_val);
 
     AXIS2_FREE(env->allocator, content);
     content = NULL;
 
-    if(AXIS2_FAILURE == status){
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Signature is not valid " );
+    if(AXIS2_FAILURE == status)
+    {
+        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+            "Signature is not valid ");
         return AXIS2_FAILURE;
-    }else{
+    }
+    else
+    {
         return AXIS2_SUCCESS;
     }
 
-
 }