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         if (sock_init())
 176                 return (0);
 177 #elif defined(OPENSSL_SYS_WINDOWS)
 178         if (!wsa_init_done)
 179                 {
 180                 int err;
 181
 182 #ifdef SIGINT
 183                 signal(SIGINT,(void (*)(int))ssl_sock_cleanup);
 184 #endif
 185                 wsa_init_done=1;
 186                 memset(&wsa_state,0,sizeof(wsa_state));
 187                 if (WSAStartup(0x0101,&wsa_state)!=0)
 188                         {
 189                         err=WSAGetLastError();
 190                         BIO_printf(bio_err,"unable to start WINSOCK, error code=%d\n",err);
 191                         return(0);
 192                         }
 193
 194 #ifdef OPENSSL_SYS_WIN16
 195                 EnumTaskWindows(GetCurrentTask(),enumproc,0L);
 196                 lpTopWndProc=(FARPROC)GetWindowLong(topWnd,GWL_WNDPROC);
 197                 lpTopHookProc=MakeProcInstance((FARPROC)topHookProc,_hInstance);
 198
 199                 SetWindowLong(topWnd,GWL_WNDPROC,(LONG)lpTopHookProc);
 200 #endif /* OPENSSL_SYS_WIN16 */
 201                 }
 202 #elif defined(OPENSSL_SYS_NETWARE)
 203    WORD wVerReq;
 204    WSADATA wsaData;
 205    int err;
 206
 207    if (!wsa_init_done)
 208       {
 209
 210 # ifdef SIGINT
 211       signal(SIGINT,(void (*)(int))sock_cleanup);
 212 # endif
 213
 214       wsa_init_done=1;
 215       wVerReq = MAKEWORD( 2, 0 );
 216       err = WSAStartup(wVerReq,&wsaData);
 217       if (err != 0)
 218          {
 219          BIO_printf(bio_err,"unable to start WINSOCK2, error code=%d\n",err);
 220          return(0);
 221          }
 222       }
 223 #endif /* OPENSSL_SYS_WINDOWS */
 224         return(1);
 225         }
 226
 227 int init_client(int *sock, char *host, int port)
 228         {
 229         unsigned char ip[4];
 230         short p=0;
 231
 232         if (!host_ip(host,&(ip[0])))
 233                 {
 234                 return(0);
 235                 }
 236         if (p != 0) port=p;
 237         return(init_client_ip(sock,ip,port));
 238         }
 239
 240 static int init_client_ip(int *sock, unsigned char ip[4], int port)
 241         {
 242         unsigned long addr;
 243         struct sockaddr_in them;
 244         int s,i;
 245
 246         if (!ssl_sock_init()) return(0);
 247
 248         memset((char *)&them,0,sizeof(them));
 249         them.sin_family=AF_INET;
 250         them.sin_port=htons((unsigned short)port);
 251         addr=(unsigned long)
 252                 ((unsigned long)ip[0]<<24L)|
 253                 ((unsigned long)ip[1]<<16L)|
 254                 ((unsigned long)ip[2]<< 8L)|
 255                 ((unsigned long)ip[3]);
 256         them.sin_addr.s_addr=htonl(addr);
 257
 258         s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
 259         if (s == INVALID_SOCKET) { perror("socket"); return(0); }
 260
 261 #ifndef OPENSSL_SYS_MPE
 262         i=0;
 263         i=setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
 264         if (i < 0) { perror("keepalive"); return(0); }
 265 #endif
 266
 267         if (connect(s,(struct sockaddr *)&them,sizeof(them)) == -1)
 268                 { close(s); perror("connect"); return(0); }
 269         *sock=s;
 270         return(1);
 271         }
 272
 273 int do_server(int port, int *ret, int (*cb)(char *hostname, int s, unsigned char *context), char *context)
 274         {
 275         int sock;
 276         char *name;
 277         int accept_socket;
 278         int i;
 279
 280         if (!init_server(&accept_socket,port)) return(0);
 281
 282         if (ret != NULL)
 283                 {
 284                 *ret=accept_socket;
 285                 /* return(1);*/
 286                 }
 287         for (;;)
 288                 {
 289                 if (do_accept(accept_socket,&sock,&name) == 0)
 290                         {
 291                         SHUTDOWN(accept_socket);
 292                         return(0);
 293                         }
 294                 i=(*cb)(name,sock, context);
 295                 if (name != NULL) OPENSSL_free(name);
 296                 SHUTDOWN2(sock);
 297                 if (i < 0)
 298                         {
 299                         SHUTDOWN2(accept_socket);
 300                         return(i);
 301                         }
 302                 }
 303         }
 304
 305 static int init_server_long(int *sock, int port, char *ip)
 306         {
 307         int ret=0;
 308         struct sockaddr_in server;
 309         int s= -1,i;
 310
 311         if (!ssl_sock_init()) return(0);
 312
 313         memset((char *)&server,0,sizeof(server));
 314         server.sin_family=AF_INET;
 315         server.sin_port=htons((unsigned short)port);
 316         if (ip == NULL)
 317                 server.sin_addr.s_addr=INADDR_ANY;
 318         else
 319 /* Added for T3E, address-of fails on bit field (beckman@acl.lanl.gov) */
 320 #ifndef BIT_FIELD_LIMITS
 321                 memcpy(&server.sin_addr.s_addr,ip,4);
 322 #else
 323                 memcpy(&server.sin_addr,ip,4);
 324 #endif
 325         s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
 326
 327         if (s == INVALID_SOCKET) goto err;
 328 #if defined SOL_SOCKET && defined SO_REUSEADDR
 329                 {
 330                 int j = 1;
 331                 setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
 332                            (void *) &j, sizeof j);
 333                 }
 334 #endif
 335         if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1)
 336                 {
 337 #ifndef OPENSSL_SYS_WINDOWS
 338                 perror("bind");
 339 #endif
 340                 goto err;
 341                 }
 342         /* Make it 128 for linux */
 343         if (listen(s,128) == -1) goto err;
 344         i=0;
 345         *sock=s;
 346         ret=1;
 347 err:
 348         if ((ret == 0) && (s != -1))
 349                 {
 350                 SHUTDOWN(s);
 351                 }
 352         return(ret);
 353         }
 354
 355 static int init_server(int *sock, int port)
 356         {
 357         return(init_server_long(sock, port, NULL));
 358         }
 359
 360 static int do_accept(int acc_sock, int *sock, char **host)
 361         {
 362         int ret,i;
 363         struct hostent *h1,*h2;
 364         static struct sockaddr_in from;
 365         int len;
 366 /*      struct linger ling; */
 367
 368         if (!ssl_sock_init()) return(0);
 369
 370 #ifndef OPENSSL_SYS_WINDOWS
 371 redoit:
 372 #endif
 373
 374         memset((char *)&from,0,sizeof(from));
 375         len=sizeof(from);
 376         /* Note: under VMS with SOCKETSHR the fourth parameter is currently
 377          * of type (int *) whereas under other systems it is (void *) if
 378          * you don't have a cast it will choke the compiler: if you do
 379          * have a cast then you can either go for (int *) or (void *).
 380          */
 381         ret=accept(acc_sock,(struct sockaddr *)&from,(void *)&len);
 382         if (ret == INVALID_SOCKET)
 383                 {
 384 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_NETWARE)
 385                 i=WSAGetLastError();
 386                 BIO_printf(bio_err,"accept error %d\n",i);
 387 #else
 388                 if (errno == EINTR)
 389                         {
 390                         /*check_timeout(); */
 391                         goto redoit;
 392                         }
 393                 fprintf(stderr,"errno=%d ",errno);
 394                 perror("accept");
 395 #endif
 396                 return(0);
 397                 }
 398
 399 /*
 400         ling.l_onoff=1;
 401         ling.l_linger=0;
 402         i=setsockopt(ret,SOL_SOCKET,SO_LINGER,(char *)&ling,sizeof(ling));
 403         if (i < 0) { perror("linger"); return(0); }
 404         i=0;
 405         i=setsockopt(ret,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
 406         if (i < 0) { perror("keepalive"); return(0); }
 407 */
 408
 409         if (host == NULL) goto end;
 410 #ifndef BIT_FIELD_LIMITS
 411         /* I should use WSAAsyncGetHostByName() under windows */
 412         h1=gethostbyaddr((char *)&from.sin_addr.s_addr,
 413                 sizeof(from.sin_addr.s_addr),AF_INET);
 414 #else
 415         h1=gethostbyaddr((char *)&from.sin_addr,
 416                 sizeof(struct in_addr),AF_INET);
 417 #endif
 418         if (h1 == NULL)
 419                 {
 420                 BIO_printf(bio_err,"bad gethostbyaddr\n");
 421                 *host=NULL;
 422                 /* return(0); */
 423                 }
 424         else
 425                 {
 426                 if ((*host=(char *)OPENSSL_malloc(strlen(h1->h_name)+1)) == NULL)
 427                         {
 428                         perror("OPENSSL_malloc");
 429                         return(0);
 430                         }
 431                 BUF_strlcpy(*host,h1->h_name,strlen(h1->h_name)+1);
 432
 433                 h2=GetHostByName(*host);
 434                 if (h2 == NULL)
 435                         {
 436                         BIO_printf(bio_err,"gethostbyname failure\n");
 437                         return(0);
 438                         }
 439                 i=0;
 440                 if (h2->h_addrtype != AF_INET)
 441                         {
 442                         BIO_printf(bio_err,"gethostbyname addr is not AF_INET\n");
 443                         return(0);
 444                         }
 445                 }
 446 end:
 447         *sock=ret;
 448         return(1);
 449         }
 450
 451 int extract_host_port(char *str, char **host_ptr, unsigned char *ip,
 452              short *port_ptr)
 453         {
 454         char *h,*p;
 455
 456         h=str;
 457         p=strchr(str,':');
 458         if (p == NULL)
 459                 {
 460                 BIO_printf(bio_err,"no port defined\n");
 461                 return(0);
 462                 }
 463         *(p++)='\0';
 464
 465         if ((ip != NULL) && !host_ip(str,ip))
 466                 goto err;
 467         if (host_ptr != NULL) *host_ptr=h;
 468
 469         if (!extract_port(p,port_ptr))
 470                 goto err;
 471         return(1);
 472 err:
 473         return(0);
 474         }
 475
 476 static int host_ip(char *str, unsigned char ip[4])
 477         {
 478         unsigned int in[4];
 479         int i;
 480
 481         if (sscanf(str,"%u.%u.%u.%u",&(in[0]),&(in[1]),&(in[2]),&(in[3])) == 4)
 482                 {
 483                 for (i=0; i<4; i++)
 484                         if (in[i] > 255)
 485                                 {
 486                                 BIO_printf(bio_err,"invalid IP address\n");
 487                                 goto err;
 488                                 }
 489                 ip[0]=in[0];
 490                 ip[1]=in[1];
 491                 ip[2]=in[2];
 492                 ip[3]=in[3];
 493                 }
 494         else
 495                 { /* do a gethostbyname */
 496                 struct hostent *he;
 497
 498                 if (!ssl_sock_init()) return(0);
 499
 500                 he=GetHostByName(str);
 501                 if (he == NULL)
 502                         {
 503                         BIO_printf(bio_err,"gethostbyname failure\n");
 504                         goto err;
 505                         }
 506                 /* cast to short because of win16 winsock definition */
 507                 if ((short)he->h_addrtype != AF_INET)
 508                         {
 509                         BIO_printf(bio_err,"gethostbyname addr is not AF_INET\n");
 510                         return(0);
 511                         }
 512                 ip[0]=he->h_addr_list[0][0];
 513                 ip[1]=he->h_addr_list[0][1];
 514                 ip[2]=he->h_addr_list[0][2];
 515                 ip[3]=he->h_addr_list[0][3];
 516                 }
 517         return(1);
 518 err:
 519         return(0);
 520         }
 521
 522 int extract_port(char *str, short *port_ptr)
 523         {
 524         int i;
 525         struct servent *s;
 526
 527         i=atoi(str);
 528         if (i != 0)
 529                 *port_ptr=(unsigned short)i;
 530         else
 531                 {
 532                 s=getservbyname(str,"tcp");
 533                 if (s == NULL)
 534                         {
 535                         BIO_printf(bio_err,"getservbyname failure for %s\n",str);
 536                         return(0);
 537                         }
 538                 *port_ptr=ntohs((unsigned short)s->s_port);
 539                 }
 540         return(1);
 541         }
 542
 543 #define GHBN_NUM        4
 544 static struct ghbn_cache_st
 545         {
 546         char name[128];
 547         struct hostent ent;
 548         unsigned long order;
 549         } ghbn_cache[GHBN_NUM];
 550
 551 static unsigned long ghbn_hits=0L;
 552 static unsigned long ghbn_miss=0L;
 553
 554 static struct hostent *GetHostByName(char *name)
 555         {
 556         struct hostent *ret;
 557         int i,lowi=0;
 558         unsigned long low= (unsigned long)-1;
 559
 560         for (i=0; i<GHBN_NUM; i++)
 561                 {
 562                 if (low > ghbn_cache[i].order)
 563                         {
 564                         low=ghbn_cache[i].order;
 565                         lowi=i;
 566                         }
 567                 if (ghbn_cache[i].order > 0)
 568                         {
 569                         if (strncmp(name,ghbn_cache[i].name,128) == 0)
 570                                 break;
 571                         }
 572                 }
 573         if (i == GHBN_NUM) /* no hit*/
 574                 {
 575                 ghbn_miss++;
 576                 ret=gethostbyname(name);
 577                 if (ret == NULL) return(NULL);
 578                 /* else add to cache */
 579                 if(strlen(name) < sizeof ghbn_cache[0].name)
 580                         {
 581                         strcpy(ghbn_cache[lowi].name,name);
 582                         memcpy((char *)&(ghbn_cache[lowi].ent),ret,sizeof(struct hostent));
 583                         ghbn_cache[lowi].order=ghbn_miss+ghbn_hits;
 584                         }
 585                 return(ret);
 586                 }
 587         else
 588                 {
 589                 ghbn_hits++;
 590                 ret= &(ghbn_cache[i].ent);
 591                 ghbn_cache[i].order=ghbn_miss+ghbn_hits;
 592                 return(ret);
 593                 }
 594         }
 595
 596 #endif