Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/asn1/tasn_new.c

 /* tasn_new.c */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2000.
  */
 /* ====================================================================
  * 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
  * are met:
@@ skipping 50 matching lines @@
 #include <openssl/asn1.h>
 #include <openssl/objects.h>
 #include <openssl/err.h>
 #include <openssl/asn1t.h>
 #include <string.h>
 
 static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
                                                                 int combine);
 static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
 static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
-void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
+static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
 
 ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it)
         {
         ASN1_VALUE *ret = NULL;
         if (ASN1_item_ex_new(&ret, it) > 0)
                 return ret;
         return NULL;
         }
 
 /* Allocate an ASN1 structure */
@@ skipping 57 matching lines @@
                 break;
 
                 case ASN1_ITYPE_MSTRING:
                 if (!ASN1_primitive_new(pval, it))
                                 goto memerr;
                 break;
 
                 case ASN1_ITYPE_CHOICE:
                 if (asn1_cb)
                         {
-                        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it);
+                        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
                         if (!i)
                                 goto auxerr;
                         if (i==2)
                                 {
 #ifdef CRYPTO_MDEBUG
                                 if (it->sname)
                                         CRYPTO_pop_info();
 #endif
                                 return 1;
                                 }
                         }
                 if (!combine)
                         {
                         *pval = OPENSSL_malloc(it->size);
                         if (!*pval)
                                 goto memerr;
                         memset(*pval, 0, it->size);
                         }
                 asn1_set_choice_selector(pval, -1, it);
-                if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it))
+                if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
                                 goto auxerr;
                 break;
 
                 case ASN1_ITYPE_NDEF_SEQUENCE:
                 case ASN1_ITYPE_SEQUENCE:
                 if (asn1_cb)
                         {
-                        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it);
+                        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
                         if (!i)
                                 goto auxerr;
                         if (i==2)
                                 {
 #ifdef CRYPTO_MDEBUG
                                 if (it->sname)
                                         CRYPTO_pop_info();
 #endif
                                 return 1;
                                 }
                         }
                 if (!combine)
                         {
                         *pval = OPENSSL_malloc(it->size);
                         if (!*pval)
                                 goto memerr;
                         memset(*pval, 0, it->size);
                         asn1_do_lock(pval, 0, it);
                         asn1_enc_init(pval, it);
                         }
                 for (i = 0, tt = it->templates; i < it->tcount; tt++, i++)
                         {
                         pseqval = asn1_get_field_ptr(pval, tt);
                         if (!ASN1_template_new(pseqval, tt))
                                 goto memerr;
                         }
-                if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it))
+                if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
                                 goto auxerr;
                 break;
         }
 #ifdef CRYPTO_MDEBUG
         if (it->sname) CRYPTO_pop_info();
 #endif
         return 1;
 
         memerr:
         ASN1err(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW, ERR_R_MALLOC_FAILURE);
@@ skipping 103 matching lines @@
         }
 
 
 /* NB: could probably combine most of the real XXX_new() behaviour and junk
  * all the old functions.
  */
 
 int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
         {
         ASN1_TYPE *typ;
+        ASN1_STRING *str;
         int utype;
 
         if (it && it->funcs)
                 {
                 const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;
                 if (pf->prim_new)
                         return pf->prim_new(pval, it);
                 }
 
         if (!it || (it->itype == ASN1_ITYPE_MSTRING))
                 utype = -1;
         else
                 utype = it->utype;
         switch(utype)
                 {
                 case V_ASN1_OBJECT:
                 *pval = (ASN1_VALUE *)OBJ_nid2obj(NID_undef);
                 return 1;
 
                 case V_ASN1_BOOLEAN:
-                if (it)
-                        *(ASN1_BOOLEAN *)pval = it->size;
-                else
-                        *(ASN1_BOOLEAN *)pval = -1;
+                *(ASN1_BOOLEAN *)pval = it->size;
                 return 1;
 
                 case V_ASN1_NULL:
                 *pval = (ASN1_VALUE *)1;
                 return 1;
 
                 case V_ASN1_ANY:
                 typ = OPENSSL_malloc(sizeof(ASN1_TYPE));
                 if (!typ)
                         return 0;
                 typ->value.ptr = NULL;
                 typ->type = -1;
                 *pval = (ASN1_VALUE *)typ;
                 break;
 
                 default:
-                *pval = (ASN1_VALUE *)ASN1_STRING_type_new(utype);
+                str = ASN1_STRING_type_new(utype);
+                if (it->itype == ASN1_ITYPE_MSTRING && str)
+                        str->flags |= ASN1_STRING_FLAG_MSTRING;
+                *pval = (ASN1_VALUE *)str;
                 break;
                 }
         if (*pval)
                 return 1;
         return 0;
         }
 
-void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
+static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
         {
         int utype;
         if (it && it->funcs)
                 {
                 const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;
                 if (pf->prim_clear)
                         pf->prim_clear(pval, it);
                 else 
                         *pval = NULL;
                 return;
                 }
         if (!it || (it->itype == ASN1_ITYPE_MSTRING))
                 utype = -1;
         else
                 utype = it->utype;
         if (utype == V_ASN1_BOOLEAN)
                 *(ASN1_BOOLEAN *)pval = it->size;
         else *pval = NULL;
         }