/*
* pj_ioqueue_destroy()
*
* Destroy ioqueue.
*/
PJ_DEF(pj_status_t) pj_ioqueue_destroy(pj_ioqueue_t *ioqueue)
{
pj_ioqueue_key_t *key;
PJ_ASSERT_RETURN(ioqueue, PJ_EINVAL);
PJ_ASSERT_RETURN(ioqueue->epfd > 0, PJ_EINVALIDOP);
pj_lock_acquire(ioqueue->lock);
os_close(ioqueue->epfd);
ioqueue->epfd = 0;
#if PJ_IOQUEUE_HAS_SAFE_UNREG
/* Destroy reference counters */
key = ioqueue->active_list.next;
while (key != &ioqueue->active_list) {
pj_lock_destroy(key->lock);
key = key->next;
}
key = ioqueue->closing_list.next;
while (key != &ioqueue->closing_list) {
pj_lock_destroy(key->lock);
key = key->next;
}
key = ioqueue->free_list.next;
while (key != &ioqueue->free_list) {
pj_lock_destroy(key->lock);
key = key->next;
}
pj_mutex_destroy(ioqueue->ref_cnt_mutex);
#endif
return ioqueue_destroy(ioqueue);
}
/*
* Destroy.
*/
static void destroy(pj_turn_sock *turn_sock)
{
if (turn_sock->lock) {
pj_lock_acquire(turn_sock->lock);
}
if (turn_sock->sess) {
pj_turn_session_set_user_data(turn_sock->sess, NULL);
pj_turn_session_shutdown(turn_sock->sess);
turn_sock->sess = NULL;
}
if (turn_sock->active_sock) {
PJ_LOG(4, ("turn_session.c", "!!! TURN DEALLOCATE !!! in destroy() close connection"));
pj_activesock_set_user_data(turn_sock->active_sock, NULL);
pj_activesock_close(turn_sock->active_sock);
turn_sock->active_sock = NULL;
}
if (turn_sock->lock) {
pj_lock_release(turn_sock->lock);
pj_lock_destroy(turn_sock->lock);
turn_sock->lock = NULL;
}
if (turn_sock->pool) {
pj_pool_t *pool = turn_sock->pool;
turn_sock->pool = NULL;
pj_pool_release(pool);
}
}
/*
* Destroy.
*/
static void destroy(pj_turn_sock *turn_sock)
{
if (turn_sock->lock) {
pj_lock_acquire(turn_sock->lock);
}
if (turn_sock->sess) {
pj_turn_session_set_user_data(turn_sock->sess, NULL);
pj_turn_session_shutdown(turn_sock->sess);
turn_sock->sess = NULL;
}
if (turn_sock->active_sock) {
pj_activesock_close(turn_sock->active_sock);
turn_sock->active_sock = NULL;
}
if (turn_sock->lock) {
pj_lock_release(turn_sock->lock);
pj_lock_destroy(turn_sock->lock);
turn_sock->lock = NULL;
}
if (turn_sock->pool) {
pj_pool_t *pool = turn_sock->pool;
turn_sock->pool = NULL;
pj_pool_release(pool);
}
}
/*
* Start the clock.
*/
PJ_DEF(pj_status_t) pjmedia_clock_start(pjmedia_clock *clock)
{
pj_timestamp now;
pj_status_t status;
PJ_ASSERT_RETURN(clock != NULL, PJ_EINVAL);
if (clock->running)
return PJ_SUCCESS;
status = pj_get_timestamp(&now);
if (status != PJ_SUCCESS)
return status;
clock->next_tick.u64 = now.u64 + clock->interval.u64;
clock->running = PJ_TRUE;
clock->quitting = PJ_FALSE;
if ((clock->options & PJMEDIA_CLOCK_NO_ASYNC) == 0 && !clock->thread) {
status = pj_thread_create(clock->pool, "clock", &clock_thread, clock,
0, 0, &clock->thread);
if (status != PJ_SUCCESS) {
pj_lock_destroy(clock->lock);
return status;
}
}
return PJ_SUCCESS;
}
/*
* Destroy the clock.
*/
PJ_DEF(pj_status_t) pjmedia_clock_destroy(pjmedia_clock *clock)
{
PJ_ASSERT_RETURN(clock != NULL, PJ_EINVAL);
clock->running = PJ_FALSE;
clock->quitting = PJ_TRUE;
if (clock->thread) {
pj_thread_join(clock->thread);
pj_thread_destroy(clock->thread);
clock->thread = NULL;
}
if (clock->lock) {
pj_lock_destroy(clock->lock);
clock->lock = NULL;
}
if (clock->pool) {
pj_pool_t *pool = clock->pool;
clock->pool = NULL;
pj_pool_release(pool);
}
return PJ_SUCCESS;
}
/*
* Destroy the master port, and optionally destroy the u_port and
* d_port ports.
*/
PJ_DEF(pj_status_t) pjmedia_master_port_destroy(pjmedia_master_port *m,
pj_bool_t destroy_ports)
{
PJ_ASSERT_RETURN(m, PJ_EINVAL);
if (m->clock) {
pjmedia_clock_destroy(m->clock);
m->clock = NULL;
}
if (m->u_port && destroy_ports) {
pjmedia_port_destroy(m->u_port);
m->u_port = NULL;
}
if (m->d_port && destroy_ports) {
pjmedia_port_destroy(m->d_port);
m->d_port = NULL;
}
if (m->lock) {
pj_lock_destroy(m->lock);
m->lock = NULL;
}
return PJ_SUCCESS;
}
/* This callback is called by transport manager to destroy listener */
static pj_status_t lis_destroy(pjsip_tpfactory *factory)
{
struct tls_listener *listener = (struct tls_listener *)factory;
if (listener->is_registered) {
pjsip_tpmgr_unregister_tpfactory(listener->tpmgr, &listener->factory);
listener->is_registered = PJ_FALSE;
}
if (listener->ssock) {
pj_ssl_sock_close(listener->ssock);
listener->ssock = NULL;
}
if (listener->factory.lock) {
pj_lock_destroy(listener->factory.lock);
listener->factory.lock = NULL;
}
if (listener->factory.pool) {
pj_pool_t *pool = listener->factory.pool;
PJ_LOG(4,(listener->factory.obj_name, "SIP TLS listener destroyed"));
listener->factory.pool = NULL;
pj_pool_release(pool);
}
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pjsip_regc_destroy(pjsip_regc *regc)
{
PJ_ASSERT_RETURN(regc, PJ_EINVAL);
pj_lock_acquire(regc->lock);
if (regc->has_tsx || pj_atomic_get(regc->busy_ctr) != 0) {
regc->_delete_flag = 1;
regc->cb = NULL;
pj_lock_release(regc->lock);
} else {
pjsip_tpselector_dec_ref(®c->tp_sel);
if (regc->last_transport) {
pjsip_transport_dec_ref(regc->last_transport);
regc->last_transport = NULL;
}
if (regc->timer.id != 0) {
pjsip_endpt_cancel_timer(regc->endpt, ®c->timer);
regc->timer.id = 0;
}
pj_atomic_destroy(regc->busy_ctr);
pj_lock_release(regc->lock);
pj_lock_destroy(regc->lock);
regc->lock = NULL;
pjsip_endpt_release_pool(regc->endpt, regc->pool);
}
return PJ_SUCCESS;
}
static pj_status_t transport_destroy (pjmedia_transport *tp)
{
transport_srtp *srtp = (transport_srtp *) tp;
pj_status_t status;
unsigned i;
PJ_ASSERT_RETURN(tp, PJ_EINVAL);
/* Close keying */
for (i=0; i < srtp->keying_cnt; i++)
pjmedia_transport_close(srtp->keying[i]);
/* Close member if configured */
if (srtp->setting.close_member_tp && srtp->member_tp) {
pjmedia_transport_close(srtp->member_tp);
}
status = pjmedia_transport_srtp_stop(tp);
/* In case mutex is being acquired by other thread */
pj_lock_acquire(srtp->mutex);
pj_lock_release(srtp->mutex);
pj_lock_destroy(srtp->mutex);
pj_pool_release(srtp->pool);
return status;
}
PJ_DEF(void) pj_timer_heap_destroy( pj_timer_heap_t *ht )
{
if (ht->lock && ht->auto_delete_lock) {
pj_lock_destroy(ht->lock);
ht->lock = NULL;
}
}
PJ_DEF(void) pj_caching_pool_destroy( pj_caching_pool *cp )
{
int i;
pj_pool_t *pool;
PJ_CHECK_STACK();
/* Delete all pool in free list */
for (i=0; i < PJ_CACHING_POOL_ARRAY_SIZE; ++i) {
pj_pool_t *pool = (pj_pool_t*) cp->free_list[i].next;
pj_pool_t *next;
for (; pool != (void*)&cp->free_list[i]; pool = next) {
next = pool->next;
pj_list_erase(pool);
pj_pool_destroy_int(pool);
}
}
/* Delete all pools in used list */
pool = (pj_pool_t*) cp->used_list.next;
while (pool != (pj_pool_t*) &cp->used_list) {
pj_pool_t *next = pool->next;
pj_list_erase(pool);
PJ_LOG(4,(pool->obj_name,
"Pool is not released by application, releasing now"));
pj_pool_destroy_int(pool);
pool = next;
}
if (cp->lock) {
pj_lock_destroy(cp->lock);
pj_lock_create_null_mutex(NULL, "cachingpool", &cp->lock);
}
}
PJ_DEF(void) pj_timer_heap_set_lock( pj_timer_heap_t *ht,
pj_lock_t *lock,
pj_bool_t auto_del )
{
PJ_UNUSED_ARG(ht);
if (auto_del)
pj_lock_destroy(lock);
}
SipIceTransport::~SipIceTransport()
{
RING_DBG("~SipIceTransport@%p", this);
Manager::instance().unregisterEventHandler((uintptr_t)this);
pj_lock_destroy(trData_.base.lock);
pj_atomic_destroy(trData_.base.ref_cnt);
RING_DBG("destroying SipIceTransport@%p", this);
}
static pj_status_t ioqueue_destroy(pj_ioqueue_t *ioqueue)
{
if (ioqueue->auto_delete_lock && ioqueue->lock ) {
pj_lock_release(ioqueue->lock);
return pj_lock_destroy(ioqueue->lock);
}
return PJ_SUCCESS;
}
PJ_DEF(void) pj_timer_heap_set_lock( pj_timer_heap_t *ht,
pj_lock_t *lock,
pj_bool_t auto_del )
{
if (ht->lock && ht->auto_delete_lock)
pj_lock_destroy(ht->lock);
ht->lock = lock;
ht->auto_delete_lock = auto_del;
}
PJ_DEF(pj_status_t) pj_stun_session_create( pj_stun_config *cfg,
const char *name,
const pj_stun_session_cb *cb,
pj_bool_t fingerprint,
pj_stun_session **p_sess)
{
pj_pool_t *pool;
pj_stun_session *sess;
pj_status_t status;
PJ_ASSERT_RETURN(cfg && cb && p_sess, PJ_EINVAL);
if (name==NULL)
name = "stuse%p";
pool = pj_pool_create(cfg->pf, name, PJNATH_POOL_LEN_STUN_SESS,
PJNATH_POOL_INC_STUN_SESS, NULL);
PJ_ASSERT_RETURN(pool, PJ_ENOMEM);
sess = PJ_POOL_ZALLOC_T(pool, pj_stun_session);
sess->cfg = cfg;
sess->pool = pool;
pj_memcpy(&sess->cb, cb, sizeof(*cb));
sess->use_fingerprint = fingerprint;
sess->log_flag = 0xFFFF;
sess->srv_name.ptr = (char*) pj_pool_alloc(pool, 32);
sess->srv_name.slen = pj_ansi_snprintf(sess->srv_name.ptr, 32,
"pjnath-%s", pj_get_version());
sess->rx_pool = pj_pool_create(sess->cfg->pf, name,
PJNATH_POOL_LEN_STUN_TDATA,
PJNATH_POOL_INC_STUN_TDATA, NULL);
pj_list_init(&sess->pending_request_list);
pj_list_init(&sess->cached_response_list);
status = pj_lock_create_recursive_mutex(pool, name, &sess->lock);
if (status != PJ_SUCCESS) {
pj_pool_release(pool);
return status;
}
sess->delete_lock = PJ_TRUE;
status = pj_atomic_create(pool, 0, &sess->busy);
if (status != PJ_SUCCESS) {
pj_lock_destroy(sess->lock);
pj_pool_release(pool);
return status;
}
*p_sess = sess;
return PJ_SUCCESS;
}
/*
* Create media clock.
*/
PJ_DEF(pj_status_t) pjmedia_clock_create( pj_pool_t *pool,
unsigned clock_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned options,
pjmedia_clock_callback *cb,
void *user_data,
pjmedia_clock **p_clock)
{
pjmedia_clock *clock;
pj_status_t status;
PJ_ASSERT_RETURN(pool && clock_rate && samples_per_frame && p_clock,
PJ_EINVAL);
clock = PJ_POOL_ALLOC_T(pool, pjmedia_clock);
status = pj_get_timestamp_freq(&clock->freq);
if (status != PJ_SUCCESS)
return status;
clock->interval.u64 = samples_per_frame * clock->freq.u64 /
channel_count / clock_rate;
clock->next_tick.u64 = 0;
clock->timestamp.u64 = 0;
clock->max_jump = MAX_JUMP_MSEC * clock->freq.u64 / 1000;
clock->timestamp_inc = samples_per_frame / channel_count;
clock->options = options;
clock->cb = cb;
clock->user_data = user_data;
clock->thread = NULL;
clock->running = PJ_FALSE;
clock->quitting = PJ_FALSE;
/* I don't think we need a mutex, so we'll use null. */
status = pj_lock_create_null_mutex(pool, "clock", &clock->lock);
if (status != PJ_SUCCESS)
return status;
if ((clock->options & PJMEDIA_CLOCK_NO_ASYNC) == 0) {
status = pj_thread_create(pool, "clock", &clock_thread, clock,
0, 0, &clock->thread);
if (status != PJ_SUCCESS) {
pj_lock_destroy(clock->lock);
return status;
}
}
*p_clock = clock;
return PJ_SUCCESS;
}
/*
* pj_ioqueue_destroy()
*/
PJ_DEF(pj_status_t) pj_ioqueue_destroy( pj_ioqueue_t *ioqueue )
{
#if PJ_HAS_TCP
unsigned i;
#endif
pj_ioqueue_key_t *key;
PJ_CHECK_STACK();
PJ_ASSERT_RETURN(ioqueue, PJ_EINVAL);
pj_lock_acquire(ioqueue->lock);
#if PJ_HAS_TCP
/* Destroy events in the pool */
for (i=0; i<ioqueue->event_count; ++i) {
CloseHandle(ioqueue->event_pool[i]);
}
ioqueue->event_count = 0;
#endif
if (CloseHandle(ioqueue->iocp) != TRUE)
return PJ_RETURN_OS_ERROR(GetLastError());
#if PJ_IOQUEUE_HAS_SAFE_UNREG
/* Destroy reference counters */
key = ioqueue->active_list.next;
while (key != &ioqueue->active_list) {
pj_atomic_destroy(key->ref_count);
pj_mutex_destroy(key->mutex);
key = key->next;
}
key = ioqueue->closing_list.next;
while (key != &ioqueue->closing_list) {
pj_atomic_destroy(key->ref_count);
pj_mutex_destroy(key->mutex);
key = key->next;
}
key = ioqueue->free_list.next;
while (key != &ioqueue->free_list) {
pj_atomic_destroy(key->ref_count);
pj_mutex_destroy(key->mutex);
key = key->next;
}
#endif
if (ioqueue->auto_delete_lock)
pj_lock_destroy(ioqueue->lock);
return PJ_SUCCESS;
}
/*
* Set the lock object to be used by the I/O Queue.
*/
PJ_DEF(pj_status_t) pj_ioqueue_set_lock( pj_ioqueue_t *ioq,
pj_lock_t *lock,
pj_bool_t auto_delete )
{
/* Don't really need lock for now */
PJ_UNUSED_ARG(ioq);
if (auto_delete) {
pj_lock_destroy(lock);
}
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pjsip_regc_create( pjsip_endpoint *endpt, void *token,
pjsip_regc_cb *cb,
pjsip_regc **p_regc)
{
pj_pool_t *pool;
pjsip_regc *regc;
pj_status_t status;
/* Verify arguments. */
PJ_ASSERT_RETURN(endpt && cb && p_regc, PJ_EINVAL);
pool = pjsip_endpt_create_pool(endpt, "regc%p", 1024, 1024);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
regc = PJ_POOL_ZALLOC_T(pool, pjsip_regc);
regc->pool = pool;
regc->endpt = endpt;
regc->token = token;
regc->cb = cb;
regc->expires = PJSIP_REGC_EXPIRATION_NOT_SPECIFIED;
regc->add_xuid_param = pjsip_cfg()->regc.add_xuid_param;
status = pj_lock_create_recursive_mutex(pool, pool->obj_name,
®c->lock);
if (status != PJ_SUCCESS) {
pj_pool_release(pool);
return status;
}
status = pj_atomic_create(pool, 0, ®c->busy_ctr);
if (status != PJ_SUCCESS) {
pj_lock_destroy(regc->lock);
pj_pool_release(pool);
return status;
}
status = pjsip_auth_clt_init(®c->auth_sess, endpt, regc->pool, 0);
if (status != PJ_SUCCESS)
return status;
pj_list_init(®c->route_set);
pj_list_init(®c->hdr_list);
pj_list_init(®c->contact_hdr_list);
pj_list_init(®c->removed_contact_hdr_list);
/* Done */
*p_regc = regc;
return PJ_SUCCESS;
}
/*
* Create media clock.
*/
PJ_DEF(pj_status_t) pjmedia_clock_create( pj_pool_t *pool,
unsigned clock_rate,
unsigned samples_per_frame,
unsigned options,
pjmedia_clock_callback *cb,
void *user_data,
pjmedia_clock **p_clock)
{
pjmedia_clock *clock;
pj_status_t status;
PJ_ASSERT_RETURN(pool && clock_rate && samples_per_frame && p_clock,
PJ_EINVAL);
clock = pj_pool_alloc(pool, sizeof(pjmedia_clock));
status = pj_get_timestamp_freq(&clock->freq);
if (status != PJ_SUCCESS)
return status;
clock->interval.u64 = samples_per_frame * clock->freq.u64 / clock_rate;
clock->next_tick.u64 = 0;
clock->timestamp.u64 = 0;
clock->samples_per_frame = samples_per_frame;
clock->options = options;
clock->cb = cb;
clock->user_data = user_data;
clock->thread = NULL;
clock->running = PJ_FALSE;
clock->quitting = PJ_FALSE;
/* I don't think we need a mutex, so we'll use null. */
status = pj_lock_create_null_mutex(pool, "clock", &clock->lock);
if (status != PJ_SUCCESS)
return status;
status = pj_thread_create(pool, "clock", &clock_thread, clock,
0, 0, &clock->thread);
if (status != PJ_SUCCESS) {
pj_lock_destroy(clock->lock);
return status;
}
*p_clock = clock;
return PJ_SUCCESS;
}
/*
* pj_ioqueue_set_lock()
*/
PJ_DEF(pj_status_t) pj_ioqueue_set_lock( pj_ioqueue_t *ioqueue,
pj_lock_t *lock,
pj_bool_t auto_delete )
{
PJ_ASSERT_RETURN(ioqueue && lock, PJ_EINVAL);
if (ioqueue->auto_delete_lock) {
pj_lock_destroy(ioqueue->lock);
}
ioqueue->lock = lock;
ioqueue->auto_delete_lock = auto_delete;
return PJ_SUCCESS;
}
/*!
* \brief Destroy the pjsip transport.
*
* Called by pjsip transport manager.
*/
static pj_status_t ws_destroy(pjsip_transport *transport)
{
struct ws_transport *wstransport = (struct ws_transport *)transport;
if (wstransport->transport.ref_cnt) {
pj_atomic_destroy(wstransport->transport.ref_cnt);
}
if (wstransport->transport.lock) {
pj_lock_destroy(wstransport->transport.lock);
}
pjsip_endpt_release_pool(wstransport->transport.endpt, wstransport->transport.pool);
return PJ_SUCCESS;
}
/* Clean up listener resources */
static void lis_on_destroy(void *arg)
{
struct tcp_listener *listener = (struct tcp_listener *)arg;
if (listener->factory.lock) {
pj_lock_destroy(listener->factory.lock);
listener->factory.lock = NULL;
}
if (listener->factory.pool) {
pj_pool_t *pool = listener->factory.pool;
PJ_LOG(4,(listener->factory.obj_name, "SIP TCP listener destroyed"));
listener->factory.pool = NULL;
pj_pool_release(pool);
}
}
/*
* Decrease transport data reference, destroy it when the reference count
* reaches zero.
*/
PJ_DEF(pj_status_t) pjsip_tx_data_dec_ref( pjsip_tx_data *tdata )
{
pj_assert( pj_atomic_get(tdata->ref_cnt) > 0);
if (pj_atomic_dec_and_get(tdata->ref_cnt) <= 0) {
PJ_LOG(5,(tdata->obj_name, "Destroying txdata %s",
pjsip_tx_data_get_info(tdata)));
pjsip_tpselector_dec_ref(&tdata->tp_sel);
#if defined(PJ_DEBUG) && PJ_DEBUG!=0
pj_atomic_dec( tdata->mgr->tdata_counter );
#endif
pj_atomic_destroy( tdata->ref_cnt );
pj_lock_destroy( tdata->lock );
pjsip_endpt_release_pool( tdata->mgr->endpt, tdata->pool );
return PJSIP_EBUFDESTROYED;
} else {
return PJ_SUCCESS;
}
}
PJ_DEF(pj_status_t) pjmedia_delay_buf_destroy(pjmedia_delay_buf *b)
{
pj_status_t status;
PJ_ASSERT_RETURN(b, PJ_EINVAL);
pj_lock_acquire(b->lock);
status = pjmedia_wsola_destroy(b->wsola);
if (status == PJ_SUCCESS)
b->wsola = NULL;
pj_lock_release(b->lock);
pj_lock_destroy(b->lock);
b->lock = NULL;
return status;
}
/* Clean up TCP resources */
static void tcp_on_destroy(void *arg)
{
struct tcp_transport *tcp = (struct tcp_transport*)arg;
if (tcp->base.lock) {
pj_lock_destroy(tcp->base.lock);
tcp->base.lock = NULL;
}
if (tcp->base.ref_cnt) {
pj_atomic_destroy(tcp->base.ref_cnt);
tcp->base.ref_cnt = NULL;
}
if (tcp->rdata.tp_info.pool) {
pj_pool_release(tcp->rdata.tp_info.pool);
tcp->rdata.tp_info.pool = NULL;
}
if (tcp->base.pool) {
pj_pool_t *pool;
if (tcp->close_reason != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(tcp->close_reason, errmsg, sizeof(errmsg));
PJ_LOG(4,(tcp->base.obj_name,
"TCP transport destroyed with reason %d: %s",
tcp->close_reason, errmsg));
} else {
PJ_LOG(4,(tcp->base.obj_name,
"TCP transport destroyed normally"));
}
pool = tcp->base.pool;
tcp->base.pool = NULL;
pj_pool_release(pool);
}
}
PJ_DEF(pj_status_t) pj_stun_session_set_lock( pj_stun_session *sess,
pj_lock_t *lock,
pj_bool_t auto_del)
{
pj_lock_t *old_lock = sess->lock;
pj_bool_t old_del;
PJ_ASSERT_RETURN(sess && lock, PJ_EINVAL);
pj_lock_acquire(old_lock);
sess->lock = lock;
old_del = sess->delete_lock;
sess->delete_lock = auto_del;
pj_lock_release(old_lock);
if (old_lock)
pj_lock_destroy(old_lock);
return PJ_SUCCESS;
}
/* Destroy */
static void do_destroy(pj_tcp_session *sess)
{
/* Lock session */
if (sess->lock) {
pj_lock_acquire(sess->lock);
}
/* Cancel pending timer, if any */
if (sess->timer.id != TIMER_NONE) {
pj_timer_heap_cancel(sess->timer_heap, &sess->timer);
sess->timer.id = TIMER_NONE;
}
/* Destroy STUN session */
if (sess->stun) {
pj_stun_session_destroy(sess->stun);
sess->stun = NULL;
}
/* Destroy lock */
if (sess->lock) {
pj_lock_release(sess->lock);
pj_lock_destroy(sess->lock);
sess->lock = NULL;
}
#if 0
if (sess->asock) {
pj_activesock_close(sess->asock);
sess->asock = NULL;
}
#endif
/* Destroy pool */
if (sess->pool) {
pj_pool_t *pool = sess->pool;
PJ_LOG(4,(sess->obj_name, "TCP client session destroyed"));
sess->pool = NULL;
pj_pool_release(pool);
}
}
/*
* Really destroy allocation.
*/
static void destroy_allocation(pj_turn_allocation *alloc)
{
pj_pool_t *pool;
/* Unregister this allocation */
pj_turn_srv_unregister_allocation(alloc->server, alloc);
/* Destroy relay */
destroy_relay(&alloc->relay);
/* Must lock only after destroying relay otherwise deadlock */
if (alloc->lock) {
pj_lock_acquire(alloc->lock);
}
/* Unreference transport */
if (alloc->transport) {
pj_turn_transport_dec_ref(alloc->transport, alloc);
alloc->transport = NULL;
}
/* Destroy STUN session */
if (alloc->sess) {
pj_stun_session_destroy(alloc->sess);
alloc->sess = NULL;
}
/* Destroy lock */
if (alloc->lock) {
pj_lock_release(alloc->lock);
pj_lock_destroy(alloc->lock);
alloc->lock = NULL;
}
/* Destroy pool */
pool = alloc->pool;
if (pool) {
alloc->pool = NULL;
pj_pool_release(pool);
}
}
