Multiple revisions 380735-380736
[asterisk/asterisk.git] / 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