crypto/bio/bss_conn.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   4  * This package is an SSL implementation written
   5  * by Eric Young (eay@cryptsoft.com).
   6  * The implementation was written so as to conform with Netscapes SSL.
   7  *
   8  * This library is free for commercial and non-commercial use as long as
   9  * the following conditions are aheared to.  The following conditions
  10  * apply to all code found in this distribution, be it the RC4, RSA,
  11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  12  * included with this distribution is covered by the same copyright terms
  13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.
  17  * If this package is used in a product, Eric Young should be given attribution
  18  * as the author of the parts of the library used.
  19  * This can be in the form of a textual message at program startup or
  20  * in documentation (online or textual) provided with the package.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *    "This product includes cryptographic software written by
  33  *     Eric Young (eay@cryptsoft.com)"
  34  *    The word 'cryptographic' can be left out if the rouines from the library
  35  *    being used are not cryptographic related :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  * The licence and distribution terms for any publically available version or
  53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  54  * copied and put under another distribution licence
  55  * [including the GNU Public Licence.]
  56  */
  57
  58 #include <stdio.h>
  59 #include <errno.h>
  60
  61 #include "bio_lcl.h"
  62
  63 #ifndef OPENSSL_NO_SOCK
  64
  65 typedef struct bio_connect_st {
  66     int state;
  67     int connect_family;
  68     char *param_hostname;
  69     char *param_service;
  70     int connect_mode;
  71
  72     BIO_ADDRINFO *addr_first;
  73     const BIO_ADDRINFO *addr_iter;
  74     /*
  75      * int socket; this will be kept in bio->num so that it is compatible
  76      * with the bss_sock bio
  77      */
  78     /*
  79      * called when the connection is initially made callback(BIO,state,ret);
  80      * The callback should return 'ret'.  state is for compatibility with the
  81      * ssl info_callback
  82      */
  83     int (*info_callback) (const BIO *bio, int state, int ret);
  84 } BIO_CONNECT;
  85
  86 static int conn_write(BIO *h, const char *buf, int num);
  87 static int conn_read(BIO *h, char *buf, int size);
  88 static int conn_puts(BIO *h, const char *str);
  89 static long conn_ctrl(BIO *h, int cmd, long arg1, void *arg2);
  90 static int conn_new(BIO *h);
  91 static int conn_free(BIO *data);
  92 static long conn_callback_ctrl(BIO *h, int cmd, bio_info_cb *);
  93
  94 static int conn_state(BIO *b, BIO_CONNECT *c);
  95 static void conn_close_socket(BIO *data);
  96 BIO_CONNECT *BIO_CONNECT_new(void);
  97 void BIO_CONNECT_free(BIO_CONNECT *a);
  98
  99 #define BIO_CONN_S_BEFORE                1
 100 #define BIO_CONN_S_GET_ADDR              2
 101 #define BIO_CONN_S_CREATE_SOCKET         3
 102 #define BIO_CONN_S_CONNECT               4
 103 #define BIO_CONN_S_OK                    5
 104 #define BIO_CONN_S_BLOCKED_CONNECT       6
 105
 106 static const BIO_METHOD methods_connectp = {
 107     BIO_TYPE_CONNECT,
 108     "socket connect",
 109     conn_write,
 110     conn_read,
 111     conn_puts,
 112     NULL,                       /* connect_gets, */
 113     conn_ctrl,
 114     conn_new,
 115     conn_free,
 116     conn_callback_ctrl,
 117 };
 118
 119 static int conn_state(BIO *b, BIO_CONNECT *c)
 120 {
 121     int ret = -1, i;
 122     int (*cb) (const BIO *, int, int) = NULL;
 123
 124     if (c->info_callback != NULL)
 125         cb = c->info_callback;
 126
 127     for (;;) {
 128         switch (c->state) {
 129         case BIO_CONN_S_BEFORE:
 130             if (c->param_hostname == NULL && c->param_service == NULL) {
 131                 BIOerr(BIO_F_CONN_STATE, BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED);
 132                 ERR_add_error_data(4,
 133                                    "hostname=", c->param_hostname,
 134                                    " service=", c->param_service);
 135                 goto exit_loop;
 136             }
 137             c->state = BIO_CONN_S_GET_ADDR;
 138             break;
 139
 140         case BIO_CONN_S_GET_ADDR:
 141             {
 142                 int family = AF_UNSPEC;
 143                 switch (c->connect_family) {
 144                 case BIO_FAMILY_IPV6:
 145                     if (1) { /* This is a trick we use to avoid bit rot.
 146                               * at least the "else" part will always be
 147                               * compiled.
 148                               */
 149 #ifdef AF_INET6
 150                         family = AF_INET6;
 151                     } else {
 152 #endif
 153                         BIOerr(BIO_F_CONN_STATE, BIO_R_UNAVAILABLE_IP_FAMILY);
 154                         goto exit_loop;
 155                     }
 156                     break;
 157                 case BIO_FAMILY_IPV4:
 158                     family = AF_INET;
 159                     break;
 160                 case BIO_FAMILY_IPANY:
 161                     family = AF_UNSPEC;
 162                     break;
 163                 default:
 164                     BIOerr(BIO_F_CONN_STATE, BIO_R_UNSUPPORTED_IP_FAMILY);
 165                     goto exit_loop;
 166                 }
 167                 if (BIO_lookup(c->param_hostname, c->param_service,
 168                                BIO_LOOKUP_CLIENT,
 169                                family, SOCK_STREAM, &c->addr_first) == 0)
 170                     goto exit_loop;
 171             }
 172             if (c->addr_first == NULL) {
 173                 BIOerr(BIO_F_CONN_STATE, BIO_R_LOOKUP_RETURNED_NOTHING);
 174                 goto exit_loop;
 175             }
 176             c->addr_iter = c->addr_first;
 177             c->state = BIO_CONN_S_CREATE_SOCKET;
 178             break;
 179
 180         case BIO_CONN_S_CREATE_SOCKET:
 181             ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
 182                              BIO_ADDRINFO_socktype(c->addr_iter),
 183                              BIO_ADDRINFO_protocol(c->addr_iter), 0);
 184             if (ret == (int)INVALID_SOCKET) {
 185                 SYSerr(SYS_F_SOCKET, get_last_socket_error());
 186                 ERR_add_error_data(4,
 187                                    "hostname=", c->param_hostname,
 188                                    " service=", c->param_service);
 189                 BIOerr(BIO_F_CONN_STATE, BIO_R_UNABLE_TO_CREATE_SOCKET);
 190                 goto exit_loop;
 191             }
 192             b->num = ret;
 193             c->state = BIO_CONN_S_CONNECT;
 194             break;
 195
 196         case BIO_CONN_S_CONNECT:
 197             BIO_clear_retry_flags(b);
 198             ret = BIO_connect(b->num, BIO_ADDRINFO_address(c->addr_iter),
 199                               BIO_SOCK_KEEPALIVE | c->connect_mode);
 200             b->retry_reason = 0;
 201             if (ret < 0) {
 202                 if (BIO_sock_should_retry(ret)) {
 203                     BIO_set_retry_special(b);
 204                     c->state = BIO_CONN_S_BLOCKED_CONNECT;
 205                     b->retry_reason = BIO_RR_CONNECT;
 206                     ERR_clear_error();
 207                 } else if ((c->addr_iter = BIO_ADDRINFO_next(c->addr_iter))
 208                            != NULL) {
 209                     /*
 210                      * if there are more addresses to try, do that first
 211                      */
 212                     BIO_closesocket(b->num);
 213                     c->state = BIO_CONN_S_CREATE_SOCKET;
 214                     ERR_clear_error();
 215                     break;
 216                 } else {
 217                     SYSerr(SYS_F_CONNECT, get_last_socket_error());
 218                     ERR_add_error_data(4,
 219                                        "hostname=", c->param_hostname,
 220                                        " service=", c->param_service);
 221                     BIOerr(BIO_F_CONN_STATE, BIO_R_CONNECT_ERROR);
 222                 }
 223                 goto exit_loop;
 224             } else {
 225                 c->state = BIO_CONN_S_OK;
 226             }
 227             break;
 228
 229         case BIO_CONN_S_BLOCKED_CONNECT:
 230             i = BIO_sock_error(b->num);
 231             if (i) {
 232                 BIO_clear_retry_flags(b);
 233                 SYSerr(SYS_F_CONNECT, i);
 234                 ERR_add_error_data(4,
 235                                    "hostname=", c->param_hostname,
 236                                    " service=", c->param_service);
 237                 BIOerr(BIO_F_CONN_STATE, BIO_R_NBIO_CONNECT_ERROR);
 238                 ret = 0;
 239                 goto exit_loop;
 240             } else
 241                 c->state = BIO_CONN_S_OK;
 242             break;
 243
 244         case BIO_CONN_S_OK:
 245             ret = 1;
 246             goto exit_loop;
 247         default:
 248             /* abort(); */
 249             goto exit_loop;
 250         }
 251
 252         if (cb != NULL) {
 253             if ((ret = cb((BIO *)b, c->state, ret)) == 0)
 254                 goto end;
 255         }
 256     }
 257
 258     /* Loop does not exit */
 259  exit_loop:
 260     if (cb != NULL)
 261         ret = cb((BIO *)b, c->state, ret);
 262  end:
 263     return (ret);
 264 }
 265
 266 BIO_CONNECT *BIO_CONNECT_new(void)
 267 {
 268     BIO_CONNECT *ret;
 269
 270     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
 271         return (NULL);
 272     ret->state = BIO_CONN_S_BEFORE;
 273     ret->connect_family = BIO_FAMILY_IPANY;
 274     return (ret);
 275 }
 276
 277 void BIO_CONNECT_free(BIO_CONNECT *a)
 278 {
 279     if (a == NULL)
 280         return;
 281
 282     OPENSSL_free(a->param_hostname);
 283     OPENSSL_free(a->param_service);
 284     BIO_ADDRINFO_free(a->addr_first);
 285     OPENSSL_free(a);
 286 }
 287
 288 const BIO_METHOD *BIO_s_connect(void)
 289 {
 290     return (&methods_connectp);
 291 }
 292
 293 static int conn_new(BIO *bi)
 294 {
 295     bi->init = 0;
 296     bi->num = (int)INVALID_SOCKET;
 297     bi->flags = 0;
 298     if ((bi->ptr = (char *)BIO_CONNECT_new()) == NULL)
 299         return (0);
 300     else
 301         return (1);
 302 }
 303
 304 static void conn_close_socket(BIO *bio)
 305 {
 306     BIO_CONNECT *c;
 307
 308     c = (BIO_CONNECT *)bio->ptr;
 309     if (bio->num != (int)INVALID_SOCKET) {
 310         /* Only do a shutdown if things were established */
 311         if (c->state == BIO_CONN_S_OK)
 312             shutdown(bio->num, 2);
 313         BIO_closesocket(bio->num);
 314         bio->num = (int)INVALID_SOCKET;
 315     }
 316 }
 317
 318 static int conn_free(BIO *a)
 319 {
 320     BIO_CONNECT *data;
 321
 322     if (a == NULL)
 323         return (0);
 324     data = (BIO_CONNECT *)a->ptr;
 325
 326     if (a->shutdown) {
 327         conn_close_socket(a);
 328         BIO_CONNECT_free(data);
 329         a->ptr = NULL;
 330         a->flags = 0;
 331         a->init = 0;
 332     }
 333     return (1);
 334 }
 335
 336 static int conn_read(BIO *b, char *out, int outl)
 337 {
 338     int ret = 0;
 339     BIO_CONNECT *data;
 340
 341     data = (BIO_CONNECT *)b->ptr;
 342     if (data->state != BIO_CONN_S_OK) {
 343         ret = conn_state(b, data);
 344         if (ret <= 0)
 345             return (ret);
 346     }
 347
 348     if (out != NULL) {
 349         clear_socket_error();
 350         ret = readsocket(b->num, out, outl);
 351         BIO_clear_retry_flags(b);
 352         if (ret <= 0) {
 353             if (BIO_sock_should_retry(ret))
 354                 BIO_set_retry_read(b);
 355         }
 356     }
 357     return (ret);
 358 }
 359
 360 static int conn_write(BIO *b, const char *in, int inl)
 361 {
 362     int ret;
 363     BIO_CONNECT *data;
 364
 365     data = (BIO_CONNECT *)b->ptr;
 366     if (data->state != BIO_CONN_S_OK) {
 367         ret = conn_state(b, data);
 368         if (ret <= 0)
 369             return (ret);
 370     }
 371
 372     clear_socket_error();
 373     ret = writesocket(b->num, in, inl);
 374     BIO_clear_retry_flags(b);
 375     if (ret <= 0) {
 376         if (BIO_sock_should_retry(ret))
 377             BIO_set_retry_write(b);
 378     }
 379     return (ret);
 380 }
 381
 382 static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
 383 {
 384     BIO *dbio;
 385     int *ip;
 386     const char **pptr = NULL;
 387     long ret = 1;
 388     BIO_CONNECT *data;
 389
 390     data = (BIO_CONNECT *)b->ptr;
 391
 392     switch (cmd) {
 393     case BIO_CTRL_RESET:
 394         ret = 0;
 395         data->state = BIO_CONN_S_BEFORE;
 396         conn_close_socket(b);
 397         BIO_ADDRINFO_free(data->addr_first);
 398         data->addr_first = NULL;
 399         b->flags = 0;
 400         break;
 401     case BIO_C_DO_STATE_MACHINE:
 402         /* use this one to start the connection */
 403         if (data->state != BIO_CONN_S_OK)
 404             ret = (long)conn_state(b, data);
 405         else
 406             ret = 1;
 407         break;
 408     case BIO_C_GET_CONNECT:
 409         if (ptr != NULL) {
 410             pptr = (const char **)ptr;
 411             if (num == 0) {
 412                 *pptr = data->param_hostname;
 413             } else if (num == 1) {
 414                 *pptr = data->param_service;
 415             } else if (num == 2) {
 416                 *pptr = (const char *)BIO_ADDRINFO_address(data->addr_iter);
 417             } else if (num == 3) {
 418                 switch (BIO_ADDRINFO_family(data->addr_iter)) {
 419 # ifdef AF_INET6
 420                 case AF_INET6:
 421                     ret = BIO_FAMILY_IPV6;
 422                     break;
 423 # endif
 424                 case AF_INET:
 425                     ret = BIO_FAMILY_IPV4;
 426                     break;
 427                 case 0:
 428                     ret = data->connect_family;
 429                     break;
 430                 default:
 431                     ret = -1;
 432                     break;
 433                 }
 434             } else {
 435                 ret = 0;
 436             }
 437         } else {
 438             ret = 0;
 439         }
 440         break;
 441     case BIO_C_SET_CONNECT:
 442         if (ptr != NULL) {
 443             b->init = 1;
 444             if (num == 0) {
 445                 char *hold_service = data->param_service;
 446                 /* We affect the hostname regardless.  However, the input
 447                  * string might contain a host:service spec, so we must
 448                  * parse it, which might or might not affect the service
 449                  */
 450                 OPENSSL_free(data->param_hostname);
 451                 data->param_hostname = NULL;
 452                 ret = BIO_parse_hostserv(ptr,
 453                                          &data->param_hostname,
 454                                          &data->param_service,
 455                                          BIO_PARSE_PRIO_HOST);
 456                 if (hold_service != data->param_service)
 457                     OPENSSL_free(hold_service);
 458             } else if (num == 1) {
 459                 OPENSSL_free(data->param_service);
 460                 data->param_service = BUF_strdup(ptr);
 461             } else if (num == 2) {
 462                 const BIO_ADDR *addr = (const BIO_ADDR *)ptr;
 463                 if (ret) {
 464                     data->param_hostname = BIO_ADDR_hostname_string(addr, 1);
 465                     data->param_service = BIO_ADDR_service_string(addr, 1);
 466                     BIO_ADDRINFO_free(data->addr_first);
 467                     data->addr_first = NULL;
 468                     data->addr_iter = NULL;
 469                 }
 470             } else if (num == 3) {
 471                 data->connect_family = *(int *)ptr;
 472             } else {
 473                 ret = 0;
 474             }
 475         }
 476         break;
 477     case BIO_C_SET_NBIO:
 478         if (num != 0)
 479             data->connect_mode |= BIO_SOCK_NONBLOCK;
 480         else
 481             data->connect_mode &= ~BIO_SOCK_NONBLOCK;
 482         break;
 483     case BIO_C_SET_CONNECT_MODE:
 484         data->connect_mode = (int)num;
 485         break;
 486     case BIO_C_GET_FD:
 487         if (b->init) {
 488             ip = (int *)ptr;
 489             if (ip != NULL)
 490                 *ip = b->num;
 491             ret = b->num;
 492         } else
 493             ret = -1;
 494         break;
 495     case BIO_CTRL_GET_CLOSE:
 496         ret = b->shutdown;
 497         break;
 498     case BIO_CTRL_SET_CLOSE:
 499         b->shutdown = (int)num;
 500         break;
 501     case BIO_CTRL_PENDING:
 502     case BIO_CTRL_WPENDING:
 503         ret = 0;
 504         break;
 505     case BIO_CTRL_FLUSH:
 506         break;
 507     case BIO_CTRL_DUP:
 508         {
 509             dbio = (BIO *)ptr;
 510             if (data->param_hostname)
 511                 BIO_set_conn_hostname(dbio, data->param_hostname);
 512             if (data->param_service)
 513                 BIO_set_conn_port(dbio, data->param_service);
 514             BIO_set_conn_ip_family(dbio, data->connect_family);
 515             BIO_set_conn_mode(dbio, data->connect_mode);
 516             /*
 517              * FIXME: the cast of the function seems unlikely to be a good
 518              * idea
 519              */
 520             (void)BIO_set_info_callback(dbio,
 521                                         (bio_info_cb *)data->info_callback);
 522         }
 523         break;
 524     case BIO_CTRL_SET_CALLBACK:
 525         {
 526 # if 0                          /* FIXME: Should this be used? -- Richard
 527                                  * Levitte */
 528             BIOerr(BIO_F_CONN_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 529             ret = -1;
 530 # else
 531             ret = 0;
 532 # endif
 533         }
 534         break;
 535     case BIO_CTRL_GET_CALLBACK:
 536         {
 537             int (**fptr) (const BIO *bio, int state, int xret);
 538
 539             fptr = (int (**)(const BIO *bio, int state, int xret))ptr;
 540             *fptr = data->info_callback;
 541         }
 542         break;
 543     default:
 544         ret = 0;
 545         break;
 546     }
 547     return (ret);
 548 }
 549
 550 static long conn_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
 551 {
 552     long ret = 1;
 553     BIO_CONNECT *data;
 554
 555     data = (BIO_CONNECT *)b->ptr;
 556
 557     switch (cmd) {
 558     case BIO_CTRL_SET_CALLBACK:
 559         {
 560             data->info_callback =
 561                 (int (*)(const struct bio_st *, int, int))fp;
 562         }
 563         break;
 564     default:
 565         ret = 0;
 566         break;
 567     }
 568     return (ret);
 569 }
 570
 571 static int conn_puts(BIO *bp, const char *str)
 572 {
 573     int n, ret;
 574
 575     n = strlen(str);
 576     ret = conn_write(bp, str, n);
 577     return (ret);
 578 }
 579
 580 BIO *BIO_new_connect(const char *str)
 581 {
 582     BIO *ret;
 583
 584     ret = BIO_new(BIO_s_connect());
 585     if (ret == NULL)
 586         return (NULL);
 587     if (BIO_set_conn_hostname(ret, str))
 588         return (ret);
 589     BIO_free(ret);
 590     return (NULL);
 591 }
 592
 593 #endif