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

openssl/crypto/bio/bss_dgram.c

 /* crypto/bio/bio_dgram.c */
 /* 
  * DTLS implementation written by Nagendra Modadugu
  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.  
  */
 /* ====================================================================
  * Copyright (c) 1999-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
@@ skipping 39 matching lines @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  * ====================================================================
  *
  * This product includes cryptographic software written by Eric Young
  * (eay@cryptsoft.com).  This product includes software written by Tim
  * Hudson (tjh@cryptsoft.com).
  *
  */
 
-#ifndef OPENSSL_NO_DGRAM
 
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
 
 #include <openssl/bio.h>
+#ifndef OPENSSL_NO_DGRAM
 
 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VMS)
 #include <sys/timeb.h>
 #endif
 
 #ifdef OPENSSL_SYS_LINUX
 #define IP_MTU      14 /* linux is lame */
 #endif
 
 #ifdef WATT32
@@ skipping 23 matching lines @@
         dgram_puts,
         NULL, /* dgram_gets, */
         dgram_ctrl,
         dgram_new,
         dgram_free,
         NULL,
         };
 
 typedef struct bio_dgram_data_st
         {
-        struct sockaddr peer;
+        union {
+                struct sockaddr sa;
+                struct sockaddr_in sa_in;
+#if OPENSSL_USE_IPV6
+                struct sockaddr_in6 sa_in6;
+#endif
+        } peer;
         unsigned int connected;
         unsigned int _errno;
         unsigned int mtu;
         struct timeval next_timeout;
         struct timeval socket_timeout;
         } bio_dgram_data;
 
 BIO_METHOD *BIO_s_datagram(void)
         {
         return(&methods_dgramp);
@@ skipping 145 matching lines @@
 #endif
                 }
 #endif
         }
 
 static int dgram_read(BIO *b, char *out, int outl)
         {
         int ret=0;
         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
 
-        struct sockaddr peer;
-        int peerlen = sizeof(peer);
+        struct  {
+        /*
+         * See commentary in b_sock.c. <appro>
+         */
+        union   { size_t s; int i; } len;
+        union   {
+                struct sockaddr sa;
+                struct sockaddr_in sa_in;
+#if OPENSSL_USE_IPV6
+                struct sockaddr_in6 sa_in6;
+#endif
+                } peer;
+        } sa;
+
+        sa.len.s=0;
+        sa.len.i=sizeof(sa.peer);
 
         if (out != NULL)
                 {
                 clear_socket_error();
-                memset(&peer, 0x00, peerlen);
-                /* Last arg in recvfrom is signed on some platforms and
-                 * unsigned on others. It is of type socklen_t on some
-                 * but this is not universal. Cast to (void *) to avoid
-                 * compiler warnings.
-                 */
+                memset(&sa.peer, 0x00, sizeof(sa.peer));
                 dgram_adjust_rcv_timeout(b);
-                ret=recvfrom(b->num,out,outl,0,&peer,(void *)&peerlen);
-                dgram_reset_rcv_timeout(b);
+                ret=recvfrom(b->num,out,outl,0,&sa.peer.sa,(void *)&sa.len);
+                if (sizeof(sa.len.i)!=sizeof(sa.len.s) && sa.len.i==0)
+                        {
+                        OPENSSL_assert(sa.len.s<=sizeof(sa.peer));
+                        sa.len.i = (int)sa.len.s;
+                        }
 
                 if ( ! data->connected  && ret >= 0)
-                        BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, &peer);
+                        BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, &sa.peer);
 
                 BIO_clear_retry_flags(b);
                 if (ret < 0)
                         {
                         if (BIO_dgram_should_retry(ret))
                                 {
                                 BIO_set_retry_read(b);
                                 data->_errno = get_last_socket_error();
                                 }
                         }
+
+                dgram_reset_rcv_timeout(b);
                 }
         return(ret);
         }
 
 static int dgram_write(BIO *b, const char *in, int inl)
         {
         int ret;
         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
         clear_socket_error();
 
-    if ( data->connected )
-        ret=writesocket(b->num,in,inl);
-    else
+        if ( data->connected )
+                ret=writesocket(b->num,in,inl);
+        else
+                {
+                int peerlen = sizeof(data->peer);
+
+                if (data->peer.sa.sa_family == AF_INET)
+                        peerlen = sizeof(data->peer.sa_in);
+#if OPENSSL_USE_IPV6
+                else if (data->peer.sa.sa_family == AF_INET6)
+                        peerlen = sizeof(data->peer.sa_in6);
+#endif
 #if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK)
-        ret=sendto(b->num, (char *)in, inl, 0, &data->peer, sizeof(data->peer));
+                ret=sendto(b->num, (char *)in, inl, 0, &data->peer.sa, peerlen);
 #else
-        ret=sendto(b->num, in, inl, 0, &data->peer, sizeof(data->peer));
+                ret=sendto(b->num, in, inl, 0, &data->peer.sa, peerlen);
 #endif
+                }
 
         BIO_clear_retry_flags(b);
         if (ret <= 0)
                 {
                 if (BIO_dgram_should_retry(ret))
                         {
                         BIO_set_retry_write(b);  
                         data->_errno = get_last_socket_error();
 
 #if 0 /* higher layers are responsible for querying MTU, if necessary */
@@ skipping 11 matching lines @@
         long ret=1;
         int *ip;
         struct sockaddr *to = NULL;
         bio_dgram_data *data = NULL;
 #if defined(IP_MTU_DISCOVER) || defined(IP_MTU)
         long sockopt_val = 0;
         unsigned int sockopt_len = 0;
 #endif
 #ifdef OPENSSL_SYS_LINUX
         socklen_t addr_len;
-        struct sockaddr_storage addr;
+        union   {
+                struct sockaddr sa;
+                struct sockaddr_in s4;
+#if OPENSSL_USE_IPV6
+                struct sockaddr_in6 s6;
+#endif
+                } addr;
 #endif
 
         data = (bio_dgram_data *)b->ptr;
 
         switch (cmd)
                 {
         case BIO_CTRL_RESET:
                 num=0;
         case BIO_C_FILE_SEEK:
                 ret=0;
@@ skipping 33 matching lines @@
                 ret=1;
                 break;
         case BIO_CTRL_DGRAM_CONNECT:
                 to = (struct sockaddr *)ptr;
 #if 0
                 if (connect(b->num, to, sizeof(struct sockaddr)) < 0)
                         { perror("connect"); ret = 0; }
                 else
                         {
 #endif
-                        memcpy(&(data->peer),to, sizeof(struct sockaddr));
+                        switch (to->sa_family)
+                                {
+                                case AF_INET:
+                                        memcpy(&data->peer,to,sizeof(data->peer.sa_in));
+                                        break;
+#if OPENSSL_USE_IPV6
+                                case AF_INET6:
+                                        memcpy(&data->peer,to,sizeof(data->peer.sa_in6));
+                                        break;
+#endif
+                                default:
+                                        memcpy(&data->peer,to,sizeof(data->peer.sa));
+                                        break;
+                                }
 #if 0
                         }
 #endif
                 break;
                 /* (Linux)kernel sets DF bit on outgoing IP packets */
         case BIO_CTRL_DGRAM_MTU_DISCOVER:
 #ifdef OPENSSL_SYS_LINUX
-                addr_len = (socklen_t)sizeof(struct sockaddr_storage);
-                memset((void *)&addr, 0, sizeof(struct sockaddr_storage));
-                if (getsockname(b->num, (void *)&addr, &addr_len) < 0)
+                addr_len = (socklen_t)sizeof(addr);
+                memset((void *)&addr, 0, sizeof(addr));
+                if (getsockname(b->num, &addr.sa, &addr_len) < 0)
                         {
                         ret = 0;
                         break;
                         }
                 sockopt_len = sizeof(sockopt_val);
-                switch (addr.ss_family)
+                switch (addr.sa.sa_family)
                         {
                 case AF_INET:
                         sockopt_val = IP_PMTUDISC_DO;
                         if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
                                 &sockopt_val, sizeof(sockopt_val))) < 0)
                                 perror("setsockopt");
                         break;
+#if OPENSSL_USE_IPV6 && defined(IPV6_MTU_DISCOVER)
                 case AF_INET6:
                         sockopt_val = IPV6_PMTUDISC_DO;
                         if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
                                 &sockopt_val, sizeof(sockopt_val))) < 0)
                                 perror("setsockopt");
                         break;
+#endif
                 default:
                         ret = -1;
                         break;
                         }
                 ret = -1;
 #else
                 break;
 #endif
         case BIO_CTRL_DGRAM_QUERY_MTU:
 #ifdef OPENSSL_SYS_LINUX
-                addr_len = (socklen_t)sizeof(struct sockaddr_storage);
-                memset((void *)&addr, 0, sizeof(struct sockaddr_storage));
-                if (getsockname(b->num, (void *)&addr, &addr_len) < 0)
+                addr_len = (socklen_t)sizeof(addr);
+                memset((void *)&addr, 0, sizeof(addr));
+                if (getsockname(b->num, &addr.sa, &addr_len) < 0)
                         {
                         ret = 0;
                         break;
                         }
                 sockopt_len = sizeof(sockopt_val);
-                switch (addr.ss_family)
+                switch (addr.sa.sa_family)
                         {
                 case AF_INET:
                         if ((ret = getsockopt(b->num, IPPROTO_IP, IP_MTU, (void *)&sockopt_val,
                                 &sockopt_len)) < 0 || sockopt_val < 0)
                                 {
                                 ret = 0;
                                 }
                         else
                                 {
                                 /* we assume that the transport protocol is UDP and no
                                  * IP options are used.
                                  */
                                 data->mtu = sockopt_val - 8 - 20;
                                 ret = data->mtu;
                                 }
                         break;
+#if OPENSSL_USE_IPV6 && defined(IPV6_MTU)
                 case AF_INET6:
                         if ((ret = getsockopt(b->num, IPPROTO_IPV6, IPV6_MTU, (void *)&sockopt_val,
                                 &sockopt_len)) < 0 || sockopt_val < 0)
                                 {
                                 ret = 0;
                                 }
                         else
                                 {
                                 /* we assume that the transport protocol is UDP and no
                                  * IPV6 options are used.
                                  */
                                 data->mtu = sockopt_val - 8 - 40;
                                 ret = data->mtu;
                                 }
                         break;
+#endif
                 default:
                         ret = 0;
                         break;
                         }
 #else
                 ret = 0;
 #endif
                 break;
         case BIO_CTRL_DGRAM_GET_MTU:
                 return data->mtu;
                 break;
         case BIO_CTRL_DGRAM_SET_MTU:
                 data->mtu = num;
                 ret = num;
                 break;
         case BIO_CTRL_DGRAM_SET_CONNECTED:
                 to = (struct sockaddr *)ptr;
 
                 if ( to != NULL)
                         {
                         data->connected = 1;
-                        memcpy(&(data->peer),to, sizeof(struct sockaddr));
+                        switch (to->sa_family)
+                                {
+                                case AF_INET:
+                                        memcpy(&data->peer,to,sizeof(data->peer.sa_in));
+                                        break;
+#if OPENSSL_USE_IPV6
+                                case AF_INET6:
+                                        memcpy(&data->peer,to,sizeof(data->peer.sa_in6));
+                                        break;
+#endif
+                                default:
+                                        memcpy(&data->peer,to,sizeof(data->peer.sa));
+                                        break;
+                                }
                         }
                 else
                         {
                         data->connected = 0;
-                        memset(&(data->peer), 0x00, sizeof(struct sockaddr));
+                        memset(&(data->peer), 0x00, sizeof(data->peer));
                         }
                 break;
-    case BIO_CTRL_DGRAM_GET_PEER:
-        to = (struct sockaddr *) ptr;
-
-        memcpy(to, &(data->peer), sizeof(struct sockaddr));
-                ret = sizeof(struct sockaddr);
-        break;
-    case BIO_CTRL_DGRAM_SET_PEER:
-        to = (struct sockaddr *) ptr;
-
-        memcpy(&(data->peer), to, sizeof(struct sockaddr));
-        break;
+        case BIO_CTRL_DGRAM_GET_PEER:
+                switch (data->peer.sa.sa_family)
+                        {
+                        case AF_INET:
+                                ret=sizeof(data->peer.sa_in);
+                                break;
+#if OPENSSL_USE_IPV6
+                        case AF_INET6:
+                                ret=sizeof(data->peer.sa_in6);
+                                break;
+#endif
+                        default:
+                                ret=sizeof(data->peer.sa);
+                                break;
+                        }
+                if (num==0 || num>ret)
+                        num=ret;
+                memcpy(ptr,&data->peer,(ret=num));
+                break;
+        case BIO_CTRL_DGRAM_SET_PEER:
+                to = (struct sockaddr *) ptr;
+                switch (to->sa_family)
+                        {
+                        case AF_INET:
+                                memcpy(&data->peer,to,sizeof(data->peer.sa_in));
+                                break;
+#if OPENSSL_USE_IPV6
+                        case AF_INET6:
+                                memcpy(&data->peer,to,sizeof(data->peer.sa_in6));
+                                break;
+#endif
+                        default:
+                                memcpy(&data->peer,to,sizeof(data->peer.sa));
+                                break;
+                        }
+                break;
         case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
-                memcpy(&(data->next_timeout), ptr, sizeof(struct timeval));             
+                memcpy(&(data->next_timeout), ptr, sizeof(struct timeval));
                 break;
 #if defined(SO_RCVTIMEO)
         case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:
 #ifdef OPENSSL_SYS_WINDOWS
                 {
                 struct timeval *tv = (struct timeval *)ptr;
                 int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000;
                 if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
                         (void*)&timeout, sizeof(timeout)) < 0)
                         { perror("setsockopt"); ret = -1; }
@@ skipping 107 matching lines @@
         }
 
 static int BIO_dgram_should_retry(int i)
         {
         int err;
 
         if ((i == 0) || (i == -1))
                 {
                 err=get_last_socket_error();
 
-#if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */
-                if ((i == -1) && (err == 0))
-                        return(1);
+#if defined(OPENSSL_SYS_WINDOWS)
+        /* If the socket return value (i) is -1
+         * and err is unexpectedly 0 at this point,
+         * the error code was overwritten by
+         * another system call before this error
+         * handling is called.
+         */
 #endif
 
                 return(BIO_dgram_non_fatal_error(err));
                 }
         return(0);
         }
 
 int BIO_dgram_non_fatal_error(int err)
         {
         switch (err)
@@ skipping 42 matching lines @@
         case EALREADY:
 #endif
 
                 return(1);
                 /* break; */
         default:
                 break;
                 }
         return(0);
         }
-#endif
 
 static void get_current_time(struct timeval *t)
         {
 #ifdef OPENSSL_SYS_WIN32
         struct _timeb tb;
         _ftime(&tb);
         t->tv_sec = (long)tb.time;
         t->tv_usec = (long)tb.millitm * 1000;
 #elif defined(OPENSSL_SYS_VMS)
         struct timeb tb;
         ftime(&tb);
         t->tv_sec = (long)tb.time;
         t->tv_usec = (long)tb.millitm * 1000;
 #else
         gettimeofday(t, NULL);
 #endif
         }
+
+#endif