res/pjproject/pjlib/src/pj/ssl_sock_ossl.c

   1 /* $Id$ */
   2 /*
   3  * Copyright (C) 2009-2011 Teluu Inc. (http://www.teluu.com)
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include <pj/ssl_sock.h>
  20 #include <pj/activesock.h>
  21 #include <pj/compat/socket.h>
  22 #include <pj/assert.h>
  23 #include <pj/errno.h>
  24 #include <pj/list.h>
  25 #include <pj/lock.h>
  26 #include <pj/log.h>
  27 #include <pj/math.h>
  28 #include <pj/os.h>
  29 #include <pj/pool.h>
  30 #include <pj/string.h>
  31 #include <pj/timer.h>
  32
  33
  34 /* Only build when PJ_HAS_SSL_SOCK is enabled */
  35 #if defined(PJ_HAS_SSL_SOCK) && PJ_HAS_SSL_SOCK!=0
  36
  37 #define THIS_FILE               "ssl_sock_ossl.c"
  38
  39 /* Workaround for ticket #985 */
  40 #define DELAYED_CLOSE_TIMEOUT   200
  41
  42 /* Maximum ciphers */
  43 #define MAX_CIPHERS             100
  44
  45 /*
  46  * Include OpenSSL headers
  47  */
  48 #include <openssl/bio.h>
  49 #include <openssl/ssl.h>
  50 #include <openssl/err.h>
  51 #include <openssl/x509v3.h>
  52
  53
  54 #ifdef _MSC_VER
  55 # ifdef _DEBUG
  56 #  pragma comment( lib, "libeay32MTd")
  57 #  pragma comment( lib, "ssleay32MTd")
  58 #else
  59 #  pragma comment( lib, "libeay32MT")
  60 #  pragma comment( lib, "ssleay32MT")
  61 # endif
  62 #endif
  63
  64
  65 /*
  66  * SSL/TLS state enumeration.
  67  */
  68 enum ssl_state {
  69     SSL_STATE_NULL,
  70     SSL_STATE_HANDSHAKING,
  71     SSL_STATE_ESTABLISHED
  72 };
  73
  74 /*
  75  * Internal timer types.
  76  */
  77 enum timer_id
  78 {
  79     TIMER_NONE,
  80     TIMER_HANDSHAKE_TIMEOUT,
  81     TIMER_CLOSE
  82 };
  83
  84 /*
  85  * Structure of SSL socket read buffer.
  86  */
  87 typedef struct read_data_t
  88 {
  89     void                 *data;
  90     pj_size_t             len;
  91 } read_data_t;
  92
  93 /*
  94  * Get the offset of pointer to read-buffer of SSL socket from read-buffer
  95  * of active socket. Note that both SSL socket and active socket employ
  96  * different but correlated read-buffers (as much as async_cnt for each),
  97  * and to make it easier/faster to find corresponding SSL socket's read-buffer
  98  * from known active socket's read-buffer, the pointer of corresponding
  99  * SSL socket's read-buffer is stored right after the end of active socket's
 100  * read-buffer.
 101  */
 102 #define OFFSET_OF_READ_DATA_PTR(ssock, asock_rbuf) \
 103                                         (read_data_t**) \
 104                                         ((pj_int8_t*)(asock_rbuf) + \
 105                                         ssock->param.read_buffer_size)
 106
 107 /*
 108  * Structure of SSL socket write buffer.
 109  */
 110 typedef struct write_data_t {
 111     pj_ioqueue_op_key_t  key;
 112     pj_size_t            record_len;
 113     pj_ioqueue_op_key_t *app_key;
 114     pj_size_t            plain_data_len;
 115     pj_size_t            data_len;
 116     unsigned             flags;
 117     union {
 118         char             content[1];
 119         const char      *ptr;
 120     } data;
 121 } write_data_t;
 122
 123 /*
 124  * Structure of SSL socket write state.
 125  */
 126 typedef struct write_state_t {
 127     char                *buf;
 128     pj_size_t            max_len;
 129     char                *start;
 130     pj_size_t            len;
 131     write_data_t        *last_data;
 132 } write_state_t;
 133
 134 /*
 135  * Structure of write data pending.
 136  */
 137 typedef struct write_pending_t {
 138     PJ_DECL_LIST_MEMBER(struct write_pending_t);
 139     write_data_t         data;
 140 } write_pending_t;
 141
 142 /*
 143  * Secure socket structure definition.
 144  */
 145 struct pj_ssl_sock_t
 146 {
 147     pj_pool_t            *pool;
 148     pj_ssl_sock_t        *parent;
 149     pj_ssl_sock_param     param;
 150     pj_ssl_cert_t        *cert;
 151
 152     pj_ssl_cert_info      local_cert_info;
 153     pj_ssl_cert_info      remote_cert_info;
 154
 155     pj_bool_t             is_server;
 156     enum ssl_state        ssl_state;
 157     pj_ioqueue_op_key_t   handshake_op_key;
 158     pj_timer_entry        timer;
 159     pj_status_t           verify_status;
 160
 161     pj_sock_t             sock;
 162     pj_activesock_t      *asock;
 163
 164     pj_sockaddr           local_addr;
 165     pj_sockaddr           rem_addr;
 166     int                   addr_len;
 167
 168     pj_bool_t             read_started;
 169     pj_size_t             read_size;
 170     pj_uint32_t           read_flags;
 171     void                **asock_rbuf;
 172     read_data_t          *ssock_rbuf;
 173
 174     write_state_t         write_state;
 175     write_pending_t       write_pending;
 176     write_pending_t       write_pending_empty;
 177     pj_lock_t            *write_mutex; /* protect write BIO and write_state */
 178
 179     SSL_CTX              *ossl_ctx;
 180     SSL                  *ossl_ssl;
 181     BIO                  *ossl_rbio;
 182     BIO                  *ossl_wbio;
 183 };
 184
 185
 186 /*
 187  * Certificate/credential structure definition.
 188  */
 189 struct pj_ssl_cert_t
 190 {
 191     pj_str_t CA_file;
 192     pj_str_t cert_file;
 193     pj_str_t privkey_file;
 194     pj_str_t privkey_pass;
 195 };
 196
 197
 198 static pj_status_t flush_delayed_send(pj_ssl_sock_t *ssock);
 199
 200 /*
 201  *******************************************************************
 202  * Static/internal functions.
 203  *******************************************************************
 204  */
 205
 206 /**
 207  * Mapping from OpenSSL error codes to pjlib error space.
 208  */
 209
 210 #define PJ_SSL_ERRNO_START              (PJ_ERRNO_START_USER + \
 211                                          PJ_ERRNO_SPACE_SIZE*6)
 212
 213 #define PJ_SSL_ERRNO_SPACE_SIZE         PJ_ERRNO_SPACE_SIZE
 214
 215 #define STATUS_FROM_SSL_ERR(err, status) { \
 216     status = ERR_GET_LIB(err)*300 + ERR_GET_REASON(err);\
 217     pj_assert(status < PJ_SSL_ERRNO_SPACE_SIZE);\
 218     if (status) status += PJ_SSL_ERRNO_START;\
 219 }
 220
 221 #define GET_SSL_STATUS(status) { \
 222     unsigned long e = ERR_get_error();\
 223     STATUS_FROM_SSL_ERR(e, status);\
 224 }
 225
 226 /*
 227  * Get error string of OpenSSL.
 228  */
 229 static pj_str_t ssl_strerror(pj_status_t status,
 230                              char *buf, pj_size_t bufsize)
 231 {
 232     pj_str_t errstr;
 233     unsigned long ssl_err = status;
 234
 235     if (ssl_err) {
 236         unsigned long l, r;
 237         ssl_err -= PJ_SSL_ERRNO_START;
 238         l = ssl_err/300;
 239         r = ssl_err%300;
 240         ssl_err = ERR_PACK(l, 0, r);
 241     }
 242
 243 #if defined(PJ_HAS_ERROR_STRING) && (PJ_HAS_ERROR_STRING != 0)
 244
 245     {
 246         const char *tmp = NULL;
 247
 248         if (ssl_err >= 300)
 249             tmp = ERR_reason_error_string(ssl_err);
 250         else
 251             tmp = X509_verify_cert_error_string(ssl_err);
 252
 253         if (tmp) {
 254             pj_ansi_strncpy(buf, tmp, bufsize);
 255             errstr = pj_str(buf);
 256             return errstr;
 257         }
 258     }
 259
 260 #endif  /* PJ_HAS_ERROR_STRING */
 261
 262     errstr.ptr = buf;
 263     errstr.slen = pj_ansi_snprintf(buf, bufsize,
 264                                    "Unknown OpenSSL error %lu",
 265                                    ssl_err);
 266
 267     return errstr;
 268 }
 269
 270
 271 /* OpenSSL library initialization counter */
 272 static int openssl_init_count;
 273
 274 /* OpenSSL available ciphers */
 275 static unsigned openssl_cipher_num;
 276 static struct openssl_ciphers_t {
 277     pj_ssl_cipher    id;
 278     const char      *name;
 279 } openssl_ciphers[MAX_CIPHERS];
 280
 281 /* OpenSSL application data index */
 282 static int sslsock_idx;
 283
 284
 285 /* Initialize OpenSSL */
 286 static pj_status_t init_openssl(void)
 287 {
 288     pj_status_t status;
 289
 290     if (openssl_init_count)
 291         return PJ_SUCCESS;
 292
 293     openssl_init_count = 1;
 294
 295     /* Register error subsystem */
 296     status = pj_register_strerror(PJ_SSL_ERRNO_START,
 297                                   PJ_SSL_ERRNO_SPACE_SIZE,
 298                                   &ssl_strerror);
 299     pj_assert(status == PJ_SUCCESS);
 300
 301     /* Init OpenSSL lib */
 302     SSL_library_init();
 303     SSL_load_error_strings();
 304     OpenSSL_add_all_algorithms();
 305
 306     /* Init available ciphers */
 307     if (openssl_cipher_num == 0) {
 308         SSL_METHOD *meth = NULL;
 309         SSL_CTX *ctx;
 310         SSL *ssl;
 311         STACK_OF(SSL_CIPHER) *sk_cipher;
 312         unsigned i, n;
 313
 314         meth = (SSL_METHOD*)SSLv23_server_method();
 315         if (!meth)
 316             meth = (SSL_METHOD*)TLSv1_server_method();
 317         if (!meth)
 318             meth = (SSL_METHOD*)SSLv3_server_method();
 319 #ifndef OPENSSL_NO_SSL2
 320         if (!meth)
 321             meth = (SSL_METHOD*)SSLv2_server_method();
 322 #endif
 323         pj_assert(meth);
 324
 325         ctx=SSL_CTX_new(meth);
 326         SSL_CTX_set_cipher_list(ctx, "ALL");
 327
 328         ssl = SSL_new(ctx);
 329         sk_cipher = SSL_get_ciphers(ssl);
 330
 331         n = sk_SSL_CIPHER_num(sk_cipher);
 332         if (n > PJ_ARRAY_SIZE(openssl_ciphers))
 333             n = PJ_ARRAY_SIZE(openssl_ciphers);
 334
 335         for (i = 0; i < n; ++i) {
 336             SSL_CIPHER *c;
 337             c = sk_SSL_CIPHER_value(sk_cipher,i);
 338             openssl_ciphers[i].id = (pj_ssl_cipher)
 339                                     (pj_uint32_t)c->id & 0x00FFFFFF;
 340             openssl_ciphers[i].name = SSL_CIPHER_get_name(c);
 341         }
 342
 343         SSL_free(ssl);
 344         SSL_CTX_free(ctx);
 345
 346         openssl_cipher_num = n;
 347     }
 348
 349     /* Create OpenSSL application data index for SSL socket */
 350     sslsock_idx = SSL_get_ex_new_index(0, "SSL socket", NULL, NULL, NULL);
 351
 352     return PJ_SUCCESS;
 353 }
 354
 355
 356 /* Shutdown OpenSSL */
 357 static void shutdown_openssl(void)
 358 {
 359     PJ_UNUSED_ARG(openssl_init_count);
 360 }
 361
 362
 363 /* SSL password callback. */
 364 static int password_cb(char *buf, int num, int rwflag, void *user_data)
 365 {
 366     pj_ssl_cert_t *cert = (pj_ssl_cert_t*) user_data;
 367
 368     PJ_UNUSED_ARG(rwflag);
 369
 370     if(num < cert->privkey_pass.slen)
 371         return 0;
 372
 373     pj_memcpy(buf, cert->privkey_pass.ptr, cert->privkey_pass.slen);
 374     return cert->privkey_pass.slen;
 375 }
 376
 377
 378 /* SSL password callback. */
 379 static int verify_cb(int preverify_ok, X509_STORE_CTX *x509_ctx)
 380 {
 381     pj_ssl_sock_t *ssock;
 382     SSL *ossl_ssl;
 383     int err;
 384
 385     /* Get SSL instance */
 386     ossl_ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
 387                                     SSL_get_ex_data_X509_STORE_CTX_idx());
 388     pj_assert(ossl_ssl);
 389
 390     /* Get SSL socket instance */
 391     ssock = SSL_get_ex_data(ossl_ssl, sslsock_idx);
 392     pj_assert(ssock);
 393
 394     /* Store verification status */
 395     err = X509_STORE_CTX_get_error(x509_ctx);
 396     switch (err) {
 397     case X509_V_OK:
 398         break;
 399
 400     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
 401         ssock->verify_status |= PJ_SSL_CERT_EISSUER_NOT_FOUND;
 402         break;
 403
 404     case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
 405     case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
 406     case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
 407     case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
 408         ssock->verify_status |= PJ_SSL_CERT_EINVALID_FORMAT;
 409         break;
 410
 411     case X509_V_ERR_CERT_NOT_YET_VALID:
 412     case X509_V_ERR_CERT_HAS_EXPIRED:
 413         ssock->verify_status |= PJ_SSL_CERT_EVALIDITY_PERIOD;
 414         break;
 415
 416     case X509_V_ERR_UNABLE_TO_GET_CRL:
 417     case X509_V_ERR_CRL_NOT_YET_VALID:
 418     case X509_V_ERR_CRL_HAS_EXPIRED:
 419     case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
 420     case X509_V_ERR_CRL_SIGNATURE_FAILURE:
 421     case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
 422     case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
 423         ssock->verify_status |= PJ_SSL_CERT_ECRL_FAILURE;
 424         break;
 425
 426     case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
 427     case X509_V_ERR_CERT_UNTRUSTED:
 428     case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
 429     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
 430         ssock->verify_status |= PJ_SSL_CERT_EUNTRUSTED;
 431         break;
 432
 433     case X509_V_ERR_CERT_SIGNATURE_FAILURE:
 434     case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
 435     case X509_V_ERR_SUBJECT_ISSUER_MISMATCH:
 436     case X509_V_ERR_AKID_SKID_MISMATCH:
 437     case X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH:
 438     case X509_V_ERR_KEYUSAGE_NO_CERTSIGN:
 439         ssock->verify_status |= PJ_SSL_CERT_EISSUER_MISMATCH;
 440         break;
 441
 442     case X509_V_ERR_CERT_REVOKED:
 443         ssock->verify_status |= PJ_SSL_CERT_EREVOKED;
 444         break;
 445
 446     case X509_V_ERR_INVALID_PURPOSE:
 447     case X509_V_ERR_CERT_REJECTED:
 448     case X509_V_ERR_INVALID_CA:
 449         ssock->verify_status |= PJ_SSL_CERT_EINVALID_PURPOSE;
 450         break;
 451
 452     case X509_V_ERR_CERT_CHAIN_TOO_LONG: /* not really used */
 453     case X509_V_ERR_PATH_LENGTH_EXCEEDED:
 454         ssock->verify_status |= PJ_SSL_CERT_ECHAIN_TOO_LONG;
 455         break;
 456
 457     /* Unknown errors */
 458     case X509_V_ERR_OUT_OF_MEM:
 459     default:
 460         ssock->verify_status |= PJ_SSL_CERT_EUNKNOWN;
 461         break;
 462     }
 463
 464     /* When verification is not requested just return ok here, however
 465      * application can still get the verification status.
 466      */
 467     if (PJ_FALSE == ssock->param.verify_peer)
 468         preverify_ok = 1;
 469
 470     return preverify_ok;
 471 }
 472
 473 /* Setting SSL sock cipher list */
 474 static pj_status_t set_cipher_list(pj_ssl_sock_t *ssock);
 475
 476
 477 /* Create and initialize new SSL context and instance */
 478 static pj_status_t create_ssl(pj_ssl_sock_t *ssock)
 479 {
 480     SSL_METHOD *ssl_method;
 481     SSL_CTX *ctx;
 482     pj_ssl_cert_t *cert;
 483     int mode, rc;
 484     pj_status_t status;
 485
 486     pj_assert(ssock);
 487
 488     cert = ssock->cert;
 489
 490     /* Make sure OpenSSL library has been initialized */
 491     init_openssl();
 492
 493     /* Determine SSL method to use */
 494     switch (ssock->param.proto) {
 495     case PJ_SSL_SOCK_PROTO_DEFAULT:
 496     case PJ_SSL_SOCK_PROTO_TLS1:
 497         ssl_method = (SSL_METHOD*)TLSv1_method();
 498         break;
 499 #ifndef OPENSSL_NO_SSL2
 500     case PJ_SSL_SOCK_PROTO_SSL2:
 501         ssl_method = (SSL_METHOD*)SSLv2_method();
 502         break;
 503 #endif
 504     case PJ_SSL_SOCK_PROTO_SSL3:
 505         ssl_method = (SSL_METHOD*)SSLv3_method();
 506         break;
 507     case PJ_SSL_SOCK_PROTO_SSL23:
 508         ssl_method = (SSL_METHOD*)SSLv23_method();
 509         break;
 510     //case PJ_SSL_SOCK_PROTO_DTLS1:
 511         //ssl_method = (SSL_METHOD*)DTLSv1_method();
 512         //break;
 513     default:
 514         return PJ_EINVAL;
 515     }
 516
 517     /* Create SSL context */
 518     ctx = SSL_CTX_new(ssl_method);
 519     if (ctx == NULL) {
 520         GET_SSL_STATUS(status);
 521         return status;
 522     }
 523
 524     /* Apply credentials */
 525     if (cert) {
 526         /* Load CA list if one is specified. */
 527         if (cert->CA_file.slen) {
 528
 529             rc = SSL_CTX_load_verify_locations(ctx, cert->CA_file.ptr, NULL);
 530
 531             if (rc != 1) {
 532                 GET_SSL_STATUS(status);
 533                 PJ_LOG(1,(ssock->pool->obj_name, "Error loading CA list file "
 534                           "'%s'", cert->CA_file.ptr));
 535                 SSL_CTX_free(ctx);
 536                 return status;
 537             }
 538         }
 539
 540         /* Set password callback */
 541         if (cert->privkey_pass.slen) {
 542             SSL_CTX_set_default_passwd_cb(ctx, password_cb);
 543             SSL_CTX_set_default_passwd_cb_userdata(ctx, cert);
 544         }
 545
 546
 547         /* Load certificate if one is specified */
 548         if (cert->cert_file.slen) {
 549
 550             /* Load certificate chain from file into ctx */
 551             rc = SSL_CTX_use_certificate_chain_file(ctx, cert->cert_file.ptr);
 552
 553             if(rc != 1) {
 554                 GET_SSL_STATUS(status);
 555                 PJ_LOG(1,(ssock->pool->obj_name, "Error loading certificate "
 556                           "chain file '%s'", cert->cert_file.ptr));
 557                 SSL_CTX_free(ctx);
 558                 return status;
 559             }
 560         }
 561
 562
 563         /* Load private key if one is specified */
 564         if (cert->privkey_file.slen) {
 565             /* Adds the first private key found in file to ctx */
 566             rc = SSL_CTX_use_PrivateKey_file(ctx, cert->privkey_file.ptr,
 567                                              SSL_FILETYPE_PEM);
 568
 569             if(rc != 1) {
 570                 GET_SSL_STATUS(status);
 571                 PJ_LOG(1,(ssock->pool->obj_name, "Error adding private key "
 572                           "from '%s'", cert->privkey_file.ptr));
 573                 SSL_CTX_free(ctx);
 574                 return status;
 575             }
 576         }
 577     }
 578
 579     /* Create SSL instance */
 580     ssock->ossl_ctx = ctx;
 581     ssock->ossl_ssl = SSL_new(ssock->ossl_ctx);
 582     if (ssock->ossl_ssl == NULL) {
 583         GET_SSL_STATUS(status);
 584         return status;
 585     }
 586
 587     /* Set SSL sock as application data of SSL instance */
 588     SSL_set_ex_data(ssock->ossl_ssl, sslsock_idx, ssock);
 589
 590     /* SSL verification options */
 591     mode = SSL_VERIFY_PEER;
 592     if (ssock->is_server && ssock->param.require_client_cert)
 593         mode |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
 594
 595     SSL_set_verify(ssock->ossl_ssl, mode, &verify_cb);
 596
 597     /* Set cipher list */
 598     status = set_cipher_list(ssock);
 599     if (status != PJ_SUCCESS)
 600         return status;
 601
 602     /* Setup SSL BIOs */
 603     ssock->ossl_rbio = BIO_new(BIO_s_mem());
 604     ssock->ossl_wbio = BIO_new(BIO_s_mem());
 605     (void)BIO_set_close(ssock->ossl_rbio, BIO_CLOSE);
 606     (void)BIO_set_close(ssock->ossl_wbio, BIO_CLOSE);
 607     SSL_set_bio(ssock->ossl_ssl, ssock->ossl_rbio, ssock->ossl_wbio);
 608
 609     return PJ_SUCCESS;
 610 }
 611
 612
 613 /* Destroy SSL context and instance */
 614 static void destroy_ssl(pj_ssl_sock_t *ssock)
 615 {
 616     /* Destroy SSL instance */
 617     if (ssock->ossl_ssl) {
 618         SSL_shutdown(ssock->ossl_ssl);
 619         SSL_free(ssock->ossl_ssl); /* this will also close BIOs */
 620         ssock->ossl_ssl = NULL;
 621     }
 622
 623     /* Destroy SSL context */
 624     if (ssock->ossl_ctx) {
 625         SSL_CTX_free(ssock->ossl_ctx);
 626         ssock->ossl_ctx = NULL;
 627     }
 628
 629     /* Potentially shutdown OpenSSL library if this is the last
 630      * context exists.
 631      */
 632     shutdown_openssl();
 633 }
 634
 635
 636 /* Reset SSL socket state */
 637 static void reset_ssl_sock_state(pj_ssl_sock_t *ssock)
 638 {
 639     ssock->ssl_state = SSL_STATE_NULL;
 640
 641     destroy_ssl(ssock);
 642
 643     if (ssock->asock) {
 644         pj_activesock_close(ssock->asock);
 645         ssock->asock = NULL;
 646         ssock->sock = PJ_INVALID_SOCKET;
 647     }
 648     if (ssock->sock != PJ_INVALID_SOCKET) {
 649         pj_sock_close(ssock->sock);
 650         ssock->sock = PJ_INVALID_SOCKET;
 651     }
 652
 653     /* Upon error, OpenSSL may leave any error description in the thread
 654      * error queue, which sometime may cause next call to SSL API returning
 655      * false error alarm, e.g: in Linux, SSL_CTX_use_certificate_chain_file()
 656      * returning false error after a handshake error (in different SSL_CTX!).
 657      * For now, just clear thread error queue here.
 658      */
 659     ERR_clear_error();
 660 }
 661
 662
 663 /* Generate cipher list with user preference order in OpenSSL format */
 664 static pj_status_t set_cipher_list(pj_ssl_sock_t *ssock)
 665 {
 666     char buf[1024];
 667     pj_str_t cipher_list;
 668     STACK_OF(SSL_CIPHER) *sk_cipher;
 669     unsigned i;
 670     int j, ret;
 671
 672     if (ssock->param.ciphers_num == 0)
 673         return PJ_SUCCESS;
 674
 675     pj_strset(&cipher_list, buf, 0);
 676
 677     /* Set SSL with ALL available ciphers */
 678     SSL_set_cipher_list(ssock->ossl_ssl, "ALL");
 679
 680     /* Generate user specified cipher list in OpenSSL format */
 681     sk_cipher = SSL_get_ciphers(ssock->ossl_ssl);
 682     for (i = 0; i < ssock->param.ciphers_num; ++i) {
 683         for (j = 0; j < sk_SSL_CIPHER_num(sk_cipher); ++j) {
 684             SSL_CIPHER *c;
 685             c = sk_SSL_CIPHER_value(sk_cipher, j);
 686             if (ssock->param.ciphers[i] == (pj_ssl_cipher)
 687                                            ((pj_uint32_t)c->id & 0x00FFFFFF))
 688             {
 689                 const char *c_name;
 690
 691                 c_name = SSL_CIPHER_get_name(c);
 692
 693                 /* Check buffer size */
 694                 if (cipher_list.slen + pj_ansi_strlen(c_name) + 2 > sizeof(buf)) {
 695                     pj_assert(!"Insufficient temporary buffer for cipher");
 696                     return PJ_ETOOMANY;
 697                 }
 698
 699                 /* Add colon separator */
 700                 if (cipher_list.slen)
 701                     pj_strcat2(&cipher_list, ":");
 702
 703                 /* Add the cipher */
 704                 pj_strcat2(&cipher_list, c_name);
 705                 break;
 706             }
 707         }
 708     }
 709
 710     /* Put NULL termination in the generated cipher list */
 711     cipher_list.ptr[cipher_list.slen] = '\0';
 712
 713     /* Finally, set chosen cipher list */
 714     ret = SSL_set_cipher_list(ssock->ossl_ssl, buf);
 715     if (ret < 1) {
 716         pj_status_t status;
 717         GET_SSL_STATUS(status);
 718         return status;
 719     }
 720
 721     return PJ_SUCCESS;
 722 }
 723
 724
 725 /* Parse OpenSSL ASN1_TIME to pj_time_val and GMT info */
 726 static pj_bool_t parse_ossl_asn1_time(pj_time_val *tv, pj_bool_t *gmt,
 727                                       const ASN1_TIME *tm)
 728 {
 729     unsigned long parts[7] = {0};
 730     char *p, *end;
 731     unsigned len;
 732     pj_bool_t utc;
 733     pj_parsed_time pt;
 734     int i;
 735
 736     utc = tm->type == V_ASN1_UTCTIME;
 737     p = (char*)tm->data;
 738     len = tm->length;
 739     end = p + len - 1;
 740
 741     /* GMT */
 742     *gmt = (*end == 'Z');
 743
 744     /* parse parts */
 745     for (i = 0; i < 7 && p < end; ++i) {
 746         pj_str_t st;
 747
 748         if (i==0 && !utc) {
 749             /* 4 digits year part for non-UTC time format */
 750             st.slen = 4;
 751         } else if (i==6) {
 752             /* fraction of seconds */
 753             if (*p == '.') ++p;
 754             st.slen = end - p + 1;
 755         } else {
 756             /* other parts always 2 digits length */
 757             st.slen = 2;
 758         }
 759         st.ptr = p;
 760
 761         parts[i] = pj_strtoul(&st);
 762         p += st.slen;
 763     }
 764
 765     /* encode parts to pj_time_val */
 766     pt.year = parts[0];
 767     if (utc)
 768         pt.year += (pt.year < 50)? 2000:1900;
 769     pt.mon = parts[1] - 1;
 770     pt.day = parts[2];
 771     pt.hour = parts[3];
 772     pt.min = parts[4];
 773     pt.sec = parts[5];
 774     pt.msec = parts[6];
 775
 776     pj_time_encode(&pt, tv);
 777
 778     return PJ_TRUE;
 779 }
 780
 781
 782 /* Get Common Name field string from a general name string */
 783 static void get_cn_from_gen_name(const pj_str_t *gen_name, pj_str_t *cn)
 784 {
 785     pj_str_t CN_sign = {"/CN=", 4};
 786     char *p, *q;
 787
 788     pj_bzero(cn, sizeof(cn));
 789
 790     p = pj_strstr(gen_name, &CN_sign);
 791     if (!p)
 792         return;
 793
 794     p += 4; /* shift pointer to value part */
 795     pj_strset(cn, p, gen_name->slen - (p - gen_name->ptr));
 796     q = pj_strchr(cn, '/');
 797     if (q)
 798         cn->slen = q - p;
 799 }
 800
 801
 802 /* Get certificate info from OpenSSL X509, in case the certificate info
 803  * hal already populated, this function will check if the contents need
 804  * to be updated by inspecting the issuer and the serial number.
 805  */
 806 static void get_cert_info(pj_pool_t *pool, pj_ssl_cert_info *ci, X509 *x)
 807 {
 808     pj_bool_t update_needed;
 809     char buf[512];
 810     pj_uint8_t serial_no[64] = {0}; /* should be >= sizeof(ci->serial_no) */
 811     pj_uint8_t *p;
 812     unsigned len;
 813     GENERAL_NAMES *names = NULL;
 814
 815     pj_assert(pool && ci && x);
 816
 817     /* Get issuer */
 818     X509_NAME_oneline(X509_get_issuer_name(x), buf, sizeof(buf));
 819
 820     /* Get serial no */
 821     p = (pj_uint8_t*) M_ASN1_STRING_data(X509_get_serialNumber(x));
 822     len = M_ASN1_STRING_length(X509_get_serialNumber(x));
 823     if (len > sizeof(ci->serial_no))
 824         len = sizeof(ci->serial_no);
 825     pj_memcpy(serial_no + sizeof(ci->serial_no) - len, p, len);
 826
 827     /* Check if the contents need to be updated. */
 828     update_needed = pj_strcmp2(&ci->issuer.info, buf) ||
 829                     pj_memcmp(ci->serial_no, serial_no, sizeof(ci->serial_no));
 830     if (!update_needed)
 831         return;
 832
 833     /* Update cert info */
 834
 835     pj_bzero(ci, sizeof(pj_ssl_cert_info));
 836
 837     /* Version */
 838     ci->version = X509_get_version(x) + 1;
 839
 840     /* Issuer */
 841     pj_strdup2(pool, &ci->issuer.info, buf);
 842     get_cn_from_gen_name(&ci->issuer.info, &ci->issuer.cn);
 843
 844     /* Serial number */
 845     pj_memcpy(ci->serial_no, serial_no, sizeof(ci->serial_no));
 846
 847     /* Subject */
 848     pj_strdup2(pool, &ci->subject.info,
 849                X509_NAME_oneline(X509_get_subject_name(x),
 850                                  buf, sizeof(buf)));
 851     get_cn_from_gen_name(&ci->subject.info, &ci->subject.cn);
 852
 853     /* Validity */
 854     parse_ossl_asn1_time(&ci->validity.start, &ci->validity.gmt,
 855                          X509_get_notBefore(x));
 856     parse_ossl_asn1_time(&ci->validity.end, &ci->validity.gmt,
 857                          X509_get_notAfter(x));
 858
 859     /* Subject Alternative Name extension */
 860     if (ci->version >= 3) {
 861         names = (GENERAL_NAMES*) X509_get_ext_d2i(x, NID_subject_alt_name,
 862                                                   NULL, NULL);
 863     }
 864     if (names) {
 865         unsigned i, cnt;
 866
 867         cnt = sk_GENERAL_NAME_num(names);
 868         ci->subj_alt_name.entry = pj_pool_calloc(pool, cnt,
 869                                             sizeof(*ci->subj_alt_name.entry));
 870
 871         for (i = 0; i < cnt; ++i) {
 872             unsigned char *p = 0;
 873             pj_ssl_cert_name_type type = PJ_SSL_CERT_NAME_UNKNOWN;
 874             const GENERAL_NAME *name;
 875
 876             name = sk_GENERAL_NAME_value(names, i);
 877
 878             switch (name->type) {
 879                 case GEN_EMAIL:
 880                     len = ASN1_STRING_to_UTF8(&p, name->d.ia5);
 881                     type = PJ_SSL_CERT_NAME_RFC822;
 882                     break;
 883                 case GEN_DNS:
 884                     len = ASN1_STRING_to_UTF8(&p, name->d.ia5);
 885                     type = PJ_SSL_CERT_NAME_DNS;
 886                     break;
 887                 case GEN_URI:
 888                     len = ASN1_STRING_to_UTF8(&p, name->d.ia5);
 889                     type = PJ_SSL_CERT_NAME_URI;
 890                     break;
 891                 case GEN_IPADD:
 892                     p = ASN1_STRING_data(name->d.ip);
 893                     len = ASN1_STRING_length(name->d.ip);
 894                     type = PJ_SSL_CERT_NAME_IP;
 895                     break;
 896                 default:
 897                     break;
 898             }
 899
 900             if (p && len && type != PJ_SSL_CERT_NAME_UNKNOWN) {
 901                 ci->subj_alt_name.entry[ci->subj_alt_name.cnt].type = type;
 902                 if (type == PJ_SSL_CERT_NAME_IP) {
 903                     int af = pj_AF_INET();
 904                     if (len == sizeof(pj_in6_addr)) af = pj_AF_INET6();
 905                     pj_inet_ntop2(af, p, buf, sizeof(buf));
 906                     pj_strdup2(pool,
 907                           &ci->subj_alt_name.entry[ci->subj_alt_name.cnt].name,
 908                           buf);
 909                 } else {
 910                     pj_strdup2(pool,
 911                           &ci->subj_alt_name.entry[ci->subj_alt_name.cnt].name,
 912                           (char*)p);
 913                     OPENSSL_free(p);
 914                 }
 915                 ci->subj_alt_name.cnt++;
 916             }
 917         }
 918     }
 919 }
 920
 921
 922 /* Update local & remote certificates info. This function should be
 923  * called after handshake or renegotiation successfully completed.
 924  */
 925 static void update_certs_info(pj_ssl_sock_t *ssock)
 926 {
 927     X509 *x;
 928
 929     pj_assert(ssock->ssl_state == SSL_STATE_ESTABLISHED);
 930
 931     /* Active local certificate */
 932     x = SSL_get_certificate(ssock->ossl_ssl);
 933     if (x) {
 934         get_cert_info(ssock->pool, &ssock->local_cert_info, x);
 935         /* Don't free local's X509! */
 936     } else {
 937         pj_bzero(&ssock->local_cert_info, sizeof(pj_ssl_cert_info));
 938     }
 939
 940     /* Active remote certificate */
 941     x = SSL_get_peer_certificate(ssock->ossl_ssl);
 942     if (x) {
 943         get_cert_info(ssock->pool, &ssock->remote_cert_info, x);
 944         /* Free peer's X509 */
 945         X509_free(x);
 946     } else {
 947         pj_bzero(&ssock->remote_cert_info, sizeof(pj_ssl_cert_info));
 948     }
 949 }
 950
 951
 952 /* When handshake completed:
 953  * - notify application
 954  * - if handshake failed, reset SSL state
 955  * - return PJ_FALSE when SSL socket instance is destroyed by application.
 956  */
 957 static pj_bool_t on_handshake_complete(pj_ssl_sock_t *ssock,
 958                                        pj_status_t status)
 959 {
 960     /* Cancel handshake timer */
 961     if (ssock->timer.id == TIMER_HANDSHAKE_TIMEOUT) {
 962         pj_timer_heap_cancel(ssock->param.timer_heap, &ssock->timer);
 963         ssock->timer.id = TIMER_NONE;
 964     }
 965
 966     /* Update certificates info on successful handshake */
 967     if (status == PJ_SUCCESS)
 968         update_certs_info(ssock);
 969
 970     /* Accepting */
 971     if (ssock->is_server) {
 972         if (status != PJ_SUCCESS) {
 973             /* Handshake failed in accepting, destroy our self silently. */
 974
 975             char errmsg[PJ_ERR_MSG_SIZE];
 976             char buf[PJ_INET6_ADDRSTRLEN+10];
 977
 978             pj_strerror(status, errmsg, sizeof(errmsg));
 979             PJ_LOG(3,(ssock->pool->obj_name, "Handshake failed in accepting "
 980                       "%s: %s",
 981                       pj_sockaddr_print(&ssock->rem_addr, buf, sizeof(buf), 3),
 982                       errmsg));
 983
 984             /* Workaround for ticket #985 */
 985 #if defined(PJ_WIN32) && PJ_WIN32!=0
 986             if (ssock->param.timer_heap) {
 987                 pj_time_val interval = {0, DELAYED_CLOSE_TIMEOUT};
 988
 989                 reset_ssl_sock_state(ssock);
 990
 991                 ssock->timer.id = TIMER_CLOSE;
 992                 pj_time_val_normalize(&interval);
 993                 if (pj_timer_heap_schedule(ssock->param.timer_heap,
 994                                            &ssock->timer, &interval) != 0)
 995                 {
 996                     ssock->timer.id = TIMER_NONE;
 997                     pj_ssl_sock_close(ssock);
 998                 }
 999             } else
1000 #endif  /* PJ_WIN32 */
1001             {
1002                 pj_ssl_sock_close(ssock);
1003             }
1004             return PJ_FALSE;
1005         }
1006         /* Notify application the newly accepted SSL socket */
1007         if (ssock->param.cb.on_accept_complete) {
1008             pj_bool_t ret;
1009             ret = (*ssock->param.cb.on_accept_complete)
1010                       (ssock->parent, ssock, (pj_sockaddr_t*)&ssock->rem_addr,
1011                        pj_sockaddr_get_len((pj_sockaddr_t*)&ssock->rem_addr));
1012             if (ret == PJ_FALSE)
1013                 return PJ_FALSE;
1014         }
1015     }
1016
1017     /* Connecting */
1018     else {
1019         /* On failure, reset SSL socket state first, as app may try to
1020          * reconnect in the callback.
1021          */
1022         if (status != PJ_SUCCESS) {
1023             reset_ssl_sock_state(ssock);
1024         }
1025         if (ssock->param.cb.on_connect_complete) {
1026             pj_bool_t ret;
1027             ret = (*ssock->param.cb.on_connect_complete)(ssock, status);
1028             if (ret == PJ_FALSE)
1029                 return PJ_FALSE;
1030         }
1031     }
1032
1033     return PJ_TRUE;
1034 }
1035
1036 /* Flush write BIO to network socket. Note that any access to write BIO
1037  * MUST be serialized, so mutex protection must cover any call to OpenSSL
1038  * API (that possibly generate data for write BIO) along with the call to
1039  * this function (flushing all data in write BIO generated by above
1040  * OpenSSL API call).
1041  */
1042 static pj_status_t flush_write_bio(pj_ssl_sock_t *ssock,
1043                                    pj_ioqueue_op_key_t *send_key,
1044                                    pj_size_t orig_len,
1045                                    unsigned flags)
1046 {
1047     char *data;
1048     pj_ssize_t len;
1049
1050     write_state_t *write_st = &ssock->write_state;
1051     write_data_t *wdata;
1052     pj_size_t avail_len, needed_len, skipped_len = 0;
1053     pj_status_t status;
1054
1055     /* Check if there is data in write BIO, flush it if any */
1056     if (!BIO_pending(ssock->ossl_wbio))
1057         return PJ_SUCCESS;
1058
1059     /* Get data and its length */
1060     len = BIO_get_mem_data(ssock->ossl_wbio, &data);
1061     if (len == 0)
1062         return PJ_SUCCESS;
1063
1064     /* Calculate buffer size needed, and align it to 8 */
1065     needed_len = len + sizeof(write_data_t);
1066     needed_len = ((needed_len + 7) >> 3) << 3;
1067
1068     /* Check buffer availability */
1069     avail_len = write_st->max_len - write_st->len;
1070     if (avail_len < needed_len)
1071         return PJ_ENOMEM;
1072
1073     /* More buffer availability check, note that the write data must be in
1074      * a contigue buffer.
1075      */
1076     if (write_st->len == 0) {
1077
1078         write_st->start = write_st->buf;
1079         wdata = (write_data_t*)write_st->start;
1080
1081     } else {
1082
1083         char *reg1, *reg2;
1084         pj_size_t reg1_len, reg2_len;
1085
1086         /* Unused slots may be wrapped/splitted into two regions, so let's
1087          * analyze them if any region can hold the write data.
1088          */
1089         reg1 = write_st->start + write_st->len;
1090         if (reg1 >= write_st->buf + write_st->max_len)
1091             reg1 -= write_st->max_len;
1092         reg1_len = write_st->max_len - write_st->len;
1093         if (reg1 + reg1_len > write_st->buf + write_st->max_len) {
1094             reg1_len = write_st->buf + write_st->max_len - reg1;
1095             reg2 = write_st->buf;
1096             reg2_len = write_st->start - write_st->buf;
1097         } else {
1098             reg2 = NULL;
1099             reg2_len = 0;
1100         }
1101         avail_len = PJ_MAX(reg1_len, reg2_len);
1102         if (avail_len < needed_len)
1103             return PJ_ENOMEM;
1104
1105         /* Get write data pointer and update buffer length */
1106         if (reg1_len >= needed_len) {
1107             wdata = (write_data_t*)reg1;
1108         } else {
1109             wdata = (write_data_t*)reg2;
1110             /* Unused slot in region 1 is skipped as current write data
1111              * doesn't fit it.
1112              */
1113             skipped_len = reg1_len;
1114         }
1115     }
1116
1117     /* Copy the data and set its properties into the buffer */
1118     pj_bzero(wdata, sizeof(write_data_t));
1119     wdata->app_key = send_key;
1120     wdata->record_len = needed_len;
1121     wdata->data_len = len;
1122     wdata->plain_data_len = orig_len;
1123     wdata->flags = flags;
1124     pj_memcpy(&wdata->data, data, len);
1125
1126     /* Send it */
1127     if (ssock->param.sock_type == pj_SOCK_STREAM()) {
1128         status = pj_activesock_send(ssock->asock, &wdata->key,
1129                                     wdata->data.content, &len,
1130                                     flags);
1131     } else {
1132         status = pj_activesock_sendto(ssock->asock, &wdata->key,
1133                                       wdata->data.content, &len,
1134                                       flags,
1135                                       (pj_sockaddr_t*)&ssock->rem_addr,
1136                                       ssock->addr_len);
1137     }
1138
1139     /* Oh no, EWOULDBLOCK! */
1140     if (status == PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK)) {
1141         /* Just return PJ_SUCCESS here, the pending data will be sent in next
1142          * call of this function since the data is still stored in write BIO.
1143          */
1144         return PJ_SUCCESS;
1145     }
1146
1147     /* Reset write BIO after flushed */
1148     (void)BIO_reset(ssock->ossl_wbio);
1149
1150     if (status == PJ_EPENDING) {
1151         /* Update write state */
1152         pj_assert(skipped_len==0 || write_st->last_data);
1153         write_st->len += needed_len + skipped_len;
1154         if (write_st->last_data)
1155             write_st->last_data->record_len += skipped_len;
1156         write_st->last_data = wdata;
1157     }
1158
1159     return status;
1160 }
1161
1162
1163 static void on_timer(pj_timer_heap_t *th, struct pj_timer_entry *te)
1164 {
1165     pj_ssl_sock_t *ssock = (pj_ssl_sock_t*)te->user_data;
1166     int timer_id = te->id;
1167
1168     te->id = TIMER_NONE;
1169
1170     PJ_UNUSED_ARG(th);
1171
1172     switch (timer_id) {
1173     case TIMER_HANDSHAKE_TIMEOUT:
1174         PJ_LOG(1,(ssock->pool->obj_name, "SSL timeout after %d.%ds",
1175                   ssock->param.timeout.sec, ssock->param.timeout.msec));
1176
1177         on_handshake_complete(ssock, PJ_ETIMEDOUT);
1178         break;
1179     case TIMER_CLOSE:
1180         pj_ssl_sock_close(ssock);
1181         break;
1182     default:
1183         pj_assert(!"Unknown timer");
1184         break;
1185     }
1186 }
1187
1188
1189 /* Asynchronouse handshake */
1190 static pj_status_t do_handshake(pj_ssl_sock_t *ssock)
1191 {
1192     pj_status_t status;
1193     int err;
1194
1195     pj_lock_acquire(ssock->write_mutex);
1196
1197     /* Perform SSL handshake */
1198     err = SSL_do_handshake(ssock->ossl_ssl);
1199     if (err < 0) {
1200         err = SSL_get_error(ssock->ossl_ssl, err);
1201         if (err != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ)
1202         {
1203             /* Handshake fails */
1204             GET_SSL_STATUS(status);
1205             pj_lock_release(ssock->write_mutex);
1206             return status;
1207         }
1208     }
1209
1210     /* SSL_do_handshake() may put some pending data into SSL write BIO,
1211      * flush it if any.
1212      */
1213     status = flush_write_bio(ssock, &ssock->handshake_op_key, 0, 0);
1214     if (status != PJ_SUCCESS && status != PJ_EPENDING) {
1215         pj_lock_release(ssock->write_mutex);
1216         return status;
1217     }
1218
1219     pj_lock_release(ssock->write_mutex);
1220
1221     /* Check if handshake has been completed */
1222     if (SSL_is_init_finished(ssock->ossl_ssl)) {
1223         ssock->ssl_state = SSL_STATE_ESTABLISHED;
1224         return PJ_SUCCESS;
1225     }
1226
1227     return PJ_EPENDING;
1228 }
1229
1230
1231 /*
1232  *******************************************************************
1233  * Active socket callbacks.
1234  *******************************************************************
1235  */
1236
1237 static pj_bool_t asock_on_data_read (pj_activesock_t *asock,
1238                                      void *data,
1239                                      pj_size_t size,
1240                                      pj_status_t status,
1241                                      pj_size_t *remainder)
1242 {
1243     pj_ssl_sock_t *ssock = (pj_ssl_sock_t*)
1244                            pj_activesock_get_user_data(asock);
1245     pj_size_t nwritten;
1246
1247     /* Socket error or closed */
1248     if (data && size > 0) {
1249         /* Consume the whole data */
1250         nwritten = BIO_write(ssock->ossl_rbio, data, size);
1251         if (nwritten < size) {
1252             GET_SSL_STATUS(status);
1253             goto on_error;
1254         }
1255     }
1256
1257     /* Check if SSL handshake hasn't finished yet */
1258     if (ssock->ssl_state == SSL_STATE_HANDSHAKING) {
1259         pj_bool_t ret = PJ_TRUE;
1260
1261         if (status == PJ_SUCCESS)
1262             status = do_handshake(ssock);
1263
1264         /* Not pending is either success or failed */
1265         if (status != PJ_EPENDING)
1266             ret = on_handshake_complete(ssock, status);
1267
1268         return ret;
1269     }
1270
1271     /* See if there is any decrypted data for the application */
1272     if (ssock->read_started) {
1273         do {
1274             read_data_t *buf = *(OFFSET_OF_READ_DATA_PTR(ssock, data));
1275             void *data_ = (pj_int8_t*)buf->data + buf->len;
1276             int size_ = ssock->read_size - buf->len;
1277
1278             /* SSL_read() may write some data to BIO write when re-negotiation
1279              * is on progress, so let's protect it with write mutex.
1280              */
1281             pj_lock_acquire(ssock->write_mutex);
1282             size_ = SSL_read(ssock->ossl_ssl, data_, size_);
1283             pj_lock_release(ssock->write_mutex);
1284
1285             if (size_ > 0 || status != PJ_SUCCESS) {
1286                 if (ssock->param.cb.on_data_read) {
1287                     pj_bool_t ret;
1288                     pj_size_t remainder_ = 0;
1289
1290                     if (size_ > 0)
1291                         buf->len += size_;
1292
1293                     ret = (*ssock->param.cb.on_data_read)(ssock, buf->data,
1294                                                           buf->len, status,
1295                                                           &remainder_);
1296                     if (!ret) {
1297                         /* We've been destroyed */
1298                         return PJ_FALSE;
1299                     }
1300
1301                     /* Application may have left some data to be consumed
1302                      * later.
1303                      */
1304                     buf->len = remainder_;
1305                 }
1306
1307                 /* Active socket signalled connection closed/error, this has
1308                  * been signalled to the application along with any remaining
1309                  * buffer. So, let's just reset SSL socket now.
1310                  */
1311                 if (status != PJ_SUCCESS) {
1312                     reset_ssl_sock_state(ssock);
1313                     return PJ_FALSE;
1314                 }
1315
1316             } else {
1317
1318                 int err = SSL_get_error(ssock->ossl_ssl, size);
1319
1320                 /* SSL might just return SSL_ERROR_WANT_READ in
1321                  * re-negotiation.
1322                  */
1323                 if (err != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ)
1324                 {
1325                     /* Reset SSL socket state, then return PJ_FALSE */
1326                     GET_SSL_STATUS(status);
1327                     reset_ssl_sock_state(ssock);
1328                     goto on_error;
1329                 }
1330
1331                 status = do_handshake(ssock);
1332                 if (status == PJ_SUCCESS) {
1333                     /* Renegotiation completed */
1334
1335                     /* Update certificates */
1336                     update_certs_info(ssock);
1337
1338                     pj_lock_acquire(ssock->write_mutex);
1339                     status = flush_delayed_send(ssock);
1340                     pj_lock_release(ssock->write_mutex);
1341
1342                     if (status != PJ_SUCCESS && status != PJ_EPENDING) {
1343                         PJ_PERROR(1,(ssock->pool->obj_name, status,
1344                                      "Failed to flush delayed send"));
1345                         goto on_error;
1346                     }
1347                 } else if (status != PJ_EPENDING) {
1348                     PJ_PERROR(1,(ssock->pool->obj_name, status,
1349                                  "Renegotiation failed"));
1350                     goto on_error;
1351                 }
1352
1353                 break;
1354             }
1355         } while (1);
1356     }
1357
1358     return PJ_TRUE;
1359
1360 on_error:
1361     if (ssock->ssl_state == SSL_STATE_HANDSHAKING)
1362         return on_handshake_complete(ssock, status);
1363
1364     if (ssock->read_started && ssock->param.cb.on_data_read) {
1365         pj_bool_t ret;
1366         ret = (*ssock->param.cb.on_data_read)(ssock, NULL, 0, status,
1367                                               remainder);
1368         if (!ret) {
1369             /* We've been destroyed */
1370             return PJ_FALSE;
1371         }
1372     }
1373
1374     reset_ssl_sock_state(ssock);
1375     return PJ_FALSE;
1376 }
1377
1378
1379 static pj_bool_t asock_on_data_sent (pj_activesock_t *asock,
1380                                      pj_ioqueue_op_key_t *send_key,
1381                                      pj_ssize_t sent)
1382 {
1383     pj_ssl_sock_t *ssock = (pj_ssl_sock_t*)
1384                            pj_activesock_get_user_data(asock);
1385
1386     PJ_UNUSED_ARG(send_key);
1387     PJ_UNUSED_ARG(sent);
1388
1389     if (ssock->ssl_state == SSL_STATE_HANDSHAKING) {
1390         /* Initial handshaking */
1391         pj_status_t status;
1392
1393         status = do_handshake(ssock);
1394         /* Not pending is either success or failed */
1395         if (status != PJ_EPENDING)
1396             return on_handshake_complete(ssock, status);
1397
1398     } else if (send_key != &ssock->handshake_op_key) {
1399         /* Some data has been sent, notify application */
1400         write_data_t *wdata = (write_data_t*)send_key;
1401         if (ssock->param.cb.on_data_sent) {
1402             pj_bool_t ret;
1403             ret = (*ssock->param.cb.on_data_sent)(ssock, wdata->app_key,
1404                                                   wdata->plain_data_len);
1405             if (!ret) {
1406                 /* We've been destroyed */
1407                 return PJ_FALSE;
1408             }
1409         }
1410
1411         /* Update write buffer state */
1412         pj_lock_acquire(ssock->write_mutex);
1413         ssock->write_state.start += wdata->record_len;
1414         ssock->write_state.len -= wdata->record_len;
1415         if (ssock->write_state.last_data == wdata) {
1416             pj_assert(ssock->write_state.len == 0);
1417             ssock->write_state.last_data = NULL;
1418         }
1419         pj_lock_release(ssock->write_mutex);
1420
1421     } else {
1422         /* SSL re-negotiation is on-progress, just do nothing */
1423     }
1424
1425     return PJ_TRUE;
1426 }
1427
1428
1429 static pj_bool_t asock_on_accept_complete (pj_activesock_t *asock,
1430                                            pj_sock_t newsock,
1431                                            const pj_sockaddr_t *src_addr,
1432                                            int src_addr_len)
1433 {
1434     pj_ssl_sock_t *ssock_parent = (pj_ssl_sock_t*)
1435                                   pj_activesock_get_user_data(asock);
1436     pj_ssl_sock_t *ssock;
1437     pj_activesock_cb asock_cb;
1438     pj_activesock_cfg asock_cfg;
1439     unsigned i;
1440     pj_status_t status;
1441
1442     PJ_UNUSED_ARG(src_addr_len);
1443
1444     /* Create new SSL socket instance */
1445     status = pj_ssl_sock_create(ssock_parent->pool, &ssock_parent->param,
1446                                 &ssock);
1447     if (status != PJ_SUCCESS)
1448         goto on_return;
1449
1450     /* Update new SSL socket attributes */
1451     ssock->sock = newsock;
1452     ssock->parent = ssock_parent;
1453     ssock->is_server = PJ_TRUE;
1454     if (ssock_parent->cert) {
1455         status = pj_ssl_sock_set_certificate(ssock, ssock->pool,
1456                                              ssock_parent->cert);
1457         if (status != PJ_SUCCESS)
1458             goto on_return;
1459     }
1460
1461     /* Apply QoS, if specified */
1462     status = pj_sock_apply_qos2(ssock->sock, ssock->param.qos_type,
1463                                 &ssock->param.qos_params, 1,
1464                                 ssock->pool->obj_name, NULL);
1465     if (status != PJ_SUCCESS && !ssock->param.qos_ignore_error)
1466         goto on_return;
1467
1468     /* Update local address */
1469     ssock->addr_len = src_addr_len;
1470     status = pj_sock_getsockname(ssock->sock, &ssock->local_addr,
1471                                  &ssock->addr_len);
1472     if (status != PJ_SUCCESS) {
1473         /* This fails on few envs, e.g: win IOCP, just tolerate this and
1474          * use parent local address instead.
1475          */
1476         pj_sockaddr_cp(&ssock->local_addr, &ssock_parent->local_addr);
1477     }
1478
1479     /* Set remote address */
1480     pj_sockaddr_cp(&ssock->rem_addr, src_addr);
1481
1482     /* Create SSL context */
1483     status = create_ssl(ssock);
1484     if (status != PJ_SUCCESS)
1485         goto on_return;
1486
1487     /* Prepare read buffer */
1488     ssock->asock_rbuf = (void**)pj_pool_calloc(ssock->pool,
1489                                                ssock->param.async_cnt,
1490                                                sizeof(void*));
1491     for (i = 0; i<ssock->param.async_cnt; ++i) {
1492         ssock->asock_rbuf[i] = (void*) pj_pool_alloc(
1493                                             ssock->pool,
1494                                             ssock->param.read_buffer_size +
1495                                             sizeof(read_data_t*));
1496     }
1497
1498     /* Create active socket */
1499     pj_activesock_cfg_default(&asock_cfg);
1500     asock_cfg.async_cnt = ssock->param.async_cnt;
1501     asock_cfg.concurrency = ssock->param.concurrency;
1502     asock_cfg.whole_data = PJ_TRUE;
1503
1504     pj_bzero(&asock_cb, sizeof(asock_cb));
1505     asock_cb.on_data_read = asock_on_data_read;
1506     asock_cb.on_data_sent = asock_on_data_sent;
1507
1508     status = pj_activesock_create(ssock->pool,
1509                                   ssock->sock,
1510                                   ssock->param.sock_type,
1511                                   &asock_cfg,
1512                                   ssock->param.ioqueue,
1513                                   &asock_cb,
1514                                   ssock,
1515                                   &ssock->asock);
1516
1517     if (status != PJ_SUCCESS)
1518         goto on_return;
1519
1520     /* Start read */
1521     status = pj_activesock_start_read2(ssock->asock, ssock->pool,
1522                                        ssock->param.read_buffer_size,
1523                                        ssock->asock_rbuf,
1524                                        PJ_IOQUEUE_ALWAYS_ASYNC);
1525     if (status != PJ_SUCCESS)
1526         goto on_return;
1527
1528     /* Prepare write/send state */
1529     pj_assert(ssock->write_state.max_len == 0);
1530     ssock->write_state.buf = (char*)
1531                              pj_pool_alloc(ssock->pool,
1532                                            ssock->param.send_buffer_size);
1533     ssock->write_state.max_len = ssock->param.send_buffer_size;
1534     ssock->write_state.start = ssock->write_state.buf;
1535     ssock->write_state.len = 0;
1536
1537     /* Start handshake timer */
1538     if (ssock->param.timer_heap && (ssock->param.timeout.sec != 0 ||
1539         ssock->param.timeout.msec != 0))
1540     {
1541         pj_assert(ssock->timer.id == TIMER_NONE);
1542         ssock->timer.id = TIMER_HANDSHAKE_TIMEOUT;
1543         status = pj_timer_heap_schedule(ssock->param.timer_heap,
1544                                         &ssock->timer,
1545                                         &ssock->param.timeout);
1546         if (status != PJ_SUCCESS)
1547             ssock->timer.id = TIMER_NONE;
1548     }
1549
1550     /* Start SSL handshake */
1551     ssock->ssl_state = SSL_STATE_HANDSHAKING;
1552     SSL_set_accept_state(ssock->ossl_ssl);
1553     status = do_handshake(ssock);
1554
1555 on_return:
1556     if (ssock && status != PJ_EPENDING)
1557         on_handshake_complete(ssock, status);
1558
1559     /* Must return PJ_TRUE whatever happened, as active socket must
1560      * continue listening.
1561      */
1562     return PJ_TRUE;
1563 }
1564
1565
1566 static pj_bool_t asock_on_connect_complete (pj_activesock_t *asock,
1567                                             pj_status_t status)
1568 {
1569     pj_ssl_sock_t *ssock = (pj_ssl_sock_t*)
1570                            pj_activesock_get_user_data(asock);
1571     unsigned i;
1572
1573     if (status != PJ_SUCCESS)
1574         goto on_return;
1575
1576     /* Update local address */
1577     ssock->addr_len = sizeof(pj_sockaddr);
1578     status = pj_sock_getsockname(ssock->sock, &ssock->local_addr,
1579                                  &ssock->addr_len);
1580     if (status != PJ_SUCCESS)
1581         goto on_return;
1582
1583     /* Create SSL context */
1584     status = create_ssl(ssock);
1585     if (status != PJ_SUCCESS)
1586         goto on_return;
1587
1588     /* Prepare read buffer */
1589     ssock->asock_rbuf = (void**)pj_pool_calloc(ssock->pool,
1590                                                ssock->param.async_cnt,
1591                                                sizeof(void*));
1592     for (i = 0; i<ssock->param.async_cnt; ++i) {
1593         ssock->asock_rbuf[i] = (void*) pj_pool_alloc(
1594                                             ssock->pool,
1595                                             ssock->param.read_buffer_size +
1596                                             sizeof(read_data_t*));
1597     }
1598
1599     /* Start read */
1600     status = pj_activesock_start_read2(ssock->asock, ssock->pool,
1601                                        ssock->param.read_buffer_size,
1602                                        ssock->asock_rbuf,
1603                                        PJ_IOQUEUE_ALWAYS_ASYNC);
1604     if (status != PJ_SUCCESS)
1605         goto on_return;
1606
1607     /* Prepare write/send state */
1608     pj_assert(ssock->write_state.max_len == 0);
1609     ssock->write_state.buf = (char*)
1610                              pj_pool_alloc(ssock->pool,
1611                                            ssock->param.send_buffer_size);
1612     ssock->write_state.max_len = ssock->param.send_buffer_size;
1613     ssock->write_state.start = ssock->write_state.buf;
1614     ssock->write_state.len = 0;
1615
1616 #ifdef SSL_set_tlsext_host_name
1617     /* Set server name to connect */
1618     if (ssock->param.server_name.slen) {
1619         /* Server name is null terminated already */
1620         if (!SSL_set_tlsext_host_name(ssock->ossl_ssl,
1621                                       ssock->param.server_name.ptr))
1622         {
1623             char err_str[PJ_ERR_MSG_SIZE];
1624
1625             ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
1626             PJ_LOG(3,(ssock->pool->obj_name, "SSL_set_tlsext_host_name() "
1627                 "failed: %s", err_str));
1628         }
1629     }
1630 #endif
1631
1632     /* Start SSL handshake */
1633     ssock->ssl_state = SSL_STATE_HANDSHAKING;
1634     SSL_set_connect_state(ssock->ossl_ssl);
1635
1636     status = do_handshake(ssock);
1637     if (status != PJ_EPENDING)
1638         goto on_return;
1639
1640     return PJ_TRUE;
1641
1642 on_return:
1643     return on_handshake_complete(ssock, status);
1644 }
1645
1646
1647
1648 /*
1649  *******************************************************************
1650  * API
1651  *******************************************************************
1652  */
1653
1654 /* Load credentials from files. */
1655 PJ_DEF(pj_status_t) pj_ssl_cert_load_from_files (pj_pool_t *pool,
1656                                                  const pj_str_t *CA_file,
1657                                                  const pj_str_t *cert_file,
1658                                                  const pj_str_t *privkey_file,
1659                                                  const pj_str_t *privkey_pass,
1660                                                  pj_ssl_cert_t **p_cert)
1661 {
1662     pj_ssl_cert_t *cert;
1663
1664     PJ_ASSERT_RETURN(pool && CA_file && cert_file && privkey_file, PJ_EINVAL);
1665
1666     cert = PJ_POOL_ZALLOC_T(pool, pj_ssl_cert_t);
1667     pj_strdup_with_null(pool, &cert->CA_file, CA_file);
1668     pj_strdup_with_null(pool, &cert->cert_file, cert_file);
1669     pj_strdup_with_null(pool, &cert->privkey_file, privkey_file);
1670     pj_strdup_with_null(pool, &cert->privkey_pass, privkey_pass);
1671
1672     *p_cert = cert;
1673
1674     return PJ_SUCCESS;
1675 }
1676
1677
1678 /* Set SSL socket credentials. */
1679 PJ_DECL(pj_status_t) pj_ssl_sock_set_certificate(
1680                                             pj_ssl_sock_t *ssock,
1681                                             pj_pool_t *pool,
1682                                             const pj_ssl_cert_t *cert)
1683 {
1684     pj_ssl_cert_t *cert_;
1685
1686     PJ_ASSERT_RETURN(ssock && pool && cert, PJ_EINVAL);
1687
1688     cert_ = PJ_POOL_ZALLOC_T(pool, pj_ssl_cert_t);
1689     pj_memcpy(cert_, cert, sizeof(cert));
1690     pj_strdup_with_null(pool, &cert_->CA_file, &cert->CA_file);
1691     pj_strdup_with_null(pool, &cert_->cert_file, &cert->cert_file);
1692     pj_strdup_with_null(pool, &cert_->privkey_file, &cert->privkey_file);
1693     pj_strdup_with_null(pool, &cert_->privkey_pass, &cert->privkey_pass);
1694
1695     ssock->cert = cert_;
1696
1697     return PJ_SUCCESS;
1698 }
1699
1700
1701 /* Get available ciphers. */
1702 PJ_DEF(pj_status_t) pj_ssl_cipher_get_availables(pj_ssl_cipher ciphers[],
1703                                                  unsigned *cipher_num)
1704 {
1705     unsigned i;
1706
1707     PJ_ASSERT_RETURN(ciphers && cipher_num, PJ_EINVAL);
1708
1709     if (openssl_cipher_num == 0) {
1710         init_openssl();
1711         shutdown_openssl();
1712     }
1713
1714     if (openssl_cipher_num == 0) {
1715         *cipher_num = 0;
1716         return PJ_ENOTFOUND;
1717     }
1718
1719     *cipher_num = PJ_MIN(*cipher_num, openssl_cipher_num);
1720
1721     for (i = 0; i < *cipher_num; ++i)
1722         ciphers[i] = openssl_ciphers[i].id;
1723
1724     return PJ_SUCCESS;
1725 }
1726
1727
1728 /* Get cipher name string */
1729 PJ_DEF(const char*) pj_ssl_cipher_name(pj_ssl_cipher cipher)
1730 {
1731     unsigned i;
1732
1733     if (openssl_cipher_num == 0) {
1734         init_openssl();
1735         shutdown_openssl();
1736     }
1737
1738     for (i = 0; i < openssl_cipher_num; ++i) {
1739         if (cipher == openssl_ciphers[i].id)
1740             return openssl_ciphers[i].name;
1741     }
1742
1743     return NULL;
1744 }
1745
1746 /* Check if the specified cipher is supported by SSL/TLS backend. */
1747 PJ_DEF(pj_bool_t) pj_ssl_cipher_is_supported(pj_ssl_cipher cipher)
1748 {
1749     unsigned i;
1750
1751     if (openssl_cipher_num == 0) {
1752         init_openssl();
1753         shutdown_openssl();
1754     }
1755
1756     for (i = 0; i < openssl_cipher_num; ++i) {
1757         if (cipher == openssl_ciphers[i].id)
1758             return PJ_TRUE;
1759     }
1760
1761     return PJ_FALSE;
1762 }
1763
1764
1765 /*
1766  * Create SSL socket instance.
1767  */
1768 PJ_DEF(pj_status_t) pj_ssl_sock_create (pj_pool_t *pool,
1769                                         const pj_ssl_sock_param *param,
1770                                         pj_ssl_sock_t **p_ssock)
1771 {
1772     pj_ssl_sock_t *ssock;
1773     pj_status_t status;
1774
1775     PJ_ASSERT_RETURN(pool && param && p_ssock, PJ_EINVAL);
1776     PJ_ASSERT_RETURN(param->sock_type == pj_SOCK_STREAM(), PJ_ENOTSUP);
1777
1778     pool = pj_pool_create(pool->factory, "ssl%p", 512, 512, NULL);
1779
1780     /* Create secure socket */
1781     ssock = PJ_POOL_ZALLOC_T(pool, pj_ssl_sock_t);
1782     ssock->pool = pool;
1783     ssock->sock = PJ_INVALID_SOCKET;
1784     ssock->ssl_state = SSL_STATE_NULL;
1785     pj_list_init(&ssock->write_pending);
1786     pj_list_init(&ssock->write_pending_empty);
1787     pj_timer_entry_init(&ssock->timer, 0, ssock, &on_timer);
1788
1789     /* Create secure socket mutex */
1790     status = pj_lock_create_recursive_mutex(pool, pool->obj_name,
1791                                             &ssock->write_mutex);
1792     if (status != PJ_SUCCESS)
1793         return status;
1794
1795     /* Init secure socket param */
1796     ssock->param = *param;
1797     ssock->param.read_buffer_size = ((ssock->param.read_buffer_size+7)>>3)<<3;
1798     if (param->ciphers_num > 0) {
1799         unsigned i;
1800         ssock->param.ciphers = (pj_ssl_cipher*)
1801                                pj_pool_calloc(pool, param->ciphers_num,
1802                                               sizeof(pj_ssl_cipher));
1803         for (i = 0; i < param->ciphers_num; ++i)
1804             ssock->param.ciphers[i] = param->ciphers[i];
1805     }
1806
1807     /* Server name must be null-terminated */
1808     pj_strdup_with_null(pool, &ssock->param.server_name,
1809                         &param->server_name);
1810
1811     /* Finally */
1812     *p_ssock = ssock;
1813
1814     return PJ_SUCCESS;
1815 }
1816
1817
1818 /*
1819  * Close the secure socket. This will unregister the socket from the
1820  * ioqueue and ultimately close the socket.
1821  */
1822 PJ_DEF(pj_status_t) pj_ssl_sock_close(pj_ssl_sock_t *ssock)
1823 {
1824     pj_pool_t *pool;
1825
1826     PJ_ASSERT_RETURN(ssock, PJ_EINVAL);
1827
1828     if (!ssock->pool)
1829         return PJ_SUCCESS;
1830
1831     if (ssock->timer.id != TIMER_NONE) {
1832         pj_timer_heap_cancel(ssock->param.timer_heap, &ssock->timer);
1833         ssock->timer.id = TIMER_NONE;
1834     }
1835
1836     reset_ssl_sock_state(ssock);
1837     pj_lock_destroy(ssock->write_mutex);
1838
1839     pool = ssock->pool;
1840     ssock->pool = NULL;
1841     if (pool)
1842         pj_pool_release(pool);
1843
1844     return PJ_SUCCESS;
1845 }
1846
1847
1848 /*
1849  * Associate arbitrary data with the secure socket.
1850  */
1851 PJ_DEF(pj_status_t) pj_ssl_sock_set_user_data(pj_ssl_sock_t *ssock,
1852                                               void *user_data)
1853 {
1854     PJ_ASSERT_RETURN(ssock, PJ_EINVAL);
1855
1856     ssock->param.user_data = user_data;
1857     return PJ_SUCCESS;
1858 }
1859
1860
1861 /*
1862  * Retrieve the user data previously associated with this secure
1863  * socket.
1864  */
1865 PJ_DEF(void*) pj_ssl_sock_get_user_data(pj_ssl_sock_t *ssock)
1866 {
1867     PJ_ASSERT_RETURN(ssock, NULL);
1868
1869     return ssock->param.user_data;
1870 }
1871
1872
1873 /*
1874  * Retrieve the local address and port used by specified SSL socket.
1875  */
1876 PJ_DEF(pj_status_t) pj_ssl_sock_get_info (pj_ssl_sock_t *ssock,
1877                                           pj_ssl_sock_info *info)
1878 {
1879     pj_bzero(info, sizeof(*info));
1880
1881     /* Established flag */
1882     info->established = (ssock->ssl_state == SSL_STATE_ESTABLISHED);
1883
1884     /* Protocol */
1885     info->proto = ssock->param.proto;
1886
1887     /* Local address */
1888     pj_sockaddr_cp(&info->local_addr, &ssock->local_addr);
1889
1890     if (info->established) {
1891         const SSL_CIPHER *cipher;
1892
1893         /* Current cipher */
1894         cipher = SSL_get_current_cipher(ssock->ossl_ssl);
1895         info->cipher = (cipher->id & 0x00FFFFFF);
1896
1897         /* Remote address */
1898         pj_sockaddr_cp(&info->remote_addr, &ssock->rem_addr);
1899
1900         /* Certificates info */
1901         info->local_cert_info = &ssock->local_cert_info;
1902         info->remote_cert_info = &ssock->remote_cert_info;
1903
1904         /* Verification status */
1905         info->verify_status = ssock->verify_status;
1906     }
1907
1908     return PJ_SUCCESS;
1909 }
1910
1911
1912 /*
1913  * Starts read operation on this secure socket.
1914  */
1915 PJ_DEF(pj_status_t) pj_ssl_sock_start_read (pj_ssl_sock_t *ssock,
1916                                             pj_pool_t *pool,
1917                                             unsigned buff_size,
1918                                             pj_uint32_t flags)
1919 {
1920     void **readbuf;
1921     unsigned i;
1922
1923     PJ_ASSERT_RETURN(ssock && pool && buff_size, PJ_EINVAL);
1924     PJ_ASSERT_RETURN(ssock->ssl_state==SSL_STATE_ESTABLISHED, PJ_EINVALIDOP);
1925
1926     readbuf = (void**) pj_pool_calloc(pool, ssock->param.async_cnt,
1927                                       sizeof(void*));
1928
1929     for (i=0; i<ssock->param.async_cnt; ++i) {
1930         readbuf[i] = pj_pool_alloc(pool, buff_size);
1931     }
1932
1933     return pj_ssl_sock_start_read2(ssock, pool, buff_size,
1934                                    readbuf, flags);
1935 }
1936
1937
1938 /*
1939  * Same as #pj_ssl_sock_start_read(), except that the application
1940  * supplies the buffers for the read operation so that the acive socket
1941  * does not have to allocate the buffers.
1942  */
1943 PJ_DEF(pj_status_t) pj_ssl_sock_start_read2 (pj_ssl_sock_t *ssock,
1944                                              pj_pool_t *pool,
1945                                              unsigned buff_size,
1946                                              void *readbuf[],
1947                                              pj_uint32_t flags)
1948 {
1949     unsigned i;
1950
1951     PJ_ASSERT_RETURN(ssock && pool && buff_size && readbuf, PJ_EINVAL);
1952     PJ_ASSERT_RETURN(ssock->ssl_state==SSL_STATE_ESTABLISHED, PJ_EINVALIDOP);
1953
1954     /* Create SSL socket read buffer */
1955     ssock->ssock_rbuf = (read_data_t*)pj_pool_calloc(pool,
1956                                                ssock->param.async_cnt,
1957                                                sizeof(read_data_t));
1958
1959     /* Store SSL socket read buffer pointer in the activesock read buffer */
1960     for (i=0; i<ssock->param.async_cnt; ++i) {
1961         read_data_t **p_ssock_rbuf =
1962                         OFFSET_OF_READ_DATA_PTR(ssock, ssock->asock_rbuf[i]);
1963
1964         ssock->ssock_rbuf[i].data = readbuf[i];
1965         ssock->ssock_rbuf[i].len = 0;
1966
1967         *p_ssock_rbuf = &ssock->ssock_rbuf[i];
1968     }
1969
1970     ssock->read_size = buff_size;
1971     ssock->read_started = PJ_TRUE;
1972     ssock->read_flags = flags;
1973
1974     return PJ_SUCCESS;
1975 }
1976
1977
1978 /*
1979  * Same as pj_ssl_sock_start_read(), except that this function is used
1980  * only for datagram sockets, and it will trigger \a on_data_recvfrom()
1981  * callback instead.
1982  */
1983 PJ_DEF(pj_status_t) pj_ssl_sock_start_recvfrom (pj_ssl_sock_t *ssock,
1984                                                 pj_pool_t *pool,
1985                                                 unsigned buff_size,
1986                                                 pj_uint32_t flags)
1987 {
1988     PJ_UNUSED_ARG(ssock);
1989     PJ_UNUSED_ARG(pool);
1990     PJ_UNUSED_ARG(buff_size);
1991     PJ_UNUSED_ARG(flags);
1992
1993     return PJ_ENOTSUP;
1994 }
1995
1996
1997 /*
1998  * Same as #pj_ssl_sock_start_recvfrom() except that the recvfrom()
1999  * operation takes the buffer from the argument rather than creating
2000  * new ones.
2001  */
2002 PJ_DEF(pj_status_t) pj_ssl_sock_start_recvfrom2 (pj_ssl_sock_t *ssock,
2003                                                  pj_pool_t *pool,
2004                                                  unsigned buff_size,
2005                                                  void *readbuf[],
2006                                                  pj_uint32_t flags)
2007 {
2008     PJ_UNUSED_ARG(ssock);
2009     PJ_UNUSED_ARG(pool);
2010     PJ_UNUSED_ARG(buff_size);
2011     PJ_UNUSED_ARG(readbuf);
2012     PJ_UNUSED_ARG(flags);
2013
2014     return PJ_ENOTSUP;
2015 }
2016
2017 /* Write plain data to SSL and flush write BIO. Note that accessing
2018  * write BIO must be serialized, so a call to this function must be
2019  * protected by write mutex of SSL socket.
2020  */
2021 static pj_status_t ssl_write(pj_ssl_sock_t *ssock,
2022                              pj_ioqueue_op_key_t *send_key,
2023                              const void *data,
2024                              pj_ssize_t size,
2025                              unsigned flags)
2026 {
2027     pj_status_t status;
2028     int nwritten;
2029
2030     /* Write the plain data to SSL, after SSL encrypts it, write BIO will
2031      * contain the secured data to be sent via socket. Note that re-
2032      * negotitation may be on progress, so sending data should be delayed
2033      * until re-negotiation is completed.
2034      */
2035     nwritten = SSL_write(ssock->ossl_ssl, data, size);
2036
2037     if (nwritten == size) {
2038         /* All data written, flush write BIO to network socket */
2039         status = flush_write_bio(ssock, send_key, size, flags);
2040     } else if (nwritten <= 0) {
2041         /* SSL failed to process the data, it may just that re-negotiation
2042          * is on progress.
2043          */
2044         int err;
2045         err = SSL_get_error(ssock->ossl_ssl, nwritten);
2046         if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_NONE) {
2047             /* Re-negotiation is on progress, flush re-negotiation data */
2048             status = flush_write_bio(ssock, &ssock->handshake_op_key, 0, 0);
2049             if (status == PJ_SUCCESS || status == PJ_EPENDING)
2050                 /* Just return PJ_EBUSY when re-negotiation is on progress */
2051                 status = PJ_EBUSY;
2052         } else {
2053             /* Some problem occured */
2054             GET_SSL_STATUS(status);
2055         }
2056     } else {
2057         /* nwritten < *size, shouldn't happen, unless write BIO cannot hold
2058          * the whole secured data, perhaps because of insufficient memory.
2059          */
2060         status = PJ_ENOMEM;
2061     }
2062
2063     return status;
2064 }
2065
2066 /* Flush delayed data sending in the write pending list. Note that accessing
2067  * write pending list must be serialized, so a call to this function must be
2068  * protected by write mutex of SSL socket.
2069  */
2070 static pj_status_t flush_delayed_send(pj_ssl_sock_t *ssock)
2071 {
2072     while (!pj_list_empty(&ssock->write_pending)) {
2073         write_pending_t *wp;
2074         pj_status_t status;
2075
2076         wp = ssock->write_pending.next;
2077
2078         status = ssl_write(ssock, &wp->data.key, wp->data.data.ptr,
2079                            wp->data.plain_data_len, wp->data.flags);
2080         if (status != PJ_SUCCESS)
2081             return status;
2082
2083         pj_list_erase(wp);
2084         pj_list_push_back(&ssock->write_pending_empty, wp);
2085     }
2086
2087     return PJ_SUCCESS;
2088 }
2089
2090 /* Sending is delayed, push back the sending data into pending list. Note that
2091  * accessing write pending list must be serialized, so a call to this function
2092  * must be protected by write mutex of SSL socket.
2093  */
2094 static pj_status_t delay_send (pj_ssl_sock_t *ssock,
2095                                pj_ioqueue_op_key_t *send_key,
2096                                const void *data,
2097                                pj_ssize_t size,
2098                                unsigned flags)
2099 {
2100     write_pending_t *wp;
2101
2102     /* Init write pending instance */
2103     if (!pj_list_empty(&ssock->write_pending_empty)) {
2104         wp = ssock->write_pending_empty.next;
2105         pj_list_erase(wp);
2106     } else {
2107         wp = PJ_POOL_ZALLOC_T(ssock->pool, write_pending_t);
2108     }
2109
2110     wp->data.app_key = send_key;
2111     wp->data.plain_data_len = size;
2112     wp->data.data.ptr = data;
2113     wp->data.flags = flags;
2114
2115     pj_list_push_back(&ssock->write_pending, wp);
2116
2117     /* Must return PJ_EPENDING */
2118     return PJ_EPENDING;
2119 }
2120
2121 /**
2122  * Send data using the socket.
2123  */
2124 PJ_DEF(pj_status_t) pj_ssl_sock_send (pj_ssl_sock_t *ssock,
2125                                       pj_ioqueue_op_key_t *send_key,
2126                                       const void *data,
2127                                       pj_ssize_t *size,
2128                                       unsigned flags)
2129 {
2130     pj_status_t status;
2131
2132     PJ_ASSERT_RETURN(ssock && data && size && (*size>0), PJ_EINVAL);
2133     PJ_ASSERT_RETURN(ssock->ssl_state==SSL_STATE_ESTABLISHED, PJ_EINVALIDOP);
2134
2135     pj_lock_acquire(ssock->write_mutex);
2136
2137     /* Flush delayed send first. Sending data might be delayed when
2138      * re-negotiation is on-progress.
2139      */
2140     status = flush_delayed_send(ssock);
2141     if (status == PJ_EBUSY) {
2142         /* Re-negotiation is on progress, delay sending */
2143         status = delay_send(ssock, send_key, data, *size, flags);
2144         goto on_return;
2145     } else if (status != PJ_SUCCESS) {
2146         goto on_return;
2147     }
2148
2149     /* Write data to SSL */
2150     status = ssl_write(ssock, send_key, data, *size, flags);
2151     if (status == PJ_EBUSY) {
2152         /* Re-negotiation is on progress, delay sending */
2153         status = delay_send(ssock, send_key, data, *size, flags);
2154     }
2155
2156 on_return:
2157     pj_lock_release(ssock->write_mutex);
2158     return status;
2159 }
2160
2161
2162 /**
2163  * Send datagram using the socket.
2164  */
2165 PJ_DEF(pj_status_t) pj_ssl_sock_sendto (pj_ssl_sock_t *ssock,
2166                                         pj_ioqueue_op_key_t *send_key,
2167                                         const void *data,
2168                                         pj_ssize_t *size,
2169                                         unsigned flags,
2170                                         const pj_sockaddr_t *addr,
2171                                         int addr_len)
2172 {
2173     PJ_UNUSED_ARG(ssock);
2174     PJ_UNUSED_ARG(send_key);
2175     PJ_UNUSED_ARG(data);
2176     PJ_UNUSED_ARG(size);
2177     PJ_UNUSED_ARG(flags);
2178     PJ_UNUSED_ARG(addr);
2179     PJ_UNUSED_ARG(addr_len);
2180
2181     return PJ_ENOTSUP;
2182 }
2183
2184
2185 /**
2186  * Starts asynchronous socket accept() operations on this secure socket.
2187  */
2188 PJ_DEF(pj_status_t) pj_ssl_sock_start_accept (pj_ssl_sock_t *ssock,
2189                                               pj_pool_t *pool,
2190                                               const pj_sockaddr_t *localaddr,
2191                                               int addr_len)
2192 {
2193     pj_activesock_cb asock_cb;
2194     pj_activesock_cfg asock_cfg;
2195     pj_status_t status;
2196
2197     PJ_ASSERT_RETURN(ssock && pool && localaddr && addr_len, PJ_EINVAL);
2198
2199     /* Create socket */
2200     status = pj_sock_socket(ssock->param.sock_af, ssock->param.sock_type, 0,
2201                             &ssock->sock);
2202     if (status != PJ_SUCCESS)
2203         goto on_error;
2204
2205     /* Apply QoS, if specified */
2206     status = pj_sock_apply_qos2(ssock->sock, ssock->param.qos_type,
2207                                 &ssock->param.qos_params, 2,
2208                                 ssock->pool->obj_name, NULL);
2209     if (status != PJ_SUCCESS && !ssock->param.qos_ignore_error)
2210         goto on_error;
2211
2212     /* Bind socket */
2213     status = pj_sock_bind(ssock->sock, localaddr, addr_len);
2214     if (status != PJ_SUCCESS)
2215         goto on_error;
2216
2217     /* Start listening to the address */
2218     status = pj_sock_listen(ssock->sock, PJ_SOMAXCONN);
2219     if (status != PJ_SUCCESS)
2220         goto on_error;
2221
2222     /* Create active socket */
2223     pj_activesock_cfg_default(&asock_cfg);
2224     asock_cfg.async_cnt = ssock->param.async_cnt;
2225     asock_cfg.concurrency = ssock->param.concurrency;
2226     asock_cfg.whole_data = PJ_TRUE;
2227
2228     pj_bzero(&asock_cb, sizeof(asock_cb));
2229     asock_cb.on_accept_complete = asock_on_accept_complete;
2230
2231     status = pj_activesock_create(pool,
2232                                   ssock->sock,
2233                                   ssock->param.sock_type,
2234                                   &asock_cfg,
2235                                   ssock->param.ioqueue,
2236                                   &asock_cb,
2237                                   ssock,
2238                                   &ssock->asock);
2239
2240     if (status != PJ_SUCCESS)
2241         goto on_error;
2242
2243     /* Start accepting */
2244     status = pj_activesock_start_accept(ssock->asock, pool);
2245     if (status != PJ_SUCCESS)
2246         goto on_error;
2247
2248     /* Update local address */
2249     ssock->addr_len = addr_len;
2250     status = pj_sock_getsockname(ssock->sock, &ssock->local_addr,
2251                                  &ssock->addr_len);
2252     if (status != PJ_SUCCESS)
2253         pj_sockaddr_cp(&ssock->local_addr, localaddr);
2254
2255     ssock->is_server = PJ_TRUE;
2256
2257     return PJ_SUCCESS;
2258
2259 on_error:
2260     reset_ssl_sock_state(ssock);
2261     return status;
2262 }
2263
2264
2265 /**
2266  * Starts asynchronous socket connect() operation.
2267  */
2268 PJ_DECL(pj_status_t) pj_ssl_sock_start_connect(pj_ssl_sock_t *ssock,
2269                                                pj_pool_t *pool,
2270                                                const pj_sockaddr_t *localaddr,
2271                                                const pj_sockaddr_t *remaddr,
2272                                                int addr_len)
2273 {
2274     pj_activesock_cb asock_cb;
2275     pj_activesock_cfg asock_cfg;
2276     pj_status_t status;
2277
2278     PJ_ASSERT_RETURN(ssock && pool && localaddr && remaddr && addr_len,
2279                      PJ_EINVAL);
2280
2281     /* Create socket */
2282     status = pj_sock_socket(ssock->param.sock_af, ssock->param.sock_type, 0,
2283                             &ssock->sock);
2284     if (status != PJ_SUCCESS)
2285         goto on_error;
2286
2287     /* Apply QoS, if specified */
2288     status = pj_sock_apply_qos2(ssock->sock, ssock->param.qos_type,
2289                                 &ssock->param.qos_params, 2,
2290                                 ssock->pool->obj_name, NULL);
2291     if (status != PJ_SUCCESS && !ssock->param.qos_ignore_error)
2292         goto on_error;
2293
2294     /* Bind socket */
2295     status = pj_sock_bind(ssock->sock, localaddr, addr_len);
2296     if (status != PJ_SUCCESS)
2297         goto on_error;
2298
2299     /* Create active socket */
2300     pj_activesock_cfg_default(&asock_cfg);
2301     asock_cfg.async_cnt = ssock->param.async_cnt;
2302     asock_cfg.concurrency = ssock->param.concurrency;
2303     asock_cfg.whole_data = PJ_TRUE;
2304
2305     pj_bzero(&asock_cb, sizeof(asock_cb));
2306     asock_cb.on_connect_complete = asock_on_connect_complete;
2307     asock_cb.on_data_read = asock_on_data_read;
2308     asock_cb.on_data_sent = asock_on_data_sent;
2309
2310     status = pj_activesock_create(pool,
2311                                   ssock->sock,
2312                                   ssock->param.sock_type,
2313                                   &asock_cfg,
2314                                   ssock->param.ioqueue,
2315                                   &asock_cb,
2316                                   ssock,
2317                                   &ssock->asock);
2318
2319     if (status != PJ_SUCCESS)
2320         goto on_error;
2321
2322     /* Save remote address */
2323     pj_sockaddr_cp(&ssock->rem_addr, remaddr);
2324
2325     /* Start timer */
2326     if (ssock->param.timer_heap && (ssock->param.timeout.sec != 0 ||
2327         ssock->param.timeout.msec != 0))
2328     {
2329         pj_assert(ssock->timer.id == TIMER_NONE);
2330         ssock->timer.id = TIMER_HANDSHAKE_TIMEOUT;
2331         status = pj_timer_heap_schedule(ssock->param.timer_heap,
2332                                         &ssock->timer,
2333                                         &ssock->param.timeout);
2334         if (status != PJ_SUCCESS)
2335             ssock->timer.id = TIMER_NONE;
2336     }
2337
2338     status = pj_activesock_start_connect(ssock->asock, pool, remaddr,
2339                                          addr_len);
2340
2341     if (status == PJ_SUCCESS)
2342         asock_on_connect_complete(ssock->asock, PJ_SUCCESS);
2343     else if (status != PJ_EPENDING)
2344         goto on_error;
2345
2346     /* Update local address */
2347     ssock->addr_len = addr_len;
2348     status = pj_sock_getsockname(ssock->sock, &ssock->local_addr,
2349                                  &ssock->addr_len);
2350     /* Note that we may not get an IP address here. This can
2351      * happen for example on Windows, where getsockname()
2352      * would return 0.0.0.0 if socket has just started the
2353      * async connect. In this case, just leave the local
2354      * address with 0.0.0.0 for now; it will be updated
2355      * once the socket is established.
2356      */
2357
2358     /* Update SSL state */
2359     ssock->is_server = PJ_FALSE;
2360
2361     return PJ_EPENDING;
2362
2363 on_error:
2364     reset_ssl_sock_state(ssock);
2365     return status;
2366 }
2367
2368
2369 PJ_DEF(pj_status_t) pj_ssl_sock_renegotiate(pj_ssl_sock_t *ssock)
2370 {
2371     int ret;
2372     pj_status_t status;
2373
2374     PJ_ASSERT_RETURN(ssock->ssl_state == SSL_STATE_ESTABLISHED, PJ_EINVALIDOP);
2375
2376     if (SSL_renegotiate_pending(ssock->ossl_ssl))
2377         return PJ_EPENDING;
2378
2379     ret = SSL_renegotiate(ssock->ossl_ssl);
2380     if (ret <= 0) {
2381         GET_SSL_STATUS(status);
2382     } else {
2383         status = do_handshake(ssock);
2384     }
2385
2386     return status;
2387 }
2388
2389 #endif  /* PJ_HAS_SSL_SOCK */
2390