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);
}
}
/*
* Create a new I/O Queue framework.
*/
PJ_DEF(pj_status_t) pj_ioqueue_create( pj_pool_t *pool,
pj_size_t max_fd,
pj_ioqueue_t **p_ioqueue)
{
pj_ioqueue_t *ioq;
pj_lock_t *lock;
pj_status_t rc;
PJ_UNUSED_ARG(max_fd);
ioq = PJ_POOL_ZALLOC_T(pool, pj_ioqueue_t);
/* Create and init ioqueue mutex */
rc = pj_lock_create_null_mutex(pool, "ioq%p", &lock);
if (rc != PJ_SUCCESS)
return rc;
rc = pj_ioqueue_set_lock(ioq, lock, PJ_TRUE);
if (rc != PJ_SUCCESS)
return rc;
PJ_LOG(4, ("pjlib", "select() I/O Queue created (%p)", ioq));
*p_ioqueue = ioq;
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;
}
/*
* 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_DEF(pj_status_t) pjmedia_clock_create2(pj_pool_t *pool,
const pjmedia_clock_param *param,
unsigned options,
pjmedia_clock_callback *cb,
void *user_data,
pjmedia_clock **p_clock)
{
pjmedia_clock *clock;
pj_status_t status;
PJ_ASSERT_RETURN(pool && param->usec_interval && param->clock_rate &&
p_clock, PJ_EINVAL);
pool = pj_pool_create(pool->factory, "clock%p", 512, 512, NULL);
clock = PJ_POOL_ALLOC_T(pool, pjmedia_clock);
clock->pool = pool;
status = pj_get_timestamp_freq(&clock->freq);
if (status != PJ_SUCCESS)
return status;
clock->interval.u64 = param->usec_interval * clock->freq.u64 /
USEC_IN_SEC;
clock->next_tick.u64 = 0;
clock->timestamp.u64 = 0;
clock->max_jump = MAX_JUMP_MSEC * clock->freq.u64 / 1000;
clock->timestamp_inc = (unsigned)(param->usec_interval *
param->clock_rate /
USEC_IN_SEC);
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;
*p_clock = clock;
return PJ_SUCCESS;
}
/*
* Create new transmit buffer.
*/
PJ_DEF(pj_status_t) pjsip_tx_data_create( pjsip_tpmgr *mgr,
pjsip_tx_data **p_tdata )
{
pj_pool_t *pool;
pjsip_tx_data *tdata;
pj_status_t status;
PJ_ASSERT_RETURN(mgr && p_tdata, PJ_EINVAL);
pool = pjsip_endpt_create_pool( mgr->endpt, "tdta%p",
PJSIP_POOL_LEN_TDATA,
PJSIP_POOL_INC_TDATA );
if (!pool)
return PJ_ENOMEM;
tdata = PJ_POOL_ZALLOC_T(pool, pjsip_tx_data);
tdata->pool = pool;
tdata->mgr = mgr;
pj_memcpy(tdata->obj_name, pool->obj_name, PJ_MAX_OBJ_NAME);
status = pj_atomic_create(tdata->pool, 0, &tdata->ref_cnt);
if (status != PJ_SUCCESS) {
pjsip_endpt_release_pool( mgr->endpt, tdata->pool );
return status;
}
//status = pj_lock_create_simple_mutex(pool, "tdta%p", &tdata->lock);
status = pj_lock_create_null_mutex(pool, "tdta%p", &tdata->lock);
if (status != PJ_SUCCESS) {
pjsip_endpt_release_pool( mgr->endpt, tdata->pool );
return status;
}
pj_ioqueue_op_key_init(&tdata->op_key.key, sizeof(tdata->op_key.key));
#if defined(PJ_DEBUG) && PJ_DEBUG!=0
pj_atomic_inc( tdata->mgr->tdata_counter );
#endif
*p_tdata = tdata;
return PJ_SUCCESS;
}
//
// Default constructor.
//
explicit Pj_Null_Lock(Pj_Pool *pool, const char *name = NULL)
: Pj_Lock(NULL)
{
pj_lock_create_null_mutex(pool->pool_(), name, &lock_);
}
/*
* Create TCP client session.
*/
PJ_DEF(pj_status_t) pj_tcp_session_create( const pj_stun_config *cfg,
const char *name,
int af,
const pj_tcp_session_cb *cb,
unsigned options,
void *user_data,
pj_stun_session *default_stun,
pj_tcp_session **p_sess,
int sess_idx,
int check_idx)
{
pj_pool_t *pool;
pj_tcp_session *sess;
pj_stun_session_cb stun_cb;
pj_lock_t *null_lock;
pj_status_t status;
PJ_ASSERT_RETURN(cfg && cfg->pf && cb && p_sess, PJ_EINVAL);
PJ_ASSERT_RETURN(cb->on_send_pkt, PJ_EINVAL);
PJ_UNUSED_ARG(options);
if (name == NULL)
name = "tcp%p";
/* Allocate and create TCP session */
pool = pj_pool_create(cfg->pf, name, PJNATH_POOL_LEN_TCP_SESS,
PJNATH_POOL_INC_TCP_SESS, NULL);
sess = PJ_POOL_ZALLOC_T(pool, pj_tcp_session);
sess->pool = pool;
sess->obj_name = pool->obj_name;
sess->timer_heap = cfg->timer_heap;
sess->af = (pj_uint16_t)af;
sess->ka_interval = PJ_TCP_KEEP_ALIVE_SEC;
sess->user_data = user_data;
sess->sess_idx = sess_idx;
sess->check_idx = check_idx;
/* Copy STUN session */
pj_memcpy(&sess->stun_cfg, cfg, sizeof(pj_stun_config));
/* Copy callback */
pj_memcpy(&sess->cb, cb, sizeof(*cb));
/* Session lock */
status = pj_lock_create_recursive_mutex(pool, sess->obj_name,
&sess->lock);
if (status != PJ_SUCCESS) {
do_destroy(sess);
return status;
}
/* Timer */
pj_timer_entry_init(&sess->timer, TIMER_NONE, sess, &on_timer_event);
//DEAN
if (default_stun) {
sess->stun = default_stun;
} else {
/* Create STUN session */
pj_bzero(&stun_cb, sizeof(stun_cb));
stun_cb.on_send_msg = &stun_on_send_msg;
#if 0
stun_cb.on_request_complete = &stun_on_request_complete;
#else
stun_cb.on_request_complete = &on_stun_request_complete;
#endif
stun_cb.on_rx_request = &on_stun_rx_request;
stun_cb.on_rx_indication = &on_stun_rx_indication;
status = pj_stun_session_create2(&sess->stun_cfg, sess->obj_name, &stun_cb,
PJ_FALSE, NULL, &sess->stun, PJ_TRUE, sess);
if (status != PJ_SUCCESS) {
do_destroy(sess);
return status;
}
}
/* Attach ourself to STUN session */
pj_stun_session_set_user_data(sess->stun, pj_tcp_sock_get_tsd(user_data));
/* Replace mutex in STUN session with a NULL mutex, since access to
* STUN session is serialized.
*/
status = pj_lock_create_null_mutex(pool, name, &null_lock);
if (status != PJ_SUCCESS) {
do_destroy(sess);
return status;
}
pj_stun_session_set_lock(sess->stun, null_lock, PJ_TRUE);
/* Done */
PJ_LOG(4,(sess->obj_name, "TCP client session created"));
*p_sess = sess;
return PJ_SUCCESS;
}
