1 files changed, 51 insertions, 77 deletions

diff --git a/src/lib/libcrypto/asn1/tasn_utl.c b/src/lib/libcrypto/asn1/tasn_utl.c
index 34d520b180..8996ce8c13 100644
--- a/src/lib/libcrypto/asn1/tasn_utl.c
+++ b/src/lib/libcrypto/asn1/tasn_utl.c
@@ -3,7 +3,7 @@
  * project 2000.
  */
 /* ====================================================================
- * Copyright (c) 2000-2004 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -74,23 +74,23 @@
  */
 
 int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it)
-        {
+{
         int *sel = offset2ptr(*pval, it->utype);
         return *sel;
-        }
+}
 
 /* Given an ASN1_ITEM CHOICE type set
  * the selector value, return old value.
  */
 
 int asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it)
-        {       
+{       
         int *sel, ret;
         sel = offset2ptr(*pval, it->utype);
         ret = *sel;
         *sel = value;
         return ret;
-        }
+}
 
 /* Do reference counting. The value 'op' decides what to do. 
  * if it is +1 then the count is incremented. If op is 0 count is
@@ -99,134 +99,114 @@ int asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it)
  */
 
 int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it)
-        {
+{
         const ASN1_AUX *aux;
         int *lck, ret;
-        if ((it->itype != ASN1_ITYPE_SEQUENCE)
-           && (it->itype != ASN1_ITYPE_NDEF_SEQUENCE))
-                return 0;
+        if(it->itype != ASN1_ITYPE_SEQUENCE) return 0;
         aux = it->funcs;
-        if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT))
-                return 0;
+        if(!aux || !(aux->flags & ASN1_AFLG_REFCOUNT)) return 0;
         lck = offset2ptr(*pval, aux->ref_offset);
-        if (op == 0)
-                {
+        if(op == 0) {
                 *lck = 1;
                 return 1;
-                }
+        }
         ret = CRYPTO_add(lck, op, aux->ref_lock);
 #ifdef REF_PRINT
         fprintf(stderr, "%s: Reference Count: %d\n", it->sname, *lck);
 #endif
 #ifdef REF_CHECK
-        if (ret < 0) 
+        if(ret < 0) 
                 fprintf(stderr, "%s, bad reference count\n", it->sname);
 #endif
         return ret;
-        }
+}
 
 static ASN1_ENCODING *asn1_get_enc_ptr(ASN1_VALUE **pval, const ASN1_ITEM *it)
-        {
+{
         const ASN1_AUX *aux;
-        if (!pval || !*pval)
-                return NULL;
+        if(!pval || !*pval) return NULL;
         aux = it->funcs;
-        if (!aux || !(aux->flags & ASN1_AFLG_ENCODING))
-                return NULL;
+        if(!aux || !(aux->flags & ASN1_AFLG_ENCODING)) return NULL;
         return offset2ptr(*pval, aux->enc_offset);
-        }
+}
 
 void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it)
-        {
+{
         ASN1_ENCODING *enc;
         enc = asn1_get_enc_ptr(pval, it);
-        if (enc)
-                {
+        if(enc) {
                 enc->enc = NULL;
                 enc->len = 0;
                 enc->modified = 1;
-                }
         }
+}
 
 void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
-        {
+{
         ASN1_ENCODING *enc;
         enc = asn1_get_enc_ptr(pval, it);
-        if (enc)
-                {
-                if (enc->enc)
-                        OPENSSL_free(enc->enc);
+        if(enc) {
+                if(enc->enc) OPENSSL_free(enc->enc);
                 enc->enc = NULL;
                 enc->len = 0;
                 enc->modified = 1;
-                }
         }
+}
 
-int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
-                                                         const ASN1_ITEM *it)
-        {
+int asn1_enc_save(ASN1_VALUE **pval, unsigned char *in, int inlen, const ASN1_ITEM *it)
+{
         ASN1_ENCODING *enc;
         enc = asn1_get_enc_ptr(pval, it);
-        if (!enc)
-                return 1;
+        if(!enc) return 1;
 
-        if (enc->enc)
-                OPENSSL_free(enc->enc);
+        if(enc->enc) OPENSSL_free(enc->enc);
         enc->enc = OPENSSL_malloc(inlen);
-        if (!enc->enc)
-                return 0;
+        if(!enc->enc) return 0;
         memcpy(enc->enc, in, inlen);
         enc->len = inlen;
         enc->modified = 0;
 
         return 1;
-        }
+}
                 
-int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval,
-                                                        const ASN1_ITEM *it)
-        {
+int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval, const ASN1_ITEM *it)
+{
         ASN1_ENCODING *enc;
         enc = asn1_get_enc_ptr(pval, it);
-        if (!enc || enc->modified)
-                return 0;
-        if (out)
-                {
+        if(!enc || enc->modified) return 0;
+        if(out) {
                 memcpy(*out, enc->enc, enc->len);
                 *out += enc->len;
-                }
-        if (len)
-                *len = enc->len;
-        return 1;
         }
+        if(len) *len = enc->len;
+        return 1;
+}
 
 /* Given an ASN1_TEMPLATE get a pointer to a field */
 ASN1_VALUE ** asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
-        {
+{
         ASN1_VALUE **pvaltmp;
-        if (tt->flags & ASN1_TFLG_COMBINE)
-                return pval;
+        if(tt->flags & ASN1_TFLG_COMBINE) return pval;
         pvaltmp = offset2ptr(*pval, tt->offset);
         /* NOTE for BOOLEAN types the field is just a plain
          * int so we can't return int **, so settle for
          * (int *).
          */
         return pvaltmp;
-        }
+}
 
 /* Handle ANY DEFINED BY template, find the selector, look up
  * the relevant ASN1_TEMPLATE in the table and return it.
  */
 
-const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
-                                                                int nullerr)
-        {
+const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int nullerr)
+{
         const ASN1_ADB *adb;
         const ASN1_ADB_TABLE *atbl;
         long selector;
         ASN1_VALUE **sfld;
         int i;
-        if (!(tt->flags & ASN1_TFLG_ADB_MASK))
-                return tt;
+        if(!(tt->flags & ASN1_TFLG_ADB_MASK)) return tt;
 
         /* Else ANY DEFINED BY ... get the table */
         adb = ASN1_ADB_ptr(tt->item);
@@ -235,18 +215,16 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
         sfld = offset2ptr(*pval, adb->offset);
 
         /* Check if NULL */
-        if (!sfld)
-                {
-                if (!adb->null_tt)
-                        goto err;
+        if(!sfld) {
+                if(!adb->null_tt) goto err;
                 return adb->null_tt;
-                }
+        }
 
         /* Convert type to a long:
          * NB: don't check for NID_undef here because it
          * might be a legitimate value in the table
          */
-        if (tt->flags & ASN1_TFLG_ADB_OID) 
+        if(tt->flags & ASN1_TFLG_ADB_OID) 
                 selector = OBJ_obj2nid((ASN1_OBJECT *)*sfld);
         else 
                 selector = ASN1_INTEGER_get((ASN1_INTEGER *)*sfld);
@@ -259,21 +237,17 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
          * linear search.
          */
 
-        for (atbl = adb->tbl, i = 0; i < adb->tblcount; i++, atbl++)
-                if (atbl->value == selector)
-                        return &atbl->tt;
+        for(atbl = adb->tbl, i = 0; i < adb->tblcount; i++, atbl++)
+                if(atbl->value == selector) return &atbl->tt;
 
         /* FIXME: need to search application table too */
 
         /* No match, return default type */
-        if (!adb->default_tt)
-                goto err;               
+        if(!adb->default_tt) goto err;          
         return adb->default_tt;
         
         err:
         /* FIXME: should log the value or OID of unsupported type */
-        if (nullerr)
-                ASN1err(ASN1_F_ASN1_DO_ADB,
-                        ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE);
+        if(nullerr) ASN1err(ASN1_F_ASN1_DO_ADB, ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE);
         return NULL;
-        }
+}