/* * 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); } }