VirtualBox

source: vbox/trunk/src/libs/openssl-1.1.0g/crypto/bio/bss_acpt.c@ 69890

Last change on this file since 69890 was 69890, checked in by vboxsync, 7 years ago

Added OpenSSL 1.1.0g with unneeded files removed, otherwise unmodified.
bugref:8070: src/libs maintenance
  • Property svn:eol-style set to native
File size: 15.7 KB
Line 
1/*
2 * Copyright 1995-2016 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#include "bio_lcl.h"
13
14#ifndef OPENSSL_NO_SOCK
15
16typedef struct bio_accept_st {
17 int state;
18 int accept_family;
19 int bind_mode; /* Socket mode for BIO_listen */
20 int accepted_mode; /* Socket mode for BIO_accept (set on accepted sock) */
21 char *param_addr;
22 char *param_serv;
23
24 int accept_sock;
25
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;
32
33 BIO *bio_chain;
34} BIO_ACCEPT;
35
36static int acpt_write(BIO *h, const char *buf, int num);
37static int acpt_read(BIO *h, char *buf, int size);
38static int acpt_puts(BIO *h, const char *str);
39static long acpt_ctrl(BIO *h, int cmd, long arg1, void *arg2);
40static int acpt_new(BIO *h);
41static int acpt_free(BIO *data);
42static int acpt_state(BIO *b, BIO_ACCEPT *c);
43static void acpt_close_socket(BIO *data);
44static BIO_ACCEPT *BIO_ACCEPT_new(void);
45static void BIO_ACCEPT_free(BIO_ACCEPT *a);
46
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
52# define ACPT_S_OK 6
53
54static const BIO_METHOD methods_acceptp = {
55 BIO_TYPE_ACCEPT,
56 "socket accept",
57 acpt_write,
58 acpt_read,
59 acpt_puts,
60 NULL, /* connect_gets, */
61 acpt_ctrl,
62 acpt_new,
63 acpt_free,
64 NULL,
65};
66
67const BIO_METHOD *BIO_s_accept(void)
68{
69 return (&methods_acceptp);
70}
71
72static int acpt_new(BIO *bi)
73{
74 BIO_ACCEPT *ba;
75
76 bi->init = 0;
77 bi->num = (int)INVALID_SOCKET;
78 bi->flags = 0;
79 if ((ba = BIO_ACCEPT_new()) == NULL)
80 return (0);
81 bi->ptr = (char *)ba;
82 ba->state = ACPT_S_BEFORE;
83 bi->shutdown = 1;
84 return (1);
85}
86
87static BIO_ACCEPT *BIO_ACCEPT_new(void)
88{
89 BIO_ACCEPT *ret;
90
91 if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
92 return (NULL);
93 ret->accept_family = BIO_FAMILY_IPANY;
94 ret->accept_sock = (int)INVALID_SOCKET;
95 return (ret);
96}
97
98static void BIO_ACCEPT_free(BIO_ACCEPT *a)
99{
100 if (a == NULL)
101 return;
102
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);
111 OPENSSL_free(a);
112}
113
114static void acpt_close_socket(BIO *bio)
115{
116 BIO_ACCEPT *c;
117
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;
124 }
125}
126
127static int acpt_free(BIO *a)
128{
129 BIO_ACCEPT *data;
130
131 if (a == NULL)
132 return (0);
133 data = (BIO_ACCEPT *)a->ptr;
134
135 if (a->shutdown) {
136 acpt_close_socket(a);
137 BIO_ACCEPT_free(data);
138 a->ptr = NULL;
139 a->flags = 0;
140 a->init = 0;
141 }
142 return (1);
143}
144
145static int acpt_state(BIO *b, BIO_ACCEPT *c)
146{
147 BIO *bio = NULL, *dbio;
148 int s = -1, ret = -1;
149
150 for (;;) {
151 switch (c->state) {
152 case ACPT_S_BEFORE:
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);
158 goto exit_loop;
159 }
160
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?
164 */
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;
173
174 c->state = ACPT_S_GET_ADDR;
175 break;
176
177 case ACPT_S_GET_ADDR:
178 {
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
184 * compiled.
185 */
186#ifdef AF_INET6
187 family = AF_INET6;
188 } else {
189#endif
190 BIOerr(BIO_F_ACPT_STATE, BIO_R_UNAVAILABLE_IP_FAMILY);
191 goto exit_loop;
192 }
193 break;
194 case BIO_FAMILY_IPV4:
195 family = AF_INET;
196 break;
197 case BIO_FAMILY_IPANY:
198 family = AF_UNSPEC;
199 break;
200 default:
201 BIOerr(BIO_F_ACPT_STATE, BIO_R_UNSUPPORTED_IP_FAMILY);
202 goto exit_loop;
203 }
204 if (BIO_lookup(c->param_addr, c->param_serv, BIO_LOOKUP_SERVER,
205 family, SOCK_STREAM, &c->addr_first) == 0)
206 goto exit_loop;
207 }
208 if (c->addr_first == NULL) {
209 BIOerr(BIO_F_ACPT_STATE, BIO_R_LOOKUP_RETURNED_NOTHING);
210 goto exit_loop;
211 }
212 /* We're currently not iterating, but set this as preparation
213 * for possible future development in that regard
214 */
215 c->addr_iter = c->addr_first;
216 c->state = ACPT_S_CREATE_SOCKET;
217 break;
218
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);
229 goto exit_loop;
230 }
231 c->accept_sock = ret;
232 b->num = ret;
233 c->state = ACPT_S_LISTEN;
234 break;
235
236 case ACPT_S_LISTEN:
237 {
238 if (!BIO_listen(c->accept_sock,
239 BIO_ADDRINFO_address(c->addr_iter),
240 c->bind_mode)) {
241 BIO_closesocket(c->accept_sock);
242 goto exit_loop;
243 }
244 }
245
246 {
247 union BIO_sock_info_u info;
248
249 info.addr = &c->cache_accepting_addr;
250 if (!BIO_sock_info(c->accept_sock, BIO_SOCK_INFO_ADDRESS,
251 &info)) {
252 BIO_closesocket(c->accept_sock);
253 goto exit_loop;
254 }
255 }
256
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;
262 s = -1;
263 ret = 1;
264 goto end;
265
266 case ACPT_S_ACCEPT:
267 if (b->next_bio != NULL) {
268 c->state = ACPT_S_OK;
269 break;
270 }
271 BIO_clear_retry_flags(b);
272 b->retry_reason = 0;
273
274 s = BIO_accept_ex(c->accept_sock, &c->cache_peer_addr,
275 c->accepted_mode);
276
277 /* If the returned socket is invalid, this might still be
278 * retryable
279 */
280 if (s < 0) {
281 if (BIO_sock_should_retry(s)) {
282 BIO_set_retry_special(b);
283 b->retry_reason = BIO_RR_ACCEPT;
284 goto end;
285 }
286 }
287
288 /* If it wasn't retryable, we fail */
289 if (s < 0) {
290 ret = s;
291 goto exit_loop;
292 }
293
294 bio = BIO_new_socket(s, BIO_CLOSE);
295 if (bio == NULL)
296 goto exit_loop;
297
298 BIO_set_callback(bio, BIO_get_callback(b));
299 BIO_set_callback_arg(bio, BIO_get_callback_arg(b));
300
301 /*
302 * If the accept BIO has an bio_chain, we dup it and put the new
303 * socket at the end.
304 */
305 if (c->bio_chain != NULL) {
306 if ((dbio = BIO_dup_chain(c->bio_chain)) == NULL)
307 goto exit_loop;
308 if (!BIO_push(dbio, bio))
309 goto exit_loop;
310 bio = dbio;
311 }
312 if (BIO_push(b, bio) == NULL)
313 goto exit_loop;
314
315 c->cache_peer_name =
316 BIO_ADDR_hostname_string(&c->cache_peer_addr, 1);
317 c->cache_peer_serv =
318 BIO_ADDR_service_string(&c->cache_peer_addr, 1);
319 c->state = ACPT_S_OK;
320 bio = NULL;
321 ret = 1;
322 goto end;
323
324 case ACPT_S_OK:
325 if (b->next_bio == NULL) {
326 c->state = ACPT_S_ACCEPT;
327 break;
328 }
329 ret = 1;
330 goto end;
331
332 default:
333 ret = 0;
334 goto end;
335 }
336 }
337
338 exit_loop:
339 if (bio != NULL)
340 BIO_free(bio);
341 else if (s >= 0)
342 BIO_closesocket(s);
343 end:
344 return ret;
345}
346
347static int acpt_read(BIO *b, char *out, int outl)
348{
349 int ret = 0;
350 BIO_ACCEPT *data;
351
352 BIO_clear_retry_flags(b);
353 data = (BIO_ACCEPT *)b->ptr;
354
355 while (b->next_bio == NULL) {
356 ret = acpt_state(b, data);
357 if (ret <= 0)
358 return (ret);
359 }
360
361 ret = BIO_read(b->next_bio, out, outl);
362 BIO_copy_next_retry(b);
363 return (ret);
364}
365
366static int acpt_write(BIO *b, const char *in, int inl)
367{
368 int ret;
369 BIO_ACCEPT *data;
370
371 BIO_clear_retry_flags(b);
372 data = (BIO_ACCEPT *)b->ptr;
373
374 while (b->next_bio == NULL) {
375 ret = acpt_state(b, data);
376 if (ret <= 0)
377 return (ret);
378 }
379
380 ret = BIO_write(b->next_bio, in, inl);
381 BIO_copy_next_retry(b);
382 return (ret);
383}
384
385static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)
386{
387 int *ip;
388 long ret = 1;
389 BIO_ACCEPT *data;
390 char **pp;
391
392 data = (BIO_ACCEPT *)b->ptr;
393
394 switch (cmd) {
395 case BIO_CTRL_RESET:
396 ret = 0;
397 data->state = ACPT_S_BEFORE;
398 acpt_close_socket(b);
399 BIO_ADDRINFO_free(data->addr_first);
400 data->addr_first = NULL;
401 b->flags = 0;
402 break;
403 case BIO_C_DO_STATE_MACHINE:
404 /* use this one to start the connection */
405 ret = (long)acpt_state(b, data);
406 break;
407 case BIO_C_SET_ACCEPT:
408 if (ptr != NULL) {
409 if (num == 0) {
410 char *hold_serv = data->param_serv;
411 /* We affect the hostname regardless. However, the input
412 * string might contain a host:service spec, so we must
413 * parse it, which might or might not affect the service
414 */
415 OPENSSL_free(data->param_addr);
416 data->param_addr = NULL;
417 ret = BIO_parse_hostserv(ptr,
418 &data->param_addr,
419 &data->param_serv,
420 BIO_PARSE_PRIO_SERV);
421 if (hold_serv != data->param_serv)
422 OPENSSL_free(hold_serv);
423 b->init = 1;
424 } else if (num == 1) {
425 OPENSSL_free(data->param_serv);
426 data->param_serv = BUF_strdup(ptr);
427 b->init = 1;
428 } else if (num == 2) {
429 data->bind_mode |= BIO_SOCK_NONBLOCK;
430 } else if (num == 3) {
431 BIO_free(data->bio_chain);
432 data->bio_chain = (BIO *)ptr;
433 } else if (num == 4) {
434 data->accept_family = *(int *)ptr;
435 }
436 } else {
437 if (num == 2) {
438 data->bind_mode &= ~BIO_SOCK_NONBLOCK;
439 }
440 }
441 break;
442 case BIO_C_SET_NBIO:
443 if (num != 0)
444 data->accepted_mode |= BIO_SOCK_NONBLOCK;
445 else
446 data->accepted_mode &= ~BIO_SOCK_NONBLOCK;
447 break;
448 case BIO_C_SET_FD:
449 b->init = 1;
450 b->num = *((int *)ptr);
451 data->accept_sock = b->num;
452 data->state = ACPT_S_ACCEPT;
453 b->shutdown = (int)num;
454 b->init = 1;
455 break;
456 case BIO_C_GET_FD:
457 if (b->init) {
458 ip = (int *)ptr;
459 if (ip != NULL)
460 *ip = data->accept_sock;
461 ret = data->accept_sock;
462 } else
463 ret = -1;
464 break;
465 case BIO_C_GET_ACCEPT:
466 if (b->init) {
467 if (num == 0 && ptr != NULL) {
468 pp = (char **)ptr;
469 *pp = data->cache_accepting_name;
470 } else if (num == 1 && ptr != NULL) {
471 pp = (char **)ptr;
472 *pp = data->cache_accepting_serv;
473 } else if (num == 2 && ptr != NULL) {
474 pp = (char **)ptr;
475 *pp = data->cache_peer_name;
476 } else if (num == 3 && ptr != NULL) {
477 pp = (char **)ptr;
478 *pp = data->cache_peer_serv;
479 } else if (num == 4) {
480 switch (BIO_ADDRINFO_family(data->addr_iter)) {
481#ifdef AF_INET6
482 case AF_INET6:
483 ret = BIO_FAMILY_IPV6;
484 break;
485#endif
486 case AF_INET:
487 ret = BIO_FAMILY_IPV4;
488 break;
489 case 0:
490 ret = data->accept_family;
491 break;
492 default:
493 ret = -1;
494 break;
495 }
496 } else
497 ret = -1;
498 } else
499 ret = -1;
500 break;
501 case BIO_CTRL_GET_CLOSE:
502 ret = b->shutdown;
503 break;
504 case BIO_CTRL_SET_CLOSE:
505 b->shutdown = (int)num;
506 break;
507 case BIO_CTRL_PENDING:
508 case BIO_CTRL_WPENDING:
509 ret = 0;
510 break;
511 case BIO_CTRL_FLUSH:
512 break;
513 case BIO_C_SET_BIND_MODE:
514 data->bind_mode = (int)num;
515 break;
516 case BIO_C_GET_BIND_MODE:
517 ret = (long)data->bind_mode;
518 break;
519 case BIO_CTRL_DUP:
520/*- dbio=(BIO *)ptr;
521 if (data->param_port) EAY EAY
522 BIO_set_port(dbio,data->param_port);
523 if (data->param_hostname)
524 BIO_set_hostname(dbio,data->param_hostname);
525 BIO_set_nbio(dbio,data->nbio); */
526 break;
527
528 default:
529 ret = 0;
530 break;
531 }
532 return (ret);
533}
534
535static int acpt_puts(BIO *bp, const char *str)
536{
537 int n, ret;
538
539 n = strlen(str);
540 ret = acpt_write(bp, str, n);
541 return (ret);
542}
543
544BIO *BIO_new_accept(const char *str)
545{
546 BIO *ret;
547
548 ret = BIO_new(BIO_s_accept());
549 if (ret == NULL)
550 return (NULL);
551 if (BIO_set_accept_name(ret, str))
552 return (ret);
553 BIO_free(ret);
554 return (NULL);
555}
556
557#endif
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette