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

openssl/crypto/x509/x509_req.c

 /* crypto/x509/x509_req.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 43 matching lines @@
  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
 
 #include <stdio.h>
 #include "cryptlib.h"
 #include <openssl/bn.h>
 #include <openssl/evp.h>
 #include <openssl/asn1.h>
+#include <openssl/asn1t.h>
 #include <openssl/x509.h>
 #include <openssl/objects.h>
 #include <openssl/buffer.h>
 #include <openssl/pem.h>
 
 X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
         {
         X509_REQ *ret;
         X509_REQ_INFO *ri;
         int i;
@@ skipping 124 matching lines @@
                         continue;
                 attr = X509_REQ_get_attr(req, idx);
                 if(attr->single) ext = attr->value.single;
                 else if(sk_ASN1_TYPE_num(attr->value.set))
                         ext = sk_ASN1_TYPE_value(attr->value.set, 0);
                 break;
                 }
         if(!ext || (ext->type != V_ASN1_SEQUENCE))
                 return NULL;
         p = ext->value.sequence->data;
-        return d2i_ASN1_SET_OF_X509_EXTENSION(NULL, &p,
-                        ext->value.sequence->length,
-                        d2i_X509_EXTENSION, X509_EXTENSION_free,
-                        V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL);
+        return (STACK_OF(X509_EXTENSION) *)
+                ASN1_item_d2i(NULL, &p, ext->value.sequence->length,
+                                ASN1_ITEM_rptr(X509_EXTENSIONS));
 }
 
 /* Add a STACK_OF extensions to a certificate request: allow alternative OIDs
  * in case we want to create a non standard one.
  */
 
 int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,
                                 int nid)
 {
-        unsigned char *p = NULL, *q;
-        long len;
         ASN1_TYPE *at = NULL;
         X509_ATTRIBUTE *attr = NULL;
         if(!(at = ASN1_TYPE_new()) ||
                 !(at->value.sequence = ASN1_STRING_new())) goto err;
 
         at->type = V_ASN1_SEQUENCE;
         /* Generate encoding of extensions */
-        len = i2d_ASN1_SET_OF_X509_EXTENSION(exts, NULL, i2d_X509_EXTENSION,
-                        V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, IS_SEQUENCE);
-        if(!(p = OPENSSL_malloc(len))) goto err;
-        q = p;
-        i2d_ASN1_SET_OF_X509_EXTENSION(exts, &q, i2d_X509_EXTENSION,
-                        V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, IS_SEQUENCE);
-        at->value.sequence->data = p;
-        p = NULL;
-        at->value.sequence->length = len;
+        at->value.sequence->length = 
+                        ASN1_item_i2d((ASN1_VALUE *)exts,
+                                &at->value.sequence->data,
+                                ASN1_ITEM_rptr(X509_EXTENSIONS));
         if(!(attr = X509_ATTRIBUTE_new())) goto err;
         if(!(attr->value.set = sk_ASN1_TYPE_new_null())) goto err;
         if(!sk_ASN1_TYPE_push(attr->value.set, at)) goto err;
         at = NULL;
         attr->single = 0;
         attr->object = OBJ_nid2obj(nid);
         if (!req->req_info->attributes)
                 {
                 if (!(req->req_info->attributes = sk_X509_ATTRIBUTE_new_null()))
                         goto err;
                 }
         if(!sk_X509_ATTRIBUTE_push(req->req_info->attributes, attr)) goto err;
         return 1;
         err:
-        if(p) OPENSSL_free(p);
         X509_ATTRIBUTE_free(attr);
         ASN1_TYPE_free(at);
         return 0;
 }
 /* This is the normal usage: use the "official" OID */
 int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts)
 {
         return X509_REQ_add_extensions_nid(req, exts, NID_ext_req);
 }
 
@@ skipping 51 matching lines @@
 }
 
 int X509_REQ_add1_attr_by_txt(X509_REQ *req,
                         const char *attrname, int type,
                         const unsigned char *bytes, int len)
 {
         if(X509at_add1_attr_by_txt(&req->req_info->attributes, attrname,
                                 type, bytes, len)) return 1;
         return 0;
 }