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; }