apps/s_socket.c

   1 /* apps/s_socket.c -  socket-related functions used by s_client and s_server */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62 #include <errno.h>
  63 #include <signal.h>
  64
  65 /* With IPv6, it looks like Digital has mixed up the proper order of
  66    recursive header file inclusion, resulting in the compiler complaining
  67    that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which
  68    is needed to have fileno() declared correctly...  So let's define u_int */
  69 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
  70 #define __U_INT
  71 typedef unsigned int u_int;
  72 #endif
  73
  74 #define USE_SOCKETS
  75 #define NON_MAIN
  76 #include "apps.h"
  77 #undef USE_SOCKETS
  78 #undef NON_MAIN
  79 #include "s_apps.h"
  80 #include <openssl/ssl.h>
  81
  82 #ifdef FLAT_INC
  83 #include "e_os.h"
  84 #else
  85 #include "../e_os.h"
  86 #endif
  87
  88 #ifndef OPENSSL_NO_SOCK
  89
  90 static struct hostent *GetHostByName(char *name);
  91 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_NETWARE)
  92 static void ssl_sock_cleanup(void);
  93 #endif
  94 static int ssl_sock_init(void);
  95 static int init_client_ip(int *sock,unsigned char ip[4], int port);
  96 static int init_server(int *sock, int port);
  97 static int init_server_long(int *sock, int port,char *ip);
  98 static int do_accept(int acc_sock, int *sock, char **host);
  99 static int host_ip(char *str, unsigned char ip[4]);
 100
 101 #ifdef OPENSSL_SYS_WIN16
 102 #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
 103 #else
 104 #define SOCKET_PROTOCOL IPPROTO_TCP
 105 #endif
 106
 107 #ifdef OPENSSL_SYS_NETWARE
 108 static int wsa_init_done=0;
 109 #endif
 110
 111 #ifdef OPENSSL_SYS_WINDOWS
 112 static struct WSAData wsa_state;
 113 static int wsa_init_done=0;
 114
 115 #ifdef OPENSSL_SYS_WIN16
 116 static HWND topWnd=0;
 117 static FARPROC lpTopWndProc=NULL;
 118 static FARPROC lpTopHookProc=NULL;
 119 extern HINSTANCE _hInstance;  /* nice global CRT provides */
 120
 121 static LONG FAR PASCAL topHookProc(HWND hwnd, UINT message, WPARAM wParam,
 122              LPARAM lParam)
 123         {
 124         if (hwnd == topWnd)
 125                 {
 126                 switch(message)
 127                         {
 128                 case WM_DESTROY:
 129                 case WM_CLOSE:
 130                         SetWindowLong(topWnd,GWL_WNDPROC,(LONG)lpTopWndProc);
 131                         ssl_sock_cleanup();
 132                         break;
 133                         }
 134                 }
 135         return CallWindowProc(lpTopWndProc,hwnd,message,wParam,lParam);
 136         }
 137
 138 static BOOL CALLBACK enumproc(HWND hwnd,LPARAM lParam)
 139         {
 140         topWnd=hwnd;
 141         return(FALSE);
 142         }
 143
 144 #endif /* OPENSSL_SYS_WIN32 */
 145 #endif /* OPENSSL_SYS_WINDOWS */
 146
 147 #ifdef OPENSSL_SYS_WINDOWS
 148 static void ssl_sock_cleanup(void)
 149         {
 150         if (wsa_init_done)
 151                 {
 152                 wsa_init_done=0;
 153 #ifndef OPENSSL_SYS_WINCE
 154                 WSACancelBlockingCall();
 155 #endif
 156                 WSACleanup();
 157                 }
 158         }
 159 #elif defined(OPENSSL_SYS_NETWARE)
 160 static void sock_cleanup(void)
 161     {
 162     if (wsa_init_done)
 163         {
 164         wsa_init_done=0;
 165                 WSACleanup();
 166                 }
 167         }
 168 #endif
 169
 170 static int ssl_sock_init(void)
 171         {
 172 #ifdef WATT32
 173         extern int _watt_do_exit;
 174         _watt_do_exit = 0;
 175         dbug_init();
 176         if (sock_init())
 177                 return (0);
 178 #elif defined(OPENSSL_SYS_WINDOWS)
 179         if (!wsa_init_done)
 180                 {
 181                 int err;
 182
 183 #ifdef SIGINT
 184                 signal(SIGINT,(void (*)(int))ssl_sock_cleanup);
 185 #endif
 186                 wsa_init_done=1;
 187                 memset(&wsa_state,0,sizeof(wsa_state));
 188                 if (WSAStartup(0x0101,&wsa_state)!=0)
 189                         {
 190                         err=WSAGetLastError();
 191                         BIO_printf(bio_err,"unable to start WINSOCK, error code=%d\n",err);
 192                         return(0);
 193                         }
 194
 195 #ifdef OPENSSL_SYS_WIN16
 196                 EnumTaskWindows(GetCurrentTask(),enumproc,0L);
 197                 lpTopWndProc=(FARPROC)GetWindowLong(topWnd,GWL_WNDPROC);
 198                 lpTopHookProc=MakeProcInstance((FARPROC)topHookProc,_hInstance);
 199
 200                 SetWindowLong(topWnd,GWL_WNDPROC,(LONG)lpTopHookProc);
 201 #endif /* OPENSSL_SYS_WIN16 */
 202                 }
 203 #elif defined(OPENSSL_SYS_NETWARE)
 204    WORD wVerReq;
 205    WSADATA wsaData;
 206    int err;
 207
 208    if (!wsa_init_done)
 209       {
 210
 211 # ifdef SIGINT
 212       signal(SIGINT,(void (*)(int))sock_cleanup);
 213 # endif
 214
 215       wsa_init_done=1;
 216       wVerReq = MAKEWORD( 2, 0 );
 217       err = WSAStartup(wVerReq,&wsaData);
 218       if (err != 0)
 219          {
 220          BIO_printf(bio_err,"unable to start WINSOCK2, error code=%d\n",err);
 221          return(0);
 222          }
 223       }
 224 #endif /* OPENSSL_SYS_WINDOWS */
 225         return(1);
 226         }
 227
 228 int init_client(int *sock, char *host, int port)
 229         {
 230         unsigned char ip[4];
 231         short p=0;
 232
 233         if (!host_ip(host,&(ip[0])))
 234                 {
 235                 return(0);
 236                 }
 237         if (p != 0) port=p;
 238         return(init_client_ip(sock,ip,port));
 239         }
 240
 241 static int init_client_ip(int *sock, unsigned char ip[4], int port)
 242         {
 243         unsigned long addr;
 244         struct sockaddr_in them;
 245         int s,i;
 246
 247         if (!ssl_sock_init()) return(0);
 248
 249         memset((char *)&them,0,sizeof(them));
 250         them.sin_family=AF_INET;
 251         them.sin_port=htons((unsigned short)port);
 252         addr=(unsigned long)
 253                 ((unsigned long)ip[0]<<24L)|
 254                 ((unsigned long)ip[1]<<16L)|
 255                 ((unsigned long)ip[2]<< 8L)|
 256                 ((unsigned long)ip[3]);
 257         them.sin_addr.s_addr=htonl(addr);
 258
 259         s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
 260         if (s == INVALID_SOCKET) { perror("socket"); return(0); }
 261
 262 #ifndef OPENSSL_SYS_MPE
 263         i=0;
 264         i=setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
 265         if (i < 0) { perror("keepalive"); return(0); }
 266 #endif
 267
 268         if (connect(s,(struct sockaddr *)&them,sizeof(them)) == -1)
 269                 { close(s); perror("connect"); return(0); }
 270         *sock=s;
 271         return(1);
 272         }
 273
 274 int do_server(int port, int *ret, int (*cb)(), char *context)
 275         {
 276         int sock;
 277         char *name;
 278         int accept_socket;
 279         int i;
 280
 281         if (!init_server(&accept_socket,port)) return(0);
 282
 283         if (ret != NULL)
 284                 {
 285                 *ret=accept_socket;
 286                 /* return(1);*/
 287                 }
 288         for (;;)
 289                 {
 290                 if (do_accept(accept_socket,&sock,&name) == 0)
 291                         {
 292                         SHUTDOWN(accept_socket);
 293                         return(0);
 294                         }
 295                 i=(*cb)(name,sock, context);
 296                 if (name != NULL) OPENSSL_free(name);
 297                 SHUTDOWN2(sock);
 298                 if (i < 0)
 299                         {
 300                         SHUTDOWN2(accept_socket);
 301                         return(i);
 302                         }
 303                 }
 304         }
 305
 306 static int init_server_long(int *sock, int port, char *ip)
 307         {
 308         int ret=0;
 309         struct sockaddr_in server;
 310         int s= -1,i;
 311
 312         if (!ssl_sock_init()) return(0);
 313
 314         memset((char *)&server,0,sizeof(server));
 315         server.sin_family=AF_INET;
 316         server.sin_port=htons((unsigned short)port);
 317         if (ip == NULL)
 318                 server.sin_addr.s_addr=INADDR_ANY;
 319         else
 320 /* Added for T3E, address-of fails on bit field (beckman@acl.lanl.gov) */
 321 #ifndef BIT_FIELD_LIMITS
 322                 memcpy(&server.sin_addr.s_addr,ip,4);
 323 #else
 324                 memcpy(&server.sin_addr,ip,4);
 325 #endif
 326         s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
 327
 328         if (s == INVALID_SOCKET) goto err;
 329 #if defined SOL_SOCKET && defined SO_REUSEADDR
 330                 {
 331                 int j = 1;
 332                 setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
 333                            (void *) &j, sizeof j);
 334                 }
 335 #endif
 336         if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1)
 337                 {
 338 #ifndef OPENSSL_SYS_WINDOWS
 339                 perror("bind");
 340 #endif
 341                 goto err;
 342                 }
 343         /* Make it 128 for linux */
 344         if (listen(s,128) == -1) goto err;
 345         i=0;
 346         *sock=s;
 347         ret=1;
 348 err:
 349         if ((ret == 0) && (s != -1))
 350                 {
 351                 SHUTDOWN(s);
 352                 }
 353         return(ret);
 354         }
 355
 356 static int init_server(int *sock, int port)
 357         {
 358         return(init_server_long(sock, port, NULL));
 359         }
 360
 361 static int do_accept(int acc_sock, int *sock, char **host)
 362         {
 363         int ret,i;
 364         struct hostent *h1,*h2;
 365         static struct sockaddr_in from;
 366         int len;
 367 /*      struct linger ling; */
 368
 369         if (!ssl_sock_init()) return(0);
 370
 371 #ifndef OPENSSL_SYS_WINDOWS
 372 redoit:
 373 #endif
 374
 375         memset((char *)&from,0,sizeof(from));
 376         len=sizeof(from);
 377         /* Note: under VMS with SOCKETSHR the fourth parameter is currently
 378          * of type (int *) whereas under other systems it is (void *) if
 379          * you don't have a cast it will choke the compiler: if you do
 380          * have a cast then you can either go for (int *) or (void *).
 381          */
 382         ret=accept(acc_sock,(struct sockaddr *)&from,(void *)&len);
 383         if (ret == INVALID_SOCKET)
 384                 {
 385 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_NETWARE)
 386                 i=WSAGetLastError();
 387                 BIO_printf(bio_err,"accept error %d\n",i);
 388 #else
 389                 if (errno == EINTR)
 390                         {
 391                         /*check_timeout(); */
 392                         goto redoit;
 393                         }
 394                 fprintf(stderr,"errno=%d ",errno);
 395                 perror("accept");
 396 #endif
 397                 return(0);
 398                 }
 399
 400 /*
 401         ling.l_onoff=1;
 402         ling.l_linger=0;
 403         i=setsockopt(ret,SOL_SOCKET,SO_LINGER,(char *)&ling,sizeof(ling));
 404         if (i < 0) { perror("linger"); return(0); }
 405         i=0;
 406         i=setsockopt(ret,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
 407         if (i < 0) { perror("keepalive"); return(0); }
 408 */
 409
 410         if (host == NULL) goto end;
 411 #ifndef BIT_FIELD_LIMITS
 412         /* I should use WSAAsyncGetHostByName() under windows */
 413         h1=gethostbyaddr((char *)&from.sin_addr.s_addr,
 414                 sizeof(from.sin_addr.s_addr),AF_INET);
 415 #else
 416         h1=gethostbyaddr((char *)&from.sin_addr,
 417                 sizeof(struct in_addr),AF_INET);
 418 #endif
 419         if (h1 == NULL)
 420                 {
 421                 BIO_printf(bio_err,"bad gethostbyaddr\n");
 422                 *host=NULL;
 423                 /* return(0); */
 424                 }
 425         else
 426                 {
 427                 if ((*host=(char *)OPENSSL_malloc(strlen(h1->h_name)+1)) == NULL)
 428                         {
 429                         perror("OPENSSL_malloc");
 430                         return(0);
 431                         }
 432                 BUF_strlcpy(*host,h1->h_name,strlen(h1->h_name)+1);
 433
 434                 h2=GetHostByName(*host);
 435                 if (h2 == NULL)
 436                         {
 437                         BIO_printf(bio_err,"gethostbyname failure\n");
 438                         return(0);
 439                         }
 440                 i=0;
 441                 if (h2->h_addrtype != AF_INET)
 442                         {
 443                         BIO_printf(bio_err,"gethostbyname addr is not AF_INET\n");
 444                         return(0);
 445                         }
 446                 }
 447 end:
 448         *sock=ret;
 449         return(1);
 450         }
 451
 452 int extract_host_port(char *str, char **host_ptr, unsigned char *ip,
 453              short *port_ptr)
 454         {
 455         char *h,*p;
 456
 457         h=str;
 458         p=strchr(str,':');
 459         if (p == NULL)
 460                 {
 461                 BIO_printf(bio_err,"no port defined\n");
 462                 return(0);
 463                 }
 464         *(p++)='\0';
 465
 466         if ((ip != NULL) && !host_ip(str,ip))
 467                 goto err;
 468         if (host_ptr != NULL) *host_ptr=h;
 469
 470         if (!extract_port(p,port_ptr))
 471                 goto err;
 472         return(1);
 473 err:
 474         return(0);
 475         }
 476
 477 static int host_ip(char *str, unsigned char ip[4])
 478         {
 479         unsigned int in[4];
 480         int i;
 481
 482         if (sscanf(str,"%u.%u.%u.%u",&(in[0]),&(in[1]),&(in[2]),&(in[3])) == 4)
 483                 {
 484                 for (i=0; i<4; i++)
 485                         if (in[i] > 255)
 486                                 {
 487                                 BIO_printf(bio_err,"invalid IP address\n");
 488                                 goto err;
 489                                 }
 490                 ip[0]=in[0];
 491                 ip[1]=in[1];
 492                 ip[2]=in[2];
 493                 ip[3]=in[3];
 494                 }
 495         else
 496                 { /* do a gethostbyname */
 497                 struct hostent *he;
 498
 499                 if (!ssl_sock_init()) return(0);
 500
 501                 he=GetHostByName(str);
 502                 if (he == NULL)
 503                         {
 504                         BIO_printf(bio_err,"gethostbyname failure\n");
 505                         goto err;
 506                         }
 507                 /* cast to short because of win16 winsock definition */
 508                 if ((short)he->h_addrtype != AF_INET)
 509                         {
 510                         BIO_printf(bio_err,"gethostbyname addr is not AF_INET\n");
 511                         return(0);
 512                         }
 513                 ip[0]=he->h_addr_list[0][0];
 514                 ip[1]=he->h_addr_list[0][1];
 515                 ip[2]=he->h_addr_list[0][2];
 516                 ip[3]=he->h_addr_list[0][3];
 517                 }
 518         return(1);
 519 err:
 520         return(0);
 521         }
 522
 523 int extract_port(char *str, short *port_ptr)
 524         {
 525         int i;
 526         struct servent *s;
 527
 528         i=atoi(str);
 529         if (i != 0)
 530                 *port_ptr=(unsigned short)i;
 531         else
 532                 {
 533                 s=getservbyname(str,"tcp");
 534                 if (s == NULL)
 535                         {
 536                         BIO_printf(bio_err,"getservbyname failure for %s\n",str);
 537                         return(0);
 538                         }
 539                 *port_ptr=ntohs((unsigned short)s->s_port);
 540                 }
 541         return(1);
 542         }
 543
 544 #define GHBN_NUM        4
 545 static struct ghbn_cache_st
 546         {
 547         char name[128];
 548         struct hostent ent;
 549         unsigned long order;
 550         } ghbn_cache[GHBN_NUM];
 551
 552 static unsigned long ghbn_hits=0L;
 553 static unsigned long ghbn_miss=0L;
 554
 555 static struct hostent *GetHostByName(char *name)
 556         {
 557         struct hostent *ret;
 558         int i,lowi=0;
 559         unsigned long low= (unsigned long)-1;
 560
 561         for (i=0; i<GHBN_NUM; i++)
 562                 {
 563                 if (low > ghbn_cache[i].order)
 564                         {
 565                         low=ghbn_cache[i].order;
 566                         lowi=i;
 567                         }
 568                 if (ghbn_cache[i].order > 0)
 569                         {
 570                         if (strncmp(name,ghbn_cache[i].name,128) == 0)
 571                                 break;
 572                         }
 573                 }
 574         if (i == GHBN_NUM) /* no hit*/
 575                 {
 576                 ghbn_miss++;
 577                 ret=gethostbyname(name);
 578                 if (ret == NULL) return(NULL);
 579                 /* else add to cache */
 580                 if(strlen(name) < sizeof ghbn_cache[0].name)
 581                         {
 582                         strcpy(ghbn_cache[lowi].name,name);
 583                         memcpy((char *)&(ghbn_cache[lowi].ent),ret,sizeof(struct hostent));
 584                         ghbn_cache[lowi].order=ghbn_miss+ghbn_hits;
 585                         }
 586                 return(ret);
 587                 }
 588         else
 589                 {
 590                 ghbn_hits++;
 591                 ret= &(ghbn_cache[i].ent);
 592                 ghbn_cache[i].order=ghbn_miss+ghbn_hits;
 593                 return(ret);
 594                 }
 595         }
 596
 597 #endif