1 files changed, 108 insertions, 108 deletions

diff --git a/src/lib/libcrypto/asn1/tasn_prn.c b/src/lib/libcrypto/asn1/tasn_prn.c
index ec524edac8..f62c085f3b 100644
--- a/src/lib/libcrypto/asn1/tasn_prn.c
+++ b/src/lib/libcrypto/asn1/tasn_prn.c
@@ -73,86 +73,86 @@
 /* ASN1_PCTX routines */
 
 ASN1_PCTX default_pctx = 
-        {
+{
         ASN1_PCTX_FLAGS_SHOW_ABSENT,    /* flags */
         0,      /* nm_flags */
         0,      /* cert_flags */
         0,      /* oid_flags */
         0       /* str_flags */
-        };
+};
         
 
 ASN1_PCTX *ASN1_PCTX_new(void)
-        {
+{
         ASN1_PCTX *ret;
         ret = malloc(sizeof(ASN1_PCTX));
         if (ret == NULL)
-                {
+        {
                 ASN1err(ASN1_F_ASN1_PCTX_NEW, ERR_R_MALLOC_FAILURE);
                 return NULL;
-                }
+        }
         ret->flags = 0;
         ret->nm_flags = 0;
         ret->cert_flags = 0;
         ret->oid_flags = 0;
         ret->str_flags = 0;
         return ret;
-        }
+}
 
 void ASN1_PCTX_free(ASN1_PCTX *p)
-        {
+{
         free(p);
-        }
+}
 
 unsigned long ASN1_PCTX_get_flags(ASN1_PCTX *p)
-        {
+{
         return p->flags;
-        }
+}
 
 void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags)
-        {
+{
         p->flags = flags;
-        }
+}
 
 unsigned long ASN1_PCTX_get_nm_flags(ASN1_PCTX *p)
-        {
+{
         return p->nm_flags;
-        }
+}
 
 void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags)
-        {
+{
         p->nm_flags = flags;
-        }
+}
 
 unsigned long ASN1_PCTX_get_cert_flags(ASN1_PCTX *p)
-        {
+{
         return p->cert_flags;
-        }
+}
 
 void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags)
-        {
+{
         p->cert_flags = flags;
-        }
+}
 
 unsigned long ASN1_PCTX_get_oid_flags(ASN1_PCTX *p)
-        {
+{
         return p->oid_flags;
-        }
+}
 
 void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags)
-        {
+{
         p->oid_flags = flags;
-        }
+}
 
 unsigned long ASN1_PCTX_get_str_flags(ASN1_PCTX *p)
-        {
+{
         return p->str_flags;
-        }
+}
 
 void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags)
-        {
+{
         p->str_flags = flags;
-        }
+}
 
 /* Main print routines */
 
@@ -175,7 +175,7 @@ static int asn1_print_fsname(BIO *out, int indent,
 
 int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent,
                                 const ASN1_ITEM *it, const ASN1_PCTX *pctx)
-        {
+{
         const char *sname;
         if (pctx == NULL)
                 pctx = &default_pctx;
@@ -185,13 +185,13 @@ int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent,
                 sname = it->sname;
         return asn1_item_print_ctx(out, &ifld, indent, it,
                                                         NULL, sname, 0, pctx);
-        }
+}
 
 static int asn1_item_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
                                 const ASN1_ITEM *it,
                                 const char *fname, const char *sname,
                                 int nohdr, const ASN1_PCTX *pctx)
-        {
+{
         const ASN1_TEMPLATE *tt;
         const ASN1_EXTERN_FUNCS *ef;
         ASN1_VALUE **tmpfld;
@@ -200,36 +200,36 @@ static int asn1_item_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
         ASN1_PRINT_ARG parg;
         int i;
         if (aux && aux->asn1_cb)
-                {
+        {
                 parg.out = out;
                 parg.indent = indent;
                 parg.pctx = pctx;
                 asn1_cb = aux->asn1_cb;
-                }
+        }
         else asn1_cb = 0;
 
         if(*fld == NULL)
-                {
+        {
                 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_ABSENT)
-                        {
+                {
                         if (!nohdr && !asn1_print_fsname(out, indent,
                                                         fname, sname, pctx))
                                 return 0;
                         if (BIO_puts(out, "<ABSENT>\n") <= 0)
                                 return 0;
-                        }
-                return 1;
                 }
+                return 1;
+        }
 
         switch(it->itype)
-                {
+        {
                 case ASN1_ITYPE_PRIMITIVE:
                 if(it->templates)
-                        {
+                {
                         if (!asn1_template_print_ctx(out, fld, indent,
                                                         it->templates, pctx))
                                 return 0;
-                        }
+                }
                 /* fall thru */
                 case ASN1_ITYPE_MSTRING:
                 if (!asn1_primitive_print(out, fld, it,
@@ -243,14 +243,14 @@ static int asn1_item_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
                 /* Use new style print routine if possible */
                 ef = it->funcs;
                 if (ef && ef->asn1_ex_print)
-                        {
+                {
                         i = ef->asn1_ex_print(out, fld, indent, "", pctx);
                         if (!i)
                                 return 0;
                         if ((i == 2) && (BIO_puts(out, "\n") <= 0))
                                 return 0;
                         return 1;
-                        }
+                }
                 else if (sname && 
                         BIO_printf(out, ":EXTERNAL TYPE %s\n", sname) <= 0)
                         return 0;
@@ -265,12 +265,12 @@ static int asn1_item_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
                 i = asn1_get_choice_selector(fld, it);
                 /* This should never happen... */
                 if((i < 0) || (i >= it->tcount))
-                        {
+                {
                         if (BIO_printf(out,
                                 "ERROR: selector [%d] invalid\n", i) <= 0)
                                 return 0;
                         return 1;
-                        }
+                }
                 tt = it->templates + i;
                 tmpfld = asn1_get_field_ptr(fld, tt);
                 if (!asn1_template_print_ctx(out, tmpfld, indent, tt, pctx))
@@ -282,63 +282,63 @@ static int asn1_item_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
                 if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
                         return 0;
                 if (fname || sname)
-                        {
+                {
                         if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE)
-                                {
+                        {
                                 if (BIO_puts(out, " {\n") <= 0)
                                         return 0;
-                                }
+                        }
                         else
-                                {
+                        {
                                 if (BIO_puts(out, "\n") <= 0)
                                         return 0;
-                                }
                         }
+                }
 
                 if (asn1_cb)
-                        {
+                {
                         i = asn1_cb(ASN1_OP_PRINT_PRE, fld, it, &parg);
                         if (i == 0)
                                 return 0;
                         if (i == 2)
                                 return 1;
-                        }
+                }
 
                 /* Print each field entry */
                 for(i = 0, tt = it->templates; i < it->tcount; i++, tt++)
-                        {
+                {
                         const ASN1_TEMPLATE *seqtt;
                         seqtt = asn1_do_adb(fld, tt, 1);
                         tmpfld = asn1_get_field_ptr(fld, seqtt);
                         if (!asn1_template_print_ctx(out, tmpfld,
                                                 indent + 2, seqtt, pctx))
                                 return 0;
-                        }
+                }
                 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE)
-                        {
+                {
                         if (BIO_printf(out, "%*s}\n", indent, "") < 0)
                                 return 0;
-                        }
+                }
 
                 if (asn1_cb)
-                        {
+                {
                         i = asn1_cb(ASN1_OP_PRINT_POST, fld, it, &parg);
                         if (i == 0)
                                 return 0;
-                        }
+                }
                 break;
 
                 default:
                 BIO_printf(out, "Unprocessed type %d\n", it->itype);
                 return 0;
-                }
+        }
 
         return 1;
-        }
+}
 
 int asn1_template_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
                                 const ASN1_TEMPLATE *tt, const ASN1_PCTX *pctx)
-        {
+{
         int i, flags;
         const char *sname, *fname;
         flags = tt->flags;
@@ -351,16 +351,16 @@ int asn1_template_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
         else
                 fname = tt->field_name;
         if(flags & ASN1_TFLG_SK_MASK)
-                {
+        {
                 char *tname;
                 ASN1_VALUE *skitem;
                 STACK_OF(ASN1_VALUE) *stack;
 
                 /* SET OF, SEQUENCE OF */
                 if (fname)
-                        {
+                {
                         if(pctx->flags & ASN1_PCTX_FLAGS_SHOW_SSOF)
-                                {
+                        {
                                 if(flags & ASN1_TFLG_SET_OF)
                                         tname = "SET";
                                 else
@@ -368,14 +368,14 @@ int asn1_template_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
                                 if (BIO_printf(out, "%*s%s OF %s {\n",
                                         indent, "", tname, tt->field_name) <= 0)
                                         return 0;
-                                }
+                        }
                         else if (BIO_printf(out, "%*s%s:\n", indent, "",
                                         fname) <= 0)
                                 return 0;
-                        }
+                }
                 stack = (STACK_OF(ASN1_VALUE) *)*fld;
                 for(i = 0; i < sk_ASN1_VALUE_num(stack); i++)
-                        {
+                {
                         if ((i > 0) && (BIO_puts(out, "\n") <= 0))
                                 return 0;
 
@@ -383,24 +383,24 @@ int asn1_template_print_ctx(BIO *out, ASN1_VALUE **fld, int indent,
                         if (!asn1_item_print_ctx(out, &skitem, indent + 2,
                                 ASN1_ITEM_ptr(tt->item), NULL, NULL, 1, pctx))
                                 return 0;
-                        }
+                }
                 if (!i && BIO_printf(out, "%*s<EMPTY>\n", indent + 2, "") <= 0)
                                 return 0;
                 if(pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE)
-                        {
+                {
                         if (BIO_printf(out, "%*s}\n", indent, "") <= 0)
                                 return 0;
-                        }
-                return 1;
                 }
+                return 1;
+        }
         return asn1_item_print_ctx(out, fld, indent, ASN1_ITEM_ptr(tt->item),
                                                         fname, sname, 0, pctx);
-        }
+}
 
 static int asn1_print_fsname(BIO *out, int indent,
                         const char *fname, const char *sname,
                         const ASN1_PCTX *pctx)
-        {
+{
         static char spaces[] = "                    ";
         const int nspaces = sizeof(spaces) - 1;
 
@@ -410,11 +410,11 @@ static int asn1_print_fsname(BIO *out, int indent,
 #endif
 
         while (indent > nspaces)
-                {
+        {
                 if (BIO_write(out, spaces, nspaces) != nspaces)
                         return 0;
                 indent -= nspaces;
-                }
+        }
         if (BIO_write(out, spaces, indent) != indent)
                 return 0;
         if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME)
@@ -424,34 +424,34 @@ static int asn1_print_fsname(BIO *out, int indent,
         if (!sname && !fname)
                 return 1;
         if (fname)
-                {
+        {
                 if (BIO_puts(out, fname) <= 0)
                         return 0;
-                }
+        }
         if (sname)
-                {
+        {
                 if (fname)
-                        {
+                {
                         if (BIO_printf(out, " (%s)", sname) <= 0)
                                 return 0;
-                        }
+                }
                 else
-                        {
+                {
                         if (BIO_puts(out, sname) <= 0)
                                 return 0;
-                        }
                 }
+        }
         if (BIO_write(out, ": ", 2) != 2)
                 return 0;
         return 1;
-        }
+}
 
 static int asn1_print_boolean_ctx(BIO *out, int boolval,
                                                         const ASN1_PCTX *pctx)
-        {
+{
         const char *str;
         switch (boolval)
-                {
+        {
                 case -1:
                 str = "BOOL ABSENT";
                 break;
@@ -464,17 +464,17 @@ static int asn1_print_boolean_ctx(BIO *out, int boolval,
                 str = "TRUE";
                 break;
 
-                }
+        }
 
         if (BIO_puts(out, str) <= 0)
                 return 0;
         return 1;
 
-        }
+}
 
 static int asn1_print_integer_ctx(BIO *out, ASN1_INTEGER *str,
                                                 const ASN1_PCTX *pctx)
-        {
+{
         char *s;
         int ret = 1;
         s = i2s_ASN1_INTEGER(NULL, str);
@@ -482,11 +482,11 @@ static int asn1_print_integer_ctx(BIO *out, ASN1_INTEGER *str,
                 ret = 0;
         free(s);
         return ret;
-        }
+}
 
 static int asn1_print_oid_ctx(BIO *out, const ASN1_OBJECT *oid,
                                                 const ASN1_PCTX *pctx)
-        {
+{
         char objbuf[80];
         const char *ln;
         ln = OBJ_nid2ln(OBJ_obj2nid(oid));
@@ -496,17 +496,17 @@ static int asn1_print_oid_ctx(BIO *out, const ASN1_OBJECT *oid,
         if (BIO_printf(out, "%s (%s)", ln, objbuf) <= 0)
                 return 0;
         return 1;
-        }
+}
 
 static int asn1_print_obstring_ctx(BIO *out, ASN1_STRING *str, int indent,
                                                 const ASN1_PCTX *pctx)
-        {
+{
         if (str->type == V_ASN1_BIT_STRING)
-                {
+        {
                 if (BIO_printf(out, " (%ld unused bits)\n",
                                         str->flags & 0x7) <= 0)
                                 return 0;
-                }
+        }
         else if (BIO_puts(out, "\n") <= 0)
                 return 0;
         if ((str->length > 0)
@@ -514,13 +514,13 @@ static int asn1_print_obstring_ctx(BIO *out, ASN1_STRING *str, int indent,
                                 indent + 2) <= 0)
                 return 0;
         return 1;
-        }
+}
 
 static int asn1_primitive_print(BIO *out, ASN1_VALUE **fld,
                                 const ASN1_ITEM *it, int indent,
                                 const char *fname, const char *sname,
                                 const ASN1_PCTX *pctx)
-        {
+{
         long utype;
         ASN1_STRING *str;
         int ret = 1, needlf = 1;
@@ -537,7 +537,7 @@ static int asn1_primitive_print(BIO *out, ASN1_VALUE **fld,
         else
                 utype = it->utype;
         if (utype == V_ASN1_ANY)
-                {
+        {
                 ASN1_TYPE *atype = (ASN1_TYPE *)*fld;
                 utype = atype->type;
                 fld = &atype->value.asn1_value;
@@ -546,39 +546,39 @@ static int asn1_primitive_print(BIO *out, ASN1_VALUE **fld,
                         pname = NULL;
                 else 
                         pname = ASN1_tag2str(utype);
-                }
+        }
         else
-                {
+        {
                 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_TYPE)
                         pname = ASN1_tag2str(utype);
                 else 
                         pname = NULL;
-                }
+        }
 
         if (utype == V_ASN1_NULL)
-                {
+        {
                 if (BIO_puts(out, "NULL\n") <= 0)
                         return 0;
                 return 1;
-                }
+        }
 
         if (pname)
-                {
+        {
                 if (BIO_puts(out, pname) <= 0)
                         return 0;
                 if (BIO_puts(out, ":") <= 0)
                         return 0;
-                }
+        }
 
         switch (utype)
-                {
+        {
                 case V_ASN1_BOOLEAN:
-                        {
+                {
                         int boolval = *(int *)fld;
                         if (boolval == -1)
                                 boolval = it->size;
                         ret = asn1_print_boolean_ctx(out, boolval, pctx);
-                        }
+                }
                 break;
 
                 case V_ASN1_INTEGER:
@@ -618,10 +618,10 @@ static int asn1_primitive_print(BIO *out, ASN1_VALUE **fld,
                 default:
                 ret = ASN1_STRING_print_ex(out, str, pctx->str_flags);
 
-                }
+        }
         if (!ret)
                 return 0;
         if (needlf && BIO_puts(out, "\n") <= 0)
                 return 0;
         return 1;
-        }
+}