bss_conn.c@ 94467

最後變更在這個檔案從94467是 91772,由 vboxsync 提交於 3 年前
openssl-1.1.1l: Applied and adjusted our OpenSSL changes to 1.1.1l. bugref:10126
檔案大小: 16.5 KB

行
1	/*
2	* Copyright 1995-2020 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 <stdio.h>
11	#include <errno.h>
12
13	#include "bio_local.h"
14
15	#ifndef OPENSSL_NO_SOCK
16
17	typedef struct bio_connect_st {
18	int state;
19	int connect_family;
20	char *param_hostname;
21	char *param_service;
22	int connect_mode;
23
24	BIO_ADDRINFO *addr_first;
25	const BIO_ADDRINFO *addr_iter;
26	/*
27	* int socket; this will be kept in bio->num so that it is compatible
28	* with the bss_sock bio
29	*/
30	/*
31	* called when the connection is initially made callback(BIO,state,ret);
32	* The callback should return 'ret'. state is for compatibility with the
33	* ssl info_callback
34	*/
35	BIO_info_cb *info_callback;
36	} BIO_CONNECT;
37
38	static int conn_write(BIO h, const char buf, int num);
39	static int conn_read(BIO h, char buf, int size);
40	static int conn_puts(BIO h, const char str);
41	static long conn_ctrl(BIO h, int cmd, long arg1, void arg2);
42	static int conn_new(BIO *h);
43	static int conn_free(BIO *data);
44	static long conn_callback_ctrl(BIO h, int cmd, BIO_info_cb );
45
46	static int conn_state(BIO b, BIO_CONNECT c);
47	static void conn_close_socket(BIO *data);
48	BIO_CONNECT *BIO_CONNECT_new(void);
49	void BIO_CONNECT_free(BIO_CONNECT *a);
50
51	#define BIO_CONN_S_BEFORE 1
52	#define BIO_CONN_S_GET_ADDR 2
53	#define BIO_CONN_S_CREATE_SOCKET 3
54	#define BIO_CONN_S_CONNECT 4
55	#define BIO_CONN_S_OK 5
56	#define BIO_CONN_S_BLOCKED_CONNECT 6
57	#define BIO_CONN_S_CONNECT_ERROR 7
58
59	static const BIO_METHOD methods_connectp = {
60	BIO_TYPE_CONNECT,
61	"socket connect",
62	/* TODO: Convert to new style write function */
63	bwrite_conv,
64	conn_write,
65	/* TODO: Convert to new style read function */
66	bread_conv,
67	conn_read,
68	conn_puts,
69	NULL, /* conn_gets, */
70	conn_ctrl,
71	conn_new,
72	conn_free,
73	conn_callback_ctrl,
74	};
75
76	static int conn_state(BIO b, BIO_CONNECT c)
77	{
78	int ret = -1, i;
79	BIO_info_cb *cb = NULL;
80
81	if (c->info_callback != NULL)
82	cb = c->info_callback;
83
84	for (;;) {
85	switch (c->state) {
86	case BIO_CONN_S_BEFORE:
87	if (c->param_hostname == NULL && c->param_service == NULL) {
88	BIOerr(BIO_F_CONN_STATE, BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED);
89	ERR_add_error_data(4,
90	"hostname=", c->param_hostname,
91	" service=", c->param_service);
92	goto exit_loop;
93	}
94	c->state = BIO_CONN_S_GET_ADDR;
95	break;
96
97	case BIO_CONN_S_GET_ADDR:
98	{
99	int family = AF_UNSPEC;
100	switch (c->connect_family) {
101	case BIO_FAMILY_IPV6:
102	if (1) { /* This is a trick we use to avoid bit rot.
103	* at least the "else" part will always be
104	* compiled.
105	*/
106	#ifdef AF_INET6
107	family = AF_INET6;
108	} else {
109	#endif
110	BIOerr(BIO_F_CONN_STATE, BIO_R_UNAVAILABLE_IP_FAMILY);
111	goto exit_loop;
112	}
113	break;
114	case BIO_FAMILY_IPV4:
115	family = AF_INET;
116	break;
117	case BIO_FAMILY_IPANY:
118	family = AF_UNSPEC;
119	break;
120	default:
121	BIOerr(BIO_F_CONN_STATE, BIO_R_UNSUPPORTED_IP_FAMILY);
122	goto exit_loop;
123	}
124	if (BIO_lookup(c->param_hostname, c->param_service,
125	BIO_LOOKUP_CLIENT,
126	family, SOCK_STREAM, &c->addr_first) == 0)
127	goto exit_loop;
128	}
129	if (c->addr_first == NULL) {
130	BIOerr(BIO_F_CONN_STATE, BIO_R_LOOKUP_RETURNED_NOTHING);
131	goto exit_loop;
132	}
133	c->addr_iter = c->addr_first;
134	c->state = BIO_CONN_S_CREATE_SOCKET;
135	break;
136
137	case BIO_CONN_S_CREATE_SOCKET:
138	ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
139	BIO_ADDRINFO_socktype(c->addr_iter),
140	BIO_ADDRINFO_protocol(c->addr_iter), 0);
141	if (ret == (int)INVALID_SOCKET) {
142	SYSerr(SYS_F_SOCKET, get_last_socket_error());
143	ERR_add_error_data(4,
144	"hostname=", c->param_hostname,
145	" service=", c->param_service);
146	BIOerr(BIO_F_CONN_STATE, BIO_R_UNABLE_TO_CREATE_SOCKET);
147	goto exit_loop;
148	}
149	b->num = ret;
150	c->state = BIO_CONN_S_CONNECT;
151	break;
152
153	case BIO_CONN_S_CONNECT:
154	BIO_clear_retry_flags(b);
155	ret = BIO_connect(b->num, BIO_ADDRINFO_address(c->addr_iter),
156	BIO_SOCK_KEEPALIVE \| c->connect_mode);
157	b->retry_reason = 0;
158	if (ret == 0) {
159	if (BIO_sock_should_retry(ret)) {
160	BIO_set_retry_special(b);
161	c->state = BIO_CONN_S_BLOCKED_CONNECT;
162	b->retry_reason = BIO_RR_CONNECT;
163	ERR_clear_error();
164	} else if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter))
165	!= NULL) {
166	/*
167	* if there are more addresses to try, do that first
168	*/
169	BIO_closesocket(b->num);
170	c->state = BIO_CONN_S_CREATE_SOCKET;
171	ERR_clear_error();
172	break;
173	} else {
174	SYSerr(SYS_F_CONNECT, get_last_socket_error());
175	ERR_add_error_data(4,
176	"hostname=", c->param_hostname,
177	" service=", c->param_service);
178	c->state = BIO_CONN_S_CONNECT_ERROR;
179	break;
180	}
181	goto exit_loop;
182	} else {
183	c->state = BIO_CONN_S_OK;
184	}
185	break;
186
187	case BIO_CONN_S_BLOCKED_CONNECT:
188	i = BIO_sock_error(b->num);
189	if (i != 0) {
190	BIO_clear_retry_flags(b);
191	if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter)) != NULL) {
192	/*
193	* if there are more addresses to try, do that first
194	*/
195	BIO_closesocket(b->num);
196	c->state = BIO_CONN_S_CREATE_SOCKET;
197	ERR_clear_error();
198	break;
199	}
200	SYSerr(SYS_F_CONNECT, i);
201	ERR_add_error_data(4,
202	"hostname=", c->param_hostname,
203	" service=", c->param_service);
204	BIOerr(BIO_F_CONN_STATE, BIO_R_NBIO_CONNECT_ERROR);
205	ret = 0;
206	goto exit_loop;
207	} else
208	c->state = BIO_CONN_S_OK;
209	break;
210
211	case BIO_CONN_S_CONNECT_ERROR:
212	BIOerr(BIO_F_CONN_STATE, BIO_R_CONNECT_ERROR);
213	ret = 0;
214	goto exit_loop;
215
216	case BIO_CONN_S_OK:
217	ret = 1;
218	goto exit_loop;
219	default:
220	/* abort(); */
221	goto exit_loop;
222	}
223
224	if (cb != NULL) {
225	if ((ret = cb((BIO *)b, c->state, ret)) == 0)
226	goto end;
227	}
228	}
229
230	/* Loop does not exit */
231	exit_loop:
232	if (cb != NULL)
233	ret = cb((BIO *)b, c->state, ret);
234	end:
235	return ret;
236	}
237
238	BIO_CONNECT *BIO_CONNECT_new(void)
239	{
240	BIO_CONNECT *ret;
241
242	if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
243	BIOerr(BIO_F_BIO_CONNECT_NEW, ERR_R_MALLOC_FAILURE);
244	return NULL;
245	}
246	ret->state = BIO_CONN_S_BEFORE;
247	ret->connect_family = BIO_FAMILY_IPANY;
248	return ret;
249	}
250
251	void BIO_CONNECT_free(BIO_CONNECT *a)
252	{
253	if (a == NULL)
254	return;
255	OPENSSL_free(a->param_hostname);
256	OPENSSL_free(a->param_service);
257	BIO_ADDRINFO_free(a->addr_first);
258	OPENSSL_free(a);
259	}
260
261	const BIO_METHOD *BIO_s_connect(void)
262	{
263	return &methods_connectp;
264	}
265
266	static int conn_new(BIO *bi)
267	{
268	bi->init = 0;
269	bi->num = (int)INVALID_SOCKET;
270	bi->flags = 0;
271	if ((bi->ptr = (char *)BIO_CONNECT_new()) == NULL)
272	return 0;
273	else
274	return 1;
275	}
276
277	static void conn_close_socket(BIO *bio)
278	{
279	BIO_CONNECT *c;
280
281	c = (BIO_CONNECT *)bio->ptr;
282	if (bio->num != (int)INVALID_SOCKET) {
283	/* Only do a shutdown if things were established */
284	if (c->state == BIO_CONN_S_OK)
285	shutdown(bio->num, 2);
286	BIO_closesocket(bio->num);
287	bio->num = (int)INVALID_SOCKET;
288	}
289	}
290
291	static int conn_free(BIO *a)
292	{
293	BIO_CONNECT *data;
294
295	if (a == NULL)
296	return 0;
297	data = (BIO_CONNECT *)a->ptr;
298
299	if (a->shutdown) {
300	conn_close_socket(a);
301	BIO_CONNECT_free(data);
302	a->ptr = NULL;
303	a->flags = 0;
304	a->init = 0;
305	}
306	return 1;
307	}
308
309	static int conn_read(BIO b, char out, int outl)
310	{
311	int ret = 0;
312	BIO_CONNECT *data;
313
314	data = (BIO_CONNECT *)b->ptr;
315	if (data->state != BIO_CONN_S_OK) {
316	ret = conn_state(b, data);
317	if (ret <= 0)
318	return ret;
319	}
320
321	if (out != NULL) {
322	clear_socket_error();
323	ret = readsocket(b->num, out, outl);
324	BIO_clear_retry_flags(b);
325	if (ret <= 0) {
326	if (BIO_sock_should_retry(ret))
327	BIO_set_retry_read(b);
328	else if (ret == 0)
329	b->flags \|= BIO_FLAGS_IN_EOF;
330	}
331	}
332	return ret;
333	}
334
335	static int conn_write(BIO b, const char in, int inl)
336	{
337	int ret;
338	BIO_CONNECT *data;
339
340	data = (BIO_CONNECT *)b->ptr;
341	if (data->state != BIO_CONN_S_OK) {
342	ret = conn_state(b, data);
343	if (ret <= 0)
344	return ret;
345	}
346
347	clear_socket_error();
348	ret = writesocket(b->num, in, inl);
349	BIO_clear_retry_flags(b);
350	if (ret <= 0) {
351	if (BIO_sock_should_retry(ret))
352	BIO_set_retry_write(b);
353	}
354	return ret;
355	}
356
357	static long conn_ctrl(BIO b, int cmd, long num, void ptr)
358	{
359	BIO *dbio;
360	int *ip;
361	const char **pptr = NULL;
362	long ret = 1;
363	BIO_CONNECT *data;
364
365	data = (BIO_CONNECT *)b->ptr;
366
367	switch (cmd) {
368	case BIO_CTRL_RESET:
369	ret = 0;
370	data->state = BIO_CONN_S_BEFORE;
371	conn_close_socket(b);
372	BIO_ADDRINFO_free(data->addr_first);
373	data->addr_first = NULL;
374	b->flags = 0;
375	break;
376	case BIO_C_DO_STATE_MACHINE:
377	/* use this one to start the connection */
378	if (data->state != BIO_CONN_S_OK)
379	ret = (long)conn_state(b, data);
380	else
381	ret = 1;
382	break;
383	case BIO_C_GET_CONNECT:
384	if (ptr != NULL) {
385	pptr = (const char **)ptr;
386	if (num == 0) {
387	*pptr = data->param_hostname;
388	} else if (num == 1) {
389	*pptr = data->param_service;
390	} else if (num == 2) {
391	pptr = (const char )BIO_ADDRINFO_address(data->addr_iter);
392	} else if (num == 3) {
393	switch (BIO_ADDRINFO_family(data->addr_iter)) {
394	# ifdef AF_INET6
395	case AF_INET6:
396	ret = BIO_FAMILY_IPV6;
397	break;
398	# endif
399	case AF_INET:
400	ret = BIO_FAMILY_IPV4;
401	break;
402	case 0:
403	ret = data->connect_family;
404	break;
405	default:
406	ret = -1;
407	break;
408	}
409	} else {
410	ret = 0;
411	}
412	} else {
413	ret = 0;
414	}
415	break;
416	case BIO_C_SET_CONNECT:
417	if (ptr != NULL) {
418	b->init = 1;
419	if (num == 0) { /* BIO_set_conn_hostname */
420	char *hold_service = data->param_service;
421	/* We affect the hostname regardless. However, the input
422	* string might contain a host:service spec, so we must
423	* parse it, which might or might not affect the service
424	*/
425
426	OPENSSL_free(data->param_hostname);
427	data->param_hostname = NULL;
428	ret = BIO_parse_hostserv(ptr,
429	&data->param_hostname,
430	&data->param_service,
431	BIO_PARSE_PRIO_HOST);
432	if (hold_service != data->param_service)
433	OPENSSL_free(hold_service);
434	} else if (num == 1) { /* BIO_set_conn_port */
435	OPENSSL_free(data->param_service);
436	if ((data->param_service = OPENSSL_strdup(ptr)) == NULL)
437	ret = 0;
438	} else if (num == 2) { /* BIO_set_conn_address */
439	const BIO_ADDR addr = (const BIO_ADDR )ptr;
440	char *host = BIO_ADDR_hostname_string(addr, 1);
441	char *service = BIO_ADDR_service_string(addr, 1);
442
443	ret = host != NULL && service != NULL;
444	if (ret) {
445	OPENSSL_free(data->param_hostname);
446	data->param_hostname = host;
447	OPENSSL_free(data->param_service);
448	data->param_service = service;
449	BIO_ADDRINFO_free(data->addr_first);
450	data->addr_first = NULL;
451	data->addr_iter = NULL;
452	} else {
453	OPENSSL_free(host);
454	OPENSSL_free(service);
455	}
456	} else if (num == 3) { /* BIO_set_conn_ip_family */
457	data->connect_family = (int )ptr;
458	} else {
459	ret = 0;
460	}
461	}
462	break;
463	case BIO_C_SET_NBIO:
464	if (num != 0)
465	data->connect_mode \|= BIO_SOCK_NONBLOCK;
466	else
467	data->connect_mode &= ~BIO_SOCK_NONBLOCK;
468	break;
469	case BIO_C_SET_CONNECT_MODE:
470	data->connect_mode = (int)num;
471	break;
472	case BIO_C_GET_FD:
473	if (b->init) {
474	ip = (int *)ptr;
475	if (ip != NULL)
476	*ip = b->num;
477	ret = b->num;
478	} else
479	ret = -1;
480	break;
481	case BIO_CTRL_GET_CLOSE:
482	ret = b->shutdown;
483	break;
484	case BIO_CTRL_SET_CLOSE:
485	b->shutdown = (int)num;
486	break;
487	case BIO_CTRL_PENDING:
488	case BIO_CTRL_WPENDING:
489	ret = 0;
490	break;
491	case BIO_CTRL_FLUSH:
492	break;
493	case BIO_CTRL_DUP:
494	{
495	dbio = (BIO *)ptr;
496	if (data->param_hostname)
497	BIO_set_conn_hostname(dbio, data->param_hostname);
498	if (data->param_service)
499	BIO_set_conn_port(dbio, data->param_service);
500	BIO_set_conn_ip_family(dbio, data->connect_family);
501	BIO_set_conn_mode(dbio, data->connect_mode);
502	/*
503	* FIXME: the cast of the function seems unlikely to be a good
504	* idea
505	*/
506	(void)BIO_set_info_callback(dbio, data->info_callback);
507	}
508	break;
509	case BIO_CTRL_SET_CALLBACK:
510	ret = 0; /* use callback ctrl */
511	break;
512	case BIO_CTRL_GET_CALLBACK:
513	{
514	BIO_info_cb **fptr;
515
516	fptr = (BIO_info_cb **)ptr;
517	*fptr = data->info_callback;
518	}
519	break;
520	case BIO_CTRL_EOF:
521	ret = (b->flags & BIO_FLAGS_IN_EOF) != 0 ? 1 : 0;
522	break;
523	default:
524	ret = 0;
525	break;
526	}
527	return ret;
528	}
529
530	static long conn_callback_ctrl(BIO b, int cmd, BIO_info_cb fp)
531	{
532	long ret = 1;
533	BIO_CONNECT *data;
534
535	data = (BIO_CONNECT *)b->ptr;
536
537	switch (cmd) {
538	case BIO_CTRL_SET_CALLBACK:
539	{
540	data->info_callback = fp;
541	}
542	break;
543	default:
544	ret = 0;
545	break;
546	}
547	return ret;
548	}
549
550	static int conn_puts(BIO bp, const char str)
551	{
552	int n, ret;
553
554	n = strlen(str);
555	ret = conn_write(bp, str, n);
556	return ret;
557	}
558
559	BIO BIO_new_connect(const char str)
560	{
561	BIO *ret;
562
563	ret = BIO_new(BIO_s_connect());
564	if (ret == NULL)
565	return NULL;
566	if (BIO_set_conn_hostname(ret, str))
567	return ret;
568	BIO_free(ret);
569	return NULL;
570	}
571
572	#endif

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

source: vbox/trunk/src/libs/openssl-1.1.1l/crypto/bio/bss_conn.c@ 94467

以其他格式下載: