1 /* apps/s_socket.c */
2 /* Copyright (C) 1995-1997 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 #define USE_SOCKETS
65 #define NON_MAIN
66 #include "apps.h"
67 #undef USE_SOCKETS
68 #undef NON_MAIN
69 #include "s_apps.h"
70 #include "openssl/ssl.h"
71
72 #ifndef NOPROTO
73 static struct hostent *GetHostByName(char *name);
74 int sock_init(void );
75 #else
76 static struct hostent *GetHostByName();
77 int sock_init();
78 #endif
79
80 #ifdef WIN16
81 #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
82 #else
83 #define SOCKET_PROTOCOL IPPROTO_TCP
84 #endif
85
86 #ifdef WINDOWS
87 static struct WSAData wsa_state;
88 static int wsa_init_done=0;
89
90 #ifdef WIN16
91 static HWND topWnd=0;
92 static FARPROC lpTopWndProc=NULL;
93 static FARPROC lpTopHookProc=NULL;
94 extern HINSTANCE _hInstance; /* nice global CRT provides */
95
topHookProc(hwnd,message,wParam,lParam)96 static LONG FAR PASCAL topHookProc(hwnd,message,wParam,lParam)
97 HWND hwnd;
98 UINT message;
99 WPARAM wParam;
100 LPARAM lParam;
101 {
102 if (hwnd == topWnd)
103 {
104 switch(message)
105 {
106 case WM_DESTROY:
107 case WM_CLOSE:
108 SetWindowLong(topWnd,GWL_WNDPROC,(LONG)lpTopWndProc);
109 sock_cleanup();
110 break;
111 }
112 }
113 return CallWindowProc(lpTopWndProc,hwnd,message,wParam,lParam);
114 }
115
enumproc(HWND hwnd,LPARAM lParam)116 static BOOL CALLBACK enumproc(HWND hwnd,LPARAM lParam)
117 {
118 topWnd=hwnd;
119 return(FALSE);
120 }
121
122 #endif /* WIN32 */
123 #endif /* WINDOWS */
124
sock_cleanup()125 void sock_cleanup()
126 {
127 #ifdef WINDOWS
128 if (wsa_init_done)
129 {
130 wsa_init_done=0;
131 WSACancelBlockingCall();
132 WSACleanup();
133 }
134 #endif
135 }
136
sock_init()137 int sock_init()
138 {
139 #ifdef WINDOWS
140 if (!wsa_init_done)
141 {
142 int err;
143
144 #ifdef SIGINT
145 signal(SIGINT,(void (*)(int))sock_cleanup);
146 #endif
147 wsa_init_done=1;
148 memset(&wsa_state,0,sizeof(wsa_state));
149 if (WSAStartup(0x0101,&wsa_state)!=0)
150 {
151 err=WSAGetLastError();
152 BIO_printf(bio_err,"unable to start WINSOCK, error code=%d\n",err);
153 return(0);
154 }
155
156 #ifdef WIN16
157 EnumTaskWindows(GetCurrentTask(),enumproc,0L);
158 lpTopWndProc=(FARPROC)GetWindowLong(topWnd,GWL_WNDPROC);
159 lpTopHookProc=MakeProcInstance((FARPROC)topHookProc,_hInstance);
160
161 SetWindowLong(topWnd,GWL_WNDPROC,(LONG)lpTopHookProc);
162 #endif /* WIN16 */
163 }
164 #endif /* WINDOWS */
165 return(1);
166 }
167
init_client(sock,host,port)168 int init_client(sock, host, port)
169 int *sock;
170 char *host;
171 int port;
172 {
173 unsigned char ip[4];
174 short p=0;
175
176 if (!host_ip(host,&(ip[0])))
177 {
178 return(0);
179 }
180 if (p != 0) port=p;
181 return(init_client_ip(sock,ip,port));
182 }
183
init_client_ip(sock,ip,port)184 int init_client_ip(sock, ip, port)
185 int *sock;
186 unsigned char ip[4];
187 int port;
188 {
189 unsigned long addr;
190 struct sockaddr_in them;
191 int s,i;
192
193 if (!sock_init()) return(0);
194
195 memset((char *)&them,0,sizeof(them));
196 them.sin_family=AF_INET;
197 them.sin_port=htons((unsigned short)port);
198 addr=(unsigned long)
199 ((unsigned long)ip[0]<<24L)|
200 ((unsigned long)ip[1]<<16L)|
201 ((unsigned long)ip[2]<< 8L)|
202 ((unsigned long)ip[3]);
203 them.sin_addr.s_addr=htonl(addr);
204
205 s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
206 if (s == INVALID_SOCKET) { perror("socket"); return(0); }
207
208 i=0;
209 i=setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
210 if (i < 0) { perror("keepalive"); return(0); }
211
212 if (connect(s,(struct sockaddr *)&them,sizeof(them)) == -1)
213 { close(s); perror("connect"); return(0); }
214 *sock=s;
215 return(1);
216 }
217
nbio_sock_error(sock)218 int nbio_sock_error(sock)
219 int sock;
220 {
221 int j,i,size;
222
223 size=sizeof(int);
224 i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(char *)&j,&size);
225 if (i < 0)
226 return(1);
227 else
228 return(j);
229 }
230
nbio_init_client_ip(sock,ip,port)231 int nbio_init_client_ip(sock, ip, port)
232 int *sock;
233 unsigned char ip[4];
234 int port;
235 {
236 unsigned long addr;
237 struct sockaddr_in them;
238 int s,i;
239
240 if (!sock_init()) return(0);
241
242 memset((char *)&them,0,sizeof(them));
243 them.sin_family=AF_INET;
244 them.sin_port=htons((unsigned short)port);
245 addr= (unsigned long)
246 ((unsigned long)ip[0]<<24L)|
247 ((unsigned long)ip[1]<<16L)|
248 ((unsigned long)ip[2]<< 8L)|
249 ((unsigned long)ip[3]);
250 them.sin_addr.s_addr=htonl(addr);
251
252 if (*sock <= 0)
253 {
254 unsigned long l=1;
255
256 s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
257 if (s == INVALID_SOCKET) { perror("socket"); return(0); }
258
259 i=0;
260 i=setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
261 if (i < 0) { perror("keepalive"); return(0); }
262 *sock=s;
263
264 #ifdef FIONBIO
265 socket_ioctl(s,FIONBIO,&l);
266 #endif
267 }
268 else
269 s= *sock;
270
271 i=connect(s,(struct sockaddr *)&them,sizeof(them));
272 if (i == INVALID_SOCKET)
273 {
274 if (BIO_sock_should_retry(i))
275 return(-1);
276 else
277 return(0);
278 }
279 else
280 return(1);
281 }
282
do_server(port,ret,cb)283 int do_server(port, ret, cb)
284 int port;
285 int *ret;
286 int (*cb)();
287 {
288 int sock;
289 char *name;
290 int accept_socket;
291 int i;
292
293 if (!init_server(&accept_socket,port)) return(0);
294
295 if (ret != NULL)
296 {
297 *ret=accept_socket;
298 /* return(1);*/
299 }
300 for (;;)
301 {
302 if (do_accept(accept_socket,&sock,&name) == 0)
303 {
304 SHUTDOWN(accept_socket);
305 return(0);
306 }
307 i=(*cb)(name,sock, sock);
308 if (name != NULL) free(name);
309 SHUTDOWN(sock);
310 if (i < 0)
311 {
312 SHUTDOWN(accept_socket);
313 return(i);
314 }
315 }
316 }
317
init_server(sock,port)318 int init_server(sock, port)
319 int *sock;
320 int port;
321 {
322 int ret=0;
323 struct sockaddr_in server;
324 int s= -1,i;
325
326 if (!sock_init()) return(0);
327
328 memset((char *)&server,0,sizeof(server));
329 server.sin_family=AF_INET;
330 server.sin_port=htons((unsigned short)port);
331 server.sin_addr.s_addr=INADDR_ANY;
332 s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
333
334 if (s == INVALID_SOCKET) goto err;
335 if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1)
336 {
337 #ifndef WINDOWS
338 perror("bind");
339 #endif
340 goto err;
341 }
342 if (listen(s,5) == -1) goto err;
343 i=0;
344 *sock=s;
345 ret=1;
346 err:
347 if ((ret == 0) && (s != -1))
348 {
349 SHUTDOWN(s);
350 }
351 return(ret);
352 }
353
do_accept(acc_sock,sock,host)354 int do_accept(acc_sock, sock, host)
355 int acc_sock;
356 int *sock;
357 char **host;
358 {
359 int ret,i;
360 struct hostent *h1,*h2;
361 static struct sockaddr_in from;
362 int len;
363 /* struct linger ling; */
364
365 if (!sock_init()) return(0);
366
367 #ifndef WINDOWS
368 redoit:
369 #endif
370
371 memset((char *)&from,0,sizeof(from));
372 len=sizeof(from);
373 ret=accept(acc_sock,(struct sockaddr *)&from,&len);
374 if (ret == INVALID_SOCKET)
375 {
376 #ifdef WINDOWS
377 i=WSAGetLastError();
378 BIO_printf(bio_err,"accept error %d\n",i);
379 #else
380 if (errno == EINTR)
381 {
382 /*check_timeout(); */
383 goto redoit;
384 }
385 fprintf(stderr,"errno=%d ",errno);
386 perror("accept");
387 #endif
388 return(0);
389 }
390
391 /*
392 ling.l_onoff=1;
393 ling.l_linger=0;
394 i=setsockopt(ret,SOL_SOCKET,SO_LINGER,(char *)&ling,sizeof(ling));
395 if (i < 0) { perror("linger"); return(0); }
396 i=0;
397 i=setsockopt(ret,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
398 if (i < 0) { perror("keepalive"); return(0); }
399 */
400
401 if (host == NULL) goto end;
402 /* I should use WSAAsyncGetHostByName() under windows */
403 h1=gethostbyaddr((char *)&from.sin_addr.s_addr,
404 sizeof(from.sin_addr.s_addr),AF_INET);
405 if (h1 == NULL)
406 {
407 BIO_printf(bio_err,"bad gethostbyaddr\n");
408 *host=NULL;
409 /* return(0); */
410 }
411 else
412 {
413 if ((*host=(char *)malloc(strlen(h1->h_name)+1)) == NULL)
414 {
415 perror("Malloc");
416 return(0);
417 }
418 strcpy(*host,h1->h_name);
419
420 h2=GetHostByName(*host);
421 if (h2 == NULL)
422 {
423 BIO_printf(bio_err,"gethostbyname failure\n");
424 return(0);
425 }
426 i=0;
427 if (h2->h_addrtype != AF_INET)
428 {
429 BIO_printf(bio_err,"gethostbyname addr is not AF_INET\n");
430 return(0);
431 }
432 }
433 end:
434 *sock=ret;
435 return(1);
436 }
437
socket_ioctl(fd,type,arg)438 int socket_ioctl(fd,type,arg)
439 int fd;
440 long type;
441 unsigned long *arg;
442 {
443 int i,err;
444 #ifdef WINDOWS
445 i=ioctlsocket(fd,type,arg);
446 #else
447 i=ioctl(fd,type,arg);
448 #endif
449 if (i < 0)
450 {
451 #ifdef WINDOWS
452 err=WSAGetLastError();
453 #else
454 err=errno;
455 #endif
456 BIO_printf(bio_err,"ioctl on socket failed:error %d\n",err);
457 }
458 return(i);
459 }
460
sock_err()461 int sock_err()
462 {
463 #ifdef WINDOWS
464 return(WSAGetLastError());
465 #else
466 return(errno);
467 #endif
468 }
469
extract_host_port(str,host_ptr,ip,port_ptr)470 int extract_host_port(str,host_ptr,ip,port_ptr)
471 char *str;
472 char **host_ptr;
473 unsigned char *ip;
474 short *port_ptr;
475 {
476 char *h,*p;
477
478 h=str;
479 p=strchr(str,':');
480 if (p == NULL)
481 {
482 BIO_printf(bio_err,"no port defined\n");
483 return(0);
484 }
485 *(p++)='\0';
486
487 if ((ip != NULL) && !host_ip(str,ip))
488 goto err;
489 if (host_ptr != NULL) *host_ptr=h;
490
491 if (!extract_port(p,port_ptr))
492 goto err;
493 return(1);
494 err:
495 return(0);
496 }
497
host_ip(str,ip)498 int host_ip(str,ip)
499 char *str;
500 unsigned char ip[4];
501 {
502 unsigned int in[4];
503 int i;
504
505 if (sscanf(str,"%d.%d.%d.%d",&(in[0]),&(in[1]),&(in[2]),&(in[3])) == 4)
506 {
507 for (i=0; i<4; i++)
508 if (in[i] > 255)
509 {
510 BIO_printf(bio_err,"invalid IP address\n");
511 goto err;
512 }
513 ip[0]=in[0];
514 ip[1]=in[1];
515 ip[2]=in[2];
516 ip[3]=in[3];
517 }
518 else
519 { /* do a gethostbyname */
520 struct hostent *he;
521
522 if (!sock_init()) return(0);
523
524 he=GetHostByName(str);
525 if (he == NULL)
526 {
527 BIO_printf(bio_err,"gethostbyname failure\n");
528 goto err;
529 }
530 /* cast to short because of win16 winsock definition */
531 if ((short)he->h_addrtype != AF_INET)
532 {
533 BIO_printf(bio_err,"gethostbyname addr is not AF_INET\n");
534 return(0);
535 }
536 ip[0]=he->h_addr_list[0][0];
537 ip[1]=he->h_addr_list[0][1];
538 ip[2]=he->h_addr_list[0][2];
539 ip[3]=he->h_addr_list[0][3];
540 }
541 return(1);
542 err:
543 return(0);
544 }
545
extract_port(str,port_ptr)546 int extract_port(str,port_ptr)
547 char *str;
548 short *port_ptr;
549 {
550 int i;
551 struct servent *s;
552
553 i=atoi(str);
554 if (i != 0)
555 *port_ptr=(unsigned short)i;
556 else
557 {
558 s=getservbyname(str,"tcp");
559 if (s == NULL)
560 {
561 BIO_printf(bio_err,"getservbyname failure for %s\n",str);
562 return(0);
563 }
564 *port_ptr=ntohs((unsigned short)s->s_port);
565 }
566 return(1);
567 }
568
569 #define GHBN_NUM 4
570 static struct ghbn_cache_st
571 {
572 char name[128];
573 struct hostent ent;
574 unsigned long order;
575 } ghbn_cache[GHBN_NUM];
576
577 static unsigned long ghbn_hits=0L;
578 static unsigned long ghbn_miss=0L;
579
GetHostByName(name)580 static struct hostent *GetHostByName(name)
581 char *name;
582 {
583 struct hostent *ret;
584 int i,lowi=0;
585 unsigned long low= (unsigned long)-1;
586
587 for (i=0; i<GHBN_NUM; i++)
588 {
589 if (low > ghbn_cache[i].order)
590 {
591 low=ghbn_cache[i].order;
592 lowi=i;
593 }
594 if (ghbn_cache[i].order > 0)
595 {
596 if (strncmp(name,ghbn_cache[i].name,128) == 0)
597 break;
598 }
599 }
600 if (i == GHBN_NUM) /* no hit*/
601 {
602 ghbn_miss++;
603 ret=gethostbyname(name);
604 if (ret == NULL) return(NULL);
605 /* else add to cache */
606 strncpy(ghbn_cache[lowi].name,name,128);
607 memcpy((char *)&(ghbn_cache[lowi].ent),ret,sizeof(struct hostent));
608 ghbn_cache[lowi].order=ghbn_miss+ghbn_hits;
609 return(ret);
610 }
611 else
612 {
613 ghbn_hits++;
614 ret= &(ghbn_cache[i].ent);
615 ghbn_cache[i].order=ghbn_miss+ghbn_hits;
616 return(ret);
617 }
618 }
619
620 #ifndef MSDOS
spawn(argc,argv,in,out)621 int spawn(argc, argv, in, out)
622 int argc;
623 char **argv;
624 int *in;
625 int *out;
626 {
627 int pid;
628 #define CHILD_READ p1[0]
629 #define CHILD_WRITE p2[1]
630 #define PARENT_READ p2[0]
631 #define PARENT_WRITE p1[1]
632 int p1[2],p2[2];
633
634 if ((pipe(p1) < 0) || (pipe(p2) < 0)) return(-1);
635
636 if ((pid=fork()) == 0)
637 { /* child */
638 if (dup2(CHILD_WRITE,fileno(stdout)) < 0)
639 perror("dup2");
640 if (dup2(CHILD_WRITE,fileno(stderr)) < 0)
641 perror("dup2");
642 if (dup2(CHILD_READ,fileno(stdin)) < 0)
643 perror("dup2");
644 close(CHILD_READ);
645 close(CHILD_WRITE);
646
647 close(PARENT_READ);
648 close(PARENT_WRITE);
649 execvp(argv[0],argv);
650 perror("child");
651 exit(1);
652 }
653
654 /* parent */
655 *in= PARENT_READ;
656 *out=PARENT_WRITE;
657 close(CHILD_READ);
658 close(CHILD_WRITE);
659 return(pid);
660 }
661 #endif /* MSDOS */
662
663
664 #ifdef undef
665 /* Turn on synchronous sockets so that we can do a WaitForMultipleObjects
666 * on sockets */
667 {
668 SOCKET s;
669 int optionValue = SO_SYNCHRONOUS_NONALERT;
670 int err;
671
672 err = setsockopt(
673 INVALID_SOCKET,
674 SOL_SOCKET,
675 SO_OPENTYPE,
676 (char *)&optionValue,
677 sizeof(optionValue));
678 if (err != NO_ERROR) {
679 /* failed for some reason... */
680 BIO_printf(bio_err, "failed to setsockopt(SO_OPENTYPE, SO_SYNCHRONOUS_ALERT) - %d\n",
681 WSAGetLastError());
682 }
683 }
684 #endif
685