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

openssl/crypto/asn1/tasn_dec.c

 /* tasn_dec.c */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2000.
  */
 /* ====================================================================
  * Copyright (c) 2000-2005 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 96 matching lines @@
 
 unsigned long ASN1_tag2bit(int tag)
         {
         if ((tag < 0) || (tag > 30)) return 0;
         return tag2bit[tag];
         }
 
 /* Macro to initialize and invalidate the cache */
 
 #define asn1_tlc_clear(c)       if (c) (c)->valid = 0
+/* Version to avoid compiler warning about 'c' always non-NULL */
+#define asn1_tlc_clear_nc(c)    (c)->valid = 0
 
 /* Decode an ASN1 item, this currently behaves just 
  * like a standard 'd2i' function. 'in' points to 
  * a buffer to read the data from, in future we will
  * have more advanced versions that can input data
  * a piece at a time and this will simply be a special
  * case.
  */
 
 ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **pval,
                 const unsigned char **in, long len, const ASN1_ITEM *it)
         {
         ASN1_TLC c;
         ASN1_VALUE *ptmpval = NULL;
         if (!pval)
                 pval = &ptmpval;
-        c.valid = 0;
+        asn1_tlc_clear_nc(&c);
         if (ASN1_item_ex_d2i(pval, in, len, it, -1, 0, 0, &c) > 0) 
                 return *pval;
         return NULL;
         }
 
 int ASN1_template_d2i(ASN1_VALUE **pval,
                 const unsigned char **in, long len, const ASN1_TEMPLATE *tt)
         {
         ASN1_TLC c;
-        c.valid = 0;
+        asn1_tlc_clear_nc(&c);
         return asn1_template_ex_d2i(pval, in, len, tt, 0, &c);
         }
 
 
 /* Decode an item, taking care of IMPLICIT tagging, if any.
  * If 'opt' set and tag mismatch return -1 to handle OPTIONAL
  */
 
 int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
                         const ASN1_ITEM *it,
                         int tag, int aclass, char opt, ASN1_TLC *ctx)
         {
         const ASN1_TEMPLATE *tt, *errtt = NULL;
         const ASN1_COMPAT_FUNCS *cf;
         const ASN1_EXTERN_FUNCS *ef;
         const ASN1_AUX *aux = it->funcs;
         ASN1_aux_cb *asn1_cb;
         const unsigned char *p = NULL, *q;
         unsigned char *wp=NULL; /* BIG FAT WARNING!  BREAKS CONST WHERE USED */
         unsigned char imphack = 0, oclass;
         char seq_eoc, seq_nolen, cst, isopt;
         long tmplen;
         int i;
         int otag;
         int ret = 0;
-        ASN1_VALUE *pchval, **pchptr, *ptmpval;
+        ASN1_VALUE **pchptr, *ptmpval;
         if (!pval)
                 return 0;
         if (aux && aux->asn1_cb)
                 asn1_cb = aux->asn1_cb;
         else asn1_cb = 0;
 
         switch(it->itype)
                 {
                 case ASN1_ITYPE_PRIMITIVE:
                 if (it->templates)
@@ skipping 119 matching lines @@
                         *wp = imphack;
 
                 if (ptmpval)
                         return 1;
 
                 ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_NESTED_ASN1_ERROR);
                 goto err;
 
 
                 case ASN1_ITYPE_CHOICE:
-                if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it))
+                if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL))
                                 goto auxerr;
 
                 /* Allocate structure */
                 if (!*pval && !ASN1_item_ex_new(pval, it))
                         {
                         ASN1err(ASN1_F_ASN1_ITEM_EX_D2I,
                                                 ERR_R_NESTED_ASN1_ERROR);
                         goto err;
                         }
                 /* CHOICE type, try each possibility in turn */
-                pchval = NULL;
                 p = *in;
                 for (i = 0, tt=it->templates; i < it->tcount; i++, tt++)
                         {
                         pchptr = asn1_get_field_ptr(pval, tt);
                         /* We mark field as OPTIONAL so its absence
                          * can be recognised.
                          */
                         ret = asn1_template_ex_d2i(pchptr, &p, len, tt, 1, ctx);
                         /* If field not present, try the next one */
                         if (ret == -1)
@@ skipping 18 matching lines @@
                                 ASN1_item_ex_free(pval, it);
                                 return -1;
                                 }
                         ASN1err(ASN1_F_ASN1_ITEM_EX_D2I,
                                         ASN1_R_NO_MATCHING_CHOICE_TYPE);
                         goto err;
                         }
 
                 asn1_set_choice_selector(pval, i, it);
                 *in = p;
-                if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it))
+                if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL))
                                 goto auxerr;
                 return 1;
 
                 case ASN1_ITYPE_NDEF_SEQUENCE:
                 case ASN1_ITYPE_SEQUENCE:
                 p = *in;
                 tmplen = len;
 
                 /* If no IMPLICIT tagging set to SEQUENCE, UNIVERSAL */
                 if (tag == -1)
@@ skipping 26 matching lines @@
                         goto err;
                         }
 
                 if (!*pval && !ASN1_item_ex_new(pval, it))
                         {
                         ASN1err(ASN1_F_ASN1_ITEM_EX_D2I,
                                 ERR_R_NESTED_ASN1_ERROR);
                         goto err;
                         }
 
-                if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it))
+                if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL))
                                 goto auxerr;
 
                 /* Get each field entry */
                 for (i = 0, tt = it->templates; i < it->tcount; i++, tt++)
                         {
                         const ASN1_TEMPLATE *seqtt;
                         ASN1_VALUE **pseqval;
                         seqtt = asn1_do_adb(pval, tt, 1);
                         if (!seqtt)
                                 goto err;
@@ skipping 81 matching lines @@
                                 errtt = seqtt;
                                 ASN1err(ASN1_F_ASN1_ITEM_EX_D2I,
                                                         ASN1_R_FIELD_MISSING);
                                 goto err;
                                 }
                         }
                 /* Save encoding */
                 if (!asn1_enc_save(pval, *in, p - *in, it))
                         goto auxerr;
                 *in = p;
-                if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it))
+                if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL))
                                 goto auxerr;
                 return 1;
 
                 default:
                 return 0;
                 }
         auxerr:
         ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_AUX_ERROR);
         err:
         ASN1_item_ex_free(pval, it);
@@ skipping 139 matching lines @@
                                                 ERR_R_NESTED_ASN1_ERROR);
                         return 0;
                         }
                 else if (ret == -1)
                         return -1;
                 if (!*val)
                         *val = (ASN1_VALUE *)sk_new_null();
                 else
                         {
                         /* We've got a valid STACK: free up any items present */
-                        STACK *sktmp = (STACK *)*val;
+                        STACK_OF(ASN1_VALUE) *sktmp
+                            = (STACK_OF(ASN1_VALUE) *)*val;
                         ASN1_VALUE *vtmp;
-                        while(sk_num(sktmp) > 0)
+                        while(sk_ASN1_VALUE_num(sktmp) > 0)
                                 {
-                                vtmp = (ASN1_VALUE *)sk_pop(sktmp);
+                                vtmp = sk_ASN1_VALUE_pop(sktmp);
                                 ASN1_item_ex_free(&vtmp,
                                                 ASN1_ITEM_ptr(tt->item));
                                 }
                         }
                                 
                 if (!*val)
                         {
                         ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I,
                                                 ERR_R_MALLOC_FAILURE);
                         goto err;
@@ skipping 20 matching lines @@
                         skfield = NULL;
                         if (!ASN1_item_ex_d2i(&skfield, &p, len,
                                                 ASN1_ITEM_ptr(tt->item),
                                                 -1, 0, 0, ctx))
                                 {
                                 ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I,
                                         ERR_R_NESTED_ASN1_ERROR);
                                 goto err;
                                 }
                         len -= p - q;
-                        if (!sk_push((STACK *)*val, (char *)skfield))
+                        if (!sk_ASN1_VALUE_push((STACK_OF(ASN1_VALUE) *)*val,
+                                                skfield))
                                 {
                                 ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I,
                                                 ERR_R_MALLOC_FAILURE);
                                 goto err;
                                 }
                         }
                 if (sk_eoc)
                         {
                         ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ASN1_R_MISSING_EOC);
                         goto err;
@@ skipping 611 matching lines @@
 
         if (oclass)
                 *oclass = pclass;
 
         if (otag)
                 *otag = ptag;
 
         *in = p;
         return 1;
         }