1 files changed, 66 insertions, 66 deletions

diff --git a/src/lib/libcrypto/asn1/bio_asn1.c b/src/lib/libcrypto/asn1/bio_asn1.c
index b59645909c..a6ad850e46 100644
--- a/src/lib/libcrypto/asn1/bio_asn1.c
+++ b/src/lib/libcrypto/asn1/bio_asn1.c
@@ -69,7 +69,7 @@
 #define DEFAULT_ASN1_BUF_SIZE 20
 
 typedef enum 
-        {
+{
         ASN1_STATE_START,
         ASN1_STATE_PRE_COPY,
         ASN1_STATE_HEADER,
@@ -77,16 +77,16 @@ typedef enum
         ASN1_STATE_DATA_COPY,
         ASN1_STATE_POST_COPY,
         ASN1_STATE_DONE
-        } asn1_bio_state_t;
+} asn1_bio_state_t;
 
 typedef struct BIO_ASN1_EX_FUNCS_st
-        {
+{
         asn1_ps_func    *ex_func;
         asn1_ps_func    *ex_free_func;
-        } BIO_ASN1_EX_FUNCS;
+} BIO_ASN1_EX_FUNCS;
 
 typedef struct BIO_ASN1_BUF_CTX_t
-        {
+{
         /* Internal state */
         asn1_bio_state_t state;
         /* Internal buffer */
@@ -107,7 +107,7 @@ typedef struct BIO_ASN1_BUF_CTX_t
         int ex_len;
         int ex_pos;
         void *ex_arg;
-        } BIO_ASN1_BUF_CTX;
+} BIO_ASN1_BUF_CTX;
 
 
 static int asn1_bio_write(BIO *h, const char *buf,int num);
@@ -128,7 +128,7 @@ static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
                                 asn1_bio_state_t other_state);
 
 static BIO_METHOD methods_asn1=
-        {
+{
         BIO_TYPE_ASN1,
         "asn1",
         asn1_bio_write,
@@ -139,16 +139,16 @@ static BIO_METHOD methods_asn1=
         asn1_bio_new,
         asn1_bio_free,
         asn1_bio_callback_ctrl,
-        };
+};
 
 BIO_METHOD *BIO_f_asn1(void)
-        {
+{
         return(&methods_asn1);
-        }
+}
 
 
 static int asn1_bio_new(BIO *b)
-        {
+{
         BIO_ASN1_BUF_CTX *ctx;
         ctx = malloc(sizeof(BIO_ASN1_BUF_CTX));
         if (!ctx)
@@ -156,15 +156,15 @@ static int asn1_bio_new(BIO *b)
         if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) {
                 free(ctx);
                 return 0;
-        }
+}
         b->init = 1;
         b->ptr = (char *)ctx;
         b->flags = 0;
         return 1;
-        }
+}
 
 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
-        {
+{
         ctx->buf = malloc(size);
         if (!ctx->buf)
                 return 0;
@@ -179,10 +179,10 @@ static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
         ctx->ex_len = 0;
         ctx->state = ASN1_STATE_START;
         return 1;
-        }
+}
 
 static int asn1_bio_free(BIO *b)
-        {
+{
         BIO_ASN1_BUF_CTX *ctx;
         ctx = (BIO_ASN1_BUF_CTX *) b->ptr;
         if (ctx == NULL)
@@ -194,10 +194,10 @@ static int asn1_bio_free(BIO *b)
         b->ptr = NULL;
         b->flags = 0;
         return 1;
-        }
+}
 
 static int asn1_bio_write(BIO *b, const char *in , int inl)
-        {
+{
         BIO_ASN1_BUF_CTX *ctx;
         int wrmax, wrlen, ret;
         unsigned char *p;
@@ -211,9 +211,9 @@ static int asn1_bio_write(BIO *b, const char *in , int inl)
         ret = -1;
 
         for(;;)
-                {
+        {
                 switch (ctx->state)
-                        {
+                {
 
                         /* Setup prefix data, call it */
                         case ASN1_STATE_START:
@@ -255,10 +255,10 @@ static int asn1_bio_write(BIO *b, const char *in , int inl)
                         if (ctx->buflen)
                                 ctx->bufpos += ret;
                         else
-                                {
+                        {
                                 ctx->bufpos = 0;
                                 ctx->state = ASN1_STATE_DATA_COPY;
-                                }
+                        }
 
                         break;
 
@@ -288,26 +288,26 @@ static int asn1_bio_write(BIO *b, const char *in , int inl)
                         BIO_clear_retry_flags(b);
                         return 0;
 
-                        }
-
                 }
 
+        }
+
         done:
         BIO_clear_retry_flags(b);
         BIO_copy_next_retry(b);
 
         return (wrlen > 0) ? wrlen : ret;
 
-        }
+}
 
 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
                                 asn1_ps_func *cleanup, asn1_bio_state_t next)
-        {
+{
         int ret;
         if (ctx->ex_len <= 0)
                 return 1;
         for(;;)
-                {
+        {
                 ret = BIO_write(b->next_bio, ctx->ex_buf + ctx->ex_pos,
                                                                 ctx->ex_len);
                 if (ret <= 0)
@@ -316,62 +316,62 @@ static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
                 if (ctx->ex_len > 0)
                         ctx->ex_pos += ret;
                 else
-                        {
+                {
                         if(cleanup)
                                 cleanup(b, &ctx->ex_buf, &ctx->ex_len,
                                                                 &ctx->ex_arg);
                         ctx->state = next;
                         ctx->ex_pos = 0;
                         break;
-                        }
                 }
-        return ret;
         }
+        return ret;
+}
 
 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
                                 asn1_ps_func *setup, 
                                 asn1_bio_state_t ex_state,
                                 asn1_bio_state_t other_state)
-        {
+{
         if (setup && !setup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg))
-                {
+        {
                 BIO_clear_retry_flags(b);
                 return 0;
-                }
+        }
         if (ctx->ex_len > 0)
                 ctx->state = ex_state;
         else
                 ctx->state = other_state;
         return 1;
-        }
+}
 
 static int asn1_bio_read(BIO *b, char *in , int inl)
-        {
+{
         if (!b->next_bio)
                 return 0;
         return BIO_read(b->next_bio, in , inl);
-        }
+}
 
 static int asn1_bio_puts(BIO *b, const char *str)
-        {
+{
         return asn1_bio_write(b, str, strlen(str));
-        }
+}
 
 static int asn1_bio_gets(BIO *b, char *str, int size)
-        {
+{
         if (!b->next_bio)
                 return 0;
         return BIO_gets(b->next_bio, str , size);
-        }
+}
 
 static long asn1_bio_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
-        {
+{
         if (b->next_bio == NULL) return(0);
         return BIO_callback_ctrl(b->next_bio,cmd,fp);
-        }
+}
 
 static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
-        {
+{
         BIO_ASN1_BUF_CTX *ctx;
         BIO_ASN1_EX_FUNCS *ex_func;
         long ret = 1;
@@ -379,7 +379,7 @@ static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
         if (ctx == NULL)
                 return 0;
         switch(cmd)
-                {
+        {
 
                 case BIO_C_SET_PREFIX:
                 ex_func = arg2;
@@ -419,27 +419,27 @@ static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
 
                 /* Call post function if possible */
                 if (ctx->state == ASN1_STATE_HEADER)
-                        {
+                {
                         if (!asn1_bio_setup_ex(b, ctx, ctx->suffix,
                                 ASN1_STATE_POST_COPY, ASN1_STATE_DONE))
                                 return 0;
-                        }
+                }
 
                 if (ctx->state == ASN1_STATE_POST_COPY)
-                        {
+                {
                         ret = asn1_bio_flush_ex(b, ctx, ctx->suffix_free,
                                                         ASN1_STATE_DONE);
                         if (ret <= 0)
                                 return ret;
-                        }
+                }
 
                 if (ctx->state == ASN1_STATE_DONE)
                         return BIO_ctrl(b->next_bio, cmd, arg1, arg2);
                 else
-                        {
+                {
                         BIO_clear_retry_flags(b);
                         return 0;
-                        }
+                }
                 break;
 
 
@@ -448,50 +448,50 @@ static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
                         return 0;
                 return BIO_ctrl(b->next_bio, cmd, arg1, arg2);
 
-                }
+        }
 
         return ret;
-        }
+}
 
 static int asn1_bio_set_ex(BIO *b, int cmd,
                 asn1_ps_func *ex_func, asn1_ps_func *ex_free_func)
-        {
+{
         BIO_ASN1_EX_FUNCS extmp;
         extmp.ex_func = ex_func;
         extmp.ex_free_func = ex_free_func;
         return BIO_ctrl(b, cmd, 0, &extmp);
-        }
+}
 
 static int asn1_bio_get_ex(BIO *b, int cmd,
                 asn1_ps_func **ex_func, asn1_ps_func **ex_free_func)
-        {
+{
         BIO_ASN1_EX_FUNCS extmp;
         int ret;
         ret = BIO_ctrl(b, cmd, 0, &extmp);
         if (ret > 0)
-                {
+        {
                 *ex_func = extmp.ex_func;
                 *ex_free_func = extmp.ex_free_func;
-                }
-        return ret;
         }
+        return ret;
+}
 
 int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, asn1_ps_func *prefix_free)
-        {
+{
         return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free);
-        }
+}
 
 int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, asn1_ps_func **pprefix_free)
-        {
+{
         return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free);
-        }
+}
 
 int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, asn1_ps_func *suffix_free)
-        {
+{
         return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free);
-        }
+}
 
 int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, asn1_ps_func **psuffix_free)
-        {
+{
         return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free);
-        }
+}