b_addr.c@ 83531

Last change on this file since 83531 was 83531, checked in by vboxsync, 5 years ago
setting svn:sync-process=export for openssl-1.1.1f, all files except tests
File size: 25.8 KB

Line
1	/*
2	* Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved.
3	*
4	* Licensed under the OpenSSL license (the "License"). You may not use
5	* this file except in compliance with the License. You can obtain a copy
6	* in the file LICENSE in the source distribution or at
7	* https://www.openssl.org/source/license.html
8	*/
9
10	#include <assert.h>
11	#include <string.h>
12
13	#include "bio_local.h"
14	#include <openssl/crypto.h>
15
16	#ifndef OPENSSL_NO_SOCK
17	#include <openssl/err.h>
18	#include <openssl/buffer.h>
19	#include "internal/thread_once.h"
20
21	CRYPTO_RWLOCK *bio_lookup_lock;
22	static CRYPTO_ONCE bio_lookup_init = CRYPTO_ONCE_STATIC_INIT;
23
24	/*
25	* Throughout this file and bio_local.h, the existence of the macro
26	* AI_PASSIVE is used to detect the availability of struct addrinfo,
27	* getnameinfo() and getaddrinfo(). If that macro doesn't exist,
28	* we use our own implementation instead, using gethostbyname,
29	* getservbyname and a few other.
30	*/
31
32	/**********************************************************************
33	*
34	* Address structure
35	*
36	*/
37
38	BIO_ADDR *BIO_ADDR_new(void)
39	{
40	BIO_ADDR ret = OPENSSL_zalloc(sizeof(ret));
41
42	if (ret == NULL) {
43	BIOerr(BIO_F_BIO_ADDR_NEW, ERR_R_MALLOC_FAILURE);
44	return NULL;
45	}
46
47	ret->sa.sa_family = AF_UNSPEC;
48	return ret;
49	}
50
51	void BIO_ADDR_free(BIO_ADDR *ap)
52	{
53	OPENSSL_free(ap);
54	}
55
56	void BIO_ADDR_clear(BIO_ADDR *ap)
57	{
58	memset(ap, 0, sizeof(*ap));
59	ap->sa.sa_family = AF_UNSPEC;
60	}
61
62	/*
63	* BIO_ADDR_make - non-public routine to fill a BIO_ADDR with the contents
64	* of a struct sockaddr.
65	*/
66	int BIO_ADDR_make(BIO_ADDR ap, const struct sockaddr sa)
67	{
68	if (sa->sa_family == AF_INET) {
69	memcpy(&(ap->s_in), sa, sizeof(struct sockaddr_in));
70	return 1;
71	}
72	#ifdef AF_INET6
73	if (sa->sa_family == AF_INET6) {
74	memcpy(&(ap->s_in6), sa, sizeof(struct sockaddr_in6));
75	return 1;
76	}
77	#endif
78	#ifdef AF_UNIX
79	if (sa->sa_family == AF_UNIX) {
80	memcpy(&(ap->s_un), sa, sizeof(struct sockaddr_un));
81	return 1;
82	}
83	#endif
84
85	return 0;
86	}
87
88	int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
89	const void *where, size_t wherelen,
90	unsigned short port)
91	{
92	#ifdef AF_UNIX
93	if (family == AF_UNIX) {
94	if (wherelen + 1 > sizeof(ap->s_un.sun_path))
95	return 0;
96	memset(&ap->s_un, 0, sizeof(ap->s_un));
97	ap->s_un.sun_family = family;
98	strncpy(ap->s_un.sun_path, where, sizeof(ap->s_un.sun_path) - 1);
99	return 1;
100	}
101	#endif
102	if (family == AF_INET) {
103	if (wherelen != sizeof(struct in_addr))
104	return 0;
105	memset(&ap->s_in, 0, sizeof(ap->s_in));
106	ap->s_in.sin_family = family;
107	ap->s_in.sin_port = port;
108	ap->s_in.sin_addr = (struct in_addr )where;
109	return 1;
110	}
111	#ifdef AF_INET6
112	if (family == AF_INET6) {
113	if (wherelen != sizeof(struct in6_addr))
114	return 0;
115	memset(&ap->s_in6, 0, sizeof(ap->s_in6));
116	ap->s_in6.sin6_family = family;
117	ap->s_in6.sin6_port = port;
118	ap->s_in6.sin6_addr = (struct in6_addr )where;
119	return 1;
120	}
121	#endif
122
123	return 0;
124	}
125
126	int BIO_ADDR_family(const BIO_ADDR *ap)
127	{
128	return ap->sa.sa_family;
129	}
130
131	int BIO_ADDR_rawaddress(const BIO_ADDR ap, void p, size_t *l)
132	{
133	size_t len = 0;
134	const void *addrptr = NULL;
135
136	if (ap->sa.sa_family == AF_INET) {
137	len = sizeof(ap->s_in.sin_addr);
138	addrptr = &ap->s_in.sin_addr;
139	}
140	#ifdef AF_INET6
141	else if (ap->sa.sa_family == AF_INET6) {
142	len = sizeof(ap->s_in6.sin6_addr);
143	addrptr = &ap->s_in6.sin6_addr;
144	}
145	#endif
146	#ifdef AF_UNIX
147	else if (ap->sa.sa_family == AF_UNIX) {
148	len = strlen(ap->s_un.sun_path);
149	addrptr = &ap->s_un.sun_path;
150	}
151	#endif
152
153	if (addrptr == NULL)
154	return 0;
155
156	if (p != NULL) {
157	memcpy(p, addrptr, len);
158	}
159	if (l != NULL)
160	*l = len;
161
162	return 1;
163	}
164
165	unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap)
166	{
167	if (ap->sa.sa_family == AF_INET)
168	return ap->s_in.sin_port;
169	#ifdef AF_INET6
170	if (ap->sa.sa_family == AF_INET6)
171	return ap->s_in6.sin6_port;
172	#endif
173	return 0;
174	}
175
176	/*-
177	* addr_strings - helper function to get host and service names
178	* @ap: the BIO_ADDR that has the input info
179	* @numeric: 0 if actual names should be returned, 1 if the numeric
180	* representation should be returned.
181	* @hostname: a pointer to a pointer to a memory area to store the
182	* host name or numeric representation. Unused if NULL.
183	* @service: a pointer to a pointer to a memory area to store the
184	* service name or numeric representation. Unused if NULL.
185	*
186	* The return value is 0 on failure, with the error code in the error
187	* stack, and 1 on success.
188	*/
189	static int addr_strings(const BIO_ADDR *ap, int numeric,
190	char hostname, char service)
191	{
192	if (BIO_sock_init() != 1)
193	return 0;
194
195	if (1) {
196	#ifdef AI_PASSIVE
197	int ret = 0;
198	char host[NI_MAXHOST] = "", serv[NI_MAXSERV] = "";
199	int flags = 0;
200
201	if (numeric)
202	flags \|= NI_NUMERICHOST \| NI_NUMERICSERV;
203
204	if ((ret = getnameinfo(BIO_ADDR_sockaddr(ap),
205	BIO_ADDR_sockaddr_size(ap),
206	host, sizeof(host), serv, sizeof(serv),
207	flags)) != 0) {
208	# ifdef EAI_SYSTEM
209	if (ret == EAI_SYSTEM) {
210	SYSerr(SYS_F_GETNAMEINFO, get_last_socket_error());
211	BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB);
212	} else
213	# endif
214	{
215	BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB);
216	ERR_add_error_data(1, gai_strerror(ret));
217	}
218	return 0;
219	}
220
221	/* VMS getnameinfo() has a bug, it doesn't fill in serv, which
222	* leaves it with whatever garbage that happens to be there.
223	* However, we initialise serv with the empty string (serv[0]
224	* is therefore NUL), so it gets real easy to detect when things
225	* didn't go the way one might expect.
226	*/
227	if (serv[0] == '\0') {
228	BIO_snprintf(serv, sizeof(serv), "%d",
229	ntohs(BIO_ADDR_rawport(ap)));
230	}
231
232	if (hostname != NULL)
233	*hostname = OPENSSL_strdup(host);
234	if (service != NULL)
235	*service = OPENSSL_strdup(serv);
236	} else {
237	#endif
238	if (hostname != NULL)
239	*hostname = OPENSSL_strdup(inet_ntoa(ap->s_in.sin_addr));
240	if (service != NULL) {
241	char serv[6]; /* port is 16 bits => max 5 decimal digits */
242	BIO_snprintf(serv, sizeof(serv), "%d", ntohs(ap->s_in.sin_port));
243	*service = OPENSSL_strdup(serv);
244	}
245	}
246
247	if ((hostname != NULL && *hostname == NULL)
248	\|\| (service != NULL && *service == NULL)) {
249	if (hostname != NULL) {
250	OPENSSL_free(*hostname);
251	*hostname = NULL;
252	}
253	if (service != NULL) {
254	OPENSSL_free(*service);
255	*service = NULL;
256	}
257	BIOerr(BIO_F_ADDR_STRINGS, ERR_R_MALLOC_FAILURE);
258	return 0;
259	}
260
261	return 1;
262	}
263
264	char BIO_ADDR_hostname_string(const BIO_ADDR ap, int numeric)
265	{
266	char *hostname = NULL;
267
268	if (addr_strings(ap, numeric, &hostname, NULL))
269	return hostname;
270
271	return NULL;
272	}
273
274	char BIO_ADDR_service_string(const BIO_ADDR ap, int numeric)
275	{
276	char *service = NULL;
277
278	if (addr_strings(ap, numeric, NULL, &service))
279	return service;
280
281	return NULL;
282	}
283
284	char BIO_ADDR_path_string(const BIO_ADDR ap)
285	{
286	#ifdef AF_UNIX
287	if (ap->sa.sa_family == AF_UNIX)
288	return OPENSSL_strdup(ap->s_un.sun_path);
289	#endif
290	return NULL;
291	}
292
293	/*
294	* BIO_ADDR_sockaddr - non-public routine to return the struct sockaddr
295	* for a given BIO_ADDR. In reality, this is simply a type safe cast.
296	* The returned struct sockaddr is const, so it can't be tampered with.
297	*/
298	const struct sockaddr BIO_ADDR_sockaddr(const BIO_ADDR ap)
299	{
300	return &(ap->sa);
301	}
302
303	/*
304	* BIO_ADDR_sockaddr_noconst - non-public function that does the same
305	* as BIO_ADDR_sockaddr, but returns a non-const. USE WITH CARE, as
306	* it allows you to tamper with the data (and thereby the contents
307	* of the input BIO_ADDR).
308	*/
309	struct sockaddr BIO_ADDR_sockaddr_noconst(BIO_ADDR ap)
310	{
311	return &(ap->sa);
312	}
313
314	/*
315	* BIO_ADDR_sockaddr_size - non-public function that returns the size
316	* of the struct sockaddr the BIO_ADDR is using. If the protocol family
317	* isn't set or is something other than AF_INET, AF_INET6 or AF_UNIX,
318	* the size of the BIO_ADDR type is returned.
319	*/
320	socklen_t BIO_ADDR_sockaddr_size(const BIO_ADDR *ap)
321	{
322	if (ap->sa.sa_family == AF_INET)
323	return sizeof(ap->s_in);
324	#ifdef AF_INET6
325	if (ap->sa.sa_family == AF_INET6)
326	return sizeof(ap->s_in6);
327	#endif
328	#ifdef AF_UNIX
329	if (ap->sa.sa_family == AF_UNIX)
330	return sizeof(ap->s_un);
331	#endif
332	return sizeof(*ap);
333	}
334
335	/**********************************************************************
336	*
337	* Address info database
338	*
339	*/
340
341	const BIO_ADDRINFO BIO_ADDRINFO_next(const BIO_ADDRINFO bai)
342	{
343	if (bai != NULL)
344	return bai->bai_next;
345	return NULL;
346	}
347
348	int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai)
349	{
350	if (bai != NULL)
351	return bai->bai_family;
352	return 0;
353	}
354
355	int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai)
356	{
357	if (bai != NULL)
358	return bai->bai_socktype;
359	return 0;
360	}
361
362	int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai)
363	{
364	if (bai != NULL) {
365	if (bai->bai_protocol != 0)
366	return bai->bai_protocol;
367
368	#ifdef AF_UNIX
369	if (bai->bai_family == AF_UNIX)
370	return 0;
371	#endif
372
373	switch (bai->bai_socktype) {
374	case SOCK_STREAM:
375	return IPPROTO_TCP;
376	case SOCK_DGRAM:
377	return IPPROTO_UDP;
378	default:
379	break;
380	}
381	}
382	return 0;
383	}
384
385	/*
386	* BIO_ADDRINFO_sockaddr_size - non-public function that returns the size
387	* of the struct sockaddr inside the BIO_ADDRINFO.
388	*/
389	socklen_t BIO_ADDRINFO_sockaddr_size(const BIO_ADDRINFO *bai)
390	{
391	if (bai != NULL)
392	return bai->bai_addrlen;
393	return 0;
394	}
395
396	/*
397	* BIO_ADDRINFO_sockaddr - non-public function that returns bai_addr
398	* as the struct sockaddr it is.
399	*/
400	const struct sockaddr BIO_ADDRINFO_sockaddr(const BIO_ADDRINFO bai)
401	{
402	if (bai != NULL)
403	return bai->bai_addr;
404	return NULL;
405	}
406
407	const BIO_ADDR BIO_ADDRINFO_address(const BIO_ADDRINFO bai)
408	{
409	if (bai != NULL)
410	return (BIO_ADDR *)bai->bai_addr;
411	return NULL;
412	}
413
414	void BIO_ADDRINFO_free(BIO_ADDRINFO *bai)
415	{
416	if (bai == NULL)
417	return;
418
419	#ifdef AI_PASSIVE
420	# ifdef AF_UNIX
421	# define _cond bai->bai_family != AF_UNIX
422	# else
423	# define _cond 1
424	# endif
425	if (_cond) {
426	freeaddrinfo(bai);
427	return;
428	}
429	#endif
430
431	/* Free manually when we know that addrinfo_wrap() was used.
432	* See further comment above addrinfo_wrap()
433	*/
434	while (bai != NULL) {
435	BIO_ADDRINFO *next = bai->bai_next;
436	OPENSSL_free(bai->bai_addr);
437	OPENSSL_free(bai);
438	bai = next;
439	}
440	}
441
442	/**********************************************************************
443	*
444	* Service functions
445	*
446	*/
447
448	/*-
449	* The specs in hostserv can take these forms:
450	*
451	* host:service => host = "host", service = "service"
452	* host:* => host = "host", service = NULL
453	* host: => host = "host", service = NULL
454	* :service => host = NULL, service = "service"
455	* :service => host = NULL, *service = "service"
456	*
457	* in case no : is present in the string, the result depends on
458	* hostserv_prio, as follows:
459	*
460	* when hostserv_prio == BIO_PARSE_PRIO_HOST
461	* host => host = "host", service untouched
462	*
463	* when hostserv_prio == BIO_PARSE_PRIO_SERV
464	* service => host untouched, service = "service"
465	*
466	*/
467	int BIO_parse_hostserv(const char hostserv, char host, char *service,
468	enum BIO_hostserv_priorities hostserv_prio)
469	{
470	const char *h = NULL; size_t hl = 0;
471	const char *p = NULL; size_t pl = 0;
472
473	if (*hostserv == '[') {
474	if ((p = strchr(hostserv, ']')) == NULL)
475	goto spec_err;
476	h = hostserv + 1;
477	hl = p - h;
478	p++;
479	if (*p == '\0')
480	p = NULL;
481	else if (*p != ':')
482	goto spec_err;
483	else {
484	p++;
485	pl = strlen(p);
486	}
487	} else {
488	const char *p2 = strrchr(hostserv, ':');
489	p = strchr(hostserv, ':');
490
491	/*-
492	* Check for more than one colon. There are three possible
493	* interpretations:
494	* 1. IPv6 address with port number, last colon being separator.
495	* 2. IPv6 address only.
496	* 3. IPv6 address only if hostserv_prio == BIO_PARSE_PRIO_HOST,
497	* IPv6 address and port number if hostserv_prio == BIO_PARSE_PRIO_SERV
498	* Because of this ambiguity, we currently choose to make it an
499	* error.
500	*/
501	if (p != p2)
502	goto amb_err;
503
504	if (p != NULL) {
505	h = hostserv;
506	hl = p - h;
507	p++;
508	pl = strlen(p);
509	} else if (hostserv_prio == BIO_PARSE_PRIO_HOST) {
510	h = hostserv;
511	hl = strlen(h);
512	} else {
513	p = hostserv;
514	pl = strlen(p);
515	}
516	}
517
518	if (p != NULL && strchr(p, ':'))
519	goto spec_err;
520
521	if (h != NULL && host != NULL) {
522	if (hl == 0
523	\|\| (hl == 1 && h[0] == '*')) {
524	*host = NULL;
525	} else {
526	*host = OPENSSL_strndup(h, hl);
527	if (*host == NULL)
528	goto memerr;
529	}
530	}
531	if (p != NULL && service != NULL) {
532	if (pl == 0
533	\|\| (pl == 1 && p[0] == '*')) {
534	*service = NULL;
535	} else {
536	*service = OPENSSL_strndup(p, pl);
537	if (*service == NULL)
538	goto memerr;
539	}
540	}
541
542	return 1;
543	amb_err:
544	BIOerr(BIO_F_BIO_PARSE_HOSTSERV, BIO_R_AMBIGUOUS_HOST_OR_SERVICE);
545	return 0;
546	spec_err:
547	BIOerr(BIO_F_BIO_PARSE_HOSTSERV, BIO_R_MALFORMED_HOST_OR_SERVICE);
548	return 0;
549	memerr:
550	BIOerr(BIO_F_BIO_PARSE_HOSTSERV, ERR_R_MALLOC_FAILURE);
551	return 0;
552	}
553
554	/* addrinfo_wrap is used to build our own addrinfo "chain".
555	* (it has only one entry, so calling it a chain may be a stretch)
556	* It should ONLY be called when getaddrinfo() and friends
557	* aren't available, OR when dealing with a non IP protocol
558	* family, such as AF_UNIX
559	*
560	* the return value is 1 on success, or 0 on failure, which
561	* only happens if a memory allocation error occurred.
562	*/
563	static int addrinfo_wrap(int family, int socktype,
564	const void *where, size_t wherelen,
565	unsigned short port,
566	BIO_ADDRINFO **bai)
567	{
568	if ((bai = OPENSSL_zalloc(sizeof(*bai))) == NULL) {
569	BIOerr(BIO_F_ADDRINFO_WRAP, ERR_R_MALLOC_FAILURE);
570	return 0;
571	}
572
573	(*bai)->bai_family = family;
574	(*bai)->bai_socktype = socktype;
575	if (socktype == SOCK_STREAM)
576	(*bai)->bai_protocol = IPPROTO_TCP;
577	if (socktype == SOCK_DGRAM)
578	(*bai)->bai_protocol = IPPROTO_UDP;
579	#ifdef AF_UNIX
580	if (family == AF_UNIX)
581	(*bai)->bai_protocol = 0;
582	#endif
583	{
584	/* Magic: We know that BIO_ADDR_sockaddr_noconst is really
585	just an advanced cast of BIO_ADDR* to struct sockaddr *
586	by the power of union, so while it may seem that we're
587	creating a memory leak here, we are not. It will be
588	all right. */
589	BIO_ADDR *addr = BIO_ADDR_new();
590	if (addr != NULL) {
591	BIO_ADDR_rawmake(addr, family, where, wherelen, port);
592	(*bai)->bai_addr = BIO_ADDR_sockaddr_noconst(addr);
593	}
594	}
595	(*bai)->bai_next = NULL;
596	if ((*bai)->bai_addr == NULL) {
597	BIO_ADDRINFO_free(*bai);
598	*bai = NULL;
599	return 0;
600	}
601	return 1;
602	}
603
604	DEFINE_RUN_ONCE_STATIC(do_bio_lookup_init)
605	{
606	if (!OPENSSL_init_crypto(0, NULL))
607	return 0;
608	bio_lookup_lock = CRYPTO_THREAD_lock_new();
609	return bio_lookup_lock != NULL;
610	}
611
612	int BIO_lookup(const char host, const char service,
613	enum BIO_lookup_type lookup_type,
614	int family, int socktype, BIO_ADDRINFO **res)
615	{
616	return BIO_lookup_ex(host, service, lookup_type, family, socktype, 0, res);
617	}
618
619	/*-
620	* BIO_lookup_ex - look up the node and service you want to connect to.
621	* @node: the node you want to connect to.
622	* @service: the service you want to connect to.
623	* @lookup_type: declare intent with the result, client or server.
624	* @family: the address family you want to use. Use AF_UNSPEC for any, or
625	* AF_INET, AF_INET6 or AF_UNIX.
626	* @socktype: The socket type you want to use. Can be SOCK_STREAM, SOCK_DGRAM
627	* or 0 for all.
628	* @protocol: The protocol to use, e.g. IPPROTO_TCP or IPPROTO_UDP or 0 for all.
629	* Note that some platforms may not return IPPROTO_SCTP without
630	* explicitly requesting it (i.e. IPPROTO_SCTP may not be returned
631	* with 0 for the protocol)
632	* @res: Storage place for the resulting list of returned addresses
633	*
634	* This will do a lookup of the node and service that you want to connect to.
635	* It returns a linked list of different addresses you can try to connect to.
636	*
637	* When no longer needed you should call BIO_ADDRINFO_free() to free the result.
638	*
639	* The return value is 1 on success or 0 in case of error.
640	*/
641	int BIO_lookup_ex(const char host, const char service, int lookup_type,
642	int family, int socktype, int protocol, BIO_ADDRINFO **res)
643	{
644	int ret = 0; /* Assume failure */
645
646	switch(family) {
647	case AF_INET:
648	#ifdef AF_INET6
649	case AF_INET6:
650	#endif
651	#ifdef AF_UNIX
652	case AF_UNIX:
653	#endif
654	#ifdef AF_UNSPEC
655	case AF_UNSPEC:
656	#endif
657	break;
658	default:
659	BIOerr(BIO_F_BIO_LOOKUP_EX, BIO_R_UNSUPPORTED_PROTOCOL_FAMILY);
660	return 0;
661	}
662
663	#ifdef AF_UNIX
664	if (family == AF_UNIX) {
665	if (addrinfo_wrap(family, socktype, host, strlen(host), 0, res))
666	return 1;
667	else
668	BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_MALLOC_FAILURE);
669	return 0;
670	}
671	#endif
672
673	if (BIO_sock_init() != 1)
674	return 0;
675
676	if (1) {
677	#ifdef AI_PASSIVE
678	int gai_ret = 0, old_ret = 0;
679	struct addrinfo hints;
680
681	memset(&hints, 0, sizeof(hints));
682
683	hints.ai_family = family;
684	hints.ai_socktype = socktype;
685	hints.ai_protocol = protocol;
686	# ifdef AI_ADDRCONFIG
687	# ifdef AF_UNSPEC
688	if (family == AF_UNSPEC)
689	# endif
690	hints.ai_flags \|= AI_ADDRCONFIG;
691	# endif
692
693	if (lookup_type == BIO_LOOKUP_SERVER)
694	hints.ai_flags \|= AI_PASSIVE;
695
696	/* Note that \|res\| SHOULD be a 'struct addrinfo **' thanks to
697	* macro magic in bio_local.h
698	*/
699	# if defined(AI_ADDRCONFIG) && defined(AI_NUMERICHOST)
700	retry:
701	# endif
702	switch ((gai_ret = getaddrinfo(host, service, &hints, res))) {
703	# ifdef EAI_SYSTEM
704	case EAI_SYSTEM:
705	SYSerr(SYS_F_GETADDRINFO, get_last_socket_error());
706	BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_SYS_LIB);
707	break;
708	# endif
709	# ifdef EAI_MEMORY
710	case EAI_MEMORY:
711	BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_MALLOC_FAILURE);
712	break;
713	# endif
714	case 0:
715	ret = 1; /* Success */
716	break;
717	default:
718	# if defined(AI_ADDRCONFIG) && defined(AI_NUMERICHOST)
719	if (hints.ai_flags & AI_ADDRCONFIG) {
720	hints.ai_flags &= ~AI_ADDRCONFIG;
721	hints.ai_flags \|= AI_NUMERICHOST;
722	old_ret = gai_ret;
723	goto retry;
724	}
725	# endif
726	BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_SYS_LIB);
727	ERR_add_error_data(1, gai_strerror(old_ret ? old_ret : gai_ret));
728	break;
729	}
730	} else {
731	#endif
732	const struct hostent *he;
733	/*
734	* Because struct hostent is defined for 32-bit pointers only with
735	* VMS C, we need to make sure that '&he_fallback_address' and
736	* '&he_fallback_addresses' are 32-bit pointers
737	*/
738	#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
739	# pragma pointer_size save
740	# pragma pointer_size 32
741	#endif
742	/* Windows doesn't seem to have in_addr_t */
743	#ifdef OPENSSL_SYS_WINDOWS
744	static uint32_t he_fallback_address;
745	static const char *he_fallback_addresses[] =
746	{ (char *)&he_fallback_address, NULL };
747	#else
748	static in_addr_t he_fallback_address;
749	static const char *he_fallback_addresses[] =
750	{ (char *)&he_fallback_address, NULL };
751	#endif
752	static const struct hostent he_fallback =
753	{ NULL, NULL, AF_INET, sizeof(he_fallback_address),
754	(char **)&he_fallback_addresses };
755	#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
756	# pragma pointer_size restore
757	#endif
758
759	struct servent *se;
760	/* Apparently, on WIN64, s_proto and s_port have traded places... */
761	#ifdef _WIN64
762	struct servent se_fallback = { NULL, NULL, NULL, 0 };
763	#else
764	struct servent se_fallback = { NULL, NULL, 0, NULL };
765	#endif
766
767	if (!RUN_ONCE(&bio_lookup_init, do_bio_lookup_init)) {
768	BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_MALLOC_FAILURE);
769	ret = 0;
770	goto err;
771	}
772
773	CRYPTO_THREAD_write_lock(bio_lookup_lock);
774	he_fallback_address = INADDR_ANY;
775	if (host == NULL) {
776	he = &he_fallback;
777	switch(lookup_type) {
778	case BIO_LOOKUP_CLIENT:
779	he_fallback_address = INADDR_LOOPBACK;
780	break;
781	case BIO_LOOKUP_SERVER:
782	he_fallback_address = INADDR_ANY;
783	break;
784	default:
785	/* We forgot to handle a lookup type! */
786	assert("We forgot to handle a lookup type!" == NULL);
787	BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_INTERNAL_ERROR);
788	ret = 0;
789	goto err;
790	}
791	} else {
792	he = gethostbyname(host);
793
794	if (he == NULL) {
795	#ifndef OPENSSL_SYS_WINDOWS
796	/*
797	* This might be misleading, because h_errno is used as if
798	* it was errno. To minimize mixup add 1000. Underlying
799	* reason for this is that hstrerror is declared obsolete,
800	* not to mention that a) h_errno is not always guaranteed
801	* to be meaningless; b) hstrerror can reside in yet another
802	* library, linking for sake of hstrerror is an overkill;
803	* c) this path is not executed on contemporary systems
804	* anyway [above getaddrinfo/gai_strerror is]. We just let
805	* system administrator figure this out...
806	*/
807	# if defined(OPENSSL_SYS_VXWORKS)
808	/* h_errno doesn't exist on VxWorks */
809	SYSerr(SYS_F_GETHOSTBYNAME, 1000 );
810	# else
811	SYSerr(SYS_F_GETHOSTBYNAME, 1000 + h_errno);
812	# endif
813	#else
814	SYSerr(SYS_F_GETHOSTBYNAME, WSAGetLastError());
815	#endif
816	ret = 0;
817	goto err;
818	}
819	}
820
821	if (service == NULL) {
822	se_fallback.s_port = 0;
823	se_fallback.s_proto = NULL;
824	se = &se_fallback;
825	} else {
826	char *endp = NULL;
827	long portnum = strtol(service, &endp, 10);
828
829	/*
830	* Because struct servent is defined for 32-bit pointers only with
831	* VMS C, we need to make sure that 'proto' is a 32-bit pointer.
832	*/
833	#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
834	# pragma pointer_size save
835	# pragma pointer_size 32
836	#endif
837	char *proto = NULL;
838	#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
839	# pragma pointer_size restore
840	#endif
841
842	switch (socktype) {
843	case SOCK_STREAM:
844	proto = "tcp";
845	break;
846	case SOCK_DGRAM:
847	proto = "udp";
848	break;
849	}
850
851	if (endp != service && *endp == '\0'
852	&& portnum > 0 && portnum < 65536) {
853	se_fallback.s_port = htons((unsigned short)portnum);
854	se_fallback.s_proto = proto;
855	se = &se_fallback;
856	} else if (endp == service) {
857	se = getservbyname(service, proto);
858
859	if (se == NULL) {
860	#ifndef OPENSSL_SYS_WINDOWS
861	SYSerr(SYS_F_GETSERVBYNAME, errno);
862	#else
863	SYSerr(SYS_F_GETSERVBYNAME, WSAGetLastError());
864	#endif
865	goto err;
866	}
867	} else {
868	BIOerr(BIO_F_BIO_LOOKUP_EX, BIO_R_MALFORMED_HOST_OR_SERVICE);
869	goto err;
870	}
871	}
872
873	*res = NULL;
874
875	{
876	/*
877	* Because hostent::h_addr_list is an array of 32-bit pointers with VMS C,
878	* we must make sure our iterator designates the same element type, hence
879	* the pointer size dance.
880	*/
881	#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
882	# pragma pointer_size save
883	# pragma pointer_size 32
884	#endif
885	char **addrlistp;
886	#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
887	# pragma pointer_size restore
888	#endif
889	size_t addresses;
890	BIO_ADDRINFO *tmp_bai = NULL;
891
892	/* The easiest way to create a linked list from an
893	array is to start from the back */
894	for(addrlistp = he->h_addr_list; *addrlistp != NULL;
895	addrlistp++)
896	;
897
898	for(addresses = addrlistp - he->h_addr_list;
899	addrlistp--, addresses-- > 0; ) {
900	if (!addrinfo_wrap(he->h_addrtype, socktype,
901	*addrlistp, he->h_length,
902	se->s_port, &tmp_bai))
903	goto addrinfo_malloc_err;
904	tmp_bai->bai_next = *res;
905	*res = tmp_bai;
906	continue;
907	addrinfo_malloc_err:
908	BIO_ADDRINFO_free(*res);
909	*res = NULL;
910	BIOerr(BIO_F_BIO_LOOKUP_EX, ERR_R_MALLOC_FAILURE);
911	ret = 0;
912	goto err;
913	}
914
915	ret = 1;
916	}
917	err:
918	CRYPTO_THREAD_unlock(bio_lookup_lock);
919	}
920
921	return ret;
922	}
923
924	#endif /* OPENSSL_NO_SOCK */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-1.1.1f/crypto/bio/b_addr.c@ 83531

Download in other formats: