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