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

openssl/apps/s_socket.c

 /* apps/s_socket.c -  socket-related functions used by s_client and s_server */
 /* 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 219 matching lines @@
          return(0);
          }
       }
 #endif /* OPENSSL_SYS_WINDOWS */
         return(1);
         }
 
 int init_client(int *sock, char *host, int port, int type)
         {
         unsigned char ip[4];
-        short p=0;
 
         if (!host_ip(host,&(ip[0])))
                 {
                 return(0);
                 }
-        if (p != 0) port=p;
         return(init_client_ip(sock,ip,port,type));
         }
 
 static int init_client_ip(int *sock, unsigned char ip[4], int port, int type)
         {
         unsigned long addr;
         struct sockaddr_in them;
         int s,i;
 
         if (!ssl_sock_init()) return(0);
 
         memset((char *)&them,0,sizeof(them));
         them.sin_family=AF_INET;
         them.sin_port=htons((unsigned short)port);
         addr=(unsigned long)
                 ((unsigned long)ip[0]<<24L)|
                 ((unsigned long)ip[1]<<16L)|
                 ((unsigned long)ip[2]<< 8L)|
                 ((unsigned long)ip[3]);
         them.sin_addr.s_addr=htonl(addr);
 
         if (type == SOCK_STREAM)
                 s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
         else /* ( type == SOCK_DGRAM) */
                 s=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
                         
         if (s == INVALID_SOCKET) { perror("socket"); return(0); }
 
-#ifndef OPENSSL_SYS_MPE
+#if defined(SO_KEEPALIVE) && !defined(OPENSSL_SYS_MPE)
         if (type == SOCK_STREAM)
                 {
                 i=0;
                 i=setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
                 if (i < 0) { perror("keepalive"); return(0); }
                 }
 #endif
 
         if (connect(s,(struct sockaddr *)&them,sizeof(them)) == -1)
-                { close(s); perror("connect"); return(0); }
+                { closesocket(s); perror("connect"); return(0); }
         *sock=s;
         return(1);
         }
 
 int do_server(int port, int type, int *ret, int (*cb)(char *hostname, int s, unsigned char *context), unsigned char *context)
         {
         int sock;
         char *name = NULL;
-        int accept_socket;
+        int accept_socket = 0;
         int i;
 
         if (!init_server(&accept_socket,port,type)) return(0);
 
         if (ret != NULL)
                 {
                 *ret=accept_socket;
                 /* return(1);*/
                 }
         for (;;)
@@ skipping 17 matching lines @@
                         SHUTDOWN2(accept_socket);
                         return(i);
                         }
                 }
         }
 
 static int init_server_long(int *sock, int port, char *ip, int type)
         {
         int ret=0;
         struct sockaddr_in server;
-        int s= -1,i;
+        int s= -1;
 
         if (!ssl_sock_init()) return(0);
 
         memset((char *)&server,0,sizeof(server));
         server.sin_family=AF_INET;
         server.sin_port=htons((unsigned short)port);
         if (ip == NULL)
                 server.sin_addr.s_addr=INADDR_ANY;
         else
 /* Added for T3E, address-of fails on bit field (beckman@acl.lanl.gov) */
@@ skipping 18 matching lines @@
 #endif
         if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1)
                 {
 #ifndef OPENSSL_SYS_WINDOWS
                 perror("bind");
 #endif
                 goto err;
                 }
         /* Make it 128 for linux */
         if (type==SOCK_STREAM && listen(s,128) == -1) goto err;
-        i=0;
         *sock=s;
         ret=1;
 err:
         if ((ret == 0) && (s != -1))
                 {
                 SHUTDOWN(s);
                 }
         return(ret);
         }
 
 static int init_server(int *sock, int port, int type)
         {
         return(init_server_long(sock, port, NULL, type));
         }
 
 static int do_accept(int acc_sock, int *sock, char **host)
         {
-        int ret,i;
+        int ret;
         struct hostent *h1,*h2;
         static struct sockaddr_in from;
         int len;
 /*      struct linger ling; */
 
         if (!ssl_sock_init()) return(0);
 
 #ifndef OPENSSL_SYS_WINDOWS
 redoit:
 #endif
 
         memset((char *)&from,0,sizeof(from));
         len=sizeof(from);
         /* Note: under VMS with SOCKETSHR the fourth parameter is currently
          * of type (int *) whereas under other systems it is (void *) if
          * you don't have a cast it will choke the compiler: if you do
          * have a cast then you can either go for (int *) or (void *).
          */
         ret=accept(acc_sock,(struct sockaddr *)&from,(void *)&len);
         if (ret == INVALID_SOCKET)
                 {
 #if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))
+                int i;
                 i=WSAGetLastError();
                 BIO_printf(bio_err,"accept error %d\n",i);
 #else
                 if (errno == EINTR)
                         {
                         /*check_timeout(); */
                         goto redoit;
                         }
                 fprintf(stderr,"errno=%d ",errno);
                 perror("accept");
@@ skipping 34 matching lines @@
                         return(0);
                         }
                 BUF_strlcpy(*host,h1->h_name,strlen(h1->h_name)+1);
 
                 h2=GetHostByName(*host);
                 if (h2 == NULL)
                         {
                         BIO_printf(bio_err,"gethostbyname failure\n");
                         return(0);
                         }
-                i=0;
                 if (h2->h_addrtype != AF_INET)
                         {
                         BIO_printf(bio_err,"gethostbyname addr is not AF_INET\n");
                         return(0);
                         }
                 }
 end:
         *sock=ret;
         return(1);
         }
@@ skipping 137 matching lines @@
         else
                 {
                 ghbn_hits++;
                 ret= &(ghbn_cache[i].ent);
                 ghbn_cache[i].order=ghbn_miss+ghbn_hits;
                 return(ret);
                 }
         }
 
 #endif