diff --git a/src/omxmlsec/buffer.c b/src/omxmlsec/buffer.c
index 9cd1159..ff9569a 100644
--- a/src/omxmlsec/buffer.c
+++ b/src/omxmlsec/buffer.c
@@ -23,81 +23,50 @@
 #include <oxs_axiom.h>
 #include <oxs_error.h>
 
-
-
 struct oxs_buffer
 {
-    unsigned char* data;
+    unsigned char* data; /* will be adjusted based on oxs_buffer_remove_head method */
+    unsigned char* original_data; /* to free the data */
     unsigned int size;
     unsigned int max_size;
     oxs_AllocMode alloc_mode;
 };
 
-
-/******************** end of function headers *****************/
-
 AXIS2_EXTERN oxs_buffer_t *AXIS2_CALL
-oxs_buffer_create(const axutil_env_t *env)
+oxs_buffer_create(
+    const axutil_env_t *env)
 {
     oxs_buffer_t *buffer = NULL;
-    axis2_status_t status = AXIS2_FAILURE;
-
-    AXIS2_ENV_CHECK(env, NULL);
 
     buffer = (oxs_buffer_t*)AXIS2_MALLOC(env->allocator, sizeof(oxs_buffer_t));
-    if (!buffer)
+    if(!buffer)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[rampart]insufficient memory. oxs buffer creation failed");
         return NULL;
     }
 
     buffer->data = NULL;
+    buffer->original_data = NULL;
     buffer->size = 0;
     buffer->max_size = 0;
-    buffer->alloc_mode = oxs_alloc_mode_double;
-
-    status = oxs_buffer_set_max_size(buffer, env, OXS_BUFFER_INITIAL_SIZE);
-    if (status == AXIS2_FAILURE)
-    {
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_DEFAULT,
-                  "oxs_buffer_set_max_size");
-		AXIS2_FREE(env->allocator, buffer);
-        return NULL;
-    }
-
+    buffer->alloc_mode = oxs_alloc_mode_double;  /* increase the size exponentially */
     return buffer;
-
-}
-
-AXIS2_EXTERN oxs_buffer_t *AXIS2_CALL
-oxs_buffer_dup(oxs_buffer_t *buffer, const axutil_env_t *env)
-{
-    oxs_buffer_t *buf = NULL;
-    axis2_status_t status = AXIS2_FAILURE;
-
-    AXIS2_ENV_CHECK(env, NULL);
-    buf =  oxs_buffer_create(env);
-    status = oxs_buffer_populate(buf, env, oxs_buffer_get_data(buffer, env), oxs_buffer_get_size(buffer, env));
-    return buf;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 oxs_buffer_free(
     oxs_buffer_t *buffer,
-    const axutil_env_t *env
-)
+    const axutil_env_t *env)
 {
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-    if (buffer->data)
+    if(buffer->original_data)
     {
-        AXIS2_FREE(env->allocator,  buffer->data);
-        buffer->data = NULL;
+        AXIS2_FREE(env->allocator, buffer->original_data);
     }
 
-    AXIS2_FREE(env->allocator,  buffer);
+    AXIS2_FREE(env->allocator, buffer);
     buffer = NULL;
-
     return AXIS2_SUCCESS;
 }
 
@@ -105,72 +74,28 @@
 oxs_buffer_remove_head(
     oxs_buffer_t *buffer,
     const axutil_env_t *env,
-    int size
-)
+    int size)
 {
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    if(!buffer->data)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[rampart]oxs_buffer_remove_head failed. data is NULL");
+        return AXIS2_FAILURE;
+    }
 
     /*If the size to be removed is less than the buffer size*/
-    if (size < buffer->size)
+    if(size < buffer->size)
     {
-        if (!buffer->data)
-        {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                      "oxs_buffer_remove_head failed. data is NULL");
-            return  AXIS2_FAILURE;
-        }
         buffer->size -= size;
-        memmove(buffer->data, buffer->data + size, buffer->size);
+        buffer->max_size -= size; /* since we are not freeing the head, effective max_size is less */
+        buffer->data += size;
     }
     else
     {
         buffer->size = 0;
+        buffer->data = NULL;
     }
 
-    /*If the buffer size is less than the max_size.*/
-    if (buffer->size < buffer->max_size)
-    {
-        if (!buffer->data)
-        {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                      "oxs_buffer_remove_head failed");
-            return  AXIS2_FAILURE;
-        }
-        memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
-    }
-
-    return AXIS2_SUCCESS;
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_buffer_remove_tail(
-    oxs_buffer_t *buffer,
-    const axutil_env_t *env,
-    int size
-)
-{
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-    if (size < buffer->size)
-    {
-        buffer->size -= size;
-    }
-    else
-    {
-        buffer->size = 0;
-    }
-    if (buffer->size < buffer->max_size)
-    {
-        if (buffer->data)
-        {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                      "");
-            return  AXIS2_FAILURE;
-        }
-        memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
-    }
-
-
     return AXIS2_SUCCESS;
 }
 
@@ -179,25 +104,18 @@
     oxs_buffer_t *buffer,
     const axutil_env_t *env,
     unsigned char *data,
-    int size
-)
+    int size)
 {
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-    if (size > 0)
+    if((!data) || (size <= 0))
     {
-        oxs_buffer_set_max_size(buffer, env, size);
-        if (!data)
-        {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                      "data is NULL");
-            return AXIS2_FAILURE;
-        }
-
-        memcpy(buffer->data, data, size);
-        buffer->size = size;
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[rampart]Cannot populate data to oxs buffer. data is not valid");
+        return AXIS2_FAILURE;
     }
 
+    oxs_buffer_set_max_size(buffer, env, size);
+    memcpy(buffer->data, data, size);
+    buffer->size = size;
     return AXIS2_SUCCESS;
 }
 
@@ -206,44 +124,183 @@
     oxs_buffer_t *buffer,
     const axutil_env_t *env,
     unsigned char *data,
-    int size
-)
+    int size)
 {
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-    if (size > 0)
+    if((!data) || (size <= 0))
     {
-        oxs_buffer_set_max_size(buffer, env,  buffer->size + size);
-        if (!data)
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[rampart]Cannot append data to oxs buffer. data is not valid");
+        return AXIS2_FAILURE;
+    }
+
+    oxs_buffer_set_max_size(buffer, env, buffer->size + size);
+    memcpy(buffer->data + buffer->size, data, size);
+    buffer->size += size;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+oxs_buffer_read_file(
+    oxs_buffer_t *buffer,
+    const axutil_env_t *env,
+    const axis2_char_t *filename)
+{
+    unsigned char fbuffer[1024];
+    FILE * f;
+    int len;
+
+    f = fopen(filename, "rb");
+    if(!f)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[rampart]cannot open file %s. Populating oxs buffer from file failed.", filename);
+        return AXIS2_FAILURE;
+    }
+
+    while(1)
+    {
+        len = fread(fbuffer, 1, sizeof(fbuffer), f);
+        if(len == 0)
         {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                      "data is NULL");
+            break; /*Stop reading*/
+        }
+        else if(len < 0)
+        {
+            fclose(f);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "[rampart]Cannot read file %s. Populating oxs buffer from file failed.", filename);
             return AXIS2_FAILURE;
         }
 
-        memcpy(buffer->data + buffer->size, data, size);
-        buffer->size += size;
+        if(oxs_buffer_append(buffer, env, fbuffer, len) != AXIS2_SUCCESS)
+        {
+            fclose(f);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "[rampart]Cannot append data to oxs buffer. Populating buffer from %s failed.",
+                filename);
+            return AXIS2_FAILURE;
+        }
+    }/*End of while*/
+
+    fclose(f);
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+oxs_buffer_set_size(
+    oxs_buffer_t *buffer,
+    const axutil_env_t *env,
+    int size)
+{
+    /*First we need to make sure that the max size has a value greater or equal value*/
+    if(oxs_buffer_set_max_size(buffer, env, size) != AXIS2_SUCCESS)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart] oxs_buffer_set_max_size failed");
+        return AXIS2_FAILURE;
     }
 
+    /*Now set the size*/
+    buffer->size = size;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+oxs_buffer_set_max_size(
+    oxs_buffer_t *buffer,
+    const axutil_env_t *env,
+    int size)
+{
+    unsigned char* new_data;
+    unsigned int new_size = 0;
+
+    if(size <= buffer->max_size)
+    {
+        return AXIS2_SUCCESS;
+    }
+
+    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;
+    }
+
+    if(new_size < OXS_BUFFER_INITIAL_SIZE)
+    {
+        new_size = OXS_BUFFER_INITIAL_SIZE;
+    }
+
+    new_data = (unsigned char*)AXIS2_MALLOC(env->allocator, new_size);
+    if(!new_data)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[rampart]cannot increase the size of oxs buffer. Insufficient memory");
+        return AXIS2_FAILURE;
+    }
+
+    if(buffer->data)
+    {
+        /* Copy existing data */
+        new_data = memcpy(new_data, buffer->data, buffer->size);
+    }
+
+    if(buffer->original_data)
+    {
+        /* we don't need the original data now. buffer->data is part of buffer->original_data.
+         * Since we are going to change the pointer of buffer->data, we can free original_data
+         */
+        AXIS2_FREE(env->allocator, buffer->original_data);
+    }
+
+    buffer->data = new_data;
+    buffer->original_data = new_data;
+    buffer->max_size = new_size;
+
     return AXIS2_SUCCESS;
 }
 
+AXIS2_EXTERN unsigned char* AXIS2_CALL
+oxs_buffer_get_data(
+    oxs_buffer_t *buffer,
+    const axutil_env_t *env)
+{
+    return buffer->data;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+oxs_buffer_get_size(
+    oxs_buffer_t *buffer,
+    const axutil_env_t *env)
+{
+    return buffer->size;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+oxs_buffer_get_max_size(
+    oxs_buffer_t *buffer,
+    const axutil_env_t *env)
+{
+    return buffer->max_size;
+}
+
+#if 0 /* this seemed to be not used 1.3.0*/
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 oxs_buffer_prepend(
     oxs_buffer_t *buffer,
     const axutil_env_t *env,
     unsigned char *data,
-    int size
-)
+    int size)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    if (size > 0)
+    if(size > 0)
     {
-        if (!data)
+        if(!data)
         {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                      "Passed data is NULL");
+            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA, "Passed data is NULL");
             return AXIS2_FAILURE;
         }
 
@@ -257,152 +314,53 @@
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_buffer_read_file(
+AXIS2_EXTERN oxs_buffer_t *AXIS2_CALL
+oxs_buffer_dup(
     oxs_buffer_t *buffer,
-    const axutil_env_t *env,
-    const axis2_char_t *filename
-)
+    const axutil_env_t *env)
 {
-    unsigned char fbuffer[1024];
-    FILE* f;
-    int  len;
-    axis2_status_t status = AXIS2_FAILURE;
+    oxs_buffer_t *buf = NULL;
 
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-    f = fopen(filename, "rb");
-    if (f == NULL)
+    buf = oxs_buffer_create(env);
+    if(!buf)
     {
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                  "");
-        return AXIS2_FAILURE;
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]duplicating oxs buffer failed");
+        return NULL;
     }
 
-    while (1)
+    if(oxs_buffer_populate(buf, env, oxs_buffer_get_data(buffer, env),
+        oxs_buffer_get_size(buffer, env)) != AXIS2_SUCCESS)
     {
-        len = fread(fbuffer, 1, sizeof(fbuffer), f);
-        if (len == 0)
-        {
-            break; /*Stop reading*/
-        }
-        else if (len < 0)
-        {
-            fclose(f);
-            return AXIS2_FAILURE;
-        }
-        status = oxs_buffer_append(buffer, env, fbuffer, len);
-        if (status == AXIS2_FAILURE)
-        {
-            fclose(f);
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                      "");
-            return AXIS2_FAILURE;
-        }
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[rampart]populating buffer failed. Cannot duplicate given oxs buffer");
+        oxs_buffer_free(buf, env);
+        return NULL;
+    }
 
-        /*Alright so far everything is fine. So let's close the output*/
-        fclose(f);
-        return AXIS2_SUCCESS;
-    }/*End of while*/
-
-    return AXIS2_SUCCESS;
+    return buf;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_buffer_set_size(
+oxs_buffer_remove_tail(
     oxs_buffer_t *buffer,
     const axutil_env_t *env,
-    int size
-)
+    int size)
 {
-    axis2_status_t status = AXIS2_FAILURE;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    /*First we need to make sure that the max size has a value greater or equal value*/
-    status = oxs_buffer_set_max_size(buffer, env,  size);
-    if (status == AXIS2_FAILURE)
+    if(size < buffer->size)
     {
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                  "oxs_buffer_set_max_size failed");
-        return AXIS2_FAILURE;
-    }
-    /*Now set the size*/
-    buffer->size = size;
-
-    return AXIS2_SUCCESS;
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_buffer_set_max_size(
-    oxs_buffer_t *buffer,
-    const axutil_env_t *env,
-    int size
-)
-{
-    unsigned char* new_data;
-    unsigned int new_size = 0;
-
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-    if (size <= buffer->max_size)
-    {
-        return AXIS2_SUCCESS;
-    }
-
-    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;
-    }
-
-    if (new_size < OXS_BUFFER_INITIAL_SIZE)
-    {
-        new_size = OXS_BUFFER_INITIAL_SIZE;
-    }
-
-    /*If there are data already then use realloc instead of malloc*/
-    if (buffer->data)
-    {
-#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);
-		AXIS2_FREE(env->allocator, buffer->data);
-		buffer->data = NULL;
-
-#endif
+        buffer->size -= size;
     }
     else
     {
-        new_data = (unsigned char*)AXIS2_MALLOC(env->allocator, new_size);
+        buffer->size = 0;
     }
-
-    if (new_data == NULL)
+    if(buffer->size < buffer->max_size)
     {
-        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                  "");
-        return AXIS2_FAILURE;
-    }
-
-    buffer->data = new_data;
-    buffer->max_size = new_size;
-
-    if (buffer->size < buffer->max_size)
-    {
-        if (buffer->data == NULL)
+        if(buffer->data)
         {
-            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA,
-                      "");
+            oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_INVALID_DATA, "");
             return AXIS2_FAILURE;
         }
         memset(buffer->data + buffer->size, 0, buffer->max_size - buffer->size);
@@ -410,37 +368,4 @@
 
     return AXIS2_SUCCESS;
 }
-
-AXIS2_EXTERN unsigned char* AXIS2_CALL
-oxs_buffer_get_data(
-    oxs_buffer_t *buffer,
-    const axutil_env_t *env
-)
-{
-    AXIS2_ENV_CHECK(env, NULL);
-
-    return buffer->data;
-}
-
-AXIS2_EXTERN int AXIS2_CALL
-oxs_buffer_get_size(
-    oxs_buffer_t *buffer,
-    const axutil_env_t *env
-)
-{
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-    return buffer->size;
-}
-
-AXIS2_EXTERN int AXIS2_CALL
-oxs_buffer_get_max_size(
-    oxs_buffer_t *buffer,
-    const axutil_env_t *env
-)
-{
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-    return buffer->max_size;
-}
-
+#endif
diff --git a/src/omxmlsec/openssl/crypt.c b/src/omxmlsec/openssl/crypt.c
index 4a6e5aa..5425ec7 100644
--- a/src/omxmlsec/openssl/crypt.c
+++ b/src/omxmlsec/openssl/crypt.c
@@ -27,47 +27,52 @@
 #define BUFSIZE 64
 
 AXIS2_EXTERN int AXIS2_CALL
-openssl_bc_crypt(const axutil_env_t *env,
-                 openssl_cipher_ctx_t *oc_ctx,
-                 oxs_buffer_t *input_buf,
-                 oxs_buffer_t *output_buf,
-                 int encrypt)
+openssl_bc_crypt(
+    const axutil_env_t *env,
+    openssl_cipher_ctx_t *oc_ctx,
+    oxs_buffer_t *input_buf,
+    oxs_buffer_t *output_buf,
+    int encrypt)
 {
-    EVP_CIPHER_CTX ctx ;
+    EVP_CIPHER_CTX ctx;
     oxs_key_t *okey = NULL;
-
     unsigned char iv[EVP_MAX_IV_LENGTH];
     unsigned char key[EVP_MAX_KEY_LENGTH];
-    int ret =0, iv_length =0, block_length =0;
+    int ret = 0, iv_length = 0, block_length = 0;
     int last = 0;
     axis2_status_t status = AXIS2_FAILURE;
 
-    /********************************Initialize*****************************************************/
-
+    /* Initialize */
     iv_length = EVP_CIPHER_iv_length(openssl_cipher_ctx_get_cipher(oc_ctx, env));
 
-    /*Get the IV. If encrypt, we need to generate the IV else we need to get it from the input buffer*/
-    if(encrypt){
+    /* Get the IV. If encrypt, need to generate the IV. Else need to get it from the input buffer*/
+    if(encrypt)
+    {
         /*Generate IV*/
         ret = RAND_bytes(iv, iv_length);
         /*IV to the output*/
         status = oxs_buffer_append(output_buf, env, iv, iv_length);
-    }else{ /*Decrypt*/
+    }
+    else
+    {
+        /* Decrypt */
         /*If data is less than the IV its an error*/
-        if(oxs_buffer_get_size(input_buf, env) < iv_length){
+        if(oxs_buffer_get_size(input_buf, env) < iv_length)
+        {
             return -1;
         }
         /*Copy IV from the inbuf to our buffer*/
         memcpy(iv, oxs_buffer_get_data(input_buf, env), iv_length);
         /*And remove from input*/
-        status = oxs_buffer_remove_head (input_buf, env, iv_length);
+        status = oxs_buffer_remove_head(input_buf, env, iv_length);
     }
     /*Get key*/
     okey = openssl_cipher_ctx_get_key(oc_ctx, env);
-    memcpy(key,  oxs_key_get_data(okey, env), oxs_key_get_size(okey, env));
+    memcpy(key, oxs_key_get_data(okey, env), oxs_key_get_size(okey, env));
 
     /*Set the IV */
-    ret = EVP_CipherInit(&ctx, (EVP_CIPHER *)openssl_cipher_ctx_get_cipher(oc_ctx, env), key, iv, encrypt);
+    ret = EVP_CipherInit(&ctx, (EVP_CIPHER *)openssl_cipher_ctx_get_cipher(oc_ctx, env), key, iv,
+        encrypt);
 #ifndef OXS_OPENSSL_096
     EVP_CIPHER_CTX_set_padding(&ctx, 0);
 #endif
@@ -76,19 +81,24 @@
     block_length = EVP_CIPHER_block_size((EVP_CIPHER *)openssl_cipher_ctx_get_cipher(oc_ctx, env));
 
     /*********************************Update***********************************************************/
-    for(;;){/*Loop untill all the data are encrypted*/
+    for(;;)
+    {/*Loop untill all the data are encrypted*/
         unsigned char *out_buf = NULL;
-        int  in_size =0, out_size =0, fixed=0, out_length = 0;
+        int in_size = 0, out_size = 0, fixed = 0, out_length = 0;
 
-    if (0 == oxs_buffer_get_size(input_buf, env)) {
+        if(0 == oxs_buffer_get_size(input_buf, env))
+        {
             last = 1;
             break; /*Quit loop if NO DATA!!! */
         }
 
         /*If the amnt of data available is greater than the buffer size, we limit it to buffer size */
-        if(oxs_buffer_get_size(input_buf, env) > BUFSIZE){
+        if(oxs_buffer_get_size(input_buf, env) > BUFSIZE)
+        {
             in_size = BUFSIZE;
-        }else{
+        }
+        else
+        {
             in_size = oxs_buffer_get_size(input_buf, env);
         }
 
@@ -97,46 +107,58 @@
         /*Set the output buffer size*/
         status = oxs_buffer_set_max_size(output_buf, env, out_size + in_size + block_length);
 
-        out_buf = oxs_buffer_get_data(output_buf, env) + out_size;        /*position to write*/
+        out_buf = oxs_buffer_get_data(output_buf, env) + out_size; /*position to write*/
 
 #ifndef OXS_OPENSSL_096
         /*If decrypt, we copy the final data to the out_buf of size block_length*/
-        if(!ctx.encrypt) {
-            if(ctx.final_used) {
+        if(!ctx.encrypt)
+        {
+            if(ctx.final_used)
+            {
                 memcpy(out_buf, ctx.final, block_length);
                 out_buf += block_length;
                 fixed = 1;
-        }else {
-            fixed = 0;
+            }
+            else
+            {
+                fixed = 0;
+            }
         }
-    }
 #endif
-    /* encrypt or decrypt */
-    ret = EVP_CipherUpdate(&ctx, out_buf, &out_length, oxs_buffer_get_data(input_buf, env), in_size);
+        /* encrypt or decrypt */
+        ret = EVP_CipherUpdate(&ctx, out_buf, &out_length, oxs_buffer_get_data(input_buf, env),
+            in_size);
 
 #ifndef OXS_OPENSSL_096
         /*If decrypt, we copy data from the out_buf to the ctx.final*/
-        if(!ctx.encrypt) {
-            if (block_length > 1 && !ctx.buf_len) {
+        if(!ctx.encrypt)
+        {
+            if(block_length > 1 && !ctx.buf_len)
+            {
                 out_length -= block_length;
                 ctx.final_used = 1;
                 memcpy(ctx.final, &out_buf[out_length], block_length);
-            } else {
+            }
+            else
+            {
                 ctx.final_used = 0;
             }
-            if (fixed) {
+            if(fixed)
+            {
                 out_length += block_length;
             }
         }
 #endif
         /* set correct output buffer size */
         status = oxs_buffer_set_size(output_buf, env, out_size + out_length);
-        if(AXIS2_FAILURE == status){
+        if(AXIS2_FAILURE == status)
+        {
             return -1;
         }
         /* remove the processed block from input */
         status = oxs_buffer_remove_head(input_buf, env, in_size);
-        if(AXIS2_FAILURE == status){
+        if(AXIS2_FAILURE == status)
+        {
             return -1;
         }
 
@@ -145,20 +167,23 @@
     /********************************Finalize*****************************************************/
 
     /* by now there should be no input */
-    if(last == 1){
+    if(last == 1)
+    {
         unsigned char pad[EVP_MAX_BLOCK_LENGTH];
         unsigned char *out_buf = NULL;
-        int out_size = 0,  out_length = 0, out_length2 = 0;
+        int out_size = 0, out_length = 0, out_length2 = 0;
 
         out_size = oxs_buffer_get_size(output_buf, env);
-        status = oxs_buffer_set_max_size(output_buf,  env, out_size + 2 * block_length);
-        out_buf = oxs_buffer_get_data(output_buf, env)  + out_size;/*position to write*/
+        status = oxs_buffer_set_max_size(output_buf, env, out_size + 2 * block_length);
+        out_buf = oxs_buffer_get_data(output_buf, env) + out_size;/*position to write*/
 #ifndef OXS_OPENSSL_096
-        if(encrypt){
+        if(encrypt)
+        {
             int pad_length;
             pad_length = block_length - ctx.buf_len;
             /* generate random padding */
-            if(pad_length > 1) {
+            if(pad_length > 1)
+            {
                 ret = RAND_bytes(pad, pad_length - 1);
             }
             pad[pad_length - 1] = pad_length;
@@ -170,13 +195,18 @@
         /* finalize  */
         ret = EVP_CipherFinal(&ctx, out_buf, &out_length2);
 #ifndef OXS_OPENSSL_096
-        if(!encrypt){
-            if(block_length > 1) {
+        if(!encrypt)
+        {
+            if(block_length > 1)
+            {
                 out_length2 = block_length - ctx.final[block_length - 1];
-                if(out_length2 > 0) {
+                if(out_length2 > 0)
+                {
                     memcpy(out_buf, ctx.final, out_length2);
-                } else if(out_length2 < 0) {
-                    return(-1);
+                }
+                else if(out_length2 < 0)
+                {
+                    return (-1);
                 }
             }
         }
@@ -187,9 +217,10 @@
         EVP_CIPHER_CTX_cleanup(&ctx);
         /*return the length of the outputbuf*/
         return out_size + out_length + out_length2;
-    }else{
+    }
+    else
+    {
         return -1;
     }
-
 }