← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.2.1/pjsip/src/pjsip/sip_transport_tls.c

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-01-07 14:51:16 UTC
  • mfrom: (4.3.5 sid)
  • Revision ID: package-import@ubuntu.com-20150107145116-yxnafinf4lrdvrmx
Tags: 1.4.1-0.1ubuntu1
* Merge with Debian, remaining changes:
 - Drop soprano, nepomuk build-dep
* Drop ubuntu patches, now upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.2.1/pjsip/src/pjsip/sip_transport_tls.c
 
1
/* $Id: sip_transport_tls.c 4726 2014-02-04 04:56:50Z ming $ */
 
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
 
 
20
#include <pjsip/sip_transport_tls.h>
 
21
#include <pjsip/sip_endpoint.h>
 
22
#include <pjsip/sip_errno.h>
 
23
#include <pj/compat/socket.h>
 
24
#include <pj/addr_resolv.h>
 
25
#include <pj/ssl_sock.h>
 
26
#include <pj/assert.h>
 
27
#include <pj/hash.h>
 
28
#include <pj/lock.h>
 
29
#include <pj/log.h>
 
30
#include <pj/os.h>
 
31
#include <pj/pool.h>
 
32
#include <pj/string.h>
 
33
 
 
34
#if defined(PJSIP_HAS_TLS_TRANSPORT) && PJSIP_HAS_TLS_TRANSPORT!=0
 
35
 
 
36
#define THIS_FILE       "sip_transport_tls.c"
 
37
 
 
38
#define MAX_ASYNC_CNT   16
 
39
#define POOL_LIS_INIT   512
 
40
#define POOL_LIS_INC    512
 
41
#define POOL_TP_INIT    512
 
42
#define POOL_TP_INC     512
 
43
 
 
44
struct tls_listener;
 
45
struct tls_transport;
 
46
 
 
47
/*
 
48
 * Definition of TLS/SSL transport listener, and it's descendant of
 
49
 * pjsip_tpfactory.
 
50
 */
 
51
struct tls_listener
 
52
{
 
53
    pjsip_tpfactory          factory;
 
54
    pj_bool_t                is_registered;
 
55
    pjsip_endpoint          *endpt;
 
56
    pjsip_tpmgr             *tpmgr;
 
57
    pj_ssl_sock_t           *ssock;
 
58
    pj_sockaddr              bound_addr;
 
59
    pj_ssl_cert_t           *cert;
 
60
    pjsip_tls_setting        tls_setting;
 
61
};
 
62
 
 
63
 
 
64
/*
 
65
 * This structure is used to keep delayed transmit operation in a list.
 
66
 * A delayed transmission occurs when application sends tx_data when
 
67
 * the TLS connect/establishment is still in progress. These delayed
 
68
 * transmission will be "flushed" once the socket is connected (either
 
69
 * successfully or with errors).
 
70
 */
 
71
struct delayed_tdata
 
72
{
 
73
    PJ_DECL_LIST_MEMBER(struct delayed_tdata);
 
74
    pjsip_tx_data_op_key    *tdata_op_key;
 
75
    pj_time_val              timeout;
 
76
};
 
77
 
 
78
 
 
79
/*
 
80
 * TLS/SSL transport, and it's descendant of pjsip_transport.
 
81
 */
 
82
struct tls_transport
 
83
{
 
84
    pjsip_transport          base;
 
85
    pj_bool_t                is_server;
 
86
    pj_str_t                 remote_name;
 
87
 
 
88
    pj_bool_t                is_registered;
 
89
    pj_bool_t                is_closing;
 
90
    pj_status_t              close_reason;
 
91
    pj_ssl_sock_t           *ssock;
 
92
    pj_bool_t                has_pending_connect;
 
93
    pj_bool_t                verify_server;
 
94
 
 
95
    /* Keep-alive timer. */
 
96
    pj_timer_entry           ka_timer;
 
97
    pj_time_val              last_activity;
 
98
    pjsip_tx_data_op_key     ka_op_key;
 
99
    pj_str_t                 ka_pkt;
 
100
 
 
101
    /* TLS transport can only have  one rdata!
 
102
     * Otherwise chunks of incoming PDU may be received on different
 
103
     * buffer.
 
104
     */
 
105
    pjsip_rx_data            rdata;
 
106
 
 
107
    /* Pending transmission list. */
 
108
    struct delayed_tdata     delayed_list;
 
109
};
 
110
 
 
111
 
 
112
/****************************************************************************
 
113
 * PROTOTYPES
 
114
 */
 
115
 
 
116
/* This callback is called when pending accept() operation completes. */
 
117
static pj_bool_t on_accept_complete(pj_ssl_sock_t *ssock,
 
118
                                    pj_ssl_sock_t *new_ssock,
 
119
                                    const pj_sockaddr_t *src_addr,
 
120
                                    int src_addr_len);
 
121
 
 
122
/* Callback on incoming data */
 
123
static pj_bool_t on_data_read(pj_ssl_sock_t *ssock,
 
124
                              void *data,
 
125
                              pj_size_t size,
 
126
                              pj_status_t status,
 
127
                              pj_size_t *remainder);
 
128
 
 
129
/* Callback when packet is sent */
 
130
static pj_bool_t on_data_sent(pj_ssl_sock_t *ssock,
 
131
                              pj_ioqueue_op_key_t *send_key,
 
132
                              pj_ssize_t sent);
 
133
 
 
134
/* This callback is called by transport manager to destroy listener */
 
135
static pj_status_t lis_destroy(pjsip_tpfactory *factory);
 
136
 
 
137
/* This callback is called by transport manager to create transport */
 
138
static pj_status_t lis_create_transport(pjsip_tpfactory *factory,
 
139
                                        pjsip_tpmgr *mgr,
 
140
                                        pjsip_endpoint *endpt,
 
141
                                        const pj_sockaddr *rem_addr,
 
142
                                        int addr_len,
 
143
                                        pjsip_tx_data *tdata,
 
144
                                        pjsip_transport **transport);
 
145
 
 
146
/* Common function to create and initialize transport */
 
147
static pj_status_t tls_create(struct tls_listener *listener,
 
148
                              pj_pool_t *pool,
 
149
                              pj_ssl_sock_t *ssock, 
 
150
                              pj_bool_t is_server,
 
151
                              const pj_sockaddr *local,
 
152
                              const pj_sockaddr *remote,
 
153
                              const pj_str_t *remote_name,
 
154
                              struct tls_transport **p_tls);
 
155
 
 
156
 
 
157
static void tls_perror(const char *sender, const char *title,
 
158
                       pj_status_t status)
 
159
{
 
160
    char errmsg[PJ_ERR_MSG_SIZE];
 
161
 
 
162
    pj_strerror(status, errmsg, sizeof(errmsg));
 
163
 
 
164
    PJ_LOG(1,(sender, "%s: %s [code=%d]", title, errmsg, status));
 
165
}
 
166
 
 
167
 
 
168
static void sockaddr_to_host_port( pj_pool_t *pool,
 
169
                                   pjsip_host_port *host_port,
 
170
                                   const pj_sockaddr *addr )
 
171
{
 
172
    host_port->host.ptr = (char*) pj_pool_alloc(pool, PJ_INET6_ADDRSTRLEN+4);
 
173
    pj_sockaddr_print(addr, host_port->host.ptr, PJ_INET6_ADDRSTRLEN+4, 0);
 
174
    host_port->host.slen = pj_ansi_strlen(host_port->host.ptr);
 
175
    host_port->port = pj_sockaddr_get_port(addr);
 
176
}
 
177
 
 
178
 
 
179
static void tls_init_shutdown(struct tls_transport *tls, pj_status_t status)
 
180
{
 
181
    pjsip_tp_state_callback state_cb;
 
182
 
 
183
    if (tls->close_reason == PJ_SUCCESS)
 
184
        tls->close_reason = status;
 
185
 
 
186
    if (tls->base.is_shutdown || tls->base.is_destroying)
 
187
        return;
 
188
 
 
189
    /* Prevent immediate transport destroy by application, as transport
 
190
     * state notification callback may be stacked and transport instance
 
191
     * must remain valid at any point in the callback.
 
192
     */
 
193
    pjsip_transport_add_ref(&tls->base);
 
194
 
 
195
    /* Notify application of transport disconnected state */
 
196
    state_cb = pjsip_tpmgr_get_state_cb(tls->base.tpmgr);
 
197
    if (state_cb) {
 
198
        pjsip_transport_state_info state_info;
 
199
        pjsip_tls_state_info tls_info;
 
200
        pj_ssl_sock_info ssl_info;
 
201
        
 
202
        /* Init transport state info */
 
203
        pj_bzero(&state_info, sizeof(state_info));
 
204
        state_info.status = tls->close_reason;
 
205
 
 
206
        if (tls->ssock && 
 
207
            pj_ssl_sock_get_info(tls->ssock, &ssl_info) == PJ_SUCCESS)
 
208
        {
 
209
            pj_bzero(&tls_info, sizeof(tls_info));
 
210
            tls_info.ssl_sock_info = &ssl_info;
 
211
            state_info.ext_info = &tls_info;
 
212
        }
 
213
 
 
214
        (*state_cb)(&tls->base, PJSIP_TP_STATE_DISCONNECTED, &state_info);
 
215
    }
 
216
 
 
217
    /* check again */
 
218
    if (tls->base.is_shutdown || tls->base.is_destroying) {
 
219
        pjsip_transport_dec_ref(&tls->base);
 
220
        return;
 
221
    }
 
222
 
 
223
    /* We can not destroy the transport since high level objects may
 
224
     * still keep reference to this transport. So we can only 
 
225
     * instruct transport manager to gracefully start the shutdown
 
226
     * procedure for this transport.
 
227
     */
 
228
    pjsip_transport_shutdown(&tls->base);
 
229
 
 
230
    /* Now, it is ok to destroy the transport. */
 
231
    pjsip_transport_dec_ref(&tls->base);
 
232
}
 
233
 
 
234
 
 
235
/****************************************************************************
 
236
 * The TLS listener/transport factory.
 
237
 */
 
238
 
 
239
/*
 
240
 * This is the public API to create, initialize, register, and start the
 
241
 * TLS listener.
 
242
 */
 
243
PJ_DEF(pj_status_t) pjsip_tls_transport_start (pjsip_endpoint *endpt,
 
244
                                               const pjsip_tls_setting *opt,
 
245
                                               const pj_sockaddr_in *local_in,
 
246
                                               const pjsip_host_port *a_name,
 
247
                                               unsigned async_cnt,
 
248
                                               pjsip_tpfactory **p_factory)
 
249
{
 
250
    pj_sockaddr local;
 
251
 
 
252
    if (local_in)
 
253
        pj_sockaddr_cp(&local, local_in);
 
254
 
 
255
    return pjsip_tls_transport_start2(endpt, opt, (local_in? &local : NULL),
 
256
                                      a_name, async_cnt, p_factory);
 
257
}
 
258
 
 
259
PJ_DEF(pj_status_t) pjsip_tls_transport_start2( pjsip_endpoint *endpt,
 
260
                                                const pjsip_tls_setting *opt,
 
261
                                                const pj_sockaddr *local,
 
262
                                                const pjsip_host_port *a_name,
 
263
                                                unsigned async_cnt,
 
264
                                                pjsip_tpfactory **p_factory)
 
265
{
 
266
    pj_pool_t *pool;
 
267
    pj_bool_t is_ipv6;
 
268
    int af;
 
269
    struct tls_listener *listener;
 
270
    pj_ssl_sock_param ssock_param;
 
271
    pj_sockaddr *listener_addr;
 
272
    pj_bool_t has_listener;
 
273
    pj_status_t status;
 
274
 
 
275
    /* Sanity check */
 
276
    PJ_ASSERT_RETURN(endpt && async_cnt, PJ_EINVAL);
 
277
 
 
278
    is_ipv6 = (local && local->addr.sa_family == pj_AF_INET6());
 
279
    af = is_ipv6 ? pj_AF_INET6() : pj_AF_INET();
 
280
 
 
281
    /* Verify that address given in a_name (if any) is valid */
 
282
    if (a_name && a_name->host.slen) {
 
283
        pj_sockaddr tmp;
 
284
 
 
285
        status = pj_sockaddr_init(af, &tmp, &a_name->host,
 
286
                                  (pj_uint16_t)a_name->port);
 
287
        if (status != PJ_SUCCESS || !pj_sockaddr_has_addr(&tmp) ||
 
288
            (!is_ipv6 && tmp.ipv4.sin_addr.s_addr == PJ_INADDR_NONE))
 
289
        {
 
290
            /* Invalid address */
 
291
            return PJ_EINVAL;
 
292
        }
 
293
    }
 
294
 
 
295
    pool = pjsip_endpt_create_pool(endpt, "tlslis", POOL_LIS_INIT, 
 
296
                                   POOL_LIS_INC);
 
297
    PJ_ASSERT_RETURN(pool, PJ_ENOMEM);
 
298
 
 
299
    listener = PJ_POOL_ZALLOC_T(pool, struct tls_listener);
 
300
    listener->factory.pool = pool;
 
301
    if (is_ipv6)
 
302
        listener->factory.type = PJSIP_TRANSPORT_TLS6;
 
303
    else
 
304
        listener->factory.type = PJSIP_TRANSPORT_TLS;
 
305
    listener->factory.type_name = (char*)
 
306
                pjsip_transport_get_type_name(listener->factory.type);
 
307
    listener->factory.flag = 
 
308
        pjsip_transport_get_flag_from_type(listener->factory.type);
 
309
 
 
310
    pj_ansi_strcpy(listener->factory.obj_name, "tlslis");
 
311
    if (is_ipv6)
 
312
        pj_ansi_strcat(listener->factory.obj_name, "6");
 
313
 
 
314
    if (opt)
 
315
        pjsip_tls_setting_copy(pool, &listener->tls_setting, opt);
 
316
    else
 
317
        pjsip_tls_setting_default(&listener->tls_setting);
 
318
 
 
319
    status = pj_lock_create_recursive_mutex(pool, listener->factory.obj_name,
 
320
                                            &listener->factory.lock);
 
321
    if (status != PJ_SUCCESS)
 
322
        goto on_error;
 
323
 
 
324
    if (async_cnt > MAX_ASYNC_CNT) 
 
325
        async_cnt = MAX_ASYNC_CNT;
 
326
 
 
327
    /* Build SSL socket param */
 
328
    pj_ssl_sock_param_default(&ssock_param);
 
329
    ssock_param.sock_af = af;
 
330
    ssock_param.cb.on_accept_complete = &on_accept_complete;
 
331
    ssock_param.cb.on_data_read = &on_data_read;
 
332
    ssock_param.cb.on_data_sent = &on_data_sent;
 
333
    ssock_param.async_cnt = async_cnt;
 
334
    ssock_param.ioqueue = pjsip_endpt_get_ioqueue(endpt);
 
335
    ssock_param.require_client_cert = listener->tls_setting.require_client_cert;
 
336
    ssock_param.timeout = listener->tls_setting.timeout;
 
337
    ssock_param.user_data = listener;
 
338
    ssock_param.verify_peer = PJ_FALSE; /* avoid SSL socket closing the socket
 
339
                                         * due to verification error */
 
340
    if (ssock_param.send_buffer_size < PJSIP_MAX_PKT_LEN)
 
341
        ssock_param.send_buffer_size = PJSIP_MAX_PKT_LEN;
 
342
    if (ssock_param.read_buffer_size < PJSIP_MAX_PKT_LEN)
 
343
        ssock_param.read_buffer_size = PJSIP_MAX_PKT_LEN;
 
344
    ssock_param.ciphers_num = listener->tls_setting.ciphers_num;
 
345
    ssock_param.ciphers = listener->tls_setting.ciphers;
 
346
    ssock_param.reuse_addr = listener->tls_setting.reuse_addr;
 
347
    ssock_param.qos_type = listener->tls_setting.qos_type;
 
348
    ssock_param.qos_ignore_error = listener->tls_setting.qos_ignore_error;
 
349
    pj_memcpy(&ssock_param.qos_params, &listener->tls_setting.qos_params,
 
350
              sizeof(ssock_param.qos_params));
 
351
 
 
352
    has_listener = PJ_FALSE;
 
353
 
 
354
    switch(listener->tls_setting.method) {
 
355
    case PJSIP_TLSV1_METHOD:
 
356
        ssock_param.proto = PJ_SSL_SOCK_PROTO_TLS1;
 
357
        break;
 
358
    case PJSIP_SSLV2_METHOD:
 
359
        ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL2;
 
360
        break;
 
361
    case PJSIP_SSLV3_METHOD:
 
362
        ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL3;
 
363
        break;
 
364
    case PJSIP_SSLV23_METHOD:
 
365
        ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL23;
 
366
        break;
 
367
    default:
 
368
        ssock_param.proto = PJ_SSL_SOCK_PROTO_DEFAULT;
 
369
        break;
 
370
    }
 
371
 
 
372
    /* Create SSL socket */
 
373
    status = pj_ssl_sock_create(pool, &ssock_param, &listener->ssock);
 
374
    if (status != PJ_SUCCESS)
 
375
        goto on_error;
 
376
 
 
377
    /* Bind address may be different than factory.local_addr because
 
378
     * factory.local_addr will be resolved below.
 
379
     */
 
380
    listener_addr = &listener->factory.local_addr;
 
381
    if (local) {
 
382
        pj_sockaddr_cp((pj_sockaddr_t*)listener_addr, 
 
383
                       (const pj_sockaddr_t*)local);
 
384
        pj_sockaddr_cp(&listener->bound_addr, local);
 
385
    } else {
 
386
        pj_sockaddr_init(af, listener_addr, NULL, 0);
 
387
        pj_sockaddr_init(af, &listener->bound_addr, NULL, 0);
 
388
    }
 
389
 
 
390
    /* Check if certificate/CA list for SSL socket is set */
 
391
    if (listener->tls_setting.cert_file.slen ||
 
392
        listener->tls_setting.ca_list_file.slen) 
 
393
    {
 
394
        status = pj_ssl_cert_load_from_files(pool,
 
395
                        &listener->tls_setting.ca_list_file,
 
396
                        &listener->tls_setting.cert_file,
 
397
                        &listener->tls_setting.privkey_file,
 
398
                        &listener->tls_setting.password,
 
399
                        &listener->cert);
 
400
        if (status != PJ_SUCCESS)
 
401
            goto on_error;
 
402
 
 
403
        status = pj_ssl_sock_set_certificate(listener->ssock, pool, 
 
404
                                             listener->cert);
 
405
        if (status != PJ_SUCCESS)
 
406
            goto on_error;
 
407
    }
 
408
 
 
409
    /* Start accepting incoming connections. Note that some TLS/SSL backends
 
410
     * may not support for SSL socket server.
 
411
     */
 
412
    has_listener = PJ_FALSE;
 
413
 
 
414
    status = pj_ssl_sock_start_accept(listener->ssock, pool, 
 
415
                          (pj_sockaddr_t*)listener_addr, 
 
416
                          pj_sockaddr_get_len((pj_sockaddr_t*)listener_addr));
 
417
    if (status == PJ_SUCCESS || status == PJ_EPENDING) {
 
418
        pj_ssl_sock_info info;
 
419
        has_listener = PJ_TRUE;
 
420
 
 
421
        /* Retrieve the bound address */
 
422
        status = pj_ssl_sock_get_info(listener->ssock, &info);
 
423
        if (status == PJ_SUCCESS)
 
424
            pj_sockaddr_cp(listener_addr, (pj_sockaddr_t*)&info.local_addr);
 
425
    } else if (status != PJ_ENOTSUP) {
 
426
        goto on_error;
 
427
    }
 
428
 
 
429
    /* If published host/IP is specified, then use that address as the
 
430
     * listener advertised address.
 
431
     */
 
432
    if (a_name && a_name->host.slen) {
 
433
        /* Copy the address */
 
434
        listener->factory.addr_name = *a_name;
 
435
        pj_strdup(listener->factory.pool, &listener->factory.addr_name.host, 
 
436
                  &a_name->host);
 
437
        listener->factory.addr_name.port = a_name->port;
 
438
 
 
439
    } else {
 
440
        /* No published address is given, use the bound address */
 
441
 
 
442
        /* If the address returns 0.0.0.0, use the default
 
443
         * interface address as the transport's address.
 
444
         */
 
445
        if (!pj_sockaddr_has_addr(listener_addr)) {
 
446
            pj_sockaddr hostip;
 
447
 
 
448
            status = pj_gethostip(af, &hostip);
 
449
            if (status != PJ_SUCCESS)
 
450
                goto on_error;
 
451
 
 
452
            pj_sockaddr_copy_addr(listener_addr, &hostip);
 
453
        }
 
454
 
 
455
        /* Save the address name */
 
456
        sockaddr_to_host_port(listener->factory.pool, 
 
457
                              &listener->factory.addr_name, listener_addr);
 
458
    }
 
459
 
 
460
    /* If port is zero, get the bound port */
 
461
    if (listener->factory.addr_name.port == 0) {
 
462
        listener->factory.addr_name.port = pj_sockaddr_get_port(listener_addr);
 
463
    }
 
464
 
 
465
    pj_ansi_snprintf(listener->factory.obj_name, 
 
466
                     sizeof(listener->factory.obj_name),
 
467
                     "tlslis:%d",  listener->factory.addr_name.port);
 
468
 
 
469
    /* Register to transport manager */
 
470
    listener->endpt = endpt;
 
471
    listener->tpmgr = pjsip_endpt_get_tpmgr(endpt);
 
472
    listener->factory.create_transport2 = lis_create_transport;
 
473
    listener->factory.destroy = lis_destroy;
 
474
    listener->is_registered = PJ_TRUE;
 
475
    status = pjsip_tpmgr_register_tpfactory(listener->tpmgr,
 
476
                                            &listener->factory);
 
477
    if (status != PJ_SUCCESS) {
 
478
        listener->is_registered = PJ_FALSE;
 
479
        goto on_error;
 
480
    }
 
481
 
 
482
    if (has_listener) {
 
483
        PJ_LOG(4,(listener->factory.obj_name, 
 
484
                 "SIP TLS listener is ready for incoming connections "
 
485
                 "at %.*s:%d",
 
486
                 (int)listener->factory.addr_name.host.slen,
 
487
                 listener->factory.addr_name.host.ptr,
 
488
                 listener->factory.addr_name.port));
 
489
    } else {
 
490
        PJ_LOG(4,(listener->factory.obj_name, "SIP TLS is ready "
 
491
                  "(client only)"));
 
492
    }
 
493
 
 
494
    /* Return the pointer to user */
 
495
    if (p_factory) *p_factory = &listener->factory;
 
496
 
 
497
    return PJ_SUCCESS;
 
498
 
 
499
on_error:
 
500
    lis_destroy(&listener->factory);
 
501
    return status;
 
502
}
 
503
 
 
504
 
 
505
/* This callback is called by transport manager to destroy listener */
 
506
static pj_status_t lis_destroy(pjsip_tpfactory *factory)
 
507
{
 
508
    struct tls_listener *listener = (struct tls_listener *)factory;
 
509
 
 
510
    if (listener->is_registered) {
 
511
        pjsip_tpmgr_unregister_tpfactory(listener->tpmgr, &listener->factory);
 
512
        listener->is_registered = PJ_FALSE;
 
513
    }
 
514
 
 
515
    if (listener->ssock) {
 
516
        pj_ssl_sock_close(listener->ssock);
 
517
        listener->ssock = NULL;
 
518
    }
 
519
 
 
520
    if (listener->factory.lock) {
 
521
        pj_lock_destroy(listener->factory.lock);
 
522
        listener->factory.lock = NULL;
 
523
    }
 
524
 
 
525
    if (listener->factory.pool) {
 
526
        pj_pool_t *pool = listener->factory.pool;
 
527
 
 
528
        PJ_LOG(4,(listener->factory.obj_name,  "SIP TLS listener destroyed"));
 
529
 
 
530
        listener->factory.pool = NULL;
 
531
        pj_pool_release(pool);
 
532
    }
 
533
 
 
534
    return PJ_SUCCESS;
 
535
}
 
536
 
 
537
 
 
538
/***************************************************************************/
 
539
/*
 
540
 * TLS Transport
 
541
 */
 
542
 
 
543
/*
 
544
 * Prototypes.
 
545
 */
 
546
/* Called by transport manager to send message */
 
547
static pj_status_t tls_send_msg(pjsip_transport *transport, 
 
548
                                pjsip_tx_data *tdata,
 
549
                                const pj_sockaddr_t *rem_addr,
 
550
                                int addr_len,
 
551
                                void *token,
 
552
                                pjsip_transport_callback callback);
 
553
 
 
554
/* Called by transport manager to shutdown */
 
555
static pj_status_t tls_shutdown(pjsip_transport *transport);
 
556
 
 
557
/* Called by transport manager to destroy transport */
 
558
static pj_status_t tls_destroy_transport(pjsip_transport *transport);
 
559
 
 
560
/* Utility to destroy transport */
 
561
static pj_status_t tls_destroy(pjsip_transport *transport,
 
562
                               pj_status_t reason);
 
563
 
 
564
/* Callback when connect completes */
 
565
static pj_bool_t on_connect_complete(pj_ssl_sock_t *ssock,
 
566
                                     pj_status_t status);
 
567
 
 
568
/* TLS keep-alive timer callback */
 
569
static void tls_keep_alive_timer(pj_timer_heap_t *th, pj_timer_entry *e);
 
570
 
 
571
/*
 
572
 * Common function to create TLS transport, called when pending accept() and
 
573
 * pending connect() complete.
 
574
 */
 
575
static pj_status_t tls_create( struct tls_listener *listener,
 
576
                               pj_pool_t *pool,
 
577
                               pj_ssl_sock_t *ssock,
 
578
                               pj_bool_t is_server,
 
579
                               const pj_sockaddr *local,
 
580
                               const pj_sockaddr *remote,
 
581
                               const pj_str_t *remote_name,
 
582
                               struct tls_transport **p_tls)
 
583
{
 
584
    struct tls_transport *tls;
 
585
    const pj_str_t ka_pkt = PJSIP_TLS_KEEP_ALIVE_DATA;
 
586
    char print_addr[PJ_INET6_ADDRSTRLEN+10];
 
587
    pj_status_t status;
 
588
    
 
589
 
 
590
    PJ_ASSERT_RETURN(listener && ssock && local && remote && p_tls, PJ_EINVAL);
 
591
 
 
592
 
 
593
    if (pool == NULL) {
 
594
        pool = pjsip_endpt_create_pool(listener->endpt, "tls",
 
595
                                       POOL_TP_INIT, POOL_TP_INC);
 
596
        PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
 
597
    }    
 
598
 
 
599
    /*
 
600
     * Create and initialize basic transport structure.
 
601
     */
 
602
    tls = PJ_POOL_ZALLOC_T(pool, struct tls_transport);
 
603
    tls->is_server = is_server;
 
604
    tls->verify_server = listener->tls_setting.verify_server;
 
605
    pj_list_init(&tls->delayed_list);
 
606
    tls->base.pool = pool;
 
607
 
 
608
    pj_ansi_snprintf(tls->base.obj_name, PJ_MAX_OBJ_NAME, 
 
609
                     (is_server ? "tlss%p" :"tlsc%p"), tls);
 
610
 
 
611
    status = pj_atomic_create(pool, 0, &tls->base.ref_cnt);
 
612
    if (status != PJ_SUCCESS) {
 
613
        goto on_error;
 
614
    }
 
615
 
 
616
    status = pj_lock_create_recursive_mutex(pool, "tls", &tls->base.lock);
 
617
    if (status != PJ_SUCCESS) {
 
618
        goto on_error;
 
619
    }
 
620
 
 
621
    if (remote_name)
 
622
        pj_strdup(pool, &tls->remote_name, remote_name);
 
623
 
 
624
    tls->base.key.type = listener->factory.type;
 
625
    pj_sockaddr_cp(&tls->base.key.rem_addr, remote);
 
626
    tls->base.type_name = (char*)pjsip_transport_get_type_name(
 
627
                                   (pjsip_transport_type_e)tls->base.key.type);
 
628
    tls->base.flag = pjsip_transport_get_flag_from_type(
 
629
                                   (pjsip_transport_type_e)tls->base.key.type);
 
630
 
 
631
    tls->base.info = (char*) pj_pool_alloc(pool, 64);
 
632
    pj_ansi_snprintf(tls->base.info, 64, "%s to %s",
 
633
                     tls->base.type_name,
 
634
                     pj_sockaddr_print(remote, print_addr,
 
635
                                       sizeof(print_addr), 3));
 
636
 
 
637
 
 
638
    tls->base.addr_len = pj_sockaddr_get_len(remote);
 
639
    tls->base.dir = is_server? PJSIP_TP_DIR_INCOMING : PJSIP_TP_DIR_OUTGOING;
 
640
    
 
641
    /* Set initial local address */
 
642
    if (!pj_sockaddr_has_addr(local)) {
 
643
        pj_sockaddr_cp(&tls->base.local_addr,
 
644
                       &listener->factory.local_addr);
 
645
    } else {
 
646
        pj_sockaddr_cp(&tls->base.local_addr, local);
 
647
    }
 
648
    
 
649
    sockaddr_to_host_port(pool, &tls->base.local_name, &tls->base.local_addr);
 
650
    if (tls->remote_name.slen) {
 
651
        tls->base.remote_name.host = tls->remote_name;
 
652
        tls->base.remote_name.port = pj_sockaddr_get_port(remote);
 
653
    } else {
 
654
        sockaddr_to_host_port(pool, &tls->base.remote_name, remote);
 
655
    }
 
656
 
 
657
    tls->base.endpt = listener->endpt;
 
658
    tls->base.tpmgr = listener->tpmgr;
 
659
    tls->base.send_msg = &tls_send_msg;
 
660
    tls->base.do_shutdown = &tls_shutdown;
 
661
    tls->base.destroy = &tls_destroy_transport;
 
662
 
 
663
    tls->ssock = ssock;
 
664
 
 
665
    /* Register transport to transport manager */
 
666
    status = pjsip_transport_register(listener->tpmgr, &tls->base);
 
667
    if (status != PJ_SUCCESS) {
 
668
        goto on_error;
 
669
    }
 
670
 
 
671
    tls->is_registered = PJ_TRUE;
 
672
 
 
673
    /* Initialize keep-alive timer */
 
674
    tls->ka_timer.user_data = (void*)tls;
 
675
    tls->ka_timer.cb = &tls_keep_alive_timer;
 
676
    pj_ioqueue_op_key_init(&tls->ka_op_key.key, sizeof(pj_ioqueue_op_key_t));
 
677
    pj_strdup(tls->base.pool, &tls->ka_pkt, &ka_pkt);
 
678
    
 
679
    /* Done setting up basic transport. */
 
680
    *p_tls = tls;
 
681
 
 
682
    PJ_LOG(4,(tls->base.obj_name, "TLS %s transport created",
 
683
              (tls->is_server ? "server" : "client")));
 
684
 
 
685
    return PJ_SUCCESS;
 
686
 
 
687
on_error:
 
688
    tls_destroy(&tls->base, status);
 
689
    return status;
 
690
}
 
691
 
 
692
 
 
693
/* Flush all delayed transmision once the socket is connected. */
 
694
static void tls_flush_pending_tx(struct tls_transport *tls)
 
695
{
 
696
    pj_time_val now;
 
697
 
 
698
    pj_gettickcount(&now);
 
699
    pj_lock_acquire(tls->base.lock);
 
700
    while (!pj_list_empty(&tls->delayed_list)) {
 
701
        struct delayed_tdata *pending_tx;
 
702
        pjsip_tx_data *tdata;
 
703
        pj_ioqueue_op_key_t *op_key;
 
704
        pj_ssize_t size;
 
705
        pj_status_t status;
 
706
 
 
707
        pending_tx = tls->delayed_list.next;
 
708
        pj_list_erase(pending_tx);
 
709
 
 
710
        tdata = pending_tx->tdata_op_key->tdata;
 
711
        op_key = (pj_ioqueue_op_key_t*)pending_tx->tdata_op_key;
 
712
 
 
713
        if (pending_tx->timeout.sec > 0 &&
 
714
            PJ_TIME_VAL_GT(now, pending_tx->timeout))
 
715
        {
 
716
            continue;
 
717
        }
 
718
 
 
719
        /* send! */
 
720
        size = tdata->buf.cur - tdata->buf.start;
 
721
        status = pj_ssl_sock_send(tls->ssock, op_key, tdata->buf.start, 
 
722
                                  &size, 0);
 
723
 
 
724
        if (status != PJ_EPENDING) {
 
725
            pj_lock_release(tls->base.lock);
 
726
            on_data_sent(tls->ssock, op_key, size);
 
727
            pj_lock_acquire(tls->base.lock);
 
728
        }
 
729
    }
 
730
    pj_lock_release(tls->base.lock);
 
731
}
 
732
 
 
733
 
 
734
/* Called by transport manager to destroy transport */
 
735
static pj_status_t tls_destroy_transport(pjsip_transport *transport)
 
736
{
 
737
    struct tls_transport *tls = (struct tls_transport*)transport;
 
738
 
 
739
    /* Transport would have been unregistered by now since this callback
 
740
     * is called by transport manager.
 
741
     */
 
742
    tls->is_registered = PJ_FALSE;
 
743
 
 
744
    return tls_destroy(transport, tls->close_reason);
 
745
}
 
746
 
 
747
 
 
748
/* Destroy TLS transport */
 
749
static pj_status_t tls_destroy(pjsip_transport *transport, 
 
750
                               pj_status_t reason)
 
751
{
 
752
    struct tls_transport *tls = (struct tls_transport*)transport;
 
753
 
 
754
    if (tls->close_reason == 0)
 
755
        tls->close_reason = reason;
 
756
 
 
757
    if (tls->is_registered) {
 
758
        tls->is_registered = PJ_FALSE;
 
759
        pjsip_transport_destroy(transport);
 
760
 
 
761
        /* pjsip_transport_destroy will recursively call this function
 
762
         * again.
 
763
         */
 
764
        return PJ_SUCCESS;
 
765
    }
 
766
 
 
767
    /* Mark transport as closing */
 
768
    tls->is_closing = PJ_TRUE;
 
769
 
 
770
    /* Stop keep-alive timer. */
 
771
    if (tls->ka_timer.id) {
 
772
        pjsip_endpt_cancel_timer(tls->base.endpt, &tls->ka_timer);
 
773
        tls->ka_timer.id = PJ_FALSE;
 
774
    }
 
775
 
 
776
    /* Cancel all delayed transmits */
 
777
    while (!pj_list_empty(&tls->delayed_list)) {
 
778
        struct delayed_tdata *pending_tx;
 
779
        pj_ioqueue_op_key_t *op_key;
 
780
 
 
781
        pending_tx = tls->delayed_list.next;
 
782
        pj_list_erase(pending_tx);
 
783
 
 
784
        op_key = (pj_ioqueue_op_key_t*)pending_tx->tdata_op_key;
 
785
 
 
786
        on_data_sent(tls->ssock, op_key, -reason);
 
787
    }
 
788
 
 
789
    if (tls->rdata.tp_info.pool) {
 
790
        pj_pool_release(tls->rdata.tp_info.pool);
 
791
        tls->rdata.tp_info.pool = NULL;
 
792
    }
 
793
 
 
794
    if (tls->ssock) {
 
795
        pj_ssl_sock_close(tls->ssock);
 
796
        tls->ssock = NULL;
 
797
    }
 
798
    if (tls->base.lock) {
 
799
        pj_lock_destroy(tls->base.lock);
 
800
        tls->base.lock = NULL;
 
801
    }
 
802
 
 
803
    if (tls->base.ref_cnt) {
 
804
        pj_atomic_destroy(tls->base.ref_cnt);
 
805
        tls->base.ref_cnt = NULL;
 
806
    }
 
807
 
 
808
    if (tls->base.pool) {
 
809
        pj_pool_t *pool;
 
810
 
 
811
        if (reason != PJ_SUCCESS) {
 
812
            char errmsg[PJ_ERR_MSG_SIZE];
 
813
 
 
814
            pj_strerror(reason, errmsg, sizeof(errmsg));
 
815
            PJ_LOG(4,(tls->base.obj_name, 
 
816
                      "TLS transport destroyed with reason %d: %s", 
 
817
                      reason, errmsg));
 
818
 
 
819
        } else {
 
820
 
 
821
            PJ_LOG(4,(tls->base.obj_name, 
 
822
                      "TLS transport destroyed normally"));
 
823
 
 
824
        }
 
825
 
 
826
        pool = tls->base.pool;
 
827
        tls->base.pool = NULL;
 
828
        pj_pool_release(pool);
 
829
    }
 
830
 
 
831
    return PJ_SUCCESS;
 
832
}
 
833
 
 
834
 
 
835
/*
 
836
 * This utility function creates receive data buffers and start
 
837
 * asynchronous recv() operations from the socket. It is called after
 
838
 * accept() or connect() operation complete.
 
839
 */
 
840
static pj_status_t tls_start_read(struct tls_transport *tls)
 
841
{
 
842
    pj_pool_t *pool;
 
843
    pj_uint32_t size;
 
844
    pj_sockaddr *rem_addr;
 
845
    void *readbuf[1];
 
846
    pj_status_t status;
 
847
 
 
848
    /* Init rdata */
 
849
    pool = pjsip_endpt_create_pool(tls->base.endpt,
 
850
                                   "rtd%p",
 
851
                                   PJSIP_POOL_RDATA_LEN,
 
852
                                   PJSIP_POOL_RDATA_INC);
 
853
    if (!pool) {
 
854
        tls_perror(tls->base.obj_name, "Unable to create pool", PJ_ENOMEM);
 
855
        return PJ_ENOMEM;
 
856
    }
 
857
 
 
858
    tls->rdata.tp_info.pool = pool;
 
859
 
 
860
    tls->rdata.tp_info.transport = &tls->base;
 
861
    tls->rdata.tp_info.tp_data = tls;
 
862
    tls->rdata.tp_info.op_key.rdata = &tls->rdata;
 
863
    pj_ioqueue_op_key_init(&tls->rdata.tp_info.op_key.op_key, 
 
864
                           sizeof(pj_ioqueue_op_key_t));
 
865
 
 
866
    tls->rdata.pkt_info.src_addr = tls->base.key.rem_addr;
 
867
    tls->rdata.pkt_info.src_addr_len = sizeof(tls->rdata.pkt_info.src_addr);
 
868
    rem_addr = &tls->base.key.rem_addr;
 
869
    pj_sockaddr_print(rem_addr, tls->rdata.pkt_info.src_name,
 
870
                          sizeof(tls->rdata.pkt_info.src_name), 0);
 
871
    tls->rdata.pkt_info.src_port = pj_sockaddr_get_port(rem_addr);
 
872
 
 
873
    size = sizeof(tls->rdata.pkt_info.packet);
 
874
    readbuf[0] = tls->rdata.pkt_info.packet;
 
875
    status = pj_ssl_sock_start_read2(tls->ssock, tls->base.pool, size,
 
876
                                     readbuf, 0);
 
877
    if (status != PJ_SUCCESS && status != PJ_EPENDING) {
 
878
        PJ_LOG(4, (tls->base.obj_name, 
 
879
                   "pj_ssl_sock_start_read() error, status=%d", 
 
880
                   status));
 
881
        return status;
 
882
    }
 
883
 
 
884
    return PJ_SUCCESS;
 
885
}
 
886
 
 
887
 
 
888
/* This callback is called by transport manager for the TLS factory
 
889
 * to create outgoing transport to the specified destination.
 
890
 */
 
891
static pj_status_t lis_create_transport(pjsip_tpfactory *factory,
 
892
                                        pjsip_tpmgr *mgr,
 
893
                                        pjsip_endpoint *endpt,
 
894
                                        const pj_sockaddr *rem_addr,
 
895
                                        int addr_len,
 
896
                                        pjsip_tx_data *tdata,
 
897
                                        pjsip_transport **p_transport)
 
898
{
 
899
    struct tls_listener *listener;
 
900
    struct tls_transport *tls;
 
901
    pj_pool_t *pool;
 
902
    pj_ssl_sock_t *ssock;
 
903
    pj_ssl_sock_param ssock_param;
 
904
    pj_sockaddr local_addr;
 
905
    pj_str_t remote_name;
 
906
    pj_status_t status;
 
907
 
 
908
    /* Sanity checks */
 
909
    PJ_ASSERT_RETURN(factory && mgr && endpt && rem_addr &&
 
910
                     addr_len && p_transport, PJ_EINVAL);
 
911
 
 
912
    /* Check that address is a sockaddr_in or sockaddr_in6*/
 
913
    PJ_ASSERT_RETURN((rem_addr->addr.sa_family == pj_AF_INET() &&
 
914
                      addr_len == sizeof(pj_sockaddr_in)) ||
 
915
                     (rem_addr->addr.sa_family == pj_AF_INET6() &&
 
916
                      addr_len == sizeof(pj_sockaddr_in6)), PJ_EINVAL);
 
917
 
 
918
 
 
919
    listener = (struct tls_listener*)factory;
 
920
 
 
921
    pool = pjsip_endpt_create_pool(listener->endpt, "tls",
 
922
                                   POOL_TP_INIT, POOL_TP_INC);
 
923
    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
 
924
 
 
925
    /* Get remote host name from tdata */
 
926
    if (tdata)
 
927
        remote_name = tdata->dest_info.name;
 
928
    else
 
929
        pj_bzero(&remote_name, sizeof(remote_name));
 
930
 
 
931
    /* Build SSL socket param */
 
932
    pj_ssl_sock_param_default(&ssock_param);
 
933
    ssock_param.sock_af = (factory->type & PJSIP_TRANSPORT_IPV6) ?
 
934
                            pj_AF_INET6() : pj_AF_INET();
 
935
    ssock_param.cb.on_connect_complete = &on_connect_complete;
 
936
    ssock_param.cb.on_data_read = &on_data_read;
 
937
    ssock_param.cb.on_data_sent = &on_data_sent;
 
938
    ssock_param.async_cnt = 1;
 
939
    ssock_param.ioqueue = pjsip_endpt_get_ioqueue(listener->endpt);
 
940
    ssock_param.server_name = remote_name;
 
941
    ssock_param.timeout = listener->tls_setting.timeout;
 
942
    ssock_param.user_data = NULL; /* pending, must be set later */
 
943
    ssock_param.verify_peer = PJ_FALSE; /* avoid SSL socket closing the socket
 
944
                                         * due to verification error */
 
945
    if (ssock_param.send_buffer_size < PJSIP_MAX_PKT_LEN)
 
946
        ssock_param.send_buffer_size = PJSIP_MAX_PKT_LEN;
 
947
    if (ssock_param.read_buffer_size < PJSIP_MAX_PKT_LEN)
 
948
        ssock_param.read_buffer_size = PJSIP_MAX_PKT_LEN;
 
949
    ssock_param.ciphers_num = listener->tls_setting.ciphers_num;
 
950
    ssock_param.ciphers = listener->tls_setting.ciphers;
 
951
    ssock_param.qos_type = listener->tls_setting.qos_type;
 
952
    ssock_param.qos_ignore_error = listener->tls_setting.qos_ignore_error;
 
953
    pj_memcpy(&ssock_param.qos_params, &listener->tls_setting.qos_params,
 
954
              sizeof(ssock_param.qos_params));
 
955
 
 
956
    switch(listener->tls_setting.method) {
 
957
    case PJSIP_TLSV1_METHOD:
 
958
        ssock_param.proto = PJ_SSL_SOCK_PROTO_TLS1;
 
959
        break;
 
960
    case PJSIP_SSLV2_METHOD:
 
961
        ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL2;
 
962
        break;
 
963
    case PJSIP_SSLV3_METHOD:
 
964
        ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL3;
 
965
        break;
 
966
    case PJSIP_SSLV23_METHOD:
 
967
        ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL23;
 
968
        break;
 
969
    default:
 
970
        ssock_param.proto = PJ_SSL_SOCK_PROTO_DEFAULT;
 
971
        break;
 
972
    }
 
973
 
 
974
    status = pj_ssl_sock_create(pool, &ssock_param, &ssock);
 
975
    if (status != PJ_SUCCESS)
 
976
        return status;
 
977
 
 
978
    /* Apply SSL certificate */
 
979
    if (listener->cert) {
 
980
        status = pj_ssl_sock_set_certificate(ssock, pool, listener->cert);
 
981
        if (status != PJ_SUCCESS)
 
982
            return status;
 
983
    }
 
984
 
 
985
    /* Initially set bind address to listener's bind address */
 
986
    pj_sockaddr_init(listener->bound_addr.addr.sa_family,
 
987
                     &local_addr, NULL, 0);
 
988
    pj_sockaddr_copy_addr(&local_addr, &listener->bound_addr);
 
989
 
 
990
    /* Create the transport descriptor */
 
991
    status = tls_create(listener, pool, ssock, PJ_FALSE, &local_addr, 
 
992
                        rem_addr, &remote_name, &tls);
 
993
    if (status != PJ_SUCCESS)
 
994
        return status;
 
995
 
 
996
    /* Set the "pending" SSL socket user data */
 
997
    pj_ssl_sock_set_user_data(tls->ssock, tls);
 
998
 
 
999
    /* Start asynchronous connect() operation */
 
1000
    tls->has_pending_connect = PJ_TRUE;
 
1001
    status = pj_ssl_sock_start_connect(tls->ssock, tls->base.pool, 
 
1002
                                       (pj_sockaddr_t*)&local_addr,
 
1003
                                       (pj_sockaddr_t*)rem_addr,
 
1004
                                       addr_len);
 
1005
    if (status == PJ_SUCCESS) {
 
1006
        on_connect_complete(tls->ssock, PJ_SUCCESS);
 
1007
    } else if (status != PJ_EPENDING) {
 
1008
        tls_destroy(&tls->base, status);
 
1009
        return status;
 
1010
    }
 
1011
 
 
1012
    if (tls->has_pending_connect) {
 
1013
        pj_ssl_sock_info info;
 
1014
 
 
1015
        /* Update local address, just in case local address currently set is 
 
1016
         * different now that asynchronous connect() is started.
 
1017
         */
 
1018
 
 
1019
        /* Retrieve the bound address */
 
1020
        status = pj_ssl_sock_get_info(tls->ssock, &info);
 
1021
        if (status == PJ_SUCCESS) {
 
1022
            pj_uint16_t new_port;
 
1023
 
 
1024
            new_port = pj_sockaddr_get_port((pj_sockaddr_t*)&info.local_addr);
 
1025
 
 
1026
            if (pj_sockaddr_has_addr((pj_sockaddr_t*)&info.local_addr)) {
 
1027
                /* Update sockaddr */
 
1028
                pj_sockaddr_cp((pj_sockaddr_t*)&tls->base.local_addr,
 
1029
                               (pj_sockaddr_t*)&info.local_addr);
 
1030
            } else if (new_port && new_port != pj_sockaddr_get_port(
 
1031
                                        (pj_sockaddr_t*)&tls->base.local_addr))
 
1032
            {
 
1033
                /* Update port only */
 
1034
                pj_sockaddr_set_port(&tls->base.local_addr, 
 
1035
                                     new_port);
 
1036
            }
 
1037
 
 
1038
            sockaddr_to_host_port(tls->base.pool, &tls->base.local_name,
 
1039
                                  &tls->base.local_addr);
 
1040
        }
 
1041
 
 
1042
        PJ_LOG(4,(tls->base.obj_name, 
 
1043
                  "TLS transport %.*s:%d is connecting to %.*s:%d...",
 
1044
                  (int)tls->base.local_name.host.slen,
 
1045
                  tls->base.local_name.host.ptr,
 
1046
                  tls->base.local_name.port,
 
1047
                  (int)tls->base.remote_name.host.slen,
 
1048
                  tls->base.remote_name.host.ptr,
 
1049
                  tls->base.remote_name.port));
 
1050
    }
 
1051
 
 
1052
    /* Done */
 
1053
    *p_transport = &tls->base;
 
1054
 
 
1055
    return PJ_SUCCESS;
 
1056
}
 
1057
 
 
1058
 
 
1059
/*
 
1060
 * This callback is called by SSL socket when pending accept() operation
 
1061
 * has completed.
 
1062
 */
 
1063
static pj_bool_t on_accept_complete(pj_ssl_sock_t *ssock,
 
1064
                                    pj_ssl_sock_t *new_ssock,
 
1065
                                    const pj_sockaddr_t *src_addr,
 
1066
                                    int src_addr_len)
 
1067
{
 
1068
    struct tls_listener *listener;
 
1069
    struct tls_transport *tls;
 
1070
    pj_ssl_sock_info ssl_info;
 
1071
    char addr[PJ_INET6_ADDRSTRLEN+10];
 
1072
    pjsip_tp_state_callback state_cb;
 
1073
    pj_sockaddr tmp_src_addr;
 
1074
    pj_bool_t is_shutdown;
 
1075
    pj_status_t status;
 
1076
 
 
1077
    PJ_UNUSED_ARG(src_addr_len);
 
1078
 
 
1079
    listener = (struct tls_listener*) pj_ssl_sock_get_user_data(ssock);
 
1080
 
 
1081
    PJ_ASSERT_RETURN(new_ssock, PJ_TRUE);
 
1082
 
 
1083
    PJ_LOG(4,(listener->factory.obj_name, 
 
1084
              "TLS listener %.*s:%d: got incoming TLS connection "
 
1085
              "from %s, sock=%d",
 
1086
              (int)listener->factory.addr_name.host.slen,
 
1087
              listener->factory.addr_name.host.ptr,
 
1088
              listener->factory.addr_name.port,
 
1089
              pj_sockaddr_print(src_addr, addr, sizeof(addr), 3),
 
1090
              new_ssock));
 
1091
 
 
1092
    /* Retrieve SSL socket info, close the socket if this is failed
 
1093
     * as the SSL socket info availability is rather critical here.
 
1094
     */
 
1095
    status = pj_ssl_sock_get_info(new_ssock, &ssl_info);
 
1096
    if (status != PJ_SUCCESS) {
 
1097
        pj_ssl_sock_close(new_ssock);
 
1098
        return PJ_TRUE;
 
1099
    }
 
1100
 
 
1101
    /* Copy to larger buffer, just in case */
 
1102
    pj_bzero(&tmp_src_addr, sizeof(tmp_src_addr));
 
1103
    pj_sockaddr_cp(&tmp_src_addr, src_addr);
 
1104
 
 
1105
    /* 
 
1106
     * Incoming connection!
 
1107
     * Create TLS transport for the new socket.
 
1108
     */
 
1109
    status = tls_create( listener, NULL, new_ssock, PJ_TRUE,
 
1110
                         &listener->factory.local_addr,
 
1111
                         &tmp_src_addr, NULL, &tls);
 
1112
    
 
1113
    if (status != PJ_SUCCESS)
 
1114
        return PJ_TRUE;
 
1115
 
 
1116
    /* Set the "pending" SSL socket user data */
 
1117
    pj_ssl_sock_set_user_data(new_ssock, tls);
 
1118
 
 
1119
    /* Prevent immediate transport destroy as application may access it 
 
1120
     * (getting info, etc) in transport state notification callback.
 
1121
     */
 
1122
    pjsip_transport_add_ref(&tls->base);
 
1123
 
 
1124
    /* If there is verification error and verification is mandatory, shutdown
 
1125
     * and destroy the transport.
 
1126
     */
 
1127
    if (ssl_info.verify_status && listener->tls_setting.verify_client) {
 
1128
        if (tls->close_reason == PJ_SUCCESS) 
 
1129
            tls->close_reason = PJSIP_TLS_ECERTVERIF;
 
1130
        pjsip_transport_shutdown(&tls->base);
 
1131
    }
 
1132
 
 
1133
    /* Notify transport state to application */
 
1134
    state_cb = pjsip_tpmgr_get_state_cb(tls->base.tpmgr);
 
1135
    if (state_cb) {
 
1136
        pjsip_transport_state_info state_info;
 
1137
        pjsip_tls_state_info tls_info;
 
1138
        pjsip_transport_state tp_state;
 
1139
 
 
1140
        /* Init transport state info */
 
1141
        pj_bzero(&tls_info, sizeof(tls_info));
 
1142
        pj_bzero(&state_info, sizeof(state_info));
 
1143
        tls_info.ssl_sock_info = &ssl_info;
 
1144
        state_info.ext_info = &tls_info;
 
1145
 
 
1146
        /* Set transport state based on verification status */
 
1147
        if (ssl_info.verify_status && listener->tls_setting.verify_client)
 
1148
        {
 
1149
            tp_state = PJSIP_TP_STATE_DISCONNECTED;
 
1150
            state_info.status = PJSIP_TLS_ECERTVERIF;
 
1151
        } else {
 
1152
            tp_state = PJSIP_TP_STATE_CONNECTED;
 
1153
            state_info.status = PJ_SUCCESS;
 
1154
        }
 
1155
 
 
1156
        (*state_cb)(&tls->base, tp_state, &state_info);
 
1157
    }
 
1158
 
 
1159
    /* Release transport reference. If transport is shutting down, it may
 
1160
     * get destroyed here.
 
1161
     */
 
1162
    is_shutdown = tls->base.is_shutdown;
 
1163
    pjsip_transport_dec_ref(&tls->base);
 
1164
    if (is_shutdown)
 
1165
        return PJ_TRUE;
 
1166
 
 
1167
 
 
1168
    status = tls_start_read(tls);
 
1169
    if (status != PJ_SUCCESS) {
 
1170
        PJ_LOG(3,(tls->base.obj_name, "New transport cancelled"));
 
1171
        tls_init_shutdown(tls, status);
 
1172
        tls_destroy(&tls->base, status);
 
1173
    } else {
 
1174
        /* Start keep-alive timer */
 
1175
        if (PJSIP_TLS_KEEP_ALIVE_INTERVAL) {
 
1176
            pj_time_val delay = {PJSIP_TLS_KEEP_ALIVE_INTERVAL, 0};
 
1177
            pjsip_endpt_schedule_timer(listener->endpt, 
 
1178
                                       &tls->ka_timer, 
 
1179
                                       &delay);
 
1180
            tls->ka_timer.id = PJ_TRUE;
 
1181
            pj_gettimeofday(&tls->last_activity);
 
1182
        }
 
1183
    }
 
1184
 
 
1185
    return PJ_TRUE;
 
1186
}
 
1187
 
 
1188
 
 
1189
/* 
 
1190
 * Callback from ioqueue when packet is sent.
 
1191
 */
 
1192
static pj_bool_t on_data_sent(pj_ssl_sock_t *ssock,
 
1193
                              pj_ioqueue_op_key_t *op_key,
 
1194
                              pj_ssize_t bytes_sent)
 
1195
{
 
1196
    struct tls_transport *tls = (struct tls_transport*) 
 
1197
                                pj_ssl_sock_get_user_data(ssock);
 
1198
    pjsip_tx_data_op_key *tdata_op_key = (pjsip_tx_data_op_key*)op_key;
 
1199
 
 
1200
    /* Note that op_key may be the op_key from keep-alive, thus
 
1201
     * it will not have tdata etc.
 
1202
     */
 
1203
 
 
1204
    tdata_op_key->tdata = NULL;
 
1205
 
 
1206
    if (tdata_op_key->callback) {
 
1207
        /*
 
1208
         * Notify sip_transport.c that packet has been sent.
 
1209
         */
 
1210
        if (bytes_sent == 0)
 
1211
            bytes_sent = -PJ_RETURN_OS_ERROR(OSERR_ENOTCONN);
 
1212
 
 
1213
        tdata_op_key->callback(&tls->base, tdata_op_key->token, bytes_sent);
 
1214
 
 
1215
        /* Mark last activity time */
 
1216
        pj_gettimeofday(&tls->last_activity);
 
1217
 
 
1218
    }
 
1219
 
 
1220
    /* Check for error/closure */
 
1221
    if (bytes_sent <= 0) {
 
1222
        pj_status_t status;
 
1223
 
 
1224
        PJ_LOG(5,(tls->base.obj_name, "TLS send() error, sent=%d", 
 
1225
                  bytes_sent));
 
1226
 
 
1227
        status = (bytes_sent == 0) ? PJ_RETURN_OS_ERROR(OSERR_ENOTCONN) :
 
1228
                                     (pj_status_t)-bytes_sent;
 
1229
 
 
1230
        tls_init_shutdown(tls, status);
 
1231
 
 
1232
        return PJ_FALSE;
 
1233
    }
 
1234
    
 
1235
    return PJ_TRUE;
 
1236
}
 
1237
 
 
1238
 
 
1239
/* 
 
1240
 * This callback is called by transport manager to send SIP message 
 
1241
 */
 
1242
static pj_status_t tls_send_msg(pjsip_transport *transport, 
 
1243
                                pjsip_tx_data *tdata,
 
1244
                                const pj_sockaddr_t *rem_addr,
 
1245
                                int addr_len,
 
1246
                                void *token,
 
1247
                                pjsip_transport_callback callback)
 
1248
{
 
1249
    struct tls_transport *tls = (struct tls_transport*)transport;
 
1250
    pj_ssize_t size;
 
1251
    pj_bool_t delayed = PJ_FALSE;
 
1252
    pj_status_t status = PJ_SUCCESS;
 
1253
 
 
1254
    /* Sanity check */
 
1255
    PJ_ASSERT_RETURN(transport && tdata, PJ_EINVAL);
 
1256
 
 
1257
    /* Check that there's no pending operation associated with the tdata */
 
1258
    PJ_ASSERT_RETURN(tdata->op_key.tdata == NULL, PJSIP_EPENDINGTX);
 
1259
    
 
1260
    /* Check the address is supported */
 
1261
    PJ_ASSERT_RETURN(rem_addr && (addr_len==sizeof(pj_sockaddr_in) ||
 
1262
                                  addr_len==sizeof(pj_sockaddr_in6)),
 
1263
                     PJ_EINVAL);
 
1264
 
 
1265
    /* Init op key. */
 
1266
    tdata->op_key.tdata = tdata;
 
1267
    tdata->op_key.token = token;
 
1268
    tdata->op_key.callback = callback;
 
1269
 
 
1270
    /* If asynchronous connect() has not completed yet, just put the
 
1271
     * transmit data in the pending transmission list since we can not
 
1272
     * use the socket yet.
 
1273
     */
 
1274
    if (tls->has_pending_connect) {
 
1275
 
 
1276
        /*
 
1277
         * Looks like connect() is still in progress. Check again (this time
 
1278
         * with holding the lock) to be sure.
 
1279
         */
 
1280
        pj_lock_acquire(tls->base.lock);
 
1281
 
 
1282
        if (tls->has_pending_connect) {
 
1283
            struct delayed_tdata *delayed_tdata;
 
1284
 
 
1285
            /*
 
1286
             * connect() is still in progress. Put the transmit data to
 
1287
             * the delayed list.
 
1288
             * Starting from #1583 (https://trac.pjsip.org/repos/ticket/1583),
 
1289
             * we also add timeout value for the transmit data. When the
 
1290
             * connect() is completed, the timeout value will be checked to
 
1291
             * determine whether the transmit data needs to be sent.
 
1292
             */
 
1293
            delayed_tdata = PJ_POOL_ZALLOC_T(tdata->pool, 
 
1294
                                             struct delayed_tdata);
 
1295
            delayed_tdata->tdata_op_key = &tdata->op_key;
 
1296
            if (tdata->msg && tdata->msg->type == PJSIP_REQUEST_MSG) {
 
1297
                pj_gettickcount(&delayed_tdata->timeout);
 
1298
                delayed_tdata->timeout.msec += pjsip_cfg()->tsx.td;
 
1299
                pj_time_val_normalize(&delayed_tdata->timeout);
 
1300
            }
 
1301
 
 
1302
            pj_list_push_back(&tls->delayed_list, delayed_tdata);
 
1303
            status = PJ_EPENDING;
 
1304
 
 
1305
            /* Prevent pj_ioqueue_send() to be called below */
 
1306
            delayed = PJ_TRUE;
 
1307
        }
 
1308
 
 
1309
        pj_lock_release(tls->base.lock);
 
1310
    } 
 
1311
    
 
1312
    if (!delayed) {
 
1313
        /*
 
1314
         * Transport is ready to go. Send the packet to ioqueue to be
 
1315
         * sent asynchronously.
 
1316
         */
 
1317
        size = tdata->buf.cur - tdata->buf.start;
 
1318
        status = pj_ssl_sock_send(tls->ssock, 
 
1319
                                    (pj_ioqueue_op_key_t*)&tdata->op_key,
 
1320
                                    tdata->buf.start, &size, 0);
 
1321
 
 
1322
        if (status != PJ_EPENDING) {
 
1323
            /* Not pending (could be immediate success or error) */
 
1324
            tdata->op_key.tdata = NULL;
 
1325
 
 
1326
            /* Shutdown transport on closure/errors */
 
1327
            if (size <= 0) {
 
1328
 
 
1329
                PJ_LOG(5,(tls->base.obj_name, "TLS send() error, sent=%d", 
 
1330
                          size));
 
1331
 
 
1332
                if (status == PJ_SUCCESS) 
 
1333
                    status = PJ_RETURN_OS_ERROR(OSERR_ENOTCONN);
 
1334
 
 
1335
                tls_init_shutdown(tls, status);
 
1336
            }
 
1337
        }
 
1338
    }
 
1339
 
 
1340
    return status;
 
1341
}
 
1342
 
 
1343
 
 
1344
/* 
 
1345
 * This callback is called by transport manager to shutdown transport.
 
1346
 */
 
1347
static pj_status_t tls_shutdown(pjsip_transport *transport)
 
1348
{
 
1349
    struct tls_transport *tls = (struct tls_transport*)transport;
 
1350
    
 
1351
    /* Stop keep-alive timer. */
 
1352
    if (tls->ka_timer.id) {
 
1353
        pjsip_endpt_cancel_timer(tls->base.endpt, &tls->ka_timer);
 
1354
        tls->ka_timer.id = PJ_FALSE;
 
1355
    }
 
1356
 
 
1357
    return PJ_SUCCESS;
 
1358
}
 
1359
 
 
1360
 
 
1361
/* 
 
1362
 * Callback from ioqueue that an incoming data is received from the socket.
 
1363
 */
 
1364
static pj_bool_t on_data_read(pj_ssl_sock_t *ssock,
 
1365
                              void *data,
 
1366
                              pj_size_t size,
 
1367
                              pj_status_t status,
 
1368
                              pj_size_t *remainder)
 
1369
{
 
1370
    enum { MAX_IMMEDIATE_PACKET = 10 };
 
1371
    struct tls_transport *tls;
 
1372
    pjsip_rx_data *rdata;
 
1373
 
 
1374
    PJ_UNUSED_ARG(data);
 
1375
 
 
1376
    tls = (struct tls_transport*) pj_ssl_sock_get_user_data(ssock);
 
1377
    rdata = &tls->rdata;
 
1378
 
 
1379
    /* Don't do anything if transport is closing. */
 
1380
    if (tls->is_closing) {
 
1381
        tls->is_closing++;
 
1382
        return PJ_FALSE;
 
1383
    }
 
1384
 
 
1385
    /* Houston, we have packet! Report the packet to transport manager
 
1386
     * to be parsed.
 
1387
     */
 
1388
    if (status == PJ_SUCCESS) {
 
1389
        pj_size_t size_eaten;
 
1390
 
 
1391
        /* Mark this as an activity */
 
1392
        pj_gettimeofday(&tls->last_activity);
 
1393
 
 
1394
        pj_assert((void*)rdata->pkt_info.packet == data);
 
1395
 
 
1396
        /* Init pkt_info part. */
 
1397
        rdata->pkt_info.len = size;
 
1398
        rdata->pkt_info.zero = 0;
 
1399
        pj_gettimeofday(&rdata->pkt_info.timestamp);
 
1400
 
 
1401
        /* Report to transport manager.
 
1402
         * The transport manager will tell us how many bytes of the packet
 
1403
         * have been processed (as valid SIP message).
 
1404
         */
 
1405
        size_eaten = 
 
1406
            pjsip_tpmgr_receive_packet(rdata->tp_info.transport->tpmgr, 
 
1407
                                       rdata);
 
1408
 
 
1409
        pj_assert(size_eaten <= (pj_size_t)rdata->pkt_info.len);
 
1410
 
 
1411
        /* Move unprocessed data to the front of the buffer */
 
1412
        *remainder = size - size_eaten;
 
1413
        if (*remainder > 0 && *remainder != size) {
 
1414
            pj_memmove(rdata->pkt_info.packet,
 
1415
                       rdata->pkt_info.packet + size_eaten,
 
1416
                       *remainder);
 
1417
        }
 
1418
 
 
1419
    } else {
 
1420
 
 
1421
        /* Transport is closed */
 
1422
        PJ_LOG(4,(tls->base.obj_name, "TLS connection closed"));
 
1423
 
 
1424
        tls_init_shutdown(tls, status);
 
1425
 
 
1426
        return PJ_FALSE;
 
1427
 
 
1428
    }
 
1429
 
 
1430
    /* Reset pool. */
 
1431
    pj_pool_reset(rdata->tp_info.pool);
 
1432
 
 
1433
    return PJ_TRUE;
 
1434
}
 
1435
 
 
1436
 
 
1437
/* 
 
1438
 * Callback from ioqueue when asynchronous connect() operation completes.
 
1439
 */
 
1440
static pj_bool_t on_connect_complete(pj_ssl_sock_t *ssock,
 
1441
                                     pj_status_t status)
 
1442
{
 
1443
    struct tls_transport *tls;
 
1444
    pj_ssl_sock_info ssl_info;
 
1445
    pj_sockaddr addr, *tp_addr;
 
1446
    pjsip_tp_state_callback state_cb;
 
1447
    pj_bool_t is_shutdown;
 
1448
 
 
1449
    tls = (struct tls_transport*) pj_ssl_sock_get_user_data(ssock);
 
1450
 
 
1451
    /* Check connect() status */
 
1452
    if (status != PJ_SUCCESS) {
 
1453
 
 
1454
        tls_perror(tls->base.obj_name, "TLS connect() error", status);
 
1455
 
 
1456
        /* Cancel all delayed transmits */
 
1457
        while (!pj_list_empty(&tls->delayed_list)) {
 
1458
            struct delayed_tdata *pending_tx;
 
1459
            pj_ioqueue_op_key_t *op_key;
 
1460
 
 
1461
            pending_tx = tls->delayed_list.next;
 
1462
            pj_list_erase(pending_tx);
 
1463
 
 
1464
            op_key = (pj_ioqueue_op_key_t*)pending_tx->tdata_op_key;
 
1465
 
 
1466
            on_data_sent(tls->ssock, op_key, -status);
 
1467
        }
 
1468
 
 
1469
        goto on_error;
 
1470
    }
 
1471
 
 
1472
    /* Retrieve SSL socket info, shutdown the transport if this is failed
 
1473
     * as the SSL socket info availability is rather critical here.
 
1474
     */
 
1475
    status = pj_ssl_sock_get_info(tls->ssock, &ssl_info);
 
1476
    if (status != PJ_SUCCESS)
 
1477
        goto on_error;
 
1478
 
 
1479
    /* Update (again) local address, just in case local address currently
 
1480
     * set is different now that the socket is connected (could happen
 
1481
     * on some systems, like old Win32 probably?).
 
1482
     */
 
1483
    tp_addr = &tls->base.local_addr;
 
1484
    pj_sockaddr_cp((pj_sockaddr_t*)&addr, 
 
1485
                   (pj_sockaddr_t*)&ssl_info.local_addr);
 
1486
    if (pj_sockaddr_cmp(tp_addr, &addr) != 0) {
 
1487
        pj_sockaddr_cp(tp_addr, &addr);
 
1488
        sockaddr_to_host_port(tls->base.pool, &tls->base.local_name,
 
1489
                              tp_addr);
 
1490
    }
 
1491
 
 
1492
    /* Server identity verification based on server certificate. */
 
1493
    if (ssl_info.remote_cert_info->version) {
 
1494
        pj_str_t *remote_name;
 
1495
        pj_ssl_cert_info *serv_cert = ssl_info.remote_cert_info;
 
1496
        pj_bool_t matched = PJ_FALSE;
 
1497
        unsigned i;
 
1498
 
 
1499
        /* Remote name may be hostname or IP address */
 
1500
        if (tls->remote_name.slen)
 
1501
            remote_name = &tls->remote_name;
 
1502
        else
 
1503
            remote_name = &tls->base.remote_name.host;
 
1504
 
 
1505
        /* Start matching remote name with SubjectAltName fields of 
 
1506
         * server certificate.
 
1507
         */
 
1508
        for (i = 0; i < serv_cert->subj_alt_name.cnt && !matched; ++i) {
 
1509
            pj_str_t *cert_name = &serv_cert->subj_alt_name.entry[i].name;
 
1510
 
 
1511
            switch (serv_cert->subj_alt_name.entry[i].type) {
 
1512
            case PJ_SSL_CERT_NAME_DNS:
 
1513
            case PJ_SSL_CERT_NAME_IP:
 
1514
                matched = !pj_stricmp(remote_name, cert_name);
 
1515
                break;
 
1516
            case PJ_SSL_CERT_NAME_URI:
 
1517
                if (pj_strnicmp2(cert_name, "sip:", 4) == 0 ||
 
1518
                    pj_strnicmp2(cert_name, "sips:", 5) == 0)
 
1519
                {
 
1520
                    pj_str_t host_part;
 
1521
                    char *p;
 
1522
 
 
1523
                    p = pj_strchr(cert_name, ':') + 1;
 
1524
                    pj_strset(&host_part, p, cert_name->slen - 
 
1525
                                             (p - cert_name->ptr));
 
1526
                    matched = !pj_stricmp(remote_name, &host_part);
 
1527
                }
 
1528
                break;
 
1529
            default:
 
1530
                break;
 
1531
            }
 
1532
        }
 
1533
        
 
1534
        /* When still not matched or no SubjectAltName fields in server
 
1535
         * certificate, try with Common Name of Subject field.
 
1536
         */
 
1537
        if (!matched) {
 
1538
            matched = !pj_stricmp(remote_name, &serv_cert->subject.cn);
 
1539
        }
 
1540
 
 
1541
        if (!matched)
 
1542
            ssl_info.verify_status |= PJ_SSL_CERT_EIDENTITY_NOT_MATCH;
 
1543
    }
 
1544
 
 
1545
    /* Prevent immediate transport destroy as application may access it 
 
1546
     * (getting info, etc) in transport state notification callback.
 
1547
     */
 
1548
    pjsip_transport_add_ref(&tls->base);
 
1549
 
 
1550
    /* If there is verification error and verification is mandatory, shutdown
 
1551
     * and destroy the transport.
 
1552
     */
 
1553
    if (ssl_info.verify_status && tls->verify_server) {
 
1554
        if (tls->close_reason == PJ_SUCCESS) 
 
1555
            tls->close_reason = PJSIP_TLS_ECERTVERIF;
 
1556
        pjsip_transport_shutdown(&tls->base);
 
1557
    }
 
1558
 
 
1559
    /* Notify transport state to application */
 
1560
    state_cb = pjsip_tpmgr_get_state_cb(tls->base.tpmgr);
 
1561
    if (state_cb) {
 
1562
        pjsip_transport_state_info state_info;
 
1563
        pjsip_tls_state_info tls_info;
 
1564
        pjsip_transport_state tp_state;
 
1565
 
 
1566
        /* Init transport state info */
 
1567
        pj_bzero(&state_info, sizeof(state_info));
 
1568
        pj_bzero(&tls_info, sizeof(tls_info));
 
1569
        state_info.ext_info = &tls_info;
 
1570
        tls_info.ssl_sock_info = &ssl_info;
 
1571
 
 
1572
        /* Set transport state based on verification status */
 
1573
        if (ssl_info.verify_status && tls->verify_server)
 
1574
        {
 
1575
            tp_state = PJSIP_TP_STATE_DISCONNECTED;
 
1576
            state_info.status = PJSIP_TLS_ECERTVERIF;
 
1577
        } else {
 
1578
            tp_state = PJSIP_TP_STATE_CONNECTED;
 
1579
            state_info.status = PJ_SUCCESS;
 
1580
        }
 
1581
 
 
1582
        (*state_cb)(&tls->base, tp_state, &state_info);
 
1583
    }
 
1584
 
 
1585
    /* Release transport reference. If transport is shutting down, it may
 
1586
     * get destroyed here.
 
1587
     */
 
1588
    is_shutdown = tls->base.is_shutdown;
 
1589
    pjsip_transport_dec_ref(&tls->base);
 
1590
    if (is_shutdown) {
 
1591
        status = tls->close_reason;
 
1592
        tls_perror(tls->base.obj_name, "TLS connect() error", status);
 
1593
 
 
1594
        /* Cancel all delayed transmits */
 
1595
        while (!pj_list_empty(&tls->delayed_list)) {
 
1596
            struct delayed_tdata *pending_tx;
 
1597
            pj_ioqueue_op_key_t *op_key;
 
1598
 
 
1599
            pending_tx = tls->delayed_list.next;
 
1600
            pj_list_erase(pending_tx);
 
1601
 
 
1602
            op_key = (pj_ioqueue_op_key_t*)pending_tx->tdata_op_key;
 
1603
 
 
1604
            on_data_sent(tls->ssock, op_key, -status);
 
1605
        }
 
1606
 
 
1607
        return PJ_FALSE;
 
1608
    }
 
1609
 
 
1610
 
 
1611
    /* Mark that pending connect() operation has completed. */
 
1612
    tls->has_pending_connect = PJ_FALSE;
 
1613
 
 
1614
    PJ_LOG(4,(tls->base.obj_name, 
 
1615
              "TLS transport %.*s:%d is connected to %.*s:%d",
 
1616
              (int)tls->base.local_name.host.slen,
 
1617
              tls->base.local_name.host.ptr,
 
1618
              tls->base.local_name.port,
 
1619
              (int)tls->base.remote_name.host.slen,
 
1620
              tls->base.remote_name.host.ptr,
 
1621
              tls->base.remote_name.port));
 
1622
 
 
1623
    /* Start pending read */
 
1624
    status = tls_start_read(tls);
 
1625
    if (status != PJ_SUCCESS)
 
1626
        goto on_error;
 
1627
 
 
1628
    /* Flush all pending send operations */
 
1629
    tls_flush_pending_tx(tls);
 
1630
 
 
1631
    /* Start keep-alive timer */
 
1632
    if (PJSIP_TLS_KEEP_ALIVE_INTERVAL) {
 
1633
        pj_time_val delay = { PJSIP_TLS_KEEP_ALIVE_INTERVAL, 0 };
 
1634
        pjsip_endpt_schedule_timer(tls->base.endpt, &tls->ka_timer, 
 
1635
                                   &delay);
 
1636
        tls->ka_timer.id = PJ_TRUE;
 
1637
        pj_gettimeofday(&tls->last_activity);
 
1638
    }
 
1639
 
 
1640
    return PJ_TRUE;
 
1641
 
 
1642
on_error:
 
1643
    tls_init_shutdown(tls, status);
 
1644
 
 
1645
    return PJ_FALSE;
 
1646
}
 
1647
 
 
1648
 
 
1649
/* Transport keep-alive timer callback */
 
1650
static void tls_keep_alive_timer(pj_timer_heap_t *th, pj_timer_entry *e)
 
1651
{
 
1652
    struct tls_transport *tls = (struct tls_transport*) e->user_data;
 
1653
    pj_time_val delay;
 
1654
    pj_time_val now;
 
1655
    pj_ssize_t size;
 
1656
    pj_status_t status;
 
1657
 
 
1658
    PJ_UNUSED_ARG(th);
 
1659
 
 
1660
    tls->ka_timer.id = PJ_TRUE;
 
1661
 
 
1662
    pj_gettimeofday(&now);
 
1663
    PJ_TIME_VAL_SUB(now, tls->last_activity);
 
1664
 
 
1665
    if (now.sec > 0 && now.sec < PJSIP_TLS_KEEP_ALIVE_INTERVAL) {
 
1666
        /* There has been activity, so don't send keep-alive */
 
1667
        delay.sec = PJSIP_TLS_KEEP_ALIVE_INTERVAL - now.sec;
 
1668
        delay.msec = 0;
 
1669
 
 
1670
        pjsip_endpt_schedule_timer(tls->base.endpt, &tls->ka_timer, 
 
1671
                                   &delay);
 
1672
        tls->ka_timer.id = PJ_TRUE;
 
1673
        return;
 
1674
    }
 
1675
 
 
1676
    PJ_LOG(5,(tls->base.obj_name, "Sending %d byte(s) keep-alive to %.*s:%d", 
 
1677
              (int)tls->ka_pkt.slen, (int)tls->base.remote_name.host.slen,
 
1678
              tls->base.remote_name.host.ptr,
 
1679
              tls->base.remote_name.port));
 
1680
 
 
1681
    /* Send the data */
 
1682
    size = tls->ka_pkt.slen;
 
1683
    status = pj_ssl_sock_send(tls->ssock, &tls->ka_op_key.key,
 
1684
                              tls->ka_pkt.ptr, &size, 0);
 
1685
 
 
1686
    if (status != PJ_SUCCESS && status != PJ_EPENDING) {
 
1687
        tls_perror(tls->base.obj_name, 
 
1688
                   "Error sending keep-alive packet", status);
 
1689
 
 
1690
        tls_init_shutdown(tls, status);
 
1691
        return;
 
1692
    }
 
1693
 
 
1694
    /* Register next keep-alive */
 
1695
    delay.sec = PJSIP_TLS_KEEP_ALIVE_INTERVAL;
 
1696
    delay.msec = 0;
 
1697
 
 
1698
    pjsip_endpt_schedule_timer(tls->base.endpt, &tls->ka_timer, 
 
1699
                               &delay);
 
1700
    tls->ka_timer.id = PJ_TRUE;
 
1701
}
 
1702
 
 
1703
#endif /* PJSIP_HAS_TLS_TRANSPORT */