1
/* $Id: sip_transport.c 4295 2012-11-06 05:22:11Z nanang $ */
3
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
4
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; either version 2 of the License, or
9
* (at your option) any later version.
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the Free Software
18
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
#include <pjsip/sip_transport.h>
21
#include <pjsip/sip_endpoint.h>
22
#include <pjsip/sip_parser.h>
23
#include <pjsip/sip_msg.h>
24
#include <pjsip/sip_private.h>
25
#include <pjsip/sip_errno.h>
26
#include <pjsip/sip_module.h>
27
#include <pj/addr_resolv.h>
28
#include <pj/except.h>
31
#include <pj/ioqueue.h>
33
#include <pj/string.h>
35
#include <pj/assert.h>
40
#define THIS_FILE "sip_transport.c"
43
# define TRACE_(x) PJ_LOG(5,x)
45
static const char *addr_string(const pj_sockaddr_t *addr)
47
static char str[PJ_INET6_ADDRSTRLEN];
48
pj_inet_ntop(((const pj_sockaddr*)addr)->addr.sa_family,
49
pj_sockaddr_get_addr(addr),
58
static pj_status_t mod_on_tx_msg(pjsip_tx_data *tdata);
60
/* This module has sole purpose to print transmit data to contigous buffer
61
* before actually transmitted to the wire.
63
static pjsip_module mod_msg_print =
65
NULL, NULL, /* prev and next */
66
{ "mod-msg-print", 13}, /* Name. */
68
PJSIP_MOD_PRIORITY_TRANSPORT_LAYER, /* Priority */
73
NULL, /* on_rx_request() */
74
NULL, /* on_rx_response() */
75
&mod_on_tx_msg, /* on_tx_request() */
76
&mod_on_tx_msg, /* on_tx_response() */
77
NULL, /* on_tsx_state() */
85
pj_hash_table_t *table;
87
pjsip_endpoint *endpt;
88
pjsip_tpfactory factory_list;
89
#if defined(PJ_DEBUG) && PJ_DEBUG!=0
90
pj_atomic_t *tdata_counter;
92
void (*on_rx_msg)(pjsip_endpoint*, pj_status_t, pjsip_rx_data*);
93
pj_status_t (*on_tx_msg)(pjsip_endpoint*, pjsip_tx_data*);
94
pjsip_tp_state_callback tp_state_cb;
98
/* Transport state listener list type */
99
typedef struct tp_state_listener
101
PJ_DECL_LIST_MEMBER(struct tp_state_listener);
103
pjsip_tp_state_callback cb;
111
typedef struct transport_data
113
/* Transport listeners */
114
tp_state_listener st_listeners;
115
tp_state_listener st_listeners_empty;
119
/*****************************************************************************
121
* GENERAL TRANSPORT (NAMES, TYPES, ETC.)
123
*****************************************************************************/
128
struct transport_names_t
130
pjsip_transport_type_e type; /* Transport type */
131
pj_uint16_t port; /* Default port number */
132
pj_str_t name; /* Id tag */
133
const char *description; /* Longer description */
134
unsigned flag; /* Flags */
135
char name_buf[16]; /* For user's transport */
136
} transport_names[16] =
139
PJSIP_TRANSPORT_UNSPECIFIED,
150
PJSIP_TRANSPORT_DATAGRAM
157
PJSIP_TRANSPORT_RELIABLE
164
PJSIP_TRANSPORT_RELIABLE | PJSIP_TRANSPORT_SECURE
167
PJSIP_TRANSPORT_SCTP,
171
PJSIP_TRANSPORT_RELIABLE
174
PJSIP_TRANSPORT_LOOP,
177
"Loopback transport",
178
PJSIP_TRANSPORT_RELIABLE
181
PJSIP_TRANSPORT_LOOP_DGRAM,
184
"Loopback datagram transport",
185
PJSIP_TRANSPORT_DATAGRAM
188
PJSIP_TRANSPORT_UDP6,
191
"UDP IPv6 transport",
192
PJSIP_TRANSPORT_DATAGRAM
195
PJSIP_TRANSPORT_TCP6,
198
"TCP IPv6 transport",
199
PJSIP_TRANSPORT_RELIABLE
202
PJSIP_TRANSPORT_TLS6,
205
"TLS IPv6 transport",
206
PJSIP_TRANSPORT_RELIABLE | PJSIP_TRANSPORT_SECURE
210
static void tp_state_callback(pjsip_transport *tp,
211
pjsip_transport_state state,
212
const pjsip_transport_state_info *info);
215
struct transport_names_t *get_tpname(pjsip_transport_type_e type)
218
for (i=0; i<PJ_ARRAY_SIZE(transport_names); ++i) {
219
if (transport_names[i].type == type)
220
return &transport_names[i];
222
pj_assert(!"Invalid transport type!");
229
* Register new transport type to PJSIP.
231
PJ_DEF(pj_status_t) pjsip_transport_register_type( unsigned tp_flag,
238
PJ_ASSERT_RETURN(tp_flag && tp_name && def_port, PJ_EINVAL);
239
PJ_ASSERT_RETURN(pj_ansi_strlen(tp_name) <
240
PJ_ARRAY_SIZE(transport_names[0].name_buf),
243
for (i=1; i<PJ_ARRAY_SIZE(transport_names); ++i) {
244
if (transport_names[i].type == 0)
248
if (i == PJ_ARRAY_SIZE(transport_names))
251
transport_names[i].type = (pjsip_transport_type_e)i;
252
transport_names[i].port = (pj_uint16_t)def_port;
253
pj_ansi_strcpy(transport_names[i].name_buf, tp_name);
254
transport_names[i].name = pj_str(transport_names[i].name_buf);
255
transport_names[i].flag = tp_flag;
265
* Get transport type from name.
267
PJ_DEF(pjsip_transport_type_e) pjsip_transport_get_type_from_name(const pj_str_t *name)
272
return PJSIP_TRANSPORT_UNSPECIFIED;
274
/* Get transport type from name. */
275
for (i=0; i<PJ_ARRAY_SIZE(transport_names); ++i) {
276
if (pj_stricmp(name, &transport_names[i].name) == 0) {
277
return transport_names[i].type;
281
pj_assert(!"Invalid transport name");
282
return PJSIP_TRANSPORT_UNSPECIFIED;
287
* Get the transport type for the specified flags.
289
PJ_DEF(pjsip_transport_type_e) pjsip_transport_get_type_from_flag(unsigned flag)
293
/* Get the transport type for the specified flags. */
294
for (i=0; i<PJ_ARRAY_SIZE(transport_names); ++i) {
295
if (transport_names[i].flag == flag) {
296
return transport_names[i].type;
300
pj_assert(!"Invalid transport type");
301
return PJSIP_TRANSPORT_UNSPECIFIED;
305
* Get the socket address family of a given transport type.
307
PJ_DEF(int) pjsip_transport_type_get_af(pjsip_transport_type_e type)
309
if (type & PJSIP_TRANSPORT_IPV6)
310
return pj_AF_INET6();
315
PJ_DEF(unsigned) pjsip_transport_get_flag_from_type(pjsip_transport_type_e type)
317
/* Return transport flag. */
318
return get_tpname(type)->flag;
322
* Get the default SIP port number for the specified type.
324
PJ_DEF(int) pjsip_transport_get_default_port_for_type(pjsip_transport_type_e type)
326
/* Return the port. */
327
return get_tpname(type)->port;
331
* Get transport name.
333
PJ_DEF(const char*) pjsip_transport_get_type_name(pjsip_transport_type_e type)
335
/* Return the name. */
336
return get_tpname(type)->name.ptr;
340
* Get transport description.
342
PJ_DEF(const char*) pjsip_transport_get_type_desc(pjsip_transport_type_e type)
344
/* Return the description. */
345
return get_tpname(type)->description;
349
/*****************************************************************************
353
*****************************************************************************/
356
* Add transport/listener reference in the selector.
358
PJ_DEF(void) pjsip_tpselector_add_ref(pjsip_tpselector *sel)
360
if (sel->type == PJSIP_TPSELECTOR_TRANSPORT && sel->u.transport != NULL)
361
pjsip_transport_add_ref(sel->u.transport);
362
else if (sel->type == PJSIP_TPSELECTOR_LISTENER && sel->u.listener != NULL)
363
; /* Hmm.. looks like we don't have reference counter for listener */
368
* Decrement transport/listener reference in the selector.
370
PJ_DEF(void) pjsip_tpselector_dec_ref(pjsip_tpselector *sel)
372
if (sel->type == PJSIP_TPSELECTOR_TRANSPORT && sel->u.transport != NULL)
373
pjsip_transport_dec_ref(sel->u.transport);
374
else if (sel->type == PJSIP_TPSELECTOR_LISTENER && sel->u.listener != NULL)
375
; /* Hmm.. looks like we don't have reference counter for listener */
379
/*****************************************************************************
381
* TRANSMIT DATA BUFFER MANIPULATION.
383
*****************************************************************************/
386
* Create new transmit buffer.
388
PJ_DEF(pj_status_t) pjsip_tx_data_create( pjsip_tpmgr *mgr,
389
pjsip_tx_data **p_tdata )
392
pjsip_tx_data *tdata;
395
PJ_ASSERT_RETURN(mgr && p_tdata, PJ_EINVAL);
397
pool = pjsip_endpt_create_pool( mgr->endpt, "tdta%p",
398
PJSIP_POOL_LEN_TDATA,
399
PJSIP_POOL_INC_TDATA );
403
tdata = PJ_POOL_ZALLOC_T(pool, pjsip_tx_data);
406
pj_memcpy(tdata->obj_name, pool->obj_name, PJ_MAX_OBJ_NAME);
408
status = pj_atomic_create(tdata->pool, 0, &tdata->ref_cnt);
409
if (status != PJ_SUCCESS) {
410
pjsip_endpt_release_pool( mgr->endpt, tdata->pool );
414
//status = pj_lock_create_simple_mutex(pool, "tdta%p", &tdata->lock);
415
status = pj_lock_create_null_mutex(pool, "tdta%p", &tdata->lock);
416
if (status != PJ_SUCCESS) {
417
pjsip_endpt_release_pool( mgr->endpt, tdata->pool );
421
pj_ioqueue_op_key_init(&tdata->op_key.key, sizeof(tdata->op_key.key));
423
#if defined(PJ_DEBUG) && PJ_DEBUG!=0
424
pj_atomic_inc( tdata->mgr->tdata_counter );
433
* Add reference to tx buffer.
435
PJ_DEF(void) pjsip_tx_data_add_ref( pjsip_tx_data *tdata )
437
pj_atomic_inc(tdata->ref_cnt);
441
* Decrease transport data reference, destroy it when the reference count
444
PJ_DEF(pj_status_t) pjsip_tx_data_dec_ref( pjsip_tx_data *tdata )
446
pj_assert( pj_atomic_get(tdata->ref_cnt) > 0);
447
if (pj_atomic_dec_and_get(tdata->ref_cnt) <= 0) {
448
PJ_LOG(5,(tdata->obj_name, "Destroying txdata %s",
449
pjsip_tx_data_get_info(tdata)));
450
pjsip_tpselector_dec_ref(&tdata->tp_sel);
451
#if defined(PJ_DEBUG) && PJ_DEBUG!=0
452
pj_atomic_dec( tdata->mgr->tdata_counter );
454
pj_atomic_destroy( tdata->ref_cnt );
455
pj_lock_destroy( tdata->lock );
456
pjsip_endpt_release_pool( tdata->mgr->endpt, tdata->pool );
457
return PJSIP_EBUFDESTROYED;
464
* Invalidate the content of the print buffer to force the message to be
465
* re-printed when sent.
467
PJ_DEF(void) pjsip_tx_data_invalidate_msg( pjsip_tx_data *tdata )
469
tdata->buf.cur = tdata->buf.start;
474
* Print the SIP message to transmit data buffer's internal buffer.
476
PJ_DEF(pj_status_t) pjsip_tx_data_encode(pjsip_tx_data *tdata)
478
/* Allocate buffer if necessary. */
479
if (tdata->buf.start == NULL) {
483
tdata->buf.start = (char*)
484
pj_pool_alloc(tdata->pool, PJSIP_MAX_PKT_LEN);
491
tdata->buf.cur = tdata->buf.start;
492
tdata->buf.end = tdata->buf.start + PJSIP_MAX_PKT_LEN;
495
/* Do we need to reprint? */
496
if (!pjsip_tx_data_is_valid(tdata)) {
499
size = pjsip_msg_print( tdata->msg, tdata->buf.start,
500
tdata->buf.end - tdata->buf.start);
502
return PJSIP_EMSGTOOLONG;
504
pj_assert(size != 0);
505
tdata->buf.cur[size] = '\0';
506
tdata->buf.cur += size;
512
PJ_DEF(pj_bool_t) pjsip_tx_data_is_valid( pjsip_tx_data *tdata )
514
return tdata->buf.cur != tdata->buf.start;
517
static char *get_msg_info(pj_pool_t *pool, const char *obj_name,
518
const pjsip_msg *msg)
520
char info_buf[128], *info;
521
const pjsip_cseq_hdr *cseq;
524
cseq = (const pjsip_cseq_hdr*) pjsip_msg_find_hdr(msg, PJSIP_H_CSEQ, NULL);
525
PJ_ASSERT_RETURN(cseq != NULL, "INVALID MSG");
527
if (msg->type == PJSIP_REQUEST_MSG) {
528
len = pj_ansi_snprintf(info_buf, sizeof(info_buf),
529
"Request msg %.*s/cseq=%d (%s)",
530
(int)msg->line.req.method.name.slen,
531
msg->line.req.method.name.ptr,
532
cseq->cseq, obj_name);
534
len = pj_ansi_snprintf(info_buf, sizeof(info_buf),
535
"Response msg %d/%.*s/cseq=%d (%s)",
536
msg->line.status.code,
537
(int)cseq->method.name.slen,
538
cseq->method.name.ptr,
539
cseq->cseq, obj_name);
542
if (len < 1 || len >= (int)sizeof(info_buf)) {
543
return (char*)obj_name;
546
info = (char*) pj_pool_alloc(pool, len+1);
547
pj_memcpy(info, info_buf, len+1);
552
PJ_DEF(char*) pjsip_tx_data_get_info( pjsip_tx_data *tdata )
554
/* tdata->info may be assigned by application so if it exists
560
if (tdata==NULL || tdata->msg==NULL)
563
pj_lock_acquire(tdata->lock);
564
tdata->info = get_msg_info(tdata->pool, tdata->obj_name, tdata->msg);
565
pj_lock_release(tdata->lock);
570
PJ_DEF(pj_status_t) pjsip_tx_data_set_transport(pjsip_tx_data *tdata,
571
const pjsip_tpselector *sel)
573
PJ_ASSERT_RETURN(tdata && sel, PJ_EINVAL);
575
pj_lock_acquire(tdata->lock);
577
pjsip_tpselector_dec_ref(&tdata->tp_sel);
579
pj_memcpy(&tdata->tp_sel, sel, sizeof(*sel));
580
pjsip_tpselector_add_ref(&tdata->tp_sel);
582
pj_lock_release(tdata->lock);
588
PJ_DEF(char*) pjsip_rx_data_get_info(pjsip_rx_data *rdata)
590
char obj_name[PJ_MAX_OBJ_NAME];
592
PJ_ASSERT_RETURN(rdata->msg_info.msg, "INVALID MSG");
594
if (rdata->msg_info.info)
595
return rdata->msg_info.info;
597
pj_ansi_strcpy(obj_name, "rdata");
598
pj_ansi_snprintf(obj_name+5, sizeof(obj_name)-5, "%p", rdata);
600
rdata->msg_info.info = get_msg_info(rdata->tp_info.pool, obj_name,
601
rdata->msg_info.msg);
602
return rdata->msg_info.info;
605
/* Clone pjsip_rx_data. */
606
PJ_DEF(pj_status_t) pjsip_rx_data_clone( const pjsip_rx_data *src,
608
pjsip_rx_data **p_rdata)
614
PJ_ASSERT_RETURN(src && flags==0 && p_rdata, PJ_EINVAL);
616
pool = pj_pool_create(src->tp_info.pool->factory,
618
PJSIP_POOL_RDATA_LEN,
619
PJSIP_POOL_RDATA_INC,
624
dst = PJ_POOL_ZALLOC_T(pool, pjsip_rx_data);
626
/* Parts of tp_info */
627
dst->tp_info.pool = pool;
628
dst->tp_info.transport = (pjsip_transport*)src->tp_info.transport;
630
/* pkt_info can be memcopied */
631
pj_memcpy(&dst->pkt_info, &src->pkt_info, sizeof(src->pkt_info));
633
/* msg_info needs deep clone */
634
dst->msg_info.msg_buf = dst->pkt_info.packet;
635
dst->msg_info.len = src->msg_info.len;
636
dst->msg_info.msg = pjsip_msg_clone(pool, src->msg_info.msg);
637
pj_list_init(&dst->msg_info.parse_err);
639
#define GET_MSG_HDR2(TYPE, type, var) \
640
case PJSIP_H_##TYPE: \
641
if (!dst->msg_info.var) { \
642
dst->msg_info.var = (pjsip_##type##_hdr*)hdr; \
645
#define GET_MSG_HDR(TYPE, var_type) GET_MSG_HDR2(TYPE, var_type, var_type)
647
hdr = dst->msg_info.msg->hdr.next;
648
while (hdr != &dst->msg_info.msg->hdr) {
650
GET_MSG_HDR(CALL_ID, cid);
651
GET_MSG_HDR(FROM, from);
653
GET_MSG_HDR(VIA, via);
654
GET_MSG_HDR(CSEQ, cseq);
655
GET_MSG_HDR(MAX_FORWARDS, max_fwd);
656
GET_MSG_HDR(ROUTE, route);
657
GET_MSG_HDR2(RECORD_ROUTE, rr, record_route);
658
GET_MSG_HDR(CONTENT_TYPE, ctype);
659
GET_MSG_HDR(CONTENT_LENGTH, clen);
660
GET_MSG_HDR(REQUIRE, require);
661
GET_MSG_HDR(SUPPORTED, supported);
673
/* Finally add transport ref */
674
return pjsip_transport_add_ref(dst->tp_info.transport);
677
/* Free previously cloned pjsip_rx_data. */
678
PJ_DEF(pj_status_t) pjsip_rx_data_free_cloned(pjsip_rx_data *rdata)
680
PJ_ASSERT_RETURN(rdata, PJ_EINVAL);
682
pjsip_transport_dec_ref(rdata->tp_info.transport);
683
pj_pool_release(rdata->tp_info.pool);
688
/*****************************************************************************
692
*****************************************************************************/
695
/*****************************************************************************
699
*****************************************************************************/
701
static void transport_send_callback(pjsip_transport *transport,
705
pjsip_tx_data *tdata = (pjsip_tx_data*) token;
707
PJ_UNUSED_ARG(transport);
709
/* Mark pending off so that app can resend/reuse txdata from inside
712
tdata->is_pending = 0;
714
/* Call callback, if any. */
716
(*tdata->cb)(tdata->token, tdata, size);
719
/* Decrement reference count. */
720
pjsip_tx_data_dec_ref(tdata);
723
/* This function is called by endpoint for on_tx_request() and on_tx_response()
726
static pj_status_t mod_on_tx_msg(pjsip_tx_data *tdata)
728
return pjsip_tx_data_encode(tdata);
732
* Send a SIP message using the specified transport.
734
PJ_DEF(pj_status_t) pjsip_transport_send( pjsip_transport *tr,
735
pjsip_tx_data *tdata,
736
const pj_sockaddr_t *addr,
739
pjsip_tp_send_callback cb)
743
PJ_ASSERT_RETURN(tr && tdata && addr, PJ_EINVAL);
745
/* Is it currently being sent? */
746
if (tdata->is_pending) {
747
pj_assert(!"Invalid operation step!");
748
PJ_LOG(2,(THIS_FILE, "Unable to send %s: message is pending",
749
pjsip_tx_data_get_info(tdata)));
750
return PJSIP_EPENDINGTX;
753
/* Add reference to prevent deletion, and to cancel idle timer if
756
pjsip_transport_add_ref(tr);
758
/* Fill in tp_info. */
759
tdata->tp_info.transport = tr;
760
pj_memcpy(&tdata->tp_info.dst_addr, addr, addr_len);
761
tdata->tp_info.dst_addr_len = addr_len;
763
pj_inet_ntop(((pj_sockaddr*)addr)->addr.sa_family,
764
pj_sockaddr_get_addr(addr),
765
tdata->tp_info.dst_name,
766
sizeof(tdata->tp_info.dst_name));
767
tdata->tp_info.dst_port = pj_sockaddr_get_port(addr);
769
/* Distribute to modules.
770
* When the message reach mod_msg_print, the contents of the message will
771
* be "printed" to contiguous buffer.
773
if (tr->tpmgr->on_tx_msg) {
774
status = (*tr->tpmgr->on_tx_msg)(tr->endpt, tdata);
775
if (status != PJ_SUCCESS) {
776
pjsip_transport_dec_ref(tr);
781
/* Save callback data. */
782
tdata->token = token;
785
/* Add reference counter. */
786
pjsip_tx_data_add_ref(tdata);
788
/* Mark as pending. */
789
tdata->is_pending = 1;
791
/* Send to transport. */
792
status = (*tr->send_msg)(tr, tdata, addr, addr_len, (void*)tdata,
793
&transport_send_callback);
795
if (status != PJ_EPENDING) {
796
tdata->is_pending = 0;
797
pjsip_tx_data_dec_ref(tdata);
800
pjsip_transport_dec_ref(tr);
805
/* send_raw() callback */
806
static void send_raw_callback(pjsip_transport *transport,
810
pjsip_tx_data *tdata = (pjsip_tx_data*) token;
812
/* Mark pending off so that app can resend/reuse txdata from inside
815
tdata->is_pending = 0;
817
/* Call callback, if any. */
819
(*tdata->cb)(tdata->token, tdata, size);
822
/* Decrement tdata reference count. */
823
pjsip_tx_data_dec_ref(tdata);
825
/* Decrement transport reference count */
826
pjsip_transport_dec_ref(transport);
831
PJ_DEF(pj_status_t) pjsip_tpmgr_send_raw(pjsip_tpmgr *mgr,
832
pjsip_transport_type_e tp_type,
833
const pjsip_tpselector *sel,
834
pjsip_tx_data *tdata,
835
const void *raw_data,
837
const pj_sockaddr_t *addr,
840
pjsip_tp_send_callback cb)
845
/* Acquire the transport */
846
status = pjsip_tpmgr_acquire_transport(mgr, tp_type, addr, addr_len,
848
if (status != PJ_SUCCESS)
851
/* Create transmit data buffer if one is not specified */
853
status = pjsip_endpt_create_tdata(tr->endpt, &tdata);
854
if (status != PJ_SUCCESS) {
855
pjsip_transport_dec_ref(tr);
861
/* Add reference counter. */
862
pjsip_tx_data_add_ref(tdata);
865
/* Allocate buffer */
866
if (tdata->buf.start == NULL ||
867
(tdata->buf.end - tdata->buf.start) < (int)data_len)
869
/* Note: data_len may be zero, so allocate +1 */
870
tdata->buf.start = (char*) pj_pool_alloc(tdata->pool, data_len+1);
871
tdata->buf.end = tdata->buf.start + data_len + 1;
874
/* Copy data, if any! (application may send zero len packet) */
876
pj_memcpy(tdata->buf.start, raw_data, data_len);
878
tdata->buf.cur = tdata->buf.start + data_len;
880
/* Save callback data. */
881
tdata->token = token;
884
/* Mark as pending. */
885
tdata->is_pending = 1;
887
/* Send to transport */
888
status = tr->send_msg(tr, tdata, addr, addr_len,
889
tdata, &send_raw_callback);
891
if (status != PJ_EPENDING) {
892
/* callback will not be called, so destroy tdata now. */
893
pjsip_tx_data_dec_ref(tdata);
894
pjsip_transport_dec_ref(tr);
901
static void transport_idle_callback(pj_timer_heap_t *timer_heap,
902
struct pj_timer_entry *entry)
904
pjsip_transport *tp = (pjsip_transport*) entry->user_data;
905
pj_assert(tp != NULL);
907
PJ_UNUSED_ARG(timer_heap);
909
entry->id = PJ_FALSE;
910
pjsip_transport_destroy(tp);
916
PJ_DEF(pj_status_t) pjsip_transport_add_ref( pjsip_transport *tp )
918
PJ_ASSERT_RETURN(tp != NULL, PJ_EINVAL);
920
if (pj_atomic_inc_and_get(tp->ref_cnt) == 1) {
921
pj_lock_acquire(tp->tpmgr->lock);
923
if (pj_atomic_get(tp->ref_cnt) == 1) {
924
if (tp->idle_timer.id != PJ_FALSE) {
925
pjsip_endpt_cancel_timer(tp->tpmgr->endpt, &tp->idle_timer);
926
tp->idle_timer.id = PJ_FALSE;
929
pj_lock_release(tp->tpmgr->lock);
938
PJ_DEF(pj_status_t) pjsip_transport_dec_ref( pjsip_transport *tp )
940
PJ_ASSERT_RETURN(tp != NULL, PJ_EINVAL);
942
pj_assert(pj_atomic_get(tp->ref_cnt) > 0);
944
if (pj_atomic_dec_and_get(tp->ref_cnt) == 0) {
945
pj_lock_acquire(tp->tpmgr->lock);
946
/* Verify again. Do not register timer if the transport is
949
if (pj_atomic_get(tp->ref_cnt) == 0 && !tp->is_destroying) {
952
/* If transport is in graceful shutdown, then this is the
953
* last user who uses the transport. Schedule to destroy the
954
* transport immediately. Otherwise schedule idle timer.
956
if (tp->is_shutdown) {
957
delay.sec = delay.msec = 0;
959
delay.sec = (tp->dir==PJSIP_TP_DIR_OUTGOING) ?
960
PJSIP_TRANSPORT_IDLE_TIME :
961
PJSIP_TRANSPORT_SERVER_IDLE_TIME;
965
pj_assert(tp->idle_timer.id == 0);
966
tp->idle_timer.id = PJ_TRUE;
967
pjsip_endpt_schedule_timer(tp->tpmgr->endpt, &tp->idle_timer,
970
pj_lock_release(tp->tpmgr->lock);
978
* Register a transport.
980
PJ_DEF(pj_status_t) pjsip_transport_register( pjsip_tpmgr *mgr,
981
pjsip_transport *tp )
989
pj_bzero(&tp->idle_timer, sizeof(tp->idle_timer));
990
tp->idle_timer.user_data = tp;
991
tp->idle_timer.cb = &transport_idle_callback;
994
* Register to hash table (see Trac ticket #42).
996
key_len = sizeof(tp->key.type) + tp->addr_len;
997
pj_lock_acquire(mgr->lock);
999
/* If entry already occupied, unregister previous entry */
1001
entry = pj_hash_get(mgr->table, &tp->key, key_len, &hval);
1003
pj_hash_set(NULL, mgr->table, &tp->key, key_len, hval, NULL);
1005
/* Register new entry */
1006
pj_hash_set(tp->pool, mgr->table, &tp->key, key_len, hval, tp);
1008
pj_lock_release(mgr->lock);
1010
TRACE_((THIS_FILE,"Transport %s registered: type=%s, remote=%s:%d",
1012
pjsip_transport_get_type_name(tp->key.type),
1013
addr_string(&tp->key.rem_addr),
1014
pj_sockaddr_get_port(&tp->key.rem_addr)));
1019
/* Force destroy transport (e.g. during transport manager shutdown. */
1020
static pj_status_t destroy_transport( pjsip_tpmgr *mgr,
1021
pjsip_transport *tp )
1027
TRACE_((THIS_FILE, "Transport %s is being destroyed", tp->obj_name));
1029
pj_lock_acquire(tp->lock);
1030
pj_lock_acquire(mgr->lock);
1032
tp->is_destroying = PJ_TRUE;
1035
* Unregister timer, if any.
1037
//pj_assert(tp->idle_timer.id == PJ_FALSE);
1038
if (tp->idle_timer.id != PJ_FALSE) {
1039
pjsip_endpt_cancel_timer(mgr->endpt, &tp->idle_timer);
1040
tp->idle_timer.id = PJ_FALSE;
1044
* Unregister from hash table (see Trac ticket #42).
1046
key_len = sizeof(tp->key.type) + tp->addr_len;
1048
entry = pj_hash_get(mgr->table, &tp->key, key_len, &hval);
1049
if (entry == (void*)tp)
1050
pj_hash_set(NULL, mgr->table, &tp->key, key_len, hval, NULL);
1052
pj_lock_release(mgr->lock);
1055
return tp->destroy(tp);
1060
* Start graceful shutdown procedure for this transport.
1062
PJ_DEF(pj_status_t) pjsip_transport_shutdown(pjsip_transport *tp)
1067
TRACE_((THIS_FILE, "Transport %s shutting down", tp->obj_name));
1069
pj_lock_acquire(tp->lock);
1072
pj_lock_acquire(mgr->lock);
1074
/* Do nothing if transport is being shutdown already */
1075
if (tp->is_shutdown) {
1076
pj_lock_release(tp->lock);
1077
pj_lock_release(mgr->lock);
1081
status = PJ_SUCCESS;
1083
/* Instruct transport to shutdown itself */
1084
if (tp->do_shutdown)
1085
status = tp->do_shutdown(tp);
1087
if (status == PJ_SUCCESS)
1088
tp->is_shutdown = PJ_TRUE;
1090
/* If transport reference count is zero, start timer count-down */
1091
if (pj_atomic_get(tp->ref_cnt) == 0) {
1092
pjsip_transport_add_ref(tp);
1093
pjsip_transport_dec_ref(tp);
1096
pj_lock_release(tp->lock);
1097
pj_lock_release(mgr->lock);
1104
* Unregister transport.
1106
PJ_DEF(pj_status_t) pjsip_transport_destroy( pjsip_transport *tp)
1108
/* Must have no user. */
1109
PJ_ASSERT_RETURN(pj_atomic_get(tp->ref_cnt) == 0, PJSIP_EBUSY);
1112
return destroy_transport(tp->tpmgr, tp);
1117
/*****************************************************************************
1121
*****************************************************************************/
1124
PJ_DEF(pj_status_t) pjsip_tpmgr_register_tpfactory( pjsip_tpmgr *mgr,
1125
pjsip_tpfactory *tpf)
1130
pj_lock_acquire(mgr->lock);
1132
/* Check that no factory with the same type has been registered. */
1133
status = PJ_SUCCESS;
1134
for (p=mgr->factory_list.next; p!=&mgr->factory_list; p=p->next) {
1135
if (p->type == tpf->type) {
1136
status = PJSIP_ETYPEEXISTS;
1140
status = PJ_EEXISTS;
1145
if (status != PJ_SUCCESS) {
1146
pj_lock_release(mgr->lock);
1150
pj_list_insert_before(&mgr->factory_list, tpf);
1152
pj_lock_release(mgr->lock);
1159
* Unregister factory.
1161
PJ_DEF(pj_status_t) pjsip_tpmgr_unregister_tpfactory( pjsip_tpmgr *mgr,
1162
pjsip_tpfactory *tpf)
1164
pj_lock_acquire(mgr->lock);
1166
pj_assert(pj_list_find_node(&mgr->factory_list, tpf) == tpf);
1169
pj_lock_release(mgr->lock);
1174
PJ_DECL(void) pjsip_tpmgr_fla2_param_default(pjsip_tpmgr_fla2_param *prm)
1176
pj_bzero(prm, sizeof(*prm));
1179
/*****************************************************************************
1183
*****************************************************************************/
1186
* Create a new transport manager.
1188
PJ_DEF(pj_status_t) pjsip_tpmgr_create( pj_pool_t *pool,
1189
pjsip_endpoint *endpt,
1190
pjsip_rx_callback rx_cb,
1191
pjsip_tx_callback tx_cb,
1192
pjsip_tpmgr **p_mgr)
1197
PJ_ASSERT_RETURN(pool && endpt && rx_cb && p_mgr, PJ_EINVAL);
1199
/* Register mod_msg_print module. */
1200
status = pjsip_endpt_register_module(endpt, &mod_msg_print);
1201
if (status != PJ_SUCCESS)
1204
/* Create and initialize transport manager. */
1205
mgr = PJ_POOL_ZALLOC_T(pool, pjsip_tpmgr);
1207
mgr->on_rx_msg = rx_cb;
1208
mgr->on_tx_msg = tx_cb;
1209
pj_list_init(&mgr->factory_list);
1211
mgr->table = pj_hash_create(pool, PJSIP_TPMGR_HTABLE_SIZE);
1215
status = pj_lock_create_recursive_mutex(pool, "tmgr%p", &mgr->lock);
1216
if (status != PJ_SUCCESS)
1219
#if defined(PJ_DEBUG) && PJ_DEBUG!=0
1220
status = pj_atomic_create(pool, 0, &mgr->tdata_counter);
1221
if (status != PJ_SUCCESS)
1225
/* Set transport state callback */
1226
status = pjsip_tpmgr_set_state_cb(mgr, &tp_state_callback);
1227
if (status != PJ_SUCCESS)
1230
PJ_LOG(5, (THIS_FILE, "Transport manager created."));
1236
/* Get the interface to send packet to the specified address */
1237
static pj_status_t get_net_interface(pjsip_transport_type_e tp_type,
1238
const pj_str_t *dst,
1239
pj_str_t *itf_str_addr)
1242
pj_sockaddr itf_addr;
1245
af = (tp_type & PJSIP_TRANSPORT_IPV6)? PJ_AF_INET6 : PJ_AF_INET;
1246
status = pj_getipinterface(af, dst, &itf_addr, PJ_FALSE, NULL);
1247
if (status != PJ_SUCCESS)
1251
pj_sockaddr_print(&itf_addr, itf_str_addr->ptr,
1252
PJ_INET6_ADDRSTRLEN, 0);
1253
itf_str_addr->slen = pj_ansi_strlen(itf_str_addr->ptr);
1259
* Find out the appropriate local address info (IP address and port) to
1260
* advertise in Contact header based on the remote address to be
1261
* contacted. The local address info would be the address name of the
1262
* transport or listener which will be used to send the request.
1264
* In this implementation, it will only select the transport based on
1265
* the transport type in the request.
1267
PJ_DEF(pj_status_t) pjsip_tpmgr_find_local_addr2(pjsip_tpmgr *tpmgr,
1269
pjsip_tpmgr_fla2_param *prm)
1271
char tmp_buf[PJ_INET6_ADDRSTRLEN+10];
1273
pj_status_t status = PJSIP_EUNSUPTRANSPORT;
1277
PJ_ASSERT_RETURN(tpmgr && pool && prm, PJ_EINVAL);
1279
pj_strset(&tmp_str, tmp_buf, 0);
1280
prm->ret_addr.slen = 0;
1284
flag = pjsip_transport_get_flag_from_type(prm->tp_type);
1286
if (prm->tp_sel && prm->tp_sel->type == PJSIP_TPSELECTOR_TRANSPORT &&
1287
prm->tp_sel->u.transport)
1289
const pjsip_transport *tp = prm->tp_sel->u.transport;
1290
if (prm->local_if) {
1291
status = get_net_interface((pjsip_transport_type_e)tp->key.type,
1292
&prm->dst_host, &tmp_str);
1293
if (status != PJ_SUCCESS)
1295
pj_strdup(pool, &prm->ret_addr, &tmp_str);
1296
prm->ret_port = pj_sockaddr_get_port(&tp->local_addr);
1299
pj_strdup(pool, &prm->ret_addr, &tp->local_name.host);
1300
prm->ret_port = (pj_uint16_t)tp->local_name.port;
1302
status = PJ_SUCCESS;
1304
} else if (prm->tp_sel && prm->tp_sel->type == PJSIP_TPSELECTOR_LISTENER &&
1305
prm->tp_sel->u.listener)
1307
if (prm->local_if) {
1308
status = get_net_interface(prm->tp_sel->u.listener->type,
1309
&prm->dst_host, &tmp_str);
1310
if (status != PJ_SUCCESS)
1312
pj_strdup(pool, &prm->ret_addr, &tmp_str);
1314
pj_strdup(pool, &prm->ret_addr,
1315
&prm->tp_sel->u.listener->addr_name.host);
1317
prm->ret_port = (pj_uint16_t)prm->tp_sel->u.listener->addr_name.port;
1318
status = PJ_SUCCESS;
1320
} else if ((flag & PJSIP_TRANSPORT_DATAGRAM) != 0) {
1323
pjsip_transport *tp;
1325
pj_bzero(&remote, sizeof(remote));
1326
if (prm->tp_type & PJSIP_TRANSPORT_IPV6) {
1327
addr_len = sizeof(pj_sockaddr_in6);
1328
remote.addr.sa_family = pj_AF_INET6();
1330
addr_len = sizeof(pj_sockaddr_in);
1331
remote.addr.sa_family = pj_AF_INET();
1334
status = pjsip_tpmgr_acquire_transport(tpmgr, prm->tp_type, &remote,
1335
addr_len, NULL, &tp);
1337
if (status == PJ_SUCCESS) {
1338
if (prm->local_if) {
1339
status = get_net_interface((pjsip_transport_type_e)
1341
&prm->dst_host, &tmp_str);
1342
if (status != PJ_SUCCESS)
1344
pj_strdup(pool, &prm->ret_addr, &tmp_str);
1345
prm->ret_port = pj_sockaddr_get_port(&tp->local_addr);
1348
pj_strdup(pool, &prm->ret_addr, &tp->local_name.host);
1349
prm->ret_port = (pj_uint16_t)tp->local_name.port;
1352
pjsip_transport_dec_ref(tp);
1356
/* For connection oriented transport, enum the factories */
1359
pj_lock_acquire(tpmgr->lock);
1361
f = tpmgr->factory_list.next;
1362
while (f != &tpmgr->factory_list) {
1363
if (f->type == prm->tp_type)
1368
if (f != &tpmgr->factory_list) {
1369
if (prm->local_if) {
1370
status = get_net_interface(f->type, &prm->dst_host,
1372
if (status == PJ_SUCCESS) {
1373
pj_strdup(pool, &prm->ret_addr, &tmp_str);
1375
/* It could fail "normally" on certain cases, e.g.
1376
* when connecting to IPv6 link local address, it
1377
* will wail with EINVAL.
1378
* In this case, fallback to use the default interface
1379
* rather than failing the call.
1381
PJ_PERROR(5,(THIS_FILE, status, "Warning: unable to "
1382
"determine local interface"));
1383
pj_strdup(pool, &prm->ret_addr, &f->addr_name.host);
1384
status = PJ_SUCCESS;
1387
pj_strdup(pool, &prm->ret_addr, &f->addr_name.host);
1389
prm->ret_port = (pj_uint16_t)f->addr_name.port;
1390
status = PJ_SUCCESS;
1392
pj_lock_release(tpmgr->lock);
1399
PJ_DEF(pj_status_t) pjsip_tpmgr_find_local_addr( pjsip_tpmgr *tpmgr,
1401
pjsip_transport_type_e type,
1402
const pjsip_tpselector *sel,
1406
pjsip_tpmgr_fla2_param prm;
1409
pjsip_tpmgr_fla2_param_default(&prm);
1413
status = pjsip_tpmgr_find_local_addr2(tpmgr, pool, &prm);
1414
if (status != PJ_SUCCESS)
1417
*ip_addr = prm.ret_addr;
1418
*port = prm.ret_port;
1424
* Return number of transports currently registered to the transport
1427
PJ_DEF(unsigned) pjsip_tpmgr_get_transport_count(pjsip_tpmgr *mgr)
1429
pj_hash_iterator_t itr_val;
1430
pj_hash_iterator_t *itr;
1431
int nr_of_transports = 0;
1433
pj_lock_acquire(mgr->lock);
1435
itr = pj_hash_first(mgr->table, &itr_val);
1438
itr = pj_hash_next(mgr->table, itr);
1441
pj_lock_release(mgr->lock);
1443
return nr_of_transports;
1447
* pjsip_tpmgr_destroy()
1449
* Destroy transport manager.
1451
PJ_DEF(pj_status_t) pjsip_tpmgr_destroy( pjsip_tpmgr *mgr )
1453
pj_hash_iterator_t itr_val;
1454
pj_hash_iterator_t *itr;
1455
pjsip_tpfactory *factory;
1456
pjsip_endpoint *endpt = mgr->endpt;
1458
PJ_LOG(5, (THIS_FILE, "Destroying transport manager"));
1460
pj_lock_acquire(mgr->lock);
1463
* Destroy all transports.
1465
itr = pj_hash_first(mgr->table, &itr_val);
1466
while (itr != NULL) {
1467
pj_hash_iterator_t *next;
1468
pjsip_transport *transport;
1470
transport = (pjsip_transport*) pj_hash_this(mgr->table, itr);
1472
next = pj_hash_next(mgr->table, itr);
1474
destroy_transport(mgr, transport);
1480
* Destroy all factories/listeners.
1482
factory = mgr->factory_list.next;
1483
while (factory != &mgr->factory_list) {
1484
pjsip_tpfactory *next = factory->next;
1486
factory->destroy(factory);
1491
pj_lock_release(mgr->lock);
1492
pj_lock_destroy(mgr->lock);
1494
/* Unregister mod_msg_print. */
1495
if (mod_msg_print.id != -1) {
1496
pjsip_endpt_unregister_module(endpt, &mod_msg_print);
1499
#if defined(PJ_DEBUG) && PJ_DEBUG!=0
1500
/* If you encounter assert error on this line, it means there are
1501
* leakings in transmit data (i.e. some transmit data have not been
1504
//pj_assert(pj_atomic_get(mgr->tdata_counter) == 0);
1505
if (pj_atomic_get(mgr->tdata_counter) != 0) {
1506
PJ_LOG(3,(THIS_FILE, "Warning: %d transmit buffer(s) not freed!",
1507
pj_atomic_get(mgr->tdata_counter)));
1516
* pjsip_tpmgr_receive_packet()
1518
* Called by tranports when they receive a new packet.
1520
PJ_DEF(pj_ssize_t) pjsip_tpmgr_receive_packet( pjsip_tpmgr *mgr,
1521
pjsip_rx_data *rdata)
1523
pjsip_transport *tr = rdata->tp_info.transport;
1526
pj_size_t remaining_len;
1527
pj_size_t total_processed = 0;
1530
pj_assert(rdata->pkt_info.len > 0);
1531
if (rdata->pkt_info.len <= 0)
1534
current_pkt = rdata->pkt_info.packet;
1535
remaining_len = rdata->pkt_info.len;
1537
/* Must NULL terminate buffer. This is the requirement of the
1540
current_pkt[remaining_len] = '\0';
1542
/* Process all message fragments. */
1543
while (remaining_len > 0) {
1548
pj_size_t msg_fragment_size;
1550
/* Skip leading newlines as pjsip_find_msg() currently can't
1551
* handle leading newlines.
1553
for (p=current_pkt, end=p+remaining_len; p!=end; ++p) {
1554
if (*p != '\r' && *p != '\n')
1557
if (p!=current_pkt) {
1558
remaining_len -= (p - current_pkt);
1559
total_processed += (p - current_pkt);
1561
if (remaining_len == 0) {
1562
return total_processed;
1566
/* Initialize default fragment size. */
1567
msg_fragment_size = remaining_len;
1569
/* Clear and init msg_info in rdata.
1570
* Endpoint might inspect the values there when we call the callback
1571
* to report some errors.
1573
pj_bzero(&rdata->msg_info, sizeof(rdata->msg_info));
1574
pj_list_init(&rdata->msg_info.parse_err);
1575
rdata->msg_info.msg_buf = current_pkt;
1576
rdata->msg_info.len = remaining_len;
1578
/* For TCP transport, check if the whole message has been received. */
1579
if ((tr->flag & PJSIP_TRANSPORT_DATAGRAM) == 0) {
1580
pj_status_t msg_status;
1581
msg_status = pjsip_find_msg(current_pkt, remaining_len, PJ_FALSE,
1582
&msg_fragment_size);
1583
if (msg_status != PJ_SUCCESS) {
1584
if (remaining_len == PJSIP_MAX_PKT_LEN) {
1585
mgr->on_rx_msg(mgr->endpt, PJSIP_ERXOVERFLOW, rdata);
1586
/* Exhaust all data. */
1587
return rdata->pkt_info.len;
1589
/* Not enough data in packet. */
1590
return total_processed;
1595
/* Update msg_info. */
1596
rdata->msg_info.len = msg_fragment_size;
1598
/* Null terminate packet */
1599
saved = current_pkt[msg_fragment_size];
1600
current_pkt[msg_fragment_size] = '\0';
1602
/* Parse the message. */
1603
rdata->msg_info.msg = msg =
1604
pjsip_parse_rdata( current_pkt, msg_fragment_size, rdata);
1606
/* Restore null termination */
1607
current_pkt[msg_fragment_size] = saved;
1609
/* Check for parsing syntax error */
1610
if (msg==NULL || !pj_list_empty(&rdata->msg_info.parse_err)) {
1611
pjsip_parser_err_report *err;
1615
/* Gather syntax error information */
1616
tmp.ptr = buf; tmp.slen = 0;
1617
err = rdata->msg_info.parse_err.next;
1618
while (err != &rdata->msg_info.parse_err) {
1620
len = pj_ansi_snprintf(tmp.ptr+tmp.slen, sizeof(buf)-tmp.slen,
1621
": %s exception when parsing '%.*s' "
1622
"header on line %d col %d",
1623
pj_exception_id_name(err->except_code),
1624
(int)err->hname.slen, err->hname.ptr,
1625
err->line, err->col);
1626
if (len > 0 && len < (int) (sizeof(buf)-tmp.slen)) {
1632
/* Only print error message if there's error.
1633
* Sometimes we receive blank packets (packets with only CRLF)
1634
* which were sent to keep NAT bindings.
1637
PJ_LOG(1, (THIS_FILE,
1638
"Error processing %d bytes packet from %s %s:%d %.*s:\n"
1640
"-- end of packet.",
1642
rdata->tp_info.transport->type_name,
1643
rdata->pkt_info.src_name,
1644
rdata->pkt_info.src_port,
1645
(int)tmp.slen, tmp.ptr,
1646
(int)msg_fragment_size,
1647
rdata->msg_info.msg_buf));
1650
goto finish_process_fragment;
1653
/* Perform basic header checking. */
1654
if (rdata->msg_info.cid == NULL ||
1655
rdata->msg_info.cid->id.slen == 0 ||
1656
rdata->msg_info.from == NULL ||
1657
rdata->msg_info.to == NULL ||
1658
rdata->msg_info.via == NULL ||
1659
rdata->msg_info.cseq == NULL)
1661
mgr->on_rx_msg(mgr->endpt, PJSIP_EMISSINGHDR, rdata);
1662
goto finish_process_fragment;
1666
if (rdata->msg_info.msg->type == PJSIP_REQUEST_MSG) {
1667
/* always add received parameter to the via. */
1668
pj_strdup2(rdata->tp_info.pool,
1669
&rdata->msg_info.via->recvd_param,
1670
rdata->pkt_info.src_name);
1673
* If message contains "rport" param, put the received port there.
1675
if (rdata->msg_info.via->rport_param == 0) {
1676
rdata->msg_info.via->rport_param = rdata->pkt_info.src_port;
1679
/* Drop malformed responses */
1680
if (rdata->msg_info.msg->line.status.code < 100 ||
1681
rdata->msg_info.msg->line.status.code >= 700)
1683
mgr->on_rx_msg(mgr->endpt, PJSIP_EINVALIDSTATUS, rdata);
1684
goto finish_process_fragment;
1688
/* Drop response message if it has more than one Via.
1690
/* This is wrong. Proxy DOES receive responses with multiple
1691
* Via headers! Thanks Aldo <acampi at deis.unibo.it> for pointing
1694
if (msg->type == PJSIP_RESPONSE_MSG) {
1696
hdr = (pjsip_hdr*)rdata->msg_info.via->next;
1697
if (hdr != &msg->hdr) {
1698
hdr = pjsip_msg_find_hdr(msg, PJSIP_H_VIA, hdr);
1700
mgr->on_rx_msg(mgr->endpt, PJSIP_EMULTIPLEVIA, rdata);
1701
goto finish_process_fragment;
1707
/* Call the transport manager's upstream message callback.
1709
mgr->on_rx_msg(mgr->endpt, PJ_SUCCESS, rdata);
1712
finish_process_fragment:
1713
total_processed += msg_fragment_size;
1714
current_pkt += msg_fragment_size;
1715
remaining_len -= msg_fragment_size;
1717
} /* while (rdata->pkt_info.len > 0) */
1720
return total_processed;
1725
* pjsip_tpmgr_acquire_transport()
1727
* Get transport suitable to communicate to remote. Create a new one
1730
PJ_DEF(pj_status_t) pjsip_tpmgr_acquire_transport(pjsip_tpmgr *mgr,
1731
pjsip_transport_type_e type,
1732
const pj_sockaddr_t *remote,
1734
const pjsip_tpselector *sel,
1735
pjsip_transport **tp)
1737
return pjsip_tpmgr_acquire_transport2(mgr, type, remote, addr_len, sel,
1742
* pjsip_tpmgr_acquire_transport2()
1744
* Get transport suitable to communicate to remote. Create a new one
1747
PJ_DEF(pj_status_t) pjsip_tpmgr_acquire_transport2(pjsip_tpmgr *mgr,
1748
pjsip_transport_type_e type,
1749
const pj_sockaddr_t *remote,
1751
const pjsip_tpselector *sel,
1752
pjsip_tx_data *tdata,
1753
pjsip_transport **tp)
1755
pjsip_tpfactory *factory;
1758
TRACE_((THIS_FILE,"Acquiring transport type=%s, remote=%s:%d",
1759
pjsip_transport_get_type_name(type),
1760
addr_string(remote),
1761
pj_sockaddr_get_port(remote)));
1763
pj_lock_acquire(mgr->lock);
1765
/* If transport is specified, then just use it if it is suitable
1766
* for the destination.
1768
if (sel && sel->type == PJSIP_TPSELECTOR_TRANSPORT &&
1771
pjsip_transport *seltp = sel->u.transport;
1773
/* See if the transport is (not) suitable */
1774
if (seltp->key.type != type) {
1775
pj_lock_release(mgr->lock);
1776
return PJSIP_ETPNOTSUITABLE;
1779
/* We could also verify that the destination address is reachable
1780
* from this transport (i.e. both are equal), but if application
1781
* has requested a specific transport to be used, assume that
1782
* it knows what to do.
1784
* In other words, I don't think destination verification is a good
1788
/* Transport looks to be suitable to use, so just use it. */
1789
pjsip_transport_add_ref(seltp);
1790
pj_lock_release(mgr->lock);
1793
TRACE_((THIS_FILE, "Transport %s acquired", seltp->obj_name));
1797
} else if (sel && sel->type == PJSIP_TPSELECTOR_LISTENER &&
1800
/* Application has requested that a specific listener is to
1801
* be used. In this case, skip transport hash table lookup.
1804
/* Verify that the listener type matches the destination type */
1805
if (sel->u.listener->type != type) {
1806
pj_lock_release(mgr->lock);
1807
return PJSIP_ETPNOTSUITABLE;
1810
/* We'll use this listener to create transport */
1811
factory = sel->u.listener;
1816
* This is the "normal" flow, where application doesn't specify
1817
* specific transport/listener to be used to send message to.
1818
* In this case, lookup the transport from the hash table.
1820
pjsip_transport_key key;
1822
pjsip_transport *transport;
1824
pj_bzero(&key, sizeof(key));
1825
key_len = sizeof(key.type) + addr_len;
1827
/* First try to get exact destination. */
1829
pj_memcpy(&key.rem_addr, remote, addr_len);
1831
transport = (pjsip_transport*)
1832
pj_hash_get(mgr->table, &key, key_len, NULL);
1834
if (transport == NULL) {
1835
unsigned flag = pjsip_transport_get_flag_from_type(type);
1836
const pj_sockaddr *remote_addr = (const pj_sockaddr*)remote;
1839
/* Ignore address for loop transports. */
1840
if (type == PJSIP_TRANSPORT_LOOP ||
1841
type == PJSIP_TRANSPORT_LOOP_DGRAM)
1843
pj_sockaddr *addr = &key.rem_addr;
1845
pj_bzero(addr, addr_len);
1846
key_len = sizeof(key.type) + addr_len;
1847
transport = (pjsip_transport*)
1848
pj_hash_get(mgr->table, &key, key_len, NULL);
1850
/* For datagram transports, try lookup with zero address.
1852
else if (flag & PJSIP_TRANSPORT_DATAGRAM)
1854
pj_sockaddr *addr = &key.rem_addr;
1856
pj_bzero(addr, addr_len);
1857
addr->addr.sa_family = remote_addr->addr.sa_family;
1859
key_len = sizeof(key.type) + addr_len;
1860
transport = (pjsip_transport*)
1861
pj_hash_get(mgr->table, &key, key_len, NULL);
1865
if (transport!=NULL && !transport->is_shutdown) {
1869
pjsip_transport_add_ref(transport);
1870
pj_lock_release(mgr->lock);
1873
TRACE_((THIS_FILE, "Transport %s acquired", transport->obj_name));
1878
* Transport not found!
1879
* Find factory that can create such transport.
1881
factory = mgr->factory_list.next;
1882
while (factory != &mgr->factory_list) {
1883
if (factory->type == type)
1885
factory = factory->next;
1888
if (factory == &mgr->factory_list) {
1889
/* No factory can create the transport! */
1890
pj_lock_release(mgr->lock);
1891
TRACE_((THIS_FILE, "No suitable factory was found either"));
1892
return PJSIP_EUNSUPTRANSPORT;
1896
TRACE_((THIS_FILE, "Creating new transport from factory"));
1898
/* Request factory to create transport. */
1899
if (factory->create_transport2) {
1900
status = factory->create_transport2(factory, mgr, mgr->endpt,
1901
(const pj_sockaddr*) remote,
1902
addr_len, tdata, tp);
1904
status = factory->create_transport(factory, mgr, mgr->endpt,
1905
(const pj_sockaddr*) remote,
1908
if (status == PJ_SUCCESS) {
1909
PJ_ASSERT_ON_FAIL(tp!=NULL,
1910
{pj_lock_release(mgr->lock); return PJ_EBUG;});
1911
pjsip_transport_add_ref(*tp);
1913
pj_lock_release(mgr->lock);
1918
* Dump transport info.
1920
PJ_DEF(void) pjsip_tpmgr_dump_transports(pjsip_tpmgr *mgr)
1922
#if PJ_LOG_MAX_LEVEL >= 3
1923
pj_hash_iterator_t itr_val;
1924
pj_hash_iterator_t *itr;
1925
pjsip_tpfactory *factory;
1927
pj_lock_acquire(mgr->lock);
1929
#if defined(PJ_DEBUG) && PJ_DEBUG!=0
1930
PJ_LOG(3,(THIS_FILE, " Outstanding transmit buffers: %d",
1931
pj_atomic_get(mgr->tdata_counter)));
1934
PJ_LOG(3, (THIS_FILE, " Dumping listeners:"));
1935
factory = mgr->factory_list.next;
1936
while (factory != &mgr->factory_list) {
1937
PJ_LOG(3, (THIS_FILE, " %s %s:%.*s:%d",
1940
(int)factory->addr_name.host.slen,
1941
factory->addr_name.host.ptr,
1942
(int)factory->addr_name.port));
1943
factory = factory->next;
1946
itr = pj_hash_first(mgr->table, &itr_val);
1948
PJ_LOG(3, (THIS_FILE, " Dumping transports:"));
1951
pjsip_transport *t = (pjsip_transport*)
1952
pj_hash_this(mgr->table, itr);
1954
PJ_LOG(3, (THIS_FILE, " %s %s (refcnt=%d%s)",
1957
pj_atomic_get(t->ref_cnt),
1958
(t->idle_timer.id ? " [idle]" : "")));
1960
itr = pj_hash_next(mgr->table, itr);
1964
pj_lock_release(mgr->lock);
1971
* Set callback of global transport state notification.
1973
PJ_DEF(pj_status_t) pjsip_tpmgr_set_state_cb(pjsip_tpmgr *mgr,
1974
pjsip_tp_state_callback cb)
1976
PJ_ASSERT_RETURN(mgr, PJ_EINVAL);
1978
mgr->tp_state_cb = cb;
1984
* Get callback of global transport state notification.
1986
PJ_DEF(pjsip_tp_state_callback) pjsip_tpmgr_get_state_cb(
1987
const pjsip_tpmgr *mgr)
1989
PJ_ASSERT_RETURN(mgr, NULL);
1991
return mgr->tp_state_cb;
1996
* Allocate and init transport data.
1998
static void init_tp_data(pjsip_transport *tp)
2000
transport_data *tp_data;
2002
pj_assert(tp && !tp->data);
2004
tp_data = PJ_POOL_ZALLOC_T(tp->pool, transport_data);
2005
pj_list_init(&tp_data->st_listeners);
2006
pj_list_init(&tp_data->st_listeners_empty);
2011
static void tp_state_callback(pjsip_transport *tp,
2012
pjsip_transport_state state,
2013
const pjsip_transport_state_info *info)
2015
transport_data *tp_data;
2017
pj_lock_acquire(tp->lock);
2019
tp_data = (transport_data*)tp->data;
2021
/* Notify the transport state listeners, if any. */
2022
if (!tp_data || pj_list_empty(&tp_data->st_listeners)) {
2025
pjsip_transport_state_info st_info;
2026
tp_state_listener *st_listener = tp_data->st_listeners.next;
2028
/* As we need to put the user data into the transport state info,
2029
* let's use a copy of transport state info.
2031
pj_memcpy(&st_info, info, sizeof(st_info));
2032
while (st_listener != &tp_data->st_listeners) {
2033
st_info.user_data = st_listener->user_data;
2034
(*st_listener->cb)(tp, state, &st_info);
2036
st_listener = st_listener->next;
2041
pj_lock_release(tp->lock);
2046
* Add a listener to the specified transport for transport state notification.
2048
PJ_DEF(pj_status_t) pjsip_transport_add_state_listener (
2049
pjsip_transport *tp,
2050
pjsip_tp_state_callback cb,
2052
pjsip_tp_state_listener_key **key)
2054
transport_data *tp_data;
2055
tp_state_listener *entry;
2057
PJ_ASSERT_RETURN(tp && cb && key, PJ_EINVAL);
2059
pj_lock_acquire(tp->lock);
2061
/* Init transport data, if it hasn't */
2065
tp_data = (transport_data*)tp->data;
2067
/* Init the new listener entry. Use available empty slot, if any,
2068
* otherwise allocate it using the transport pool.
2070
if (!pj_list_empty(&tp_data->st_listeners_empty)) {
2071
entry = tp_data->st_listeners_empty.next;
2072
pj_list_erase(entry);
2074
entry = PJ_POOL_ZALLOC_T(tp->pool, tp_state_listener);
2077
entry->user_data = user_data;
2079
/* Add the new listener entry to the listeners list */
2080
pj_list_push_back(&tp_data->st_listeners, entry);
2084
pj_lock_release(tp->lock);
2090
* Remove a listener from the specified transport for transport state
2093
PJ_DEF(pj_status_t) pjsip_transport_remove_state_listener (
2094
pjsip_transport *tp,
2095
pjsip_tp_state_listener_key *key,
2096
const void *user_data)
2098
transport_data *tp_data;
2099
tp_state_listener *entry;
2101
PJ_ASSERT_RETURN(tp && key, PJ_EINVAL);
2103
pj_lock_acquire(tp->lock);
2105
tp_data = (transport_data*)tp->data;
2107
/* Transport data is NULL or no registered listener? */
2108
if (!tp_data || pj_list_empty(&tp_data->st_listeners)) {
2109
pj_lock_release(tp->lock);
2110
return PJ_ENOTFOUND;
2113
entry = (tp_state_listener*)key;
2115
/* Validate the user data */
2116
if (entry->user_data != user_data) {
2117
pj_assert(!"Invalid transport state listener key");
2118
pj_lock_release(tp->lock);
2122
/* Reset the entry and move it to the empty list */
2124
entry->user_data = NULL;
2125
pj_list_erase(entry);
2126
pj_list_push_back(&tp_data->st_listeners_empty, entry);
2128
pj_lock_release(tp->lock);
added
removed
daemon/libs/pjproject-2.1.0/pjsip/src/pjsip/sip_transport.c
