2 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
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
14 #ifndef OPENSSL_NO_SOCK
16 typedef struct bio_accept_st {
19 int bind_mode; /* Socket mode for BIO_listen */
20 int accepted_mode; /* Socket mode for BIO_accept (set on accepted sock) */
26 BIO_ADDRINFO *addr_first;
27 const BIO_ADDRINFO *addr_iter;
28 BIO_ADDR cache_accepting_addr; /* Useful if we asked for port 0 */
29 char *cache_accepting_name, *cache_accepting_serv;
30 BIO_ADDR cache_peer_addr;
31 char *cache_peer_name, *cache_peer_serv;
36 static int acpt_write(BIO *h, const char *buf, int num);
37 static int acpt_read(BIO *h, char *buf, int size);
38 static int acpt_puts(BIO *h, const char *str);
39 static long acpt_ctrl(BIO *h, int cmd, long arg1, void *arg2);
40 static int acpt_new(BIO *h);
41 static int acpt_free(BIO *data);
42 static int acpt_state(BIO *b, BIO_ACCEPT *c);
43 static void acpt_close_socket(BIO *data);
44 static BIO_ACCEPT *BIO_ACCEPT_new(void);
45 static void BIO_ACCEPT_free(BIO_ACCEPT *a);
47 # define ACPT_S_BEFORE 1
48 # define ACPT_S_GET_ADDR 2
49 # define ACPT_S_CREATE_SOCKET 3
50 # define ACPT_S_LISTEN 4
51 # define ACPT_S_ACCEPT 5
54 static const BIO_METHOD methods_acceptp = {
60 NULL, /* connect_gets, */
64 NULL, /* connect_callback_ctrl */
67 const BIO_METHOD *BIO_s_accept(void)
69 return (&methods_acceptp);
72 static int acpt_new(BIO *bi)
77 bi->num = (int)INVALID_SOCKET;
79 if ((ba = BIO_ACCEPT_new()) == NULL)
82 ba->state = ACPT_S_BEFORE;
87 static BIO_ACCEPT *BIO_ACCEPT_new(void)
91 if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
93 ret->accept_family = BIO_FAMILY_IPANY;
94 ret->accept_sock = (int)INVALID_SOCKET;
98 static void BIO_ACCEPT_free(BIO_ACCEPT *a)
103 OPENSSL_free(a->param_addr);
104 OPENSSL_free(a->param_serv);
105 BIO_ADDRINFO_free(a->addr_first);
106 OPENSSL_free(a->cache_accepting_name);
107 OPENSSL_free(a->cache_accepting_serv);
108 OPENSSL_free(a->cache_peer_name);
109 OPENSSL_free(a->cache_peer_serv);
110 BIO_free(a->bio_chain);
114 static void acpt_close_socket(BIO *bio)
118 c = (BIO_ACCEPT *)bio->ptr;
119 if (c->accept_sock != (int)INVALID_SOCKET) {
120 shutdown(c->accept_sock, 2);
121 closesocket(c->accept_sock);
122 c->accept_sock = (int)INVALID_SOCKET;
123 bio->num = (int)INVALID_SOCKET;
127 static int acpt_free(BIO *a)
133 data = (BIO_ACCEPT *)a->ptr;
136 acpt_close_socket(a);
137 BIO_ACCEPT_free(data);
145 static int acpt_state(BIO *b, BIO_ACCEPT *c)
147 BIO *bio = NULL, *dbio;
148 int s = -1, ret = -1;
153 if (c->param_addr == NULL && c->param_serv == NULL) {
154 BIOerr(BIO_F_ACPT_STATE, BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED);
155 ERR_add_error_data(4,
156 "hostname=", c->param_addr,
157 " service=", c->param_serv);
161 /* Because we're starting a new bind, any cached name and serv
162 * are now obsolete and need to be cleaned out.
163 * QUESTION: should this be done in acpt_close_socket() instead?
165 OPENSSL_free(c->cache_accepting_name);
166 c->cache_accepting_name = NULL;
167 OPENSSL_free(c->cache_accepting_serv);
168 c->cache_accepting_serv = NULL;
169 OPENSSL_free(c->cache_peer_name);
170 c->cache_peer_name = NULL;
171 OPENSSL_free(c->cache_peer_serv);
172 c->cache_peer_serv = NULL;
174 c->state = ACPT_S_GET_ADDR;
177 case ACPT_S_GET_ADDR:
179 int family = AF_UNSPEC;
180 switch (c->accept_family) {
181 case BIO_FAMILY_IPV6:
182 if (1) { /* This is a trick we use to avoid bit rot.
183 * at least the "else" part will always be
190 BIOerr(BIO_F_ACPT_STATE, BIO_R_UNAVAILABLE_IP_FAMILY);
194 case BIO_FAMILY_IPV4:
197 case BIO_FAMILY_IPANY:
201 BIOerr(BIO_F_ACPT_STATE, BIO_R_UNSUPPORTED_IP_FAMILY);
204 if (BIO_lookup(c->param_addr, c->param_serv, BIO_LOOKUP_SERVER,
205 family, SOCK_STREAM, &c->addr_first) == 0)
208 if (c->addr_first == NULL) {
209 BIOerr(BIO_F_ACPT_STATE, BIO_R_LOOKUP_RETURNED_NOTHING);
212 /* We're currently not iterating, but set this as preparation
213 * for possible future development in that regard
215 c->addr_iter = c->addr_first;
216 c->state = ACPT_S_CREATE_SOCKET;
219 case ACPT_S_CREATE_SOCKET:
220 ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
221 BIO_ADDRINFO_socktype(c->addr_iter),
222 BIO_ADDRINFO_protocol(c->addr_iter), 0);
223 if (ret == (int)INVALID_SOCKET) {
224 SYSerr(SYS_F_SOCKET, get_last_socket_error());
225 ERR_add_error_data(4,
226 "hostname=", c->param_addr,
227 " service=", c->param_serv);
228 BIOerr(BIO_F_ACPT_STATE, BIO_R_UNABLE_TO_CREATE_SOCKET);
231 c->accept_sock = ret;
233 c->state = ACPT_S_LISTEN;
238 if (!BIO_listen(c->accept_sock,
239 BIO_ADDRINFO_address(c->addr_iter),
241 BIO_closesocket(c->accept_sock);
247 union BIO_sock_info_u info;
249 info.addr = &c->cache_accepting_addr;
250 if (!BIO_sock_info(c->accept_sock, BIO_SOCK_INFO_ADDRESS,
252 BIO_closesocket(c->accept_sock);
257 c->cache_accepting_name =
258 BIO_ADDR_hostname_string(&c->cache_accepting_addr, 1);
259 c->cache_accepting_serv =
260 BIO_ADDR_service_string(&c->cache_accepting_addr, 1);
261 c->state = ACPT_S_ACCEPT;
267 if (b->next_bio != NULL) {
268 c->state = ACPT_S_OK;
271 BIO_clear_retry_flags(b);
274 OPENSSL_free(c->cache_peer_name);
275 c->cache_peer_name = NULL;
276 OPENSSL_free(c->cache_peer_serv);
277 c->cache_peer_serv = NULL;
279 s = BIO_accept_ex(c->accept_sock, &c->cache_peer_addr,
282 /* If the returned socket is invalid, this might still be
286 if (BIO_sock_should_retry(s)) {
287 BIO_set_retry_special(b);
288 b->retry_reason = BIO_RR_ACCEPT;
293 /* If it wasn't retryable, we fail */
299 bio = BIO_new_socket(s, BIO_CLOSE);
303 BIO_set_callback(bio, BIO_get_callback(b));
304 BIO_set_callback_arg(bio, BIO_get_callback_arg(b));
307 * If the accept BIO has an bio_chain, we dup it and put the new
310 if (c->bio_chain != NULL) {
311 if ((dbio = BIO_dup_chain(c->bio_chain)) == NULL)
313 if (!BIO_push(dbio, bio))
317 if (BIO_push(b, bio) == NULL)
321 BIO_ADDR_hostname_string(&c->cache_peer_addr, 1);
323 BIO_ADDR_service_string(&c->cache_peer_addr, 1);
324 c->state = ACPT_S_OK;
330 if (b->next_bio == NULL) {
331 c->state = ACPT_S_ACCEPT;
352 static int acpt_read(BIO *b, char *out, int outl)
357 BIO_clear_retry_flags(b);
358 data = (BIO_ACCEPT *)b->ptr;
360 while (b->next_bio == NULL) {
361 ret = acpt_state(b, data);
366 ret = BIO_read(b->next_bio, out, outl);
367 BIO_copy_next_retry(b);
371 static int acpt_write(BIO *b, const char *in, int inl)
376 BIO_clear_retry_flags(b);
377 data = (BIO_ACCEPT *)b->ptr;
379 while (b->next_bio == NULL) {
380 ret = acpt_state(b, data);
385 ret = BIO_write(b->next_bio, in, inl);
386 BIO_copy_next_retry(b);
390 static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)
397 data = (BIO_ACCEPT *)b->ptr;
402 data->state = ACPT_S_BEFORE;
403 acpt_close_socket(b);
404 BIO_ADDRINFO_free(data->addr_first);
405 data->addr_first = NULL;
408 case BIO_C_DO_STATE_MACHINE:
409 /* use this one to start the connection */
410 ret = (long)acpt_state(b, data);
412 case BIO_C_SET_ACCEPT:
415 char *hold_serv = data->param_serv;
416 /* We affect the hostname regardless. However, the input
417 * string might contain a host:service spec, so we must
418 * parse it, which might or might not affect the service
420 OPENSSL_free(data->param_addr);
421 data->param_addr = NULL;
422 ret = BIO_parse_hostserv(ptr,
425 BIO_PARSE_PRIO_SERV);
426 if (hold_serv != data->param_serv)
427 OPENSSL_free(hold_serv);
429 } else if (num == 1) {
430 OPENSSL_free(data->param_serv);
431 data->param_serv = BUF_strdup(ptr);
433 } else if (num == 2) {
434 data->bind_mode |= BIO_SOCK_NONBLOCK;
435 } else if (num == 3) {
436 BIO_free(data->bio_chain);
437 data->bio_chain = (BIO *)ptr;
438 } else if (num == 4) {
439 data->accept_family = *(int *)ptr;
443 data->bind_mode &= ~BIO_SOCK_NONBLOCK;
449 data->accepted_mode |= BIO_SOCK_NONBLOCK;
451 data->accepted_mode &= ~BIO_SOCK_NONBLOCK;
455 b->num = *((int *)ptr);
456 data->accept_sock = b->num;
457 data->state = ACPT_S_ACCEPT;
458 b->shutdown = (int)num;
465 *ip = data->accept_sock;
466 ret = data->accept_sock;
470 case BIO_C_GET_ACCEPT:
472 if (num == 0 && ptr != NULL) {
474 *pp = data->cache_accepting_name;
475 } else if (num == 1 && ptr != NULL) {
477 *pp = data->cache_accepting_serv;
478 } else if (num == 2 && ptr != NULL) {
480 *pp = data->cache_peer_name;
481 } else if (num == 3 && ptr != NULL) {
483 *pp = data->cache_peer_serv;
484 } else if (num == 4) {
485 switch (BIO_ADDRINFO_family(data->addr_iter)) {
488 ret = BIO_FAMILY_IPV6;
492 ret = BIO_FAMILY_IPV4;
495 ret = data->accept_family;
506 case BIO_CTRL_GET_CLOSE:
509 case BIO_CTRL_SET_CLOSE:
510 b->shutdown = (int)num;
512 case BIO_CTRL_PENDING:
513 case BIO_CTRL_WPENDING:
518 case BIO_C_SET_BIND_MODE:
519 data->bind_mode = (int)num;
521 case BIO_C_GET_BIND_MODE:
522 ret = (long)data->bind_mode;
526 if (data->param_port) EAY EAY
527 BIO_set_port(dbio,data->param_port);
528 if (data->param_hostname)
529 BIO_set_hostname(dbio,data->param_hostname);
530 BIO_set_nbio(dbio,data->nbio); */
540 static int acpt_puts(BIO *bp, const char *str)
545 ret = acpt_write(bp, str, n);
549 BIO *BIO_new_accept(const char *str)
553 ret = BIO_new(BIO_s_accept());
556 if (BIO_set_accept_name(ret, str))