1 files changed, 77 insertions, 51 deletions

diff --git a/src/lib/libcrypto/asn1/tasn_utl.c b/src/lib/libcrypto/asn1/tasn_utl.c
index 8996ce8c13..34d520b180 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 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 2000-2004 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,114 +99,134 @@ 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) return 0;
+        if ((it->itype != ASN1_ITYPE_SEQUENCE)
+           && (it->itype != ASN1_ITYPE_NDEF_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, unsigned char *in, int inlen, const ASN1_ITEM *it)
-{
+int asn1_enc_save(ASN1_VALUE **pval, const 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;
+                }
+        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);
@@ -215,16 +235,18 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int
         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);
@@ -237,17 +259,21 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int
          * 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;
-}
+        }