bio_addr.c@ 107278

最後變更在這個檔案從107278是 105949,由 vboxsync 提交於 5 月前
openssl-3.1.7: Applied and adjusted our OpenSSL changes to 3.1.7. bugref:10757
檔案大小: 26.6 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/openssl-3.1.7/crypto/bio/bio_addr.c@ 107278

以其他格式下載: