2 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
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
13 #include "bio_local.h"
14 #include "internal/ktls.h"
16 #ifndef OPENSSL_NO_SOCK
18 typedef struct bio_connect_st
{
24 # ifndef OPENSSL_NO_KTLS
25 unsigned char record_type
;
28 BIO_ADDRINFO
*addr_first
;
29 const BIO_ADDRINFO
*addr_iter
;
31 * int socket; this will be kept in bio->num so that it is compatible
32 * with the bss_sock bio
35 * called when the connection is initially made callback(BIO,state,ret);
36 * The callback should return 'ret'. state is for compatibility with the
39 BIO_info_cb
*info_callback
;
42 static int conn_write(BIO
*h
, const char *buf
, int num
);
43 static int conn_read(BIO
*h
, char *buf
, int size
);
44 static int conn_puts(BIO
*h
, const char *str
);
45 static long conn_ctrl(BIO
*h
, int cmd
, long arg1
, void *arg2
);
46 static int conn_new(BIO
*h
);
47 static int conn_free(BIO
*data
);
48 static long conn_callback_ctrl(BIO
*h
, int cmd
, BIO_info_cb
*);
50 static int conn_state(BIO
*b
, BIO_CONNECT
*c
);
51 static void conn_close_socket(BIO
*data
);
52 BIO_CONNECT
*BIO_CONNECT_new(void);
53 void BIO_CONNECT_free(BIO_CONNECT
*a
);
55 #define BIO_CONN_S_BEFORE 1
56 #define BIO_CONN_S_GET_ADDR 2
57 #define BIO_CONN_S_CREATE_SOCKET 3
58 #define BIO_CONN_S_CONNECT 4
59 #define BIO_CONN_S_OK 5
60 #define BIO_CONN_S_BLOCKED_CONNECT 6
61 #define BIO_CONN_S_CONNECT_ERROR 7
63 static const BIO_METHOD methods_connectp
= {
66 /* TODO: Convert to new style write function */
69 /* TODO: Convert to new style read function */
73 NULL
, /* conn_gets, */
80 static int conn_state(BIO
*b
, BIO_CONNECT
*c
)
83 BIO_info_cb
*cb
= NULL
;
85 if (c
->info_callback
!= NULL
)
86 cb
= c
->info_callback
;
90 case BIO_CONN_S_BEFORE
:
91 if (c
->param_hostname
== NULL
&& c
->param_service
== NULL
) {
92 ERR_raise(ERR_LIB_BIO
, BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED
);
94 "hostname=", c
->param_hostname
,
95 " service=", c
->param_service
);
98 c
->state
= BIO_CONN_S_GET_ADDR
;
101 case BIO_CONN_S_GET_ADDR
:
103 int family
= AF_UNSPEC
;
104 switch (c
->connect_family
) {
105 case BIO_FAMILY_IPV6
:
106 if (1) { /* This is a trick we use to avoid bit rot.
107 * at least the "else" part will always be
114 ERR_raise(ERR_LIB_BIO
, BIO_R_UNAVAILABLE_IP_FAMILY
);
118 case BIO_FAMILY_IPV4
:
121 case BIO_FAMILY_IPANY
:
125 ERR_raise(ERR_LIB_BIO
, BIO_R_UNSUPPORTED_IP_FAMILY
);
128 if (BIO_lookup(c
->param_hostname
, c
->param_service
,
130 family
, SOCK_STREAM
, &c
->addr_first
) == 0)
133 if (c
->addr_first
== NULL
) {
134 ERR_raise(ERR_LIB_BIO
, BIO_R_LOOKUP_RETURNED_NOTHING
);
137 c
->addr_iter
= c
->addr_first
;
138 c
->state
= BIO_CONN_S_CREATE_SOCKET
;
141 case BIO_CONN_S_CREATE_SOCKET
:
142 ret
= BIO_socket(BIO_ADDRINFO_family(c
->addr_iter
),
143 BIO_ADDRINFO_socktype(c
->addr_iter
),
144 BIO_ADDRINFO_protocol(c
->addr_iter
), 0);
145 if (ret
== (int)INVALID_SOCKET
) {
146 ERR_raise_data(ERR_LIB_SYS
, get_last_socket_error(),
147 "calling socket(%s, %s)",
148 c
->param_hostname
, c
->param_service
);
149 ERR_raise(ERR_LIB_BIO
, BIO_R_UNABLE_TO_CREATE_SOCKET
);
153 c
->state
= BIO_CONN_S_CONNECT
;
156 case BIO_CONN_S_CONNECT
:
157 BIO_clear_retry_flags(b
);
158 ret
= BIO_connect(b
->num
, BIO_ADDRINFO_address(c
->addr_iter
),
159 BIO_SOCK_KEEPALIVE
| c
->connect_mode
);
162 if (BIO_sock_should_retry(ret
)) {
163 BIO_set_retry_special(b
);
164 c
->state
= BIO_CONN_S_BLOCKED_CONNECT
;
165 b
->retry_reason
= BIO_RR_CONNECT
;
167 } else if ((c
->addr_iter
= BIO_ADDRINFO_next(c
->addr_iter
))
170 * if there are more addresses to try, do that first
172 BIO_closesocket(b
->num
);
173 c
->state
= BIO_CONN_S_CREATE_SOCKET
;
177 ERR_raise_data(ERR_LIB_SYS
, get_last_socket_error(),
178 "calling connect(%s, %s)",
179 c
->param_hostname
, c
->param_service
);
180 c
->state
= BIO_CONN_S_CONNECT_ERROR
;
185 c
->state
= BIO_CONN_S_OK
;
189 case BIO_CONN_S_BLOCKED_CONNECT
:
190 i
= BIO_sock_error(b
->num
);
192 BIO_clear_retry_flags(b
);
193 if ((c
->addr_iter
= BIO_ADDRINFO_next(c
->addr_iter
)) != NULL
) {
195 * if there are more addresses to try, do that first
197 BIO_closesocket(b
->num
);
198 c
->state
= BIO_CONN_S_CREATE_SOCKET
;
202 ERR_raise_data(ERR_LIB_SYS
, i
,
203 "calling connect(%s, %s)",
204 c
->param_hostname
, c
->param_service
);
205 ERR_raise(ERR_LIB_BIO
, BIO_R_NBIO_CONNECT_ERROR
);
209 c
->state
= BIO_CONN_S_OK
;
212 case BIO_CONN_S_CONNECT_ERROR
:
213 ERR_raise(ERR_LIB_BIO
, BIO_R_CONNECT_ERROR
);
226 if ((ret
= cb((BIO
*)b
, c
->state
, ret
)) == 0)
231 /* Loop does not exit */
234 ret
= cb((BIO
*)b
, c
->state
, ret
);
239 BIO_CONNECT
*BIO_CONNECT_new(void)
243 if ((ret
= OPENSSL_zalloc(sizeof(*ret
))) == NULL
) {
244 ERR_raise(ERR_LIB_BIO
, ERR_R_MALLOC_FAILURE
);
247 ret
->state
= BIO_CONN_S_BEFORE
;
248 ret
->connect_family
= BIO_FAMILY_IPANY
;
252 void BIO_CONNECT_free(BIO_CONNECT
*a
)
256 OPENSSL_free(a
->param_hostname
);
257 OPENSSL_free(a
->param_service
);
258 BIO_ADDRINFO_free(a
->addr_first
);
262 const BIO_METHOD
*BIO_s_connect(void)
264 return &methods_connectp
;
267 static int conn_new(BIO
*bi
)
270 bi
->num
= (int)INVALID_SOCKET
;
272 if ((bi
->ptr
= (char *)BIO_CONNECT_new()) == NULL
)
278 static void conn_close_socket(BIO
*bio
)
282 c
= (BIO_CONNECT
*)bio
->ptr
;
283 if (bio
->num
!= (int)INVALID_SOCKET
) {
284 /* Only do a shutdown if things were established */
285 if (c
->state
== BIO_CONN_S_OK
)
286 shutdown(bio
->num
, 2);
287 BIO_closesocket(bio
->num
);
288 bio
->num
= (int)INVALID_SOCKET
;
292 static int conn_free(BIO
*a
)
298 data
= (BIO_CONNECT
*)a
->ptr
;
301 conn_close_socket(a
);
302 BIO_CONNECT_free(data
);
310 static int conn_read(BIO
*b
, char *out
, int outl
)
315 data
= (BIO_CONNECT
*)b
->ptr
;
316 if (data
->state
!= BIO_CONN_S_OK
) {
317 ret
= conn_state(b
, data
);
323 clear_socket_error();
324 # ifndef OPENSSL_NO_KTLS
325 if (BIO_get_ktls_recv(b
))
326 ret
= ktls_read_record(b
->num
, out
, outl
);
329 ret
= readsocket(b
->num
, out
, outl
);
330 BIO_clear_retry_flags(b
);
332 if (BIO_sock_should_retry(ret
))
333 BIO_set_retry_read(b
);
335 b
->flags
|= BIO_FLAGS_IN_EOF
;
341 static int conn_write(BIO
*b
, const char *in
, int inl
)
346 data
= (BIO_CONNECT
*)b
->ptr
;
347 if (data
->state
!= BIO_CONN_S_OK
) {
348 ret
= conn_state(b
, data
);
353 clear_socket_error();
354 # ifndef OPENSSL_NO_KTLS
355 if (BIO_should_ktls_ctrl_msg_flag(b
)) {
356 ret
= ktls_send_ctrl_message(b
->num
, data
->record_type
, in
, inl
);
359 BIO_clear_ktls_ctrl_msg_flag(b
);
363 ret
= writesocket(b
->num
, in
, inl
);
364 BIO_clear_retry_flags(b
);
366 if (BIO_sock_should_retry(ret
))
367 BIO_set_retry_write(b
);
372 static long conn_ctrl(BIO
*b
, int cmd
, long num
, void *ptr
)
376 const char **pptr
= NULL
;
379 # ifndef OPENSSL_NO_KTLS
380 ktls_crypto_info_t
*crypto_info
;
383 data
= (BIO_CONNECT
*)b
->ptr
;
388 data
->state
= BIO_CONN_S_BEFORE
;
389 conn_close_socket(b
);
390 BIO_ADDRINFO_free(data
->addr_first
);
391 data
->addr_first
= NULL
;
394 case BIO_C_DO_STATE_MACHINE
:
395 /* use this one to start the connection */
396 if (data
->state
!= BIO_CONN_S_OK
)
397 ret
= (long)conn_state(b
, data
);
401 case BIO_C_GET_CONNECT
:
403 pptr
= (const char **)ptr
;
405 *pptr
= data
->param_hostname
;
406 } else if (num
== 1) {
407 *pptr
= data
->param_service
;
408 } else if (num
== 2) {
409 *pptr
= (const char *)BIO_ADDRINFO_address(data
->addr_iter
);
410 } else if (num
== 3) {
411 switch (BIO_ADDRINFO_family(data
->addr_iter
)) {
414 ret
= BIO_FAMILY_IPV6
;
418 ret
= BIO_FAMILY_IPV4
;
421 ret
= data
->connect_family
;
434 case BIO_C_SET_CONNECT
:
437 if (num
== 0) { /* BIO_set_conn_hostname */
438 char *hold_service
= data
->param_service
;
439 /* We affect the hostname regardless. However, the input
440 * string might contain a host:service spec, so we must
441 * parse it, which might or might not affect the service
444 OPENSSL_free(data
->param_hostname
);
445 data
->param_hostname
= NULL
;
446 ret
= BIO_parse_hostserv(ptr
,
447 &data
->param_hostname
,
448 &data
->param_service
,
449 BIO_PARSE_PRIO_HOST
);
450 if (hold_service
!= data
->param_service
)
451 OPENSSL_free(hold_service
);
452 } else if (num
== 1) { /* BIO_set_conn_port */
453 OPENSSL_free(data
->param_service
);
454 if ((data
->param_service
= OPENSSL_strdup(ptr
)) == NULL
)
456 } else if (num
== 2) { /* BIO_set_conn_address */
457 const BIO_ADDR
*addr
= (const BIO_ADDR
*)ptr
;
458 char *host
= BIO_ADDR_hostname_string(addr
, 1);
459 char *service
= BIO_ADDR_service_string(addr
, 1);
461 ret
= host
!= NULL
&& service
!= NULL
;
463 OPENSSL_free(data
->param_hostname
);
464 data
->param_hostname
= host
;
465 OPENSSL_free(data
->param_service
);
466 data
->param_service
= service
;
467 BIO_ADDRINFO_free(data
->addr_first
);
468 data
->addr_first
= NULL
;
469 data
->addr_iter
= NULL
;
472 OPENSSL_free(service
);
474 } else if (num
== 3) { /* BIO_set_conn_ip_family */
475 data
->connect_family
= *(int *)ptr
;
483 data
->connect_mode
|= BIO_SOCK_NONBLOCK
;
485 data
->connect_mode
&= ~BIO_SOCK_NONBLOCK
;
487 case BIO_C_SET_CONNECT_MODE
:
488 data
->connect_mode
= (int)num
;
499 case BIO_CTRL_GET_CLOSE
:
502 case BIO_CTRL_SET_CLOSE
:
503 b
->shutdown
= (int)num
;
505 case BIO_CTRL_PENDING
:
506 case BIO_CTRL_WPENDING
:
514 if (data
->param_hostname
)
515 BIO_set_conn_hostname(dbio
, data
->param_hostname
);
516 if (data
->param_service
)
517 BIO_set_conn_port(dbio
, data
->param_service
);
518 BIO_set_conn_ip_family(dbio
, data
->connect_family
);
519 BIO_set_conn_mode(dbio
, data
->connect_mode
);
521 * FIXME: the cast of the function seems unlikely to be a good
524 (void)BIO_set_info_callback(dbio
, data
->info_callback
);
527 case BIO_CTRL_SET_CALLBACK
:
528 ret
= 0; /* use callback ctrl */
530 case BIO_CTRL_GET_CALLBACK
:
534 fptr
= (BIO_info_cb
**)ptr
;
535 *fptr
= data
->info_callback
;
539 ret
= (b
->flags
& BIO_FLAGS_IN_EOF
) != 0 ? 1 : 0;
541 # ifndef OPENSSL_NO_KTLS
542 case BIO_CTRL_SET_KTLS
:
543 crypto_info
= (ktls_crypto_info_t
*)ptr
;
544 ret
= ktls_start(b
->num
, crypto_info
, num
);
546 BIO_set_ktls_flag(b
, num
);
548 case BIO_CTRL_GET_KTLS_SEND
:
549 return BIO_should_ktls_flag(b
, 1);
550 case BIO_CTRL_GET_KTLS_RECV
:
551 return BIO_should_ktls_flag(b
, 0);
552 case BIO_CTRL_SET_KTLS_TX_SEND_CTRL_MSG
:
553 BIO_set_ktls_ctrl_msg_flag(b
);
554 data
->record_type
= num
;
557 case BIO_CTRL_CLEAR_KTLS_TX_CTRL_MSG
:
558 BIO_clear_ktls_ctrl_msg_flag(b
);
569 static long conn_callback_ctrl(BIO
*b
, int cmd
, BIO_info_cb
*fp
)
574 data
= (BIO_CONNECT
*)b
->ptr
;
577 case BIO_CTRL_SET_CALLBACK
:
579 data
->info_callback
= fp
;
589 static int conn_puts(BIO
*bp
, const char *str
)
594 ret
= conn_write(bp
, str
, n
);
598 BIO
*BIO_new_connect(const char *str
)
602 ret
= BIO_new(BIO_s_connect());
605 if (BIO_set_conn_hostname(ret
, str
))