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

openssl/ssl/bio_ssl.c

 /* ssl/bio_ssl.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 330 matching lines @@
         case BIO_C_SET_SSL_RENEGOTIATE_BYTES:
                 ret=bs->renegotiate_count;
                 if ((long)num >=512)
                         bs->renegotiate_count=(unsigned long)num;
                 break;
         case BIO_C_GET_SSL_NUM_RENEGOTIATES:
                 ret=bs->num_renegotiates;
                 break;
         case BIO_C_SET_SSL:
                 if (ssl != NULL)
+                        {
                         ssl_free(b);
+                        if (!ssl_new(b))
+                                return 0;
+                        }
                 b->shutdown=(int)num;
                 ssl=(SSL *)ptr;
                 ((BIO_SSL *)b->ptr)->ssl=ssl;
                 bio=SSL_get_rbio(ssl);
                 if (bio != NULL)
                         {
                         if (b->next_bio != NULL)
                                 BIO_push(bio,b->next_bio);
                         b->next_bio=bio;
                         CRYPTO_add(&bio->references,1,CRYPTO_LOCK_BIO);
@@ skipping 29 matching lines @@
                 BIO_copy_next_retry(b);
                 break;
         case BIO_CTRL_PUSH:
                 if ((b->next_bio != NULL) && (b->next_bio != ssl->rbio))
                         {
                         SSL_set_bio(ssl,b->next_bio,b->next_bio);
                         CRYPTO_add(&b->next_bio->references,1,CRYPTO_LOCK_BIO);
                         }
                 break;
         case BIO_CTRL_POP:
-                /* ugly bit of a hack */
-                if (ssl->rbio != ssl->wbio) /* we are in trouble :-( */
+                /* Only detach if we are the BIO explicitly being popped */
+                if (b == ptr)
                         {
-                        BIO_free_all(ssl->wbio);
+                        /* Shouldn't happen in practice because the
+                         * rbio and wbio are the same when pushed.
+                         */
+                        if (ssl->rbio != ssl->wbio)
+                                BIO_free_all(ssl->wbio);
+                        if (b->next_bio != NULL)
+                                CRYPTO_add(&b->next_bio->references,-1,CRYPTO_LOCK_BIO);
+                        ssl->wbio=NULL;
+                        ssl->rbio=NULL;
                         }
-                if (b->next_bio != NULL)
-                        {
-                        CRYPTO_add(&b->next_bio->references,1,CRYPTO_LOCK_BIO);
-                        }
-                ssl->wbio=NULL;
-                ssl->rbio=NULL;
                 break;
         case BIO_C_DO_STATE_MACHINE:
                 BIO_clear_retry_flags(b);
 
                 b->retry_reason=0;
                 ret=(int)SSL_do_handshake(ssl);
 
                 switch (SSL_get_error(ssl,(int)ret))
                         {
                 case SSL_ERROR_WANT_READ:
@@ skipping 114 matching lines @@
 
         if ((con=BIO_new(BIO_s_connect())) == NULL)
                 return(NULL);
         if ((ssl=BIO_new_ssl(ctx,1)) == NULL)
                 goto err;
         if ((ret=BIO_push(ssl,con)) == NULL)
                 goto err;
         return(ret);
 err:
         if (con != NULL) BIO_free(con);
-        if (ret != NULL) BIO_free(ret);
         return(NULL);
         }
 
 BIO *BIO_new_ssl(SSL_CTX *ctx, int client)
         {
         BIO *ret;
         SSL *ssl;
 
         if ((ret=BIO_new(BIO_f_ssl())) == NULL)
                 return(NULL);
@@ skipping 32 matching lines @@
                 {
                 if (b->method->type == BIO_TYPE_SSL)
                         {
                         s=((BIO_SSL *)b->ptr)->ssl;
                         SSL_shutdown(s);
                         break;
                         }
                 b=b->next_bio;
                 }
         }