static void parse_digest_challenge( pj_scanner *scanner, pj_pool_t *pool,
pjsip_digest_challenge *chal)
{
pj_list_init(&chal->other_param);
for (;;) {
pj_str_t name, value;
pjsip_parse_param_imp(scanner, pool, &name, &value,
PJSIP_PARSE_REMOVE_QUOTE);
if (!pj_stricmp(&name, &pjsip_REALM_STR)) {
chal->realm = value;
} else if (!pj_stricmp(&name, &pjsip_DOMAIN_STR)) {
chal->domain = value;
} else if (!pj_stricmp(&name, &pjsip_NONCE_STR)) {
chal->nonce = value;
} else if (!pj_stricmp(&name, &pjsip_OPAQUE_STR)) {
chal->opaque = value;
} else if (!pj_stricmp(&name, &pjsip_STALE_STR)) {
if (!pj_stricmp(&value, &pjsip_TRUE_STR) ||
!pj_stricmp(&value, &pjsip_QUOTED_TRUE_STR))
{
chal->stale = 1;
}
} else if (!pj_stricmp(&name, &pjsip_ALGORITHM_STR)) {
chal->algorithm = value;
} else if (!pj_stricmp(&name, &pjsip_QOP_STR)) {
chal->qop = value;
} else {
pjsip_param *p = PJ_POOL_ALLOC_T(pool, pjsip_param);
p->name = name;
p->value = value;
pj_list_insert_before(&chal->other_param, p);
}
/* Eat comma */
if (!pj_scan_is_eof(scanner) && *scanner->curptr == ',')
pj_scan_get_char(scanner);
else
break;
}
}
PJ_DEF(void) pjsip_param_clone( pj_pool_t *pool, pjsip_param *dst_list,
const pjsip_param *src_list)
{
const pjsip_param *p = src_list->next;
pj_list_init(dst_list);
while (p && p != src_list) {
pjsip_param *new_param = PJ_POOL_ALLOC_T(pool, pjsip_param);
pj_strdup(pool, &new_param->name, &p->name);
pj_strdup(pool, &new_param->value, &p->value);
pj_list_insert_before(dst_list, new_param);
p = p->next;
}
}
/*
* Initialize and register G722 codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_g722_init( pjmedia_endpt *endpt )
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (g722_codec_factory.pool != NULL)
return PJ_SUCCESS;
/* Create G722 codec factory. */
g722_codec_factory.base.op = &g722_factory_op;
g722_codec_factory.base.factory_data = NULL;
g722_codec_factory.endpt = endpt;
g722_codec_factory.pcm_shift = PJMEDIA_G722_DEFAULT_PCM_SHIFT;
g722_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "g722", 1000,
1000);
if (!g722_codec_factory.pool)
return PJ_ENOMEM;
pj_list_init(&g722_codec_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(g722_codec_factory.pool, "g722",
&g722_codec_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&g722_codec_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
TRACE_((THIS_FILE, "G722 codec factory initialized"));
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(g722_codec_factory.pool);
g722_codec_factory.pool = NULL;
return status;
}
/*
* Create an empty multipart body.
*/
PJ_DEF(pjsip_msg_body*) pjsip_multipart_create( pj_pool_t *pool,
const pjsip_media_type *ctype,
const pj_str_t *boundary)
{
pjsip_msg_body *body;
pjsip_param *ctype_param;
struct multipart_data *mp_data;
pj_str_t STR_BOUNDARY = { "boundary", 8 };
PJ_ASSERT_RETURN(pool, NULL);
body = PJ_POOL_ZALLOC_T(pool, pjsip_msg_body);
/* content-type */
if (ctype && ctype->type.slen) {
pjsip_media_type_cp(pool, &body->content_type, ctype);
} else {
pj_str_t STR_MULTIPART = {"multipart", 9};
pj_str_t STR_MIXED = { "mixed", 5 };
pjsip_media_type_init(&body->content_type,
&STR_MULTIPART, &STR_MIXED);
}
/* multipart data */
mp_data = PJ_POOL_ZALLOC_T(pool, struct multipart_data);
pj_list_init(&mp_data->part_head);
if (boundary) {
pj_strdup(pool, &mp_data->boundary, boundary);
} else {
pj_create_unique_string(pool, &mp_data->boundary);
}
body->data = mp_data;
/* Add ";boundary" parameter to content_type parameter. */
ctype_param = pjsip_param_find(&body->content_type.param, &STR_BOUNDARY);
if (!ctype_param) {
ctype_param = PJ_POOL_ALLOC_T(pool, pjsip_param);
ctype_param->name = STR_BOUNDARY;
pj_list_push_back(&body->content_type.param, ctype_param);
}
ctype_param->value = mp_data->boundary;
/* function pointers */
body->print_body = &multipart_print_body;
body->clone_data = &multipart_clone_data;
return body;
}
/*
* Create new memory pool.
*/
PJ_DEF(pj_pool_t*) pj_pool_create_int( pj_pool_factory *f, const char *name,
pj_size_t initial_size,
pj_size_t increment_size,
pj_pool_callback *callback)
{
pj_pool_t *pool;
pj_pool_block *block;
pj_uint8_t *buffer;
PJ_CHECK_STACK();
/* Size must be at least sizeof(pj_pool)+sizeof(pj_pool_block) */
PJ_ASSERT_RETURN(initial_size >= sizeof(pj_pool_t)+sizeof(pj_pool_block),
NULL);
/* If callback is NULL, set calback from the policy */
if (callback == NULL)
callback = f->policy.callback;
/* Allocate initial block */
buffer = (pj_uint8_t*) (*f->policy.block_alloc)(f, initial_size);
if (!buffer)
return NULL;
/* Set pool administrative data. */
pool = (pj_pool_t*)buffer;
pj_bzero(pool, sizeof(*pool));
pj_list_init(&pool->block_list);
pool->factory = f;
/* Create the first block from the memory. */
block = (pj_pool_block*) (buffer + sizeof(*pool));
block->buf = ((unsigned char*)block) + sizeof(pj_pool_block);
block->end = buffer + initial_size;
/* Set the start pointer, aligning it as needed */
block->cur = ALIGN_PTR(block->buf, PJ_POOL_ALIGNMENT);
pj_list_insert_after(&pool->block_list, block);
pj_pool_init_int(pool, name, increment_size, callback);
/* Pool initial capacity and used size */
pool->capacity = initial_size;
LOG((pool->obj_name, "pool created, size=%u", pool->capacity));
return pool;
}
/* Init client session. */
PJ_DEF(pj_status_t) pjsip_auth_clt_init( pjsip_auth_clt_sess *sess,
pjsip_endpoint *endpt,
pj_pool_t *pool,
unsigned options)
{
PJ_ASSERT_RETURN(sess && endpt && pool && (options==0), PJ_EINVAL);
sess->pool = pool;
sess->endpt = endpt;
sess->cred_cnt = 0;
sess->cred_info = NULL;
pj_list_init(&sess->cached_auth);
return PJ_SUCCESS;
}
static void init_media_type(pjsip_media_type *mt,
char *type, char *subtype, char *boundary)
{
static pjsip_param prm;
pjsip_media_type_init(mt, NULL, NULL);
if (type) mt->type = pj_str(type);
if (subtype) mt->subtype = pj_str(subtype);
if (boundary) {
pj_list_init(&prm);
prm.name = pj_str("boundary");
prm.value = pj_str(boundary);
pj_list_push_back(&mt->param, &prm);
}
}
PJ_DEF(void) pjsip_param_shallow_clone( pj_pool_t *pool,
pjsip_param *dst_list,
const pjsip_param *src_list)
{
const pjsip_param *p = src_list->next;
pj_list_init(dst_list);
while (p != src_list) {
pjsip_param *new_param = PJ_POOL_ALLOC_T(pool, pjsip_param);
new_param->name = p->name;
new_param->value = p->value;
pj_list_insert_before(dst_list, new_param);
p = p->next;
}
}
/* Terminate server subscription for the account */
void pjsua_pres_delete_acc(int acc_id)
{
pjsua_acc *acc = &pjsua_var.acc[acc_id];
pjsua_acc_config *acc_cfg = &pjsua_var.acc[acc_id].cfg;
pjsua_srv_pres *uapres;
uapres = pjsua_var.acc[acc_id].pres_srv_list.next;
/* Notify all subscribers that we're no longer available */
while (uapres != &acc->pres_srv_list) {
pjsip_pres_status pres_status;
pj_str_t reason = { "noresource", 10 };
pjsua_srv_pres *next;
pjsip_tx_data *tdata;
next = uapres->next;
pjsip_pres_get_status(uapres->sub, &pres_status);
pres_status.info[0].basic_open = pjsua_var.acc[acc_id].online_status;
pjsip_pres_set_status(uapres->sub, &pres_status);
if (pjsip_pres_notify(uapres->sub,
PJSIP_EVSUB_STATE_TERMINATED, NULL,
&reason, &tdata)==PJ_SUCCESS)
{
pjsip_pres_send_request(uapres->sub, tdata);
}
uapres = next;
}
/* Clear server presence subscription list because account might be reused
* later. */
pj_list_init(&acc->pres_srv_list);
/* Terminate presence publication, if any */
if (acc->publish_sess) {
acc->online_status = PJ_FALSE;
send_publish(acc_id, PJ_FALSE);
if (acc->publish_sess) {
pjsip_publishc_destroy(acc->publish_sess);
acc->publish_sess = NULL;
}
acc_cfg->publish_enabled = PJ_FALSE;
}
}
PJ_DEF(pj_status_t) pjsip_publishc_set_headers( pjsip_publishc *pubc,
const pjsip_hdr *hdr_list)
{
const pjsip_hdr *h;
PJ_ASSERT_RETURN(pubc && hdr_list, PJ_EINVAL);
pj_list_init(&pubc->usr_hdr);
h = hdr_list->next;
while (h != hdr_list) {
pj_list_push_back(&pubc->usr_hdr, pjsip_hdr_clone(pubc->pool, h));
h = h->next;
}
return PJ_SUCCESS;
}
/*
* Initialize and register GSM codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_gsm_init( pjmedia_endpt *endpt )
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (gsm_codec_factory.pool != NULL)
return PJ_SUCCESS;
/* Create GSM codec factory. */
gsm_codec_factory.base.op = &gsm_factory_op;
gsm_codec_factory.base.factory_data = NULL;
gsm_codec_factory.endpt = endpt;
gsm_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "gsm", 4000,
4000);
if (!gsm_codec_factory.pool)
return PJ_ENOMEM;
pj_list_init(&gsm_codec_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(gsm_codec_factory.pool, "gsm",
&gsm_codec_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&gsm_codec_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(gsm_codec_factory.pool);
gsm_codec_factory.pool = NULL;
return status;
}
PJ_DEF(pj_status_t) pjsip_regc_set_route_set( pjsip_regc *regc,
const pjsip_route_hdr *route_set)
{
const pjsip_route_hdr *chdr;
PJ_ASSERT_RETURN(regc && route_set, PJ_EINVAL);
pj_list_init(®c->route_set);
chdr = route_set->next;
while (chdr != route_set) {
pj_list_push_back(®c->route_set, pjsip_hdr_clone(regc->pool, chdr));
chdr = chdr->next;
}
return PJ_SUCCESS;
}
PJ_DEF(int) session_info_init(Session_Info *session_info, packet_alloc_t *packet_alloc) {
pj_assert(session_info != NULL && packet_alloc != NULL);
session_info->session_nacked = PJ_FALSE;
session_info->isComplete = PJ_FALSE;
session_info->isDecodable = PJ_FALSE;
session_info->previous_frame_loss = PJ_TRUE;
session_info->frame_type = PJMEDIA_FRAME_TYPE_NONE;
session_info->isKeyFrame = PJ_FALSE;
//init list
pj_list_init(&session_info->packetList);
session_info->empty_low_seq_num = -1;
session_info->empty_high_seq_num = -1;
session_info->packets_not_decodable = 0;
session_info->packets_count = 0;
session_info->packet_alloc = packet_alloc;
return 0;
}
PJ_DEF(pj_status_t) pjsip_regc_unregister_all(pjsip_regc *regc,
pjsip_tx_data **p_tdata)
{
pjsip_tx_data *tdata;
pjsip_contact_hdr *hcontact;
pjsip_hdr *hdr;
pjsip_msg *msg;
pj_status_t status;
PJ_ASSERT_RETURN(regc && p_tdata, PJ_EINVAL);
pj_lock_acquire(regc->lock);
if (regc->timer.id != 0) {
pjsip_endpt_cancel_timer(regc->endpt, ®c->timer);
regc->timer.id = 0;
}
status = create_request(regc, &tdata);
if (status != PJ_SUCCESS) {
pj_lock_release(regc->lock);
return status;
}
msg = tdata->msg;
/* Clear removed_contact_hdr_list */
pj_list_init(®c->removed_contact_hdr_list);
/* Add Contact:* header */
hcontact = pjsip_contact_hdr_create(tdata->pool);
hcontact->star = 1;
pjsip_msg_add_hdr(msg, (pjsip_hdr*)hcontact);
/* Add Expires:0 header */
hdr = (pjsip_hdr*) pjsip_expires_hdr_create(tdata->pool, 0);
pjsip_msg_add_hdr(msg, hdr);
pj_lock_release(regc->lock);
*p_tdata = tdata;
return PJ_SUCCESS;
}
static pj_status_t create_tdata(pj_stun_session *sess,
pj_stun_tx_data **p_tdata)
{
pj_pool_t *pool;
pj_stun_tx_data *tdata;
/* Create pool and initialize basic tdata attributes */
pool = pj_pool_create(sess->cfg->pf, "tdata%p",
TDATA_POOL_SIZE, TDATA_POOL_INC, NULL);
PJ_ASSERT_RETURN(pool, PJ_ENOMEM);
tdata = PJ_POOL_ZALLOC_T(pool, pj_stun_tx_data);
tdata->pool = pool;
tdata->sess = sess;
pj_list_init(tdata);
*p_tdata = tdata;
return PJ_SUCCESS;
}
/*
* Set route-set.
*/
PJ_DEF(pj_status_t) pjsip_event_sub_set_route_set( pjsip_event_sub *sub,
const pjsip_route_hdr *route_set )
{
const pjsip_route_hdr *hdr;
pj_mutex_lock(sub->mutex);
/* Clear existing route set. */
pj_list_init(&sub->route_set);
/* Duplicate route headers. */
hdr = route_set->next;
while (hdr != route_set) {
pjsip_route_hdr *new_hdr = pjsip_hdr_clone(sub->pool, hdr);
pj_list_insert_before(&sub->route_set, new_hdr);
hdr = hdr->next;
}
pj_mutex_unlock(sub->mutex);
return 0;
}
static void* multipart_clone_data(pj_pool_t *pool, const void *data,
unsigned len)
{
const struct multipart_data *src;
struct multipart_data *dst;
const pjsip_multipart_part *src_part;
PJ_UNUSED_ARG(len);
src = (const struct multipart_data*) data;
dst = PJ_POOL_ALLOC_T(pool, struct multipart_data);
pj_list_init(&dst->part_head);
pj_strdup(pool, &dst->boundary, &src->boundary);
src_part = src->part_head.next;
while (src_part != &src->part_head) {
pjsip_multipart_part *dst_part;
const pjsip_hdr *src_hdr;
dst_part = pjsip_multipart_create_part(pool);
src_hdr = src_part->hdr.next;
while (src_hdr != &src_part->hdr) {
pjsip_hdr *dst_hdr = (pjsip_hdr*)pjsip_hdr_clone(pool, src_hdr);
pj_list_push_back(&dst_part->hdr, dst_hdr);
src_hdr = src_hdr->next;
}
dst_part->body = pjsip_msg_body_clone(pool, src_part->body);
pj_list_push_back(&dst->part_head, dst_part);
src_part = src_part->next;
}
return (void*)dst;
}
/*
* Initialize codec manager.
*/
PJ_DEF(pj_status_t) pjmedia_codec_mgr_init (pjmedia_codec_mgr *mgr,
pj_pool_factory *pf)
{
pj_status_t status;
PJ_ASSERT_RETURN(mgr && pf, PJ_EINVAL);
/* Init codec manager */
pj_bzero(mgr, sizeof(pjmedia_codec_mgr));
mgr->pf = pf;
pj_list_init (&mgr->factory_list);
mgr->codec_cnt = 0;
/* Create pool */
mgr->pool = pj_pool_create(mgr->pf, "codec-mgr", 256, 256, NULL);
/* Create mutex */
status = pj_mutex_create_recursive(mgr->pool, "codec-mgr", &mgr->mutex);
if (status != PJ_SUCCESS)
return status;
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pjsip_publishc_create( pjsip_endpoint *endpt,
unsigned options,
void *token,
pjsip_publishc_cb *cb,
pjsip_publishc **p_pubc)
{
pj_pool_t *pool;
pjsip_publishc *pubc;
pj_status_t status;
/* Verify arguments. */
PJ_ASSERT_RETURN(endpt && cb && p_pubc, PJ_EINVAL);
PJ_ASSERT_RETURN(options == 0, PJ_EINVAL);
PJ_UNUSED_ARG(options);
pool = pjsip_endpt_create_pool(endpt, "pubc%p", 1024, 1024);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
pubc = PJ_POOL_ZALLOC_T(pool, pjsip_publishc);
pubc->pool = pool;
pubc->endpt = endpt;
pubc->token = token;
pubc->cb = cb;
pubc->expires = PJSIP_PUBC_EXPIRATION_NOT_SPECIFIED;
status = pjsip_auth_clt_init(&pubc->auth_sess, endpt, pubc->pool, 0);
if (status != PJ_SUCCESS)
return status;
pj_list_init(&pubc->route_set);
/* Done */
*p_pubc = pubc;
return PJ_SUCCESS;
}
static int gcc_test()
{
char msgbuf[512];
pj_str_t target = pj_str("sip:alice@wonderland:5061;x-param=param%201"
"?X-Hdr-1=Header%201"
"&X-Empty-Hdr=");
pjsip_tx_data *tdata;
pjsip_parser_err_report err_list;
pjsip_msg *msg;
int len;
pj_status_t status;
PJ_LOG(3,(THIS_FILE, " header param in URI to create request"));
/* Create request with header param in target URI. */
status = pjsip_endpt_create_request(endpt, &pjsip_invite_method, &target,
&target, &target, &target, NULL, -1,
NULL, &tdata);
if (status != 0) {
app_perror(" error: Unable to create request", status);
return -200;
}
/* Print and parse the request.
* We'll check that header params are not present in
*/
len = pjsip_msg_print(tdata->msg, msgbuf, sizeof(msgbuf));
if (len < 1) {
PJ_LOG(3,(THIS_FILE, " error: printing message"));
pjsip_tx_data_dec_ref(tdata);
return -250;
}
msgbuf[len] = '\0';
PJ_LOG(5,(THIS_FILE, "%d bytes request created:--begin-msg--\n"
"%s\n"
"--end-msg--", len, msgbuf));
/* Now parse the message. */
pj_list_init(&err_list);
msg = pjsip_parse_msg( tdata->pool, msgbuf, len, &err_list);
if (msg == NULL) {
pjsip_parser_err_report *e;
PJ_LOG(3,(THIS_FILE, " error: parsing message message"));
e = err_list.next;
while (e != &err_list) {
PJ_LOG(3,(THIS_FILE, " %s in line %d col %d hname=%.*s",
pj_exception_id_name(e->except_code),
e->line, e->col+1,
(int)e->hname.slen,
e->hname.ptr));
e = e->next;
}
pjsip_tx_data_dec_ref(tdata);
return -255;
}
pjsip_tx_data_dec_ref(tdata);
return 0;
}
void process_register_request(pjsip_rx_data* rdata)
{
pj_status_t status;
int st_code = PJSIP_SC_OK;
// Get the URI from the To header and check it is a SIP or SIPS URI.
pjsip_uri* uri = (pjsip_uri*)pjsip_uri_get_uri(rdata->msg_info.to->uri);
if (!PJSIP_URI_SCHEME_IS_SIP(uri))
{
// Reject a non-SIP/SIPS URI with 404 Not Found (RFC3261 isn't clear
// whether 404 is the right status code - it says 404 should be used if
// the AoR isn't valid for the domain in the RequestURI).
// LCOV_EXCL_START
LOG_ERROR("Rejecting register request using non SIP URI");
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_NOT_FOUND,
NULL,
NULL,
NULL);
return;
// LCOV_EXCL_STOP
}
// Canonicalize the public ID from the URI in the To header.
std::string public_id = PJUtils::aor_from_uri((pjsip_sip_uri*)uri);
LOG_DEBUG("Process REGISTER for public ID %s", public_id.c_str());
// Get the call identifier and the cseq number from the respective headers.
std::string cid = PJUtils::pj_str_to_string((const pj_str_t*)&rdata->msg_info.cid->id);;
int cseq = rdata->msg_info.cseq->cseq;
pjsip_msg *msg = rdata->msg_info.msg;
// Add SAS markers to the trail attached to the message so the trail
// becomes searchable.
SAS::TrailId trail = get_trail(rdata);
LOG_DEBUG("Report SAS start marker - trail (%llx)", trail);
SAS::Marker start_marker(trail, SASMarker::INIT_TIME, 1u);
SAS::report_marker(start_marker);
SAS::Marker calling_dn(trail, SASMarker::CALLING_DN, 1u);
pjsip_sip_uri* calling_uri = (pjsip_sip_uri*)pjsip_uri_get_uri(rdata->msg_info.to->uri);
calling_dn.add_var_param(calling_uri->user.slen, calling_uri->user.ptr);
SAS::report_marker(calling_dn);
SAS::Marker cid_marker(trail, SASMarker::SIP_CALL_ID, 1u);
cid_marker.add_var_param(rdata->msg_info.cid->id.slen, rdata->msg_info.cid->id.ptr);
SAS::report_marker(cid_marker, SAS::Marker::Scope::TrailGroup);
// Query the HSS for the associated URIs.
// This should really include the private ID, but we don't yet have a
// homestead API for it. Homestead won't be able to query a third-party HSS
// without the private ID.
Json::Value* uris = hss->get_associated_uris(public_id, trail);
if ((uris == NULL) ||
(uris->size() == 0))
{
// We failed to get the list of associated URIs. This indicates that the
// HSS is unavailable, the public identity doesn't exist or the public
// identity doesn't belong to the private identity. Reject with 403.
LOG_ERROR("Rejecting register request with invalid public/private identity");
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_FORBIDDEN,
NULL,
NULL,
NULL);
return;
}
// Determine the AOR from the first entry in the uris array.
std::string aor = uris->get((Json::ArrayIndex)0, Json::Value::null).asString();
LOG_DEBUG("REGISTER for public ID %s uses AOR %s", public_id.c_str(), aor.c_str());
// Find the expire headers in the message.
pjsip_expires_hdr* expires = (pjsip_expires_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL);
// Get the system time in seconds for calculating absolute expiry times.
int now = time(NULL);
int expiry = 0;
// The registration service uses optimistic locking to avoid concurrent
// updates to the same AoR conflicting. This means we have to loop
// reading, updating and writing the AoR until the write is successful.
RegData::AoR* aor_data = NULL;
do
{
if (aor_data != NULL)
{
delete aor_data; // LCOV_EXCL_LINE - Single-threaded tests mean we'll
// always pass CAS.
}
// Find the current bindings for the AoR.
aor_data = store->get_aor_data(aor);
LOG_DEBUG("Retrieved AoR data %p", aor_data);
if (aor_data == NULL)
{
// Failed to get data for the AoR because there is no connection
// to the store. Reject the register with a 500 response.
// LCOV_EXCL_START - local store (used in testing) never fails
LOG_ERROR("Failed to get AoR binding for %s from store", aor.c_str());
st_code = PJSIP_SC_INTERNAL_SERVER_ERROR;
break;
// LCOV_EXCL_STOP
}
// Now loop through all the contacts. If there are multiple contacts in
// the contact header in the SIP message, pjsip parses them to separate
// contact header structures.
pjsip_contact_hdr* contact = (pjsip_contact_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_CONTACT, NULL);
while (contact != NULL)
{
if (contact->star)
{
// Wildcard contact, which can only be used to clear all bindings for
// the AoR.
aor_data->clear();
break;
}
pjsip_uri* uri = (contact->uri != NULL) ?
(pjsip_uri*)pjsip_uri_get_uri(contact->uri) :
NULL;
if ((uri != NULL) &&
(PJSIP_URI_SCHEME_IS_SIP(uri)))
{
// The binding identifier is based on the +sip.instance parameter if
// it is present. If not the contact URI is used instead.
std::string contact_uri = PJUtils::uri_to_string(PJSIP_URI_IN_CONTACT_HDR, uri);
std::string binding_id = get_binding_id(contact);
if (binding_id == "")
{
binding_id = contact_uri;
}
LOG_DEBUG(". Binding identifier for contact = %s", binding_id.c_str());
// Find the appropriate binding in the bindings list for this AoR.
RegData::AoR::Binding* binding = aor_data->get_binding(binding_id);
if ((cid != binding->_cid) ||
(cseq > binding->_cseq))
{
// Either this is a new binding, has come from a restarted device, or
// is an update to an existing binding.
binding->_uri = contact_uri;
// TODO Examine Via header to see if we're the first hop
// TODO Only if we're not the first hop, check that the top path header has "ob" parameter
// Get the Path headers, if present. RFC 3327 allows us the option of
// rejecting a request with a Path header if there is no corresponding
// "path" entry in the Supported header but we don't do so on the assumption
// that the edge proxy knows what it's doing.
binding->_path_headers.clear();
pjsip_generic_string_hdr* path_hdr =
(pjsip_generic_string_hdr*)pjsip_msg_find_hdr_by_name(msg, &STR_PATH, NULL);
while (path_hdr)
{
std::string path = PJUtils::pj_str_to_string(&path_hdr->hvalue);
LOG_DEBUG("Path header %s", path.c_str());
// Extract all the paths from this header.
Utils::split_string(path, ',', binding->_path_headers, 0, true);
// Look for the next header.
path_hdr = (pjsip_generic_string_hdr*)pjsip_msg_find_hdr_by_name(msg, &STR_PATH, path_hdr->next);
}
binding->_cid = cid;
binding->_cseq = cseq;
binding->_priority = contact->q1000;
binding->_params.clear();
pjsip_param* p = contact->other_param.next;
while ((p != NULL) && (p != &contact->other_param))
{
std::string pname = PJUtils::pj_str_to_string(&p->name);
std::string pvalue = PJUtils::pj_str_to_string(&p->value);
binding->_params.push_back(std::make_pair(pname, pvalue));
p = p->next;
}
// Calculate the expiry period for the updated binding.
expiry = (contact->expires != -1) ? contact->expires :
(expires != NULL) ? expires->ivalue : 300;
if (expiry > 300)
{
// Expiry is too long, set it to the maximum of 300 seconds (5 minutes).
expiry = 300;
}
binding->_expires = now + expiry;
if (analytics != NULL)
{
// Generate an analytics log for this binding update.
analytics->registration(aor, binding_id, contact_uri, expiry);
}
}
}
contact = (pjsip_contact_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_CONTACT, contact->next);
}
}
while (!store->set_aor_data(aor, aor_data));
if (aor_data != NULL)
{
// Log the bindings.
log_bindings(aor, aor_data);
}
// Build and send the reply.
pjsip_tx_data* tdata;
status = PJUtils::create_response(stack_data.endpt, rdata, st_code, NULL, &tdata);
if (status != PJ_SUCCESS)
{
// LCOV_EXCL_START - don't know how to get PJSIP to fail to create a response
LOG_ERROR("Error building REGISTER %d response %s", st_code,
PJUtils::pj_status_to_string(status).c_str());
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_INTERNAL_SERVER_ERROR,
NULL,
NULL,
NULL);
delete aor_data;
return;
// LCOV_EXCL_STOP
}
if (st_code != PJSIP_SC_OK)
{
// LCOV_EXCL_START - we only reject REGISTER if something goes wrong, and
// we aren't covering any of those paths so we can't hit this either
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
delete aor_data;
return;
// LCOV_EXCL_STOP
}
// Add supported and require headers for RFC5626.
pjsip_generic_string_hdr* gen_hdr;
gen_hdr = pjsip_generic_string_hdr_create(tdata->pool,
&STR_SUPPORTED,
&STR_OUTBOUND);
if (gen_hdr == NULL)
{
// LCOV_EXCL_START - can't see how this could ever happen
LOG_ERROR("Failed to add RFC 5626 headers");
tdata->msg->line.status.code = PJSIP_SC_INTERNAL_SERVER_ERROR;
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
delete aor_data;
return;
// LCOV_EXCL_STOP
}
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)gen_hdr);
// Add contact headers for all active bindings.
for (RegData::AoR::Bindings::const_iterator i = aor_data->bindings().begin();
i != aor_data->bindings().end();
++i)
{
RegData::AoR::Binding* binding = i->second;
if (binding->_expires > now)
{
// The binding hasn't expired.
pjsip_uri* uri = PJUtils::uri_from_string(binding->_uri, tdata->pool);
if (uri != NULL)
{
// Contact URI is well formed, so include this in the response.
pjsip_contact_hdr* contact = pjsip_contact_hdr_create(tdata->pool);
contact->star = 0;
contact->uri = uri;
contact->q1000 = binding->_priority;
contact->expires = binding->_expires - now;
pj_list_init(&contact->other_param);
for (std::list<std::pair<std::string, std::string> >::iterator j = binding->_params.begin();
j != binding->_params.end();
++j)
{
pjsip_param *new_param = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
pj_strdup2(tdata->pool, &new_param->name, j->first.c_str());
pj_strdup2(tdata->pool, &new_param->value, j->second.c_str());
pj_list_insert_before(&contact->other_param, new_param);
}
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)contact);
}
else
{
// Contact URI is malformed. Log an error, but otherwise don't try and
// fix it.
// LCOV_EXCL_START hard to hit - needs bad data in the store
LOG_WARNING("Badly formed contact URI %s for address of record %s",
binding->_uri.c_str(), aor.c_str());
// LCOV_EXCL_STOP
}
}
}
// Deal with path header related fields in the response.
pjsip_generic_string_hdr* path_hdr =
(pjsip_generic_string_hdr*)pjsip_msg_find_hdr_by_name(msg, &STR_PATH, NULL);
if ((path_hdr != NULL) &&
(!aor_data->bindings().empty()))
{
// We have bindings with path headers so we must require outbound.
pjsip_require_hdr* require_hdr = pjsip_require_hdr_create(tdata->pool);
require_hdr->count = 1;
require_hdr->values[0] = STR_OUTBOUND;
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)require_hdr);
}
// Echo back any Path headers as per RFC 3327, section 5.3. We take these
// from the request as they may not exist in the bindings any more if the
// bindings have expired.
while (path_hdr)
{
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, path_hdr));
path_hdr = (pjsip_generic_string_hdr*)pjsip_msg_find_hdr_by_name(msg, &STR_PATH, path_hdr->next);
}
// Construct a Service-Route header pointing at the sprout cluster. We don't
// care which sprout handles the subsequent requests as they all have access
// to all subscriber information.
pjsip_sip_uri* service_route_uri = pjsip_sip_uri_create(tdata->pool, false);
pj_strdup(tdata->pool,
&service_route_uri->host,
&stack_data.sprout_cluster_domain);
service_route_uri->port = stack_data.trusted_port;
service_route_uri->transport_param = pj_str("TCP");
service_route_uri->lr_param = 1;
pjsip_route_hdr* service_route = pjsip_route_hdr_create(tdata->pool);
service_route->name = STR_SERVICE_ROUTE;
service_route->sname = pj_str("");
service_route->name_addr.uri = (pjsip_uri*)service_route_uri;
pjsip_msg_insert_first_hdr(tdata->msg, (pjsip_hdr*)service_route);
// Add P-Associated-URI headers for all of the associated URIs.
static const pj_str_t p_associated_uri_hdr_name = pj_str("P-Associated-URI");
for (Json::ValueIterator it = uris->begin(); it != uris->end(); it++)
{
pj_str_t associated_uri = {(char*)(*it).asCString(), strlen((*it).asCString())};
pjsip_hdr* associated_uri_hdr =
(pjsip_hdr*)pjsip_generic_string_hdr_create(tdata->pool,
&p_associated_uri_hdr_name,
&associated_uri);
pjsip_msg_add_hdr(tdata->msg, associated_uri_hdr);
}
delete uris;
// Send the response, but prevent the transmitted data from being freed, as we may need to inform the
// ASes of the 200 OK response we sent.
pjsip_tx_data_add_ref(tdata);
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
RegistrationUtils::register_with_application_servers(ifchandler, store, rdata, tdata, "");
// Now we can free the tdata.
pjsip_tx_data_dec_ref(tdata);
LOG_DEBUG("Report SAS end marker - trail (%llx)", trail);
SAS::Marker end_marker(trail, SASMarker::END_TIME, 1u);
SAS::report_marker(end_marker);
delete aor_data;
}
/*
* Common function to create TCP transport, called when pending accept() and
* pending connect() complete.
*/
static pj_status_t tcp_create( struct tcp_listener *listener,
pj_pool_t *pool,
pj_sock_t sock, pj_bool_t is_server,
const pj_sockaddr *local,
const pj_sockaddr *remote,
struct tcp_transport **p_tcp)
{
struct tcp_transport *tcp;
pj_ioqueue_t *ioqueue;
pj_activesock_cfg asock_cfg;
pj_activesock_cb tcp_callback;
const pj_str_t ka_pkt = PJSIP_TCP_KEEP_ALIVE_DATA;
char print_addr[PJ_INET6_ADDRSTRLEN+10];
pj_status_t status;
PJ_ASSERT_RETURN(sock != PJ_INVALID_SOCKET, PJ_EINVAL);
if (pool == NULL) {
pool = pjsip_endpt_create_pool(listener->endpt, "tcp",
POOL_TP_INIT, POOL_TP_INC);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
}
/*
* Create and initialize basic transport structure.
*/
tcp = PJ_POOL_ZALLOC_T(pool, struct tcp_transport);
tcp->is_server = is_server;
tcp->sock = sock;
/*tcp->listener = listener;*/
pj_list_init(&tcp->delayed_list);
tcp->base.pool = pool;
pj_ansi_snprintf(tcp->base.obj_name, PJ_MAX_OBJ_NAME,
(is_server ? "tcps%p" :"tcpc%p"), tcp);
status = pj_atomic_create(pool, 0, &tcp->base.ref_cnt);
if (status != PJ_SUCCESS) {
goto on_error;
}
status = pj_lock_create_recursive_mutex(pool, "tcp", &tcp->base.lock);
if (status != PJ_SUCCESS) {
goto on_error;
}
tcp->base.key.type = listener->factory.type;
pj_sockaddr_cp(&tcp->base.key.rem_addr, remote);
tcp->base.type_name = (char*)pjsip_transport_get_type_name(
(pjsip_transport_type_e)tcp->base.key.type);
tcp->base.flag = pjsip_transport_get_flag_from_type(
(pjsip_transport_type_e)tcp->base.key.type);
tcp->base.info = (char*) pj_pool_alloc(pool, 64);
pj_ansi_snprintf(tcp->base.info, 64, "%s to %s",
tcp->base.type_name,
pj_sockaddr_print(remote, print_addr,
sizeof(print_addr), 3));
tcp->base.addr_len = pj_sockaddr_get_len(remote);
pj_sockaddr_cp(&tcp->base.local_addr, local);
sockaddr_to_host_port(pool, &tcp->base.local_name, local);
sockaddr_to_host_port(pool, &tcp->base.remote_name, remote);
tcp->base.dir = is_server? PJSIP_TP_DIR_INCOMING : PJSIP_TP_DIR_OUTGOING;
tcp->base.endpt = listener->endpt;
tcp->base.tpmgr = listener->tpmgr;
tcp->base.send_msg = &tcp_send_msg;
tcp->base.do_shutdown = &tcp_shutdown;
tcp->base.destroy = &tcp_destroy_transport;
/* Create active socket */
pj_activesock_cfg_default(&asock_cfg);
asock_cfg.async_cnt = 1;
pj_bzero(&tcp_callback, sizeof(tcp_callback));
tcp_callback.on_data_read = &on_data_read;
tcp_callback.on_data_sent = &on_data_sent;
tcp_callback.on_connect_complete = &on_connect_complete;
ioqueue = pjsip_endpt_get_ioqueue(listener->endpt);
status = pj_activesock_create(pool, sock, pj_SOCK_STREAM(), &asock_cfg,
ioqueue, &tcp_callback, tcp, &tcp->asock);
if (status != PJ_SUCCESS) {
goto on_error;
}
/* Register transport to transport manager */
status = pjsip_transport_register(listener->tpmgr, &tcp->base);
if (status != PJ_SUCCESS) {
goto on_error;
}
tcp->is_registered = PJ_TRUE;
/* Initialize keep-alive timer */
tcp->ka_timer.user_data = (void*)tcp;
tcp->ka_timer.cb = &tcp_keep_alive_timer;
pj_ioqueue_op_key_init(&tcp->ka_op_key.key, sizeof(pj_ioqueue_op_key_t));
pj_strdup(tcp->base.pool, &tcp->ka_pkt, &ka_pkt);
/* Done setting up basic transport. */
*p_tcp = tcp;
PJ_LOG(4,(tcp->base.obj_name, "TCP %s transport created",
(tcp->is_server ? "server" : "client")));
return PJ_SUCCESS;
on_error:
tcp_destroy(&tcp->base, status);
return status;
}
/*
* pj_ioqueue_create()
*
* Create select ioqueue.
*/
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 *ioqueue;
pj_status_t rc;
pj_lock_t *lock;
int i;
/* Check that arguments are valid. */
PJ_ASSERT_RETURN(pool != NULL && p_ioqueue != NULL &&
max_fd > 0, PJ_EINVAL);
/* Check that size of pj_ioqueue_op_key_t is sufficient */
PJ_ASSERT_RETURN(sizeof(pj_ioqueue_op_key_t)-sizeof(void*) >=
sizeof(union operation_key), PJ_EBUG);
ioqueue = pj_pool_alloc(pool, sizeof(pj_ioqueue_t));
ioqueue_init(ioqueue);
ioqueue->max = max_fd;
ioqueue->count = 0;
pj_list_init(&ioqueue->active_list);
#if PJ_IOQUEUE_HAS_SAFE_UNREG
/* When safe unregistration is used (the default), we pre-create
* all keys and put them in the free list.
*/
/* Mutex to protect key's reference counter
* We don't want to use key's mutex or ioqueue's mutex because
* that would create deadlock situation in some cases.
*/
rc = pj_mutex_create_simple(pool, NULL, &ioqueue->ref_cnt_mutex);
if (rc != PJ_SUCCESS)
return rc;
/* Init key list */
pj_list_init(&ioqueue->free_list);
pj_list_init(&ioqueue->closing_list);
/* Pre-create all keys according to max_fd */
for ( i=0; i<max_fd; ++i) {
pj_ioqueue_key_t *key;
key = PJ_POOL_ALLOC_T(pool, pj_ioqueue_key_t);
key->ref_count = 0;
rc = pj_lock_create_recursive_mutex(pool, NULL, &key->lock);
if (rc != PJ_SUCCESS) {
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);
return rc;
}
pj_list_push_back(&ioqueue->free_list, key);
}
#endif
rc = pj_lock_create_simple_mutex(pool, "ioq%p", &lock);
if (rc != PJ_SUCCESS)
return rc;
rc = pj_ioqueue_set_lock(ioqueue, lock, PJ_TRUE);
if (rc != PJ_SUCCESS)
return rc;
ioqueue->epfd = os_epoll_create(max_fd);
if (ioqueue->epfd < 0) {
ioqueue_destroy(ioqueue);
return PJ_RETURN_OS_ERROR(pj_get_native_os_error());
}
/*ioqueue->events = pj_pool_calloc(pool, max_fd, sizeof(struct epoll_event));
PJ_ASSERT_RETURN(ioqueue->events != NULL, PJ_ENOMEM);
ioqueue->queue = pj_pool_calloc(pool, max_fd, sizeof(struct queue));
PJ_ASSERT_RETURN(ioqueue->queue != NULL, PJ_ENOMEM);
*/
PJ_LOG(4, ("pjlib", "epoll I/O Queue created (%p)", ioqueue));
*p_ioqueue = ioqueue;
return PJ_SUCCESS;
}
/*
* Create the echo canceller.
*/
PJ_DEF(pj_status_t) pjmedia_echo_create2(pj_pool_t *pool,
unsigned clock_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned tail_ms,
unsigned latency_ms,
unsigned options,
pjmedia_echo_state **p_echo )
{
unsigned ptime, lat_cnt;
unsigned delay_buf_opt = 0;
pjmedia_echo_state *ec;
pj_status_t status;
/* Create new pool and instantiate and init the EC */
pool = pj_pool_create(pool->factory, "ec%p", 256, 256, NULL);
ec = PJ_POOL_ZALLOC_T(pool, struct pjmedia_echo_state);
ec->pool = pool;
ec->obj_name = pool->obj_name;
ec->samples_per_frame = samples_per_frame;
ec->frm_buf = (pj_int16_t*)pj_pool_alloc(pool, samples_per_frame<<1);
pj_list_init(&ec->lat_buf);
pj_list_init(&ec->lat_free);
/* Select the backend algorithm */
if (0) {
/* Dummy */
;
#if defined(PJMEDIA_HAS_SPEEX_AEC) && PJMEDIA_HAS_SPEEX_AEC!=0
} else if ((options & PJMEDIA_ECHO_ALGO_MASK) == PJMEDIA_ECHO_SPEEX ||
(options & PJMEDIA_ECHO_ALGO_MASK) == PJMEDIA_ECHO_DEFAULT)
{
ec->op = &speex_aec_op;
#endif
#if defined(PJMEDIA_HAS_INTEL_IPP_AEC) && PJMEDIA_HAS_INTEL_IPP_AEC!=0
} else if ((options & PJMEDIA_ECHO_ALGO_MASK) == PJMEDIA_ECHO_IPP ||
(options & PJMEDIA_ECHO_ALGO_MASK) == PJMEDIA_ECHO_DEFAULT)
{
ec->op = &ipp_aec_op;
#endif
} else {
ec->op = &echo_supp_op;
}
/* Completeness check for EC operation playback and capture, they must
* be implemented both or none.
*/
pj_assert(!ec->op->ec_capture == !ec->op->ec_playback);
PJ_LOG(5,(ec->obj_name, "Creating %s", ec->op->name));
/* Instantiate EC object */
status = (*ec->op->ec_create)(pool, clock_rate, channel_count,
samples_per_frame, tail_ms,
options, &ec->state);
if (status != PJ_SUCCESS) {
pj_pool_release(pool);
return status;
}
/* If EC algo does not have playback and capture callbakcs,
* create latency buffer and delay buffer to handle drift.
*/
if (ec->op->ec_playback && ec->op->ec_capture) {
latency_ms = 0;
} else {
/* Create latency buffers */
ptime = samples_per_frame * 1000 / clock_rate;
if (latency_ms > ptime) {
/* Normalize latency with delaybuf/WSOLA latency */
latency_ms -= PJ_MIN(ptime, PJMEDIA_WSOLA_DELAY_MSEC);
}
if (latency_ms < ptime) {
/* Give at least one frame delay to simplify programming */
latency_ms = ptime;
}
lat_cnt = latency_ms / ptime;
while (lat_cnt--) {
struct frame *frm;
frm = (struct frame*) pj_pool_alloc(pool, (samples_per_frame<<1) +
sizeof(struct frame));
pj_list_push_back(&ec->lat_free, frm);
}
/* Create delay buffer to compensate drifts */
if (options & PJMEDIA_ECHO_USE_SIMPLE_FIFO)
delay_buf_opt |= PJMEDIA_DELAY_BUF_SIMPLE_FIFO;
status = pjmedia_delay_buf_create(ec->pool, ec->obj_name, clock_rate,
samples_per_frame, channel_count,
(PJMEDIA_SOUND_BUFFER_COUNT+1) * ptime,
delay_buf_opt, &ec->delay_buf);
if (status != PJ_SUCCESS) {
pj_pool_release(pool);
return status;
}
}
PJ_LOG(4,(ec->obj_name,
"%s created, clock_rate=%d, channel=%d, "
"samples per frame=%d, tail length=%d ms, "
"latency=%d ms",
ec->op->name, clock_rate, channel_count, samples_per_frame,
tail_ms, latency_ms));
/* Done */
*p_echo = ec;
return PJ_SUCCESS;
}
/*
* Handler to receive incoming MESSAGE
*/
static pj_bool_t im_on_rx_request(pjsip_rx_data *rdata)
{
pj_str_t from, to;
pjsip_accept_hdr *accept_hdr;
pjsip_msg *msg;
msg = rdata->msg_info.msg;
/* Only want to handle MESSAGE requests. */
if (pjsip_method_cmp(&msg->line.req.method, &pjsip_message_method) != 0) {
return PJ_FALSE;
}
/* Should not have any transaction attached to rdata. */
PJ_ASSERT_RETURN(pjsip_rdata_get_tsx(rdata)==NULL, PJ_FALSE);
/* Should not have any dialog attached to rdata. */
PJ_ASSERT_RETURN(pjsip_rdata_get_dlg(rdata)==NULL, PJ_FALSE);
/* Check if we can accept the message. */
if (!pjsua_im_accept_pager(rdata, &accept_hdr)) {
pjsip_hdr hdr_list;
pj_list_init(&hdr_list);
pj_list_push_back(&hdr_list, accept_hdr);
pjsip_endpt_respond_stateless(pjsua_var.endpt, rdata,
PJSIP_SC_NOT_ACCEPTABLE_HERE, NULL,
&hdr_list, NULL);
return PJ_TRUE;
}
/* Respond with 200 first, so that remote doesn't retransmit in case
* the UI takes too long to process the message.
*/
pjsip_endpt_respond( pjsua_var.endpt, NULL, rdata, 200, NULL,
NULL, NULL, NULL);
/* For the source URI, we use Contact header if present, since
* Contact header contains the port number information. If this is
* not available, then use From header.
*/
from.ptr = (char*)pj_pool_alloc(rdata->tp_info.pool, PJSIP_MAX_URL_SIZE);
from.slen = pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR,
rdata->msg_info.from->uri,
from.ptr, PJSIP_MAX_URL_SIZE);
if (from.slen < 1)
from = pj_str("<--URI is too long-->");
/* Build the To text. */
to.ptr = (char*) pj_pool_alloc(rdata->tp_info.pool, PJSIP_MAX_URL_SIZE);
to.slen = pjsip_uri_print( PJSIP_URI_IN_FROMTO_HDR,
rdata->msg_info.to->uri,
to.ptr, PJSIP_MAX_URL_SIZE);
if (to.slen < 1)
to = pj_str("<--URI is too long-->");
/* Process pager. */
pjsua_im_process_pager(-1, &from, &to, rdata);
/* Done. */
return PJ_TRUE;
}
/* This tests the request creating functions against the following
* requirements:
* - header params in URI creates header in the request.
* - method and headers params are correctly shown or hidden in
* request URI, From, To, and Contact header.
*/
static int txdata_test_uri_params(void)
{
char msgbuf[512];
pj_str_t target = pj_str("sip:alice@wonderland:5061;x-param=param%201"
"?X-Hdr-1=Header%201"
"&X-Empty-Hdr=");
pj_str_t contact;
pj_str_t pname = pj_str("x-param");
pj_str_t hname = pj_str("X-Hdr-1");
pj_str_t hemptyname = pj_str("X-Empty-Hdr");
pjsip_from_hdr *from_hdr;
pjsip_to_hdr *to_hdr;
pjsip_contact_hdr *contact_hdr;
pjsip_generic_string_hdr *hdr;
pjsip_tx_data *tdata;
pjsip_sip_uri *uri;
pjsip_param *param;
pjsip_via_hdr *via;
pjsip_parser_err_report err_list;
pjsip_msg *msg;
int len;
pj_status_t status;
PJ_LOG(3,(THIS_FILE, " header param in URI to create request"));
/* Due to #930, contact argument is now parsed as Contact header, so
* must enclose it with <> to make it be parsed as URI.
*/
pj_ansi_snprintf(msgbuf, sizeof(msgbuf), "<%.*s>",
(int)target.slen, target.ptr);
contact.ptr = msgbuf;
contact.slen = strlen(msgbuf);
/* Create request with header param in target URI. */
status = pjsip_endpt_create_request(endpt, &pjsip_invite_method, &target,
&target, &target, &contact, NULL, -1,
NULL, &tdata);
if (status != 0) {
app_perror(" error: Unable to create request", status);
return -200;
}
/* Fill up the Via header to prevent syntax error on parsing */
via = (pjsip_via_hdr*) pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL);
via->transport = pj_str("TCP");
via->sent_by.host = pj_str("127.0.0.1");
/* Print and parse the request.
* We'll check that header params are not present in
*/
len = pjsip_msg_print(tdata->msg, msgbuf, sizeof(msgbuf));
if (len < 1) {
PJ_LOG(3,(THIS_FILE, " error: printing message"));
pjsip_tx_data_dec_ref(tdata);
return -250;
}
msgbuf[len] = '\0';
PJ_LOG(5,(THIS_FILE, "%d bytes request created:--begin-msg--\n"
"%s\n"
"--end-msg--", len, msgbuf));
/* Now parse the message. */
pj_list_init(&err_list);
msg = pjsip_parse_msg( 0, tdata->pool, msgbuf, len, &err_list);
if (msg == NULL) {
pjsip_parser_err_report *e;
PJ_LOG(3,(THIS_FILE, " error: parsing message message"));
e = err_list.next;
while (e != &err_list) {
PJ_LOG(3,(THIS_FILE, " %s in line %d col %d hname=%.*s",
pj_exception_id_name(0, e->except_code),
e->line, e->col+1,
(int)e->hname.slen,
e->hname.ptr));
e = e->next;
}
pjsip_tx_data_dec_ref(tdata);
return -256;
}
/* Check the existence of port, other_param, and header param.
* Port is now allowed in To and From header.
*/
/* Port in request URI. */
uri = (pjsip_sip_uri*) pjsip_uri_get_uri(msg->line.req.uri);
if (uri->port != 5061) {
PJ_LOG(3,(THIS_FILE, " error: port not present in request URI"));
pjsip_tx_data_dec_ref(tdata);
return -260;
}
/* other_param in request_uri */
param = pjsip_param_find(&uri->other_param, &pname);
if (param == NULL || pj_strcmp2(¶m->value, "param 1") != 0) {
PJ_LOG(3,(THIS_FILE, " error: x-param not present in request URI"));
pjsip_tx_data_dec_ref(tdata);
return -261;
}
/* header param in request uri. */
if (!pj_list_empty(&uri->header_param)) {
PJ_LOG(3,(THIS_FILE, " error: hparam in request URI"));
pjsip_tx_data_dec_ref(tdata);
return -262;
}
/* Port in From header. */
from_hdr = (pjsip_from_hdr*) pjsip_msg_find_hdr(msg, PJSIP_H_FROM, NULL);
uri = (pjsip_sip_uri*) pjsip_uri_get_uri(from_hdr->uri);
if (uri->port != 0) {
PJ_LOG(3,(THIS_FILE, " error: port most not exist in From header"));
pjsip_tx_data_dec_ref(tdata);
return -270;
}
/* other_param in From header */
param = pjsip_param_find(&uri->other_param, &pname);
if (param == NULL || pj_strcmp2(¶m->value, "param 1") != 0) {
PJ_LOG(3,(THIS_FILE, " error: x-param not present in From header"));
pjsip_tx_data_dec_ref(tdata);
return -271;
}
/* header param in From header. */
if (!pj_list_empty(&uri->header_param)) {
PJ_LOG(3,(THIS_FILE, " error: hparam in From header"));
pjsip_tx_data_dec_ref(tdata);
return -272;
}
/* Port in To header. */
to_hdr = (pjsip_to_hdr*) pjsip_msg_find_hdr(msg, PJSIP_H_TO, NULL);
uri = (pjsip_sip_uri*) pjsip_uri_get_uri(to_hdr->uri);
if (uri->port != 0) {
PJ_LOG(3,(THIS_FILE, " error: port most not exist in To header"));
pjsip_tx_data_dec_ref(tdata);
return -280;
}
/* other_param in To header */
param = pjsip_param_find(&uri->other_param, &pname);
if (param == NULL || pj_strcmp2(¶m->value, "param 1") != 0) {
PJ_LOG(3,(THIS_FILE, " error: x-param not present in To header"));
pjsip_tx_data_dec_ref(tdata);
return -281;
}
/* header param in From header. */
if (!pj_list_empty(&uri->header_param)) {
PJ_LOG(3,(THIS_FILE, " error: hparam in To header"));
pjsip_tx_data_dec_ref(tdata);
return -282;
}
/* Port in Contact header. */
contact_hdr = (pjsip_contact_hdr*) pjsip_msg_find_hdr(msg, PJSIP_H_CONTACT, NULL);
uri = (pjsip_sip_uri*) pjsip_uri_get_uri(contact_hdr->uri);
if (uri->port != 5061) {
PJ_LOG(3,(THIS_FILE, " error: port not present in Contact header"));
pjsip_tx_data_dec_ref(tdata);
return -290;
}
/* other_param in Contact header */
param = pjsip_param_find(&uri->other_param, &pname);
if (param == NULL || pj_strcmp2(¶m->value, "param 1") != 0) {
PJ_LOG(3,(THIS_FILE, " error: x-param not present in Contact header"));
pjsip_tx_data_dec_ref(tdata);
return -291;
}
/* header param in Contact header. */
if (pj_list_empty(&uri->header_param)) {
PJ_LOG(3,(THIS_FILE, " error: hparam is missing in Contact header"));
pjsip_tx_data_dec_ref(tdata);
return -292;
}
/* Check for X-Hdr-1 */
param = pjsip_param_find(&uri->header_param, &hname);
if (param == NULL || pj_strcmp2(¶m->value, "Header 1")!=0) {
PJ_LOG(3,(THIS_FILE, " error: hparam is missing in Contact header"));
pjsip_tx_data_dec_ref(tdata);
return -293;
}
/* Check for X-Empty-Hdr */
param = pjsip_param_find(&uri->header_param, &hemptyname);
if (param == NULL || pj_strcmp2(¶m->value, "")!=0) {
PJ_LOG(3,(THIS_FILE, " error: hparam is missing in Contact header"));
pjsip_tx_data_dec_ref(tdata);
return -294;
}
/* Check that headers are present in the request. */
hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(msg, &hname, NULL);
if (hdr == NULL || pj_strcmp2(&hdr->hvalue, "Header 1")!=0) {
PJ_LOG(3,(THIS_FILE, " error: header X-Hdr-1 not created"));
pjsip_tx_data_dec_ref(tdata);
return -300;
}
hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(msg, &hemptyname, NULL);
if (hdr == NULL || pj_strcmp2(¶m->value, "")!=0) {
PJ_LOG(3,(THIS_FILE, " error: header X-Empty-Hdr not created"));
pjsip_tx_data_dec_ref(tdata);
return -330;
}
pjsip_tx_data_dec_ref(tdata);
return 0;
}
/*
* Initialize and register Speex codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_speex_init( pjmedia_endpt *endpt,
unsigned options,
int quality,
int complexity )
{
pjmedia_codec_mgr *codec_mgr;
unsigned i;
pj_status_t status;
if (spx_factory.pool != NULL) {
/* Already initialized. */
return PJ_SUCCESS;
}
/* Get defaults */
if (quality < 0) quality = PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY;
if (complexity < 0) complexity = PJMEDIA_CODEC_SPEEX_DEFAULT_COMPLEXITY;
/* Validate quality & complexity */
PJ_ASSERT_RETURN(quality >= 0 && quality <= 10, PJ_EINVAL);
PJ_ASSERT_RETURN(complexity >= 1 && complexity <= 10, PJ_EINVAL);
/* Create Speex codec factory. */
spx_factory.base.op = &spx_factory_op;
spx_factory.base.factory_data = NULL;
spx_factory.endpt = endpt;
spx_factory.pool = pjmedia_endpt_create_pool(endpt, "speex",
4000, 4000);
if (!spx_factory.pool)
return PJ_ENOMEM;
pj_list_init(&spx_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(spx_factory.pool, "speex",
&spx_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Initialize default Speex parameter. */
spx_factory.speex_param[PARAM_NB].enabled =
((options & PJMEDIA_SPEEX_NO_NB) == 0);
spx_factory.speex_param[PARAM_NB].pt = PJMEDIA_RTP_PT_SPEEX_NB;
spx_factory.speex_param[PARAM_NB].mode = speex_lib_get_mode(SPEEX_MODEID_NB);
spx_factory.speex_param[PARAM_NB].clock_rate = 8000;
spx_factory.speex_param[PARAM_NB].quality = quality;
spx_factory.speex_param[PARAM_NB].complexity = complexity;
spx_factory.speex_param[PARAM_WB].enabled =
((options & PJMEDIA_SPEEX_NO_WB) == 0);
spx_factory.speex_param[PARAM_WB].pt = PJMEDIA_RTP_PT_SPEEX_WB;
spx_factory.speex_param[PARAM_WB].mode = speex_lib_get_mode(SPEEX_MODEID_WB);
spx_factory.speex_param[PARAM_WB].clock_rate = 16000;
spx_factory.speex_param[PARAM_WB].quality = quality;
spx_factory.speex_param[PARAM_WB].complexity = complexity;
spx_factory.speex_param[PARAM_UWB].enabled =
((options & PJMEDIA_SPEEX_NO_UWB) == 0);
spx_factory.speex_param[PARAM_UWB].pt = PJMEDIA_RTP_PT_SPEEX_UWB;
spx_factory.speex_param[PARAM_UWB].mode = speex_lib_get_mode(SPEEX_MODEID_UWB);
spx_factory.speex_param[PARAM_UWB].clock_rate = 32000;
spx_factory.speex_param[PARAM_UWB].quality = quality;
spx_factory.speex_param[PARAM_UWB].complexity = complexity;
/* Somehow quality <=4 is broken in linux. */
if (quality <= 4 && quality >= 0) {
PJ_LOG(5,(THIS_FILE, "Adjusting quality to 5 for uwb"));
spx_factory.speex_param[PARAM_UWB].quality = 5;
}
/* Get codec framesize and avg bitrate for each mode. */
for (i=0; i<PJ_ARRAY_SIZE(spx_factory.speex_param); ++i) {
status = get_speex_info(&spx_factory.speex_param[i]);
}
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&spx_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(spx_factory.pool);
spx_factory.pool = NULL;
return status;
}
int list_test()
{
list_node nodes[4]; // must be even number of nodes
list_node list;
list_node list2;
list_node *p;
int i; // don't change to unsigned!
//
// Test insert_before().
//
list.value = (unsigned)-1;
pj_list_init(&list);
for (i=0; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i) {
nodes[i].value = i;
pj_list_insert_before(&list, &nodes[i]);
}
// check.
for (i=0, p=list.next; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i, p=p->next) {
pj_assert(p->value == i);
if (p->value != i) {
return -1;
}
}
//
// Test insert_after()
//
pj_list_init(&list);
for (i=PJ_SIGNED_ARRAY_SIZE(nodes)-1; i>=0; --i) {
pj_list_insert_after(&list, &nodes[i]);
}
// check.
for (i=0, p=list.next; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i, p=p->next) {
pj_assert(p->value == i);
if (p->value != i) {
return -1;
}
}
//
// Test merge_last()
//
// Init lists
pj_list_init(&list);
pj_list_init(&list2);
for (i=0; i<PJ_SIGNED_ARRAY_SIZE(nodes)/2; ++i) {
pj_list_insert_before(&list, &nodes[i]);
}
for (i=PJ_SIGNED_ARRAY_SIZE(nodes)/2; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i) {
pj_list_insert_before(&list2, &nodes[i]);
}
// merge
pj_list_merge_last(&list, &list2);
// check.
for (i=0, p=list.next; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i, p=p->next) {
pj_assert(p->value == i);
if (p->value != i) {
return -1;
}
}
// check list is empty
pj_assert( pj_list_empty(&list2) );
if (!pj_list_empty(&list2)) {
return -1;
}
//
// Check merge_first()
//
pj_list_init(&list);
pj_list_init(&list2);
for (i=0; i<PJ_SIGNED_ARRAY_SIZE(nodes)/2; ++i) {
pj_list_insert_before(&list, &nodes[i]);
}
for (i=PJ_SIGNED_ARRAY_SIZE(nodes)/2; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i) {
pj_list_insert_before(&list2, &nodes[i]);
}
// merge
pj_list_merge_first(&list2, &list);
// check (list2).
for (i=0, p=list2.next; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i, p=p->next) {
pj_assert(p->value == i);
if (p->value != i) {
return -1;
}
}
// check list is empty
pj_assert( pj_list_empty(&list) );
if (!pj_list_empty(&list)) {
return -1;
}
//
// Test insert_nodes_before()
//
// init list
pj_list_init(&list);
for (i=0; i<PJ_SIGNED_ARRAY_SIZE(nodes)/2; ++i) {
pj_list_insert_before(&list, &nodes[i]);
}
// chain remaining nodes
pj_list_init(&nodes[PJ_SIGNED_ARRAY_SIZE(nodes)/2]);
for (i=PJ_SIGNED_ARRAY_SIZE(nodes)/2+1; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i) {
pj_list_insert_before(&nodes[PJ_SIGNED_ARRAY_SIZE(nodes)/2], &nodes[i]);
}
// insert nodes
pj_list_insert_nodes_before(&list, &nodes[PJ_SIGNED_ARRAY_SIZE(nodes)/2]);
// check
for (i=0, p=list.next; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i, p=p->next) {
pj_assert(p->value == i);
if (p->value != i) {
return -1;
}
}
// erase test.
pj_list_init(&list);
for (i=0; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i) {
nodes[i].value = i;
pj_list_insert_before(&list, &nodes[i]);
}
for (i=PJ_SIGNED_ARRAY_SIZE(nodes)-1; i>=0; --i) {
int j;
pj_list_erase(&nodes[i]);
for (j=0, p=list.next; j<i; ++j, p=p->next) {
pj_assert(p->value == j);
if (p->value != j) {
return -1;
}
}
}
// find and search
pj_list_init(&list);
for (i=0; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i) {
nodes[i].value = i;
pj_list_insert_before(&list, &nodes[i]);
}
for (i=0; i<PJ_SIGNED_ARRAY_SIZE(nodes); ++i) {
p = (list_node*) pj_list_find_node(&list, &nodes[i]);
pj_assert( p == &nodes[i] );
if (p != &nodes[i]) {
return -1;
}
p = (list_node*) pj_list_search(&list, (void*)(pj_ssize_t)i,
&compare_node);
pj_assert( p == &nodes[i] );
if (p != &nodes[i]) {
return -1;
}
}
return 0;
}
/*
* Common function to create TLS transport, called when pending accept() and
* pending connect() complete.
*/
static pj_status_t tls_create( struct tls_listener *listener,
pj_pool_t *pool,
pj_ssl_sock_t *ssock,
pj_bool_t is_server,
const pj_sockaddr_in *local,
const pj_sockaddr_in *remote,
const pj_str_t *remote_name,
struct tls_transport **p_tls)
{
struct tls_transport *tls;
const pj_str_t ka_pkt = PJSIP_TLS_KEEP_ALIVE_DATA;
pj_status_t status;
PJ_ASSERT_RETURN(listener && ssock && local && remote && p_tls, PJ_EINVAL);
if (pool == NULL) {
pool = pjsip_endpt_create_pool(listener->endpt, "tls",
POOL_TP_INIT, POOL_TP_INC);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
}
/*
* Create and initialize basic transport structure.
*/
tls = PJ_POOL_ZALLOC_T(pool, struct tls_transport);
tls->is_server = is_server;
tls->verify_server = listener->tls_setting.verify_server;
pj_list_init(&tls->delayed_list);
tls->base.pool = pool;
pj_ansi_snprintf(tls->base.obj_name, PJ_MAX_OBJ_NAME,
(is_server ? "tlss%p" :"tlsc%p"), tls);
status = pj_atomic_create(pool, 0, &tls->base.ref_cnt);
if (status != PJ_SUCCESS) {
goto on_error;
}
status = pj_lock_create_recursive_mutex(pool, "tls", &tls->base.lock);
if (status != PJ_SUCCESS) {
goto on_error;
}
if (remote_name)
pj_strdup(pool, &tls->remote_name, remote_name);
tls->base.key.type = PJSIP_TRANSPORT_TLS;
pj_memcpy(&tls->base.key.rem_addr, remote, sizeof(pj_sockaddr_in));
tls->base.type_name = "tls";
tls->base.flag = pjsip_transport_get_flag_from_type(PJSIP_TRANSPORT_TLS);
tls->base.info = (char*) pj_pool_alloc(pool, 64);
pj_ansi_snprintf(tls->base.info, 64, "TLS to %s:%d",
pj_inet_ntoa(remote->sin_addr),
(int)pj_ntohs(remote->sin_port));
tls->base.addr_len = sizeof(pj_sockaddr_in);
tls->base.dir = is_server? PJSIP_TP_DIR_INCOMING : PJSIP_TP_DIR_OUTGOING;
/* Set initial local address */
if (!pj_sockaddr_has_addr(local)) {
pj_sockaddr_cp(&tls->base.local_addr,
&listener->factory.local_addr);
} else {
pj_sockaddr_cp(&tls->base.local_addr, local);
}
sockaddr_to_host_port(pool, &tls->base.local_name,
(pj_sockaddr_in*)&tls->base.local_addr);
if (tls->remote_name.slen) {
tls->base.remote_name.host = tls->remote_name;
tls->base.remote_name.port = pj_sockaddr_in_get_port(remote);
} else {
sockaddr_to_host_port(pool, &tls->base.remote_name, remote);
}
tls->base.endpt = listener->endpt;
tls->base.tpmgr = listener->tpmgr;
tls->base.send_msg = &tls_send_msg;
tls->base.do_shutdown = &tls_shutdown;
tls->base.destroy = &tls_destroy_transport;
tls->ssock = ssock;
/* Register transport to transport manager */
status = pjsip_transport_register(listener->tpmgr, &tls->base);
if (status != PJ_SUCCESS) {
goto on_error;
}
tls->is_registered = PJ_TRUE;
/* Initialize keep-alive timer */
tls->ka_timer.user_data = (void*)tls;
tls->ka_timer.cb = &tls_keep_alive_timer;
pj_ioqueue_op_key_init(&tls->ka_op_key.key, sizeof(pj_ioqueue_op_key_t));
pj_strdup(tls->base.pool, &tls->ka_pkt, &ka_pkt);
/* Done setting up basic transport. */
*p_tls = tls;
PJ_LOG(4,(tls->base.obj_name, "TLS %s transport created",
(tls->is_server ? "server" : "client")));
return PJ_SUCCESS;
on_error:
tls_destroy(&tls->base, status);
return status;
}
/*
* pj_ioqueue_create()
*
* Create select ioqueue.
*/
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 *ioqueue;
pj_lock_t *lock;
unsigned i;
pj_status_t rc;
/* Check that arguments are valid. */
PJ_ASSERT_RETURN(pool != NULL && p_ioqueue != NULL &&
max_fd > 0 && max_fd <= PJ_IOQUEUE_MAX_HANDLES,
PJ_EINVAL);
/* Check that size of pj_ioqueue_op_key_t is sufficient */
PJ_ASSERT_RETURN(sizeof(pj_ioqueue_op_key_t)-sizeof(void*) >=
sizeof(union operation_key), PJ_EBUG);
/* Create and init common ioqueue stuffs */
ioqueue = PJ_POOL_ALLOC_T(pool, pj_ioqueue_t);
ioqueue_init(ioqueue);
ioqueue->max = max_fd;
ioqueue->count = 0;
PJ_FD_ZERO(&ioqueue->rfdset);
PJ_FD_ZERO(&ioqueue->wfdset);
#if PJ_HAS_TCP
PJ_FD_ZERO(&ioqueue->xfdset);
#endif
pj_list_init(&ioqueue->active_list);
rescan_fdset(ioqueue);
#if PJ_IOQUEUE_HAS_SAFE_UNREG
/* When safe unregistration is used (the default), we pre-create
* all keys and put them in the free list.
*/
/* Mutex to protect key's reference counter
* We don't want to use key's mutex or ioqueue's mutex because
* that would create deadlock situation in some cases.
*/
rc = pj_mutex_create_simple(pool, NULL, &ioqueue->ref_cnt_mutex);
if (rc != PJ_SUCCESS)
return rc;
/* Init key list */
pj_list_init(&ioqueue->free_list);
pj_list_init(&ioqueue->closing_list);
/* Pre-create all keys according to max_fd */
for (i=0; i<max_fd; ++i) {
pj_ioqueue_key_t *key;
key = PJ_POOL_ALLOC_T(pool, pj_ioqueue_key_t);
key->ref_count = 0;
rc = pj_mutex_create_recursive(pool, NULL, &key->mutex);
if (rc != PJ_SUCCESS) {
key = ioqueue->free_list.next;
while (key != &ioqueue->free_list) {
pj_mutex_destroy(key->mutex);
key = key->next;
}
pj_mutex_destroy(ioqueue->ref_cnt_mutex);
return rc;
}
pj_list_push_back(&ioqueue->free_list, key);
}
#endif
/* Create and init ioqueue mutex */
rc = pj_lock_create_simple_mutex(pool, "ioq%p", &lock);
if (rc != PJ_SUCCESS)
return rc;
rc = pj_ioqueue_set_lock(ioqueue, lock, PJ_TRUE);
if (rc != PJ_SUCCESS)
return rc;
PJ_LOG(4, ("pjlib", "select() I/O Queue created (%p)", ioqueue));
*p_ioqueue = ioqueue;
return PJ_SUCCESS;
}
