- break;
-
- case BIO_CONN_S_CONNECT:
- BIO_clear_retry_flags(b);
- ret=connect(b->num,
- (struct sockaddr *)&c->them,
- sizeof(c->them));
- b->retry_reason=0;
- if (ret < 0)
- {
- if (BIO_sock_should_retry(ret))
- {
- BIO_set_retry_special(b);
- c->state=BIO_CONN_S_BLOCKED_CONNECT;
- b->retry_reason=BIO_RR_CONNECT;
- }
- else
- {
- SYSerr(SYS_F_CONNECT,get_last_socket_error());
- ERR_add_error_data(4,"host=",
- c->param_hostname,
- ":",c->param_port);
- BIOerr(BIO_F_CONN_STATE,BIO_R_CONNECT_ERROR);
- }
- goto exit_loop;
- }
- else
- c->state=BIO_CONN_S_OK;
- break;
-
- case BIO_CONN_S_BLOCKED_CONNECT:
- i=BIO_sock_error(b->num);
- if (i)
- {
- BIO_clear_retry_flags(b);
- SYSerr(SYS_F_CONNECT,i);
- ERR_add_error_data(4,"host=",
- c->param_hostname,
- ":",c->param_port);
- BIOerr(BIO_F_CONN_STATE,BIO_R_NBIO_CONNECT_ERROR);
- ret=0;
- goto exit_loop;
- }
- else
- c->state=BIO_CONN_S_OK;
- break;
-
- case BIO_CONN_S_OK:
- ret=1;
- goto exit_loop;
- default:
- /* abort(); */
- goto exit_loop;
- }
-
- if (cb != NULL)
- {
- if (!(ret=cb((BIO *)b,c->state,ret)))
- goto end;
- }
- }
-
- /* Loop does not exit */
-exit_loop:
- if (cb != NULL)
- ret=cb((BIO *)b,c->state,ret);
-end:
- return(ret);
- }
-
-BIO_CONNECT *BIO_CONNECT_new(void)
- {
- BIO_CONNECT *ret;
-
- if ((ret=(BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL)
- return(NULL);
- ret->state=BIO_CONN_S_BEFORE;
- ret->param_hostname=NULL;
- ret->param_port=NULL;
- ret->info_callback=NULL;
- ret->nbio=0;
- ret->ip[0]=0;
- ret->ip[1]=0;
- ret->ip[2]=0;
- ret->ip[3]=0;
- ret->port=0;
- memset((char *)&ret->them,0,sizeof(ret->them));
- return(ret);
- }
-
-void BIO_CONNECT_free(BIO_CONNECT *a)
- {
- if(a == NULL)
- return;
-
- if (a->param_hostname != NULL)
- OPENSSL_free(a->param_hostname);
- if (a->param_port != NULL)
- OPENSSL_free(a->param_port);
- OPENSSL_free(a);
- }
-
-BIO_METHOD *BIO_s_connect(void)
- {
- return(&methods_connectp);
- }
+ ERR_raise(ERR_LIB_BIO, BIO_R_UNAVAILABLE_IP_FAMILY);
+ goto exit_loop;
+ }
+ break;
+ case BIO_FAMILY_IPV4:
+ family = AF_INET;
+ break;
+ case BIO_FAMILY_IPANY:
+ family = AF_UNSPEC;
+ break;
+ default:
+ ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_IP_FAMILY);
+ goto exit_loop;
+ }
+ if (BIO_lookup(c->param_hostname, c->param_service,
+ BIO_LOOKUP_CLIENT,
+ family, c->connect_sock_type,
+ &c->addr_first) == 0)
+ goto exit_loop;
+ }
+ if (c->addr_first == NULL) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOOKUP_RETURNED_NOTHING);
+ goto exit_loop;
+ }
+ c->addr_iter = c->addr_first;
+ c->state = BIO_CONN_S_CREATE_SOCKET;
+ break;
+
+ case BIO_CONN_S_CREATE_SOCKET:
+ ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
+ BIO_ADDRINFO_socktype(c->addr_iter),
+ BIO_ADDRINFO_protocol(c->addr_iter), 0);
+ if (ret == (int)INVALID_SOCKET) {
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling socket(%s, %s)",
+ c->param_hostname, c->param_service);
+ ERR_raise(ERR_LIB_BIO, BIO_R_UNABLE_TO_CREATE_SOCKET);
+ goto exit_loop;
+ }
+ b->num = ret;
+ c->state = BIO_CONN_S_CONNECT;
+ break;
+
+ case BIO_CONN_S_CONNECT:
+ BIO_clear_retry_flags(b);
+ ERR_set_mark();
+
+ opts = c->connect_mode;
+ if (BIO_ADDRINFO_socktype(c->addr_iter) == SOCK_STREAM)
+ opts |= BIO_SOCK_KEEPALIVE;
+
+ ret = BIO_connect(b->num, BIO_ADDRINFO_address(c->addr_iter), opts);
+ b->retry_reason = 0;
+ if (ret == 0) {
+ if (BIO_sock_should_retry(ret)) {
+ BIO_set_retry_special(b);
+ c->state = BIO_CONN_S_BLOCKED_CONNECT;
+ b->retry_reason = BIO_RR_CONNECT;
+ ERR_pop_to_mark();
+ } else if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter))
+ != NULL) {
+ /*
+ * if there are more addresses to try, do that first
+ */
+ BIO_closesocket(b->num);
+ c->state = BIO_CONN_S_CREATE_SOCKET;
+ ERR_pop_to_mark();
+ break;
+ } else {
+ ERR_clear_last_mark();
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling connect(%s, %s)",
+ c->param_hostname, c->param_service);
+ c->state = BIO_CONN_S_CONNECT_ERROR;
+ break;
+ }
+ goto exit_loop;
+ } else {
+ ERR_clear_last_mark();
+ if (!conn_create_dgram_bio(b, c))
+ break;
+ c->state = BIO_CONN_S_OK;
+ }
+ break;
+
+ case BIO_CONN_S_BLOCKED_CONNECT:
+ /* wait for socket being writable, before querying BIO_sock_error */
+ if (BIO_socket_wait(b->num, 0, time(NULL)) == 0)
+ break;
+ i = BIO_sock_error(b->num);
+ if (i != 0) {
+ BIO_clear_retry_flags(b);
+ if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter)) != NULL) {
+ /*
+ * if there are more addresses to try, do that first
+ */
+ BIO_closesocket(b->num);
+ c->state = BIO_CONN_S_CREATE_SOCKET;
+ break;
+ }
+ ERR_raise_data(ERR_LIB_SYS, i,
+ "calling connect(%s, %s)",
+ c->param_hostname, c->param_service);
+ ERR_raise(ERR_LIB_BIO, BIO_R_NBIO_CONNECT_ERROR);
+ ret = 0;
+ goto exit_loop;
+ } else {
+ if (!conn_create_dgram_bio(b, c))
+ break;
+ c->state = BIO_CONN_S_OK;
+# ifndef OPENSSL_NO_KTLS
+ /*
+ * The new socket is created successfully regardless of ktls_enable.
+ * ktls_enable doesn't change any functionality of the socket, except
+ * changing the setsockopt to enable the processing of ktls_start.
+ * Thus, it is not a problem to call it for non-TLS sockets.
+ */
+ ktls_enable(b->num);
+# endif
+ }
+ break;
+
+ case BIO_CONN_S_CONNECT_ERROR:
+ ERR_raise(ERR_LIB_BIO, BIO_R_CONNECT_ERROR);
+ ret = 0;
+ goto exit_loop;
+
+ case BIO_CONN_S_OK:
+ ret = 1;
+ goto exit_loop;
+ default:
+ /* abort(); */
+ goto exit_loop;
+ }
+
+ if (cb != NULL) {
+ if ((ret = cb((BIO *)b, c->state, ret)) == 0)
+ goto end;
+ }
+ }
+
+ /* Loop does not exit */
+ exit_loop:
+ if (cb != NULL)
+ ret = cb((BIO *)b, c->state, ret);
+ end:
+ return ret;
+}
+
+static BIO_CONNECT *BIO_CONNECT_new(void)
+{
+ BIO_CONNECT *ret;
+
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
+ return NULL;
+ ret->state = BIO_CONN_S_BEFORE;
+ ret->connect_family = BIO_FAMILY_IPANY;
+ ret->connect_sock_type = SOCK_STREAM;
+ return ret;
+}
+
+static void BIO_CONNECT_free(BIO_CONNECT *a)
+{
+ if (a == NULL)
+ return;
+ OPENSSL_free(a->param_hostname);
+ OPENSSL_free(a->param_service);
+ BIO_ADDRINFO_free(a->addr_first);
+ OPENSSL_free(a);
+}
+
+const BIO_METHOD *BIO_s_connect(void)
+{
+ return &methods_connectp;
+}