VirtualBox

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