1 /* crypto/bio/b_sock.c */
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 <errno.h>
62 #define USE_SOCKETS
63 #include "cryptlib.h"
64 #include <openssl/bio.h>
65 #if defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_BSDSOCK)
66 # include <netdb.h>
67 # if defined(NETWARE_CLIB)
68 # include <sys/ioctl.h>
69 NETDB_DEFINE_CONTEXT
70 # endif
71 #endif
72 #ifndef OPENSSL_NO_SOCK
73 # include <openssl/dso.h>
74 # define SOCKET_PROTOCOL IPPROTO_TCP
75 # ifdef SO_MAXCONN
76 # define MAX_LISTEN SO_MAXCONN
77 # elif defined(SOMAXCONN)
78 # define MAX_LISTEN SOMAXCONN
79 # else
80 # define MAX_LISTEN 32
81 # endif
82 # if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))
83 static int wsa_init_done = 0;
84 # endif
85
86 /*
87 * WSAAPI specifier is required to make indirect calls to run-time
88 * linked WinSock 2 functions used in this module, to be specific
89 * [get|free]addrinfo and getnameinfo. This is because WinSock uses
90 * uses non-C calling convention, __stdcall vs. __cdecl, on x86
91 * Windows. On non-WinSock platforms WSAAPI needs to be void.
92 */
93 # ifndef WSAAPI
94 # define WSAAPI
95 # endif
96
97 # if 0
98 static unsigned long BIO_ghbn_hits = 0L;
99 static unsigned long BIO_ghbn_miss = 0L;
100
101 # define GHBN_NUM 4
102 static struct ghbn_cache_st {
103 char name[129];
104 struct hostent *ent;
105 unsigned long order;
106 } ghbn_cache[GHBN_NUM];
107 # endif
108
109 static int get_ip(const char *str, unsigned char *ip);
110 # if 0
111 static void ghbn_free(struct hostent *a);
112 static struct hostent *ghbn_dup(struct hostent *a);
113 # endif
BIO_get_host_ip(const char * str,unsigned char * ip)114 int BIO_get_host_ip(const char *str, unsigned char *ip)
115 {
116 int i;
117 int err = 1;
118 int locked = 0;
119 struct hostent *he;
120
121 i = get_ip(str, ip);
122 if (i < 0) {
123 BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_INVALID_IP_ADDRESS);
124 goto err;
125 }
126
127 /*
128 * At this point, we have something that is most probably correct in some
129 * way, so let's init the socket.
130 */
131 if (BIO_sock_init() != 1)
132 return 0; /* don't generate another error code here */
133
134 /*
135 * If the string actually contained an IP address, we need not do
136 * anything more
137 */
138 if (i > 0)
139 return (1);
140
141 /* do a gethostbyname */
142 CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
143 locked = 1;
144 he = BIO_gethostbyname(str);
145 if (he == NULL) {
146 BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_BAD_HOSTNAME_LOOKUP);
147 goto err;
148 }
149
150 /* cast to short because of win16 winsock definition */
151 if ((short)he->h_addrtype != AF_INET) {
152 BIOerr(BIO_F_BIO_GET_HOST_IP,
153 BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
154 goto err;
155 }
156 for (i = 0; i < 4; i++)
157 ip[i] = he->h_addr_list[0][i];
158 err = 0;
159
160 err:
161 if (locked)
162 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
163 if (err) {
164 ERR_add_error_data(2, "host=", str);
165 return 0;
166 } else
167 return 1;
168 }
169
BIO_get_port(const char * str,unsigned short * port_ptr)170 int BIO_get_port(const char *str, unsigned short *port_ptr)
171 {
172 int i;
173 struct servent *s;
174
175 if (str == NULL) {
176 BIOerr(BIO_F_BIO_GET_PORT, BIO_R_NO_PORT_DEFINED);
177 return (0);
178 }
179 i = atoi(str);
180 if (i != 0)
181 *port_ptr = (unsigned short)i;
182 else {
183 CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
184 /*
185 * Note: under VMS with SOCKETSHR, it seems like the first parameter
186 * is 'char *', instead of 'const char *'
187 */
188 # ifndef CONST_STRICT
189 s = getservbyname((char *)str, "tcp");
190 # else
191 s = getservbyname(str, "tcp");
192 # endif
193 if (s != NULL)
194 *port_ptr = ntohs((unsigned short)s->s_port);
195 CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
196 if (s == NULL) {
197 if (strcmp(str, "http") == 0)
198 *port_ptr = 80;
199 else if (strcmp(str, "telnet") == 0)
200 *port_ptr = 23;
201 else if (strcmp(str, "socks") == 0)
202 *port_ptr = 1080;
203 else if (strcmp(str, "https") == 0)
204 *port_ptr = 443;
205 else if (strcmp(str, "ssl") == 0)
206 *port_ptr = 443;
207 else if (strcmp(str, "ftp") == 0)
208 *port_ptr = 21;
209 else if (strcmp(str, "gopher") == 0)
210 *port_ptr = 70;
211 # if 0
212 else if (strcmp(str, "wais") == 0)
213 *port_ptr = 21;
214 # endif
215 else {
216 SYSerr(SYS_F_GETSERVBYNAME, get_last_socket_error());
217 ERR_add_error_data(3, "service='", str, "'");
218 return (0);
219 }
220 }
221 }
222 return (1);
223 }
224
BIO_sock_error(int sock)225 int BIO_sock_error(int sock)
226 {
227 int j, i;
228 int size;
229
230 # if defined(OPENSSL_SYS_BEOS_R5)
231 return 0;
232 # endif
233
234 size = sizeof(int);
235 /*
236 * Note: under Windows the third parameter is of type (char *) whereas
237 * under other systems it is (void *) if you don't have a cast it will
238 * choke the compiler: if you do have a cast then you can either go for
239 * (char *) or (void *).
240 */
241 i = getsockopt(sock, SOL_SOCKET, SO_ERROR, (void *)&j, (void *)&size);
242 if (i < 0)
243 return (1);
244 else
245 return (j);
246 }
247
248 # if 0
249 long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
250 {
251 int i;
252 char **p;
253
254 switch (cmd) {
255 case BIO_GHBN_CTRL_HITS:
256 return (BIO_ghbn_hits);
257 /* break; */
258 case BIO_GHBN_CTRL_MISSES:
259 return (BIO_ghbn_miss);
260 /* break; */
261 case BIO_GHBN_CTRL_CACHE_SIZE:
262 return (GHBN_NUM);
263 /* break; */
264 case BIO_GHBN_CTRL_GET_ENTRY:
265 if ((iarg >= 0) && (iarg < GHBN_NUM) && (ghbn_cache[iarg].order > 0)) {
266 p = (char **)parg;
267 if (p == NULL)
268 return (0);
269 *p = ghbn_cache[iarg].name;
270 ghbn_cache[iarg].name[128] = '\0';
271 return (1);
272 }
273 return (0);
274 /* break; */
275 case BIO_GHBN_CTRL_FLUSH:
276 for (i = 0; i < GHBN_NUM; i++)
277 ghbn_cache[i].order = 0;
278 break;
279 default:
280 return (0);
281 }
282 return (1);
283 }
284 # endif
285
286 # if 0
287 static struct hostent *ghbn_dup(struct hostent *a)
288 {
289 struct hostent *ret;
290 int i, j;
291
292 MemCheck_off();
293 ret = (struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
294 if (ret == NULL)
295 return (NULL);
296 memset(ret, 0, sizeof(struct hostent));
297
298 for (i = 0; a->h_aliases[i] != NULL; i++) ;
299 i++;
300 ret->h_aliases = (char **)OPENSSL_malloc(i * sizeof(char *));
301 if (ret->h_aliases == NULL)
302 goto err;
303 memset(ret->h_aliases, 0, i * sizeof(char *));
304
305 for (i = 0; a->h_addr_list[i] != NULL; i++) ;
306 i++;
307 ret->h_addr_list = (char **)OPENSSL_malloc(i * sizeof(char *));
308 if (ret->h_addr_list == NULL)
309 goto err;
310 memset(ret->h_addr_list, 0, i * sizeof(char *));
311
312 j = strlen(a->h_name) + 1;
313 if ((ret->h_name = OPENSSL_malloc(j)) == NULL)
314 goto err;
315 memcpy((char *)ret->h_name, a->h_name, j);
316 for (i = 0; a->h_aliases[i] != NULL; i++) {
317 j = strlen(a->h_aliases[i]) + 1;
318 if ((ret->h_aliases[i] = OPENSSL_malloc(j)) == NULL)
319 goto err;
320 memcpy(ret->h_aliases[i], a->h_aliases[i], j);
321 }
322 ret->h_length = a->h_length;
323 ret->h_addrtype = a->h_addrtype;
324 for (i = 0; a->h_addr_list[i] != NULL; i++) {
325 if ((ret->h_addr_list[i] = OPENSSL_malloc(a->h_length)) == NULL)
326 goto err;
327 memcpy(ret->h_addr_list[i], a->h_addr_list[i], a->h_length);
328 }
329 if (0) {
330 err:
331 if (ret != NULL)
332 ghbn_free(ret);
333 ret = NULL;
334 }
335 MemCheck_on();
336 return (ret);
337 }
338
339 static void ghbn_free(struct hostent *a)
340 {
341 int i;
342
343 if (a == NULL)
344 return;
345
346 if (a->h_aliases != NULL) {
347 for (i = 0; a->h_aliases[i] != NULL; i++)
348 OPENSSL_free(a->h_aliases[i]);
349 OPENSSL_free(a->h_aliases);
350 }
351 if (a->h_addr_list != NULL) {
352 for (i = 0; a->h_addr_list[i] != NULL; i++)
353 OPENSSL_free(a->h_addr_list[i]);
354 OPENSSL_free(a->h_addr_list);
355 }
356 if (a->h_name != NULL)
357 OPENSSL_free(a->h_name);
358 OPENSSL_free(a);
359 }
360
361 # endif
362
BIO_gethostbyname(const char * name)363 struct hostent *BIO_gethostbyname(const char *name)
364 {
365 # if 1
366 /*
367 * Caching gethostbyname() results forever is wrong, so we have to let
368 * the true gethostbyname() worry about this
369 */
370 # if (defined(NETWARE_BSDSOCK) && !defined(__NOVELL_LIBC__))
371 return gethostbyname((char *)name);
372 # else
373 return gethostbyname(name);
374 # endif
375 # else
376 struct hostent *ret;
377 int i, lowi = 0, j;
378 unsigned long low = (unsigned long)-1;
379
380 # if 0
381 /*
382 * It doesn't make sense to use locking here: The function interface is
383 * not thread-safe, because threads can never be sure when some other
384 * thread destroys the data they were given a pointer to.
385 */
386 CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
387 # endif
388 j = strlen(name);
389 if (j < 128) {
390 for (i = 0; i < GHBN_NUM; i++) {
391 if (low > ghbn_cache[i].order) {
392 low = ghbn_cache[i].order;
393 lowi = i;
394 }
395 if (ghbn_cache[i].order > 0) {
396 if (strncmp(name, ghbn_cache[i].name, 128) == 0)
397 break;
398 }
399 }
400 } else
401 i = GHBN_NUM;
402
403 if (i == GHBN_NUM) { /* no hit */
404 BIO_ghbn_miss++;
405 /*
406 * Note: under VMS with SOCKETSHR, it seems like the first parameter
407 * is 'char *', instead of 'const char *'
408 */
409 # ifndef CONST_STRICT
410 ret = gethostbyname((char *)name);
411 # else
412 ret = gethostbyname(name);
413 # endif
414
415 if (ret == NULL)
416 goto end;
417 if (j > 128) { /* too big to cache */
418 # if 0
419 /*
420 * If we were trying to make this function thread-safe (which is
421 * bound to fail), we'd have to give up in this case (or allocate
422 * more memory).
423 */
424 ret = NULL;
425 # endif
426 goto end;
427 }
428
429 /* else add to cache */
430 if (ghbn_cache[lowi].ent != NULL)
431 ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */
432 ghbn_cache[lowi].name[0] = '\0';
433
434 if ((ret = ghbn_cache[lowi].ent = ghbn_dup(ret)) == NULL) {
435 BIOerr(BIO_F_BIO_GETHOSTBYNAME, ERR_R_MALLOC_FAILURE);
436 goto end;
437 }
438 strncpy(ghbn_cache[lowi].name, name, 128);
439 ghbn_cache[lowi].order = BIO_ghbn_miss + BIO_ghbn_hits;
440 } else {
441 BIO_ghbn_hits++;
442 ret = ghbn_cache[i].ent;
443 ghbn_cache[i].order = BIO_ghbn_miss + BIO_ghbn_hits;
444 }
445 end:
446 # if 0
447 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
448 # endif
449 return (ret);
450 # endif
451 }
452
BIO_sock_init(void)453 int BIO_sock_init(void)
454 {
455 # ifdef OPENSSL_SYS_WINDOWS
456 static struct WSAData wsa_state;
457
458 if (!wsa_init_done) {
459 int err;
460
461 wsa_init_done = 1;
462 memset(&wsa_state, 0, sizeof(wsa_state));
463 /*
464 * Not making wsa_state available to the rest of the code is formally
465 * wrong. But the structures we use are [beleived to be] invariable
466 * among Winsock DLLs, while API availability is [expected to be]
467 * probed at run-time with DSO_global_lookup.
468 */
469 if (WSAStartup(0x0202, &wsa_state) != 0) {
470 err = WSAGetLastError();
471 SYSerr(SYS_F_WSASTARTUP, err);
472 BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
473 return (-1);
474 }
475 }
476 # endif /* OPENSSL_SYS_WINDOWS */
477 # ifdef WATT32
478 extern int _watt_do_exit;
479 _watt_do_exit = 0; /* don't make sock_init() call exit() */
480 if (sock_init())
481 return (-1);
482 # endif
483
484 # if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
485 WORD wVerReq;
486 WSADATA wsaData;
487 int err;
488
489 if (!wsa_init_done) {
490 wsa_init_done = 1;
491 wVerReq = MAKEWORD(2, 0);
492 err = WSAStartup(wVerReq, &wsaData);
493 if (err != 0) {
494 SYSerr(SYS_F_WSASTARTUP, err);
495 BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
496 return (-1);
497 }
498 }
499 # endif
500
501 return (1);
502 }
503
BIO_sock_cleanup(void)504 void BIO_sock_cleanup(void)
505 {
506 # ifdef OPENSSL_SYS_WINDOWS
507 if (wsa_init_done) {
508 wsa_init_done = 0;
509 # if 0 /* this call is claimed to be non-present in
510 * Winsock2 */
511 WSACancelBlockingCall();
512 # endif
513 WSACleanup();
514 }
515 # elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
516 if (wsa_init_done) {
517 wsa_init_done = 0;
518 WSACleanup();
519 }
520 # endif
521 }
522
523 # if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000
524
BIO_socket_ioctl(int fd,long type,void * arg)525 int BIO_socket_ioctl(int fd, long type, void *arg)
526 {
527 int i;
528
529 # ifdef __DJGPP__
530 i = ioctlsocket(fd, type, (char *)arg);
531 # else
532 # if defined(OPENSSL_SYS_VMS)
533 /*-
534 * 2011-02-18 SMS.
535 * VMS ioctl() can't tolerate a 64-bit "void *arg", but we
536 * observe that all the consumers pass in an "unsigned long *",
537 * so we arrange a local copy with a short pointer, and use
538 * that, instead.
539 */
540 # if __INITIAL_POINTER_SIZE == 64
541 # define ARG arg_32p
542 # pragma pointer_size save
543 # pragma pointer_size 32
544 unsigned long arg_32;
545 unsigned long *arg_32p;
546 # pragma pointer_size restore
547 arg_32p = &arg_32;
548 arg_32 = *((unsigned long *)arg);
549 # else /* __INITIAL_POINTER_SIZE == 64 */
550 # define ARG arg
551 # endif /* __INITIAL_POINTER_SIZE == 64 [else] */
552 # else /* defined(OPENSSL_SYS_VMS) */
553 # define ARG arg
554 # endif /* defined(OPENSSL_SYS_VMS) [else] */
555
556 i = ioctlsocket(fd, type, ARG);
557 # endif /* __DJGPP__ */
558 if (i < 0)
559 SYSerr(SYS_F_IOCTLSOCKET, get_last_socket_error());
560 return (i);
561 }
562 # endif /* __VMS_VER */
563
564 /*
565 * The reason I have implemented this instead of using sscanf is because
566 * Visual C 1.52c gives an unresolved external when linking a DLL :-(
567 */
get_ip(const char * str,unsigned char ip[4])568 static int get_ip(const char *str, unsigned char ip[4])
569 {
570 unsigned int tmp[4];
571 int num = 0, c, ok = 0;
572
573 tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
574
575 for (;;) {
576 c = *(str++);
577 if ((c >= '0') && (c <= '9')) {
578 ok = 1;
579 tmp[num] = tmp[num] * 10 + c - '0';
580 if (tmp[num] > 255)
581 return (0);
582 } else if (c == '.') {
583 if (!ok)
584 return (-1);
585 if (num == 3)
586 return (0);
587 num++;
588 ok = 0;
589 } else if (c == '\0' && (num == 3) && ok)
590 break;
591 else
592 return (0);
593 }
594 ip[0] = tmp[0];
595 ip[1] = tmp[1];
596 ip[2] = tmp[2];
597 ip[3] = tmp[3];
598 return (1);
599 }
600
BIO_get_accept_socket(char * host,int bind_mode)601 int BIO_get_accept_socket(char *host, int bind_mode)
602 {
603 int ret = 0;
604 union {
605 struct sockaddr sa;
606 struct sockaddr_in sa_in;
607 # if OPENSSL_USE_IPV6
608 struct sockaddr_in6 sa_in6;
609 # endif
610 } server, client;
611 int s = INVALID_SOCKET, cs, addrlen;
612 unsigned char ip[4];
613 unsigned short port;
614 char *str = NULL, *e;
615 char *h, *p;
616 unsigned long l;
617 int err_num;
618
619 if (BIO_sock_init() != 1)
620 return (INVALID_SOCKET);
621
622 if ((str = BUF_strdup(host)) == NULL)
623 return (INVALID_SOCKET);
624
625 h = p = NULL;
626 h = str;
627 for (e = str; *e; e++) {
628 if (*e == ':') {
629 p = e;
630 } else if (*e == '/') {
631 *e = '\0';
632 break;
633 }
634 }
635 if (p)
636 *p++ = '\0'; /* points at last ':', '::port' is special
637 * [see below] */
638 else
639 p = h, h = NULL;
640
641 # ifdef EAI_FAMILY
642 do {
643 static union {
644 void *p;
645 int (WSAAPI *f) (const char *, const char *,
646 const struct addrinfo *, struct addrinfo **);
647 } p_getaddrinfo = {
648 NULL
649 };
650 static union {
651 void *p;
652 void (WSAAPI *f) (struct addrinfo *);
653 } p_freeaddrinfo = {
654 NULL
655 };
656 struct addrinfo *res, hint;
657
658 if (p_getaddrinfo.p == NULL) {
659 if ((p_getaddrinfo.p = DSO_global_lookup("getaddrinfo")) == NULL
660 || (p_freeaddrinfo.p =
661 DSO_global_lookup("freeaddrinfo")) == NULL)
662 p_getaddrinfo.p = (void *)-1;
663 }
664 if (p_getaddrinfo.p == (void *)-1)
665 break;
666
667 /*
668 * '::port' enforces IPv6 wildcard listener. Some OSes, e.g. Solaris,
669 * default to IPv6 without any hint. Also note that commonly IPv6
670 * wildchard socket can service IPv4 connections just as well...
671 */
672 memset(&hint, 0, sizeof(hint));
673 hint.ai_flags = AI_PASSIVE;
674 if (h) {
675 if (strchr(h, ':')) {
676 if (h[1] == '\0')
677 h = NULL;
678 # if OPENSSL_USE_IPV6
679 hint.ai_family = AF_INET6;
680 # else
681 h = NULL;
682 # endif
683 } else if (h[0] == '*' && h[1] == '\0') {
684 hint.ai_family = AF_INET;
685 h = NULL;
686 }
687 }
688
689 /* XXX: below we cast to sockaddr_in! */
690 hint.ai_family = AF_INET;
691
692 if ((*p_getaddrinfo.f) (h, p, &hint, &res))
693 break;
694
695 addrlen = res->ai_addrlen <= sizeof(server) ?
696 res->ai_addrlen : sizeof(server);
697 memcpy(&server, res->ai_addr, addrlen);
698
699 (*p_freeaddrinfo.f) (res);
700 goto again;
701 } while (0);
702 # endif
703
704 if (!BIO_get_port(p, &port))
705 goto err;
706
707 memset((char *)&server, 0, sizeof(server));
708 server.sa_in.sin_family = AF_INET;
709 server.sa_in.sin_port = htons(port);
710 addrlen = sizeof(server.sa_in);
711
712 if (h == NULL || strcmp(h, "*") == 0)
713 server.sa_in.sin_addr.s_addr = INADDR_ANY;
714 else {
715 if (!BIO_get_host_ip(h, &(ip[0])))
716 goto err;
717 l = (unsigned long)
718 ((unsigned long)ip[0] << 24L) |
719 ((unsigned long)ip[1] << 16L) |
720 ((unsigned long)ip[2] << 8L) | ((unsigned long)ip[3]);
721 server.sa_in.sin_addr.s_addr = htonl(l);
722 }
723
724 again:
725 s = socket(server.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
726 if (s == INVALID_SOCKET) {
727 SYSerr(SYS_F_SOCKET, get_last_socket_error());
728 ERR_add_error_data(3, "port='", host, "'");
729 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_CREATE_SOCKET);
730 goto err;
731 }
732 # ifdef SO_REUSEADDR
733 if (bind_mode == BIO_BIND_REUSEADDR) {
734 int i = 1;
735
736 ret = setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&i, sizeof(i));
737 bind_mode = BIO_BIND_NORMAL;
738 }
739 # endif
740 if (bind(s, &server.sa, addrlen) == -1) {
741 # ifdef SO_REUSEADDR
742 err_num = get_last_socket_error();
743 if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
744 # ifdef OPENSSL_SYS_WINDOWS
745 /*
746 * Some versions of Windows define EADDRINUSE to a dummy value.
747 */
748 (err_num == WSAEADDRINUSE))
749 # else
750 (err_num == EADDRINUSE))
751 # endif
752 {
753 client = server;
754 if (h == NULL || strcmp(h, "*") == 0) {
755 # if OPENSSL_USE_IPV6
756 if (client.sa.sa_family == AF_INET6) {
757 memset(&client.sa_in6.sin6_addr, 0,
758 sizeof(client.sa_in6.sin6_addr));
759 client.sa_in6.sin6_addr.s6_addr[15] = 1;
760 } else
761 # endif
762 if (client.sa.sa_family == AF_INET) {
763 client.sa_in.sin_addr.s_addr = htonl(0x7F000001);
764 } else
765 goto err;
766 }
767 cs = socket(client.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
768 if (cs != INVALID_SOCKET) {
769 int ii;
770 ii = connect(cs, &client.sa, addrlen);
771 closesocket(cs);
772 if (ii == INVALID_SOCKET) {
773 bind_mode = BIO_BIND_REUSEADDR;
774 closesocket(s);
775 goto again;
776 }
777 /* else error */
778 }
779 /* else error */
780 }
781 # endif
782 SYSerr(SYS_F_BIND, err_num);
783 ERR_add_error_data(3, "port='", host, "'");
784 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_BIND_SOCKET);
785 goto err;
786 }
787 if (listen(s, MAX_LISTEN) == -1) {
788 SYSerr(SYS_F_BIND, get_last_socket_error());
789 ERR_add_error_data(3, "port='", host, "'");
790 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_LISTEN_SOCKET);
791 goto err;
792 }
793 ret = 1;
794 err:
795 if (str != NULL)
796 OPENSSL_free(str);
797 if ((ret == 0) && (s != INVALID_SOCKET)) {
798 closesocket(s);
799 s = INVALID_SOCKET;
800 }
801 return (s);
802 }
803
BIO_accept(int sock,char ** addr)804 int BIO_accept(int sock, char **addr)
805 {
806 int ret = INVALID_SOCKET;
807 unsigned long l;
808 unsigned short port;
809 char *p;
810
811 struct {
812 /*
813 * As for following union. Trouble is that there are platforms
814 * that have socklen_t and there are platforms that don't, on
815 * some platforms socklen_t is int and on some size_t. So what
816 * one can do? One can cook #ifdef spaghetti, which is nothing
817 * but masochistic. Or one can do union between int and size_t.
818 * One naturally does it primarily for 64-bit platforms where
819 * sizeof(int) != sizeof(size_t). But would it work? Note that
820 * if size_t member is initialized to 0, then later int member
821 * assignment naturally does the job on little-endian platforms
822 * regardless accept's expectations! What about big-endians?
823 * If accept expects int*, then it works, and if size_t*, then
824 * length value would appear as unreasonably large. But this
825 * won't prevent it from filling in the address structure. The
826 * trouble of course would be if accept returns more data than
827 * actual buffer can accomodate and overwrite stack... That's
828 * where early OPENSSL_assert comes into picture. Besides, the
829 * only 64-bit big-endian platform found so far that expects
830 * size_t* is HP-UX, where stack grows towards higher address.
831 * <appro>
832 */
833 union {
834 size_t s;
835 int i;
836 } len;
837 union {
838 struct sockaddr sa;
839 struct sockaddr_in sa_in;
840 # if OPENSSL_USE_IPV6
841 struct sockaddr_in6 sa_in6;
842 # endif
843 } from;
844 } sa;
845
846 sa.len.s = 0;
847 sa.len.i = sizeof(sa.from);
848 memset(&sa.from, 0, sizeof(sa.from));
849 ret = accept(sock, &sa.from.sa, (void *)&sa.len);
850 if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) {
851 OPENSSL_assert(sa.len.s <= sizeof(sa.from));
852 sa.len.i = (int)sa.len.s;
853 /* use sa.len.i from this point */
854 }
855 if (ret == INVALID_SOCKET) {
856 if (BIO_sock_should_retry(ret))
857 return -2;
858 SYSerr(SYS_F_ACCEPT, get_last_socket_error());
859 BIOerr(BIO_F_BIO_ACCEPT, BIO_R_ACCEPT_ERROR);
860 goto end;
861 }
862
863 if (addr == NULL)
864 goto end;
865
866 # ifdef EAI_FAMILY
867 do {
868 char h[NI_MAXHOST], s[NI_MAXSERV];
869 size_t nl;
870 static union {
871 void *p;
872 int (WSAAPI *f) (const struct sockaddr *, size_t /* socklen_t */ ,
873 char *, size_t, char *, size_t, int);
874 } p_getnameinfo = {
875 NULL
876 };
877 /*
878 * 2nd argument to getnameinfo is specified to be socklen_t.
879 * Unfortunately there is a number of environments where socklen_t is
880 * not defined. As it's passed by value, it's safe to pass it as
881 * size_t... <appro>
882 */
883
884 if (p_getnameinfo.p == NULL) {
885 if ((p_getnameinfo.p = DSO_global_lookup("getnameinfo")) == NULL)
886 p_getnameinfo.p = (void *)-1;
887 }
888 if (p_getnameinfo.p == (void *)-1)
889 break;
890
891 if ((*p_getnameinfo.f) (&sa.from.sa, sa.len.i, h, sizeof(h), s,
892 sizeof(s), NI_NUMERICHOST | NI_NUMERICSERV))
893 break;
894 nl = strlen(h) + strlen(s) + 2;
895 p = *addr;
896 if (p) {
897 *p = '\0';
898 p = OPENSSL_realloc(p, nl);
899 } else {
900 p = OPENSSL_malloc(nl);
901 }
902 if (p == NULL) {
903 BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
904 goto end;
905 }
906 *addr = p;
907 BIO_snprintf(*addr, nl, "%s:%s", h, s);
908 goto end;
909 } while (0);
910 # endif
911 if (sa.from.sa.sa_family != AF_INET)
912 goto end;
913 l = ntohl(sa.from.sa_in.sin_addr.s_addr);
914 port = ntohs(sa.from.sa_in.sin_port);
915 if (*addr == NULL) {
916 if ((p = OPENSSL_malloc(24)) == NULL) {
917 BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
918 goto end;
919 }
920 *addr = p;
921 }
922 BIO_snprintf(*addr, 24, "%d.%d.%d.%d:%d",
923 (unsigned char)(l >> 24L) & 0xff,
924 (unsigned char)(l >> 16L) & 0xff,
925 (unsigned char)(l >> 8L) & 0xff,
926 (unsigned char)(l) & 0xff, port);
927 end:
928 return (ret);
929 }
930
BIO_set_tcp_ndelay(int s,int on)931 int BIO_set_tcp_ndelay(int s, int on)
932 {
933 int ret = 0;
934 # if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
935 int opt;
936
937 # ifdef SOL_TCP
938 opt = SOL_TCP;
939 # else
940 # ifdef IPPROTO_TCP
941 opt = IPPROTO_TCP;
942 # endif
943 # endif
944
945 ret = setsockopt(s, opt, TCP_NODELAY, (char *)&on, sizeof(on));
946 # endif
947 return (ret == 0);
948 }
949
BIO_socket_nbio(int s,int mode)950 int BIO_socket_nbio(int s, int mode)
951 {
952 int ret = -1;
953 int l;
954
955 l = mode;
956 # ifdef FIONBIO
957 ret = BIO_socket_ioctl(s, FIONBIO, &l);
958 # endif
959 return (ret == 0);
960 }
961 #endif
962