952 lines
25 KiB
C
952 lines
25 KiB
C
/* $Id$ */
|
|
/*
|
|
* Copyright (C) 2003-2007 Benny Prijono <benny@prijono.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
#include <pjsip/sip_ua_layer.h>
|
|
#include <pjsip/sip_module.h>
|
|
#include <pjsip/sip_dialog.h>
|
|
#include <pjsip/sip_endpoint.h>
|
|
#include <pjsip/sip_errno.h>
|
|
#include <pjsip/sip_transaction.h>
|
|
#include <pj/os.h>
|
|
#include <pj/hash.h>
|
|
#include <pj/assert.h>
|
|
#include <pj/string.h>
|
|
#include <pj/pool.h>
|
|
#include <pj/log.h>
|
|
|
|
|
|
#define THIS_FILE "sip_ua_layer.c"
|
|
|
|
/*
|
|
* Static prototypes.
|
|
*/
|
|
static pj_status_t mod_ua_load(pjsip_endpoint *endpt);
|
|
static pj_status_t mod_ua_unload(void);
|
|
static pj_bool_t mod_ua_on_rx_request(pjsip_rx_data *rdata);
|
|
static pj_bool_t mod_ua_on_rx_response(pjsip_rx_data *rdata);
|
|
static void mod_ua_on_tsx_state(pjsip_transaction*, pjsip_event*);
|
|
|
|
|
|
extern long pjsip_dlg_lock_tls_id; /* defined in sip_dialog.c */
|
|
|
|
/* This struct is used to represent list of dialog inside a dialog set.
|
|
* We don't want to use pjsip_dialog for this purpose, to save some
|
|
* memory (about 100 bytes per dialog set).
|
|
*/
|
|
struct dlg_set_head
|
|
{
|
|
PJ_DECL_LIST_MEMBER(pjsip_dialog);
|
|
};
|
|
|
|
/* This struct represents a dialog set.
|
|
* This is the value that will be put in the UA's hash table.
|
|
*/
|
|
struct dlg_set
|
|
{
|
|
/* To put this node in free dlg_set nodes in UA. */
|
|
PJ_DECL_LIST_MEMBER(struct dlg_set);
|
|
|
|
/* This is the buffer to store this entry in the hash table. */
|
|
pj_hash_entry_buf ht_entry;
|
|
|
|
/* List of dialog in this dialog set. */
|
|
struct dlg_set_head dlg_list;
|
|
};
|
|
|
|
|
|
/*
|
|
* Module interface.
|
|
*/
|
|
static struct user_agent
|
|
{
|
|
pjsip_module mod;
|
|
pj_pool_t *pool;
|
|
pjsip_endpoint *endpt;
|
|
pj_mutex_t *mutex;
|
|
pj_hash_table_t *dlg_table;
|
|
pjsip_ua_init_param param;
|
|
struct dlg_set free_dlgset_nodes;
|
|
|
|
} mod_ua =
|
|
{
|
|
{
|
|
NULL, NULL, /* prev, next. */
|
|
{ "mod-ua", 6 }, /* Name. */
|
|
-1, /* Id */
|
|
PJSIP_MOD_PRIORITY_UA_PROXY_LAYER, /* Priority */
|
|
&mod_ua_load, /* load() */
|
|
NULL, /* start() */
|
|
NULL, /* stop() */
|
|
&mod_ua_unload, /* unload() */
|
|
&mod_ua_on_rx_request, /* on_rx_request() */
|
|
&mod_ua_on_rx_response, /* on_rx_response() */
|
|
NULL, /* on_tx_request. */
|
|
NULL, /* on_tx_response() */
|
|
&mod_ua_on_tsx_state, /* on_tsx_state() */
|
|
}
|
|
};
|
|
|
|
/*
|
|
* mod_ua_load()
|
|
*
|
|
* Called when module is being loaded by endpoint.
|
|
*/
|
|
static pj_status_t mod_ua_load(pjsip_endpoint *endpt)
|
|
{
|
|
pj_status_t status;
|
|
|
|
/* Initialize the user agent. */
|
|
mod_ua.endpt = endpt;
|
|
mod_ua.pool = pjsip_endpt_create_pool( endpt, "ua%p", PJSIP_POOL_LEN_UA,
|
|
PJSIP_POOL_INC_UA);
|
|
if (mod_ua.pool == NULL)
|
|
return PJ_ENOMEM;
|
|
|
|
status = pj_mutex_create_recursive(mod_ua.pool, " ua%p", &mod_ua.mutex);
|
|
if (status != PJ_SUCCESS)
|
|
return status;
|
|
|
|
mod_ua.dlg_table = pj_hash_create(mod_ua.pool, PJSIP_MAX_DIALOG_COUNT);
|
|
if (mod_ua.dlg_table == NULL)
|
|
return PJ_ENOMEM;
|
|
|
|
pj_list_init(&mod_ua.free_dlgset_nodes);
|
|
|
|
/* Initialize dialog lock. */
|
|
status = pj_thread_local_alloc(&pjsip_dlg_lock_tls_id);
|
|
if (status != PJ_SUCCESS)
|
|
return status;
|
|
|
|
pj_thread_local_set(pjsip_dlg_lock_tls_id, NULL);
|
|
|
|
return PJ_SUCCESS;
|
|
|
|
}
|
|
|
|
/*
|
|
* mod_ua_unload()
|
|
*
|
|
* Called when module is being unloaded.
|
|
*/
|
|
static pj_status_t mod_ua_unload(void)
|
|
{
|
|
pj_thread_local_free(pjsip_dlg_lock_tls_id);
|
|
pj_mutex_destroy(mod_ua.mutex);
|
|
|
|
/* Release pool */
|
|
if (mod_ua.pool) {
|
|
pjsip_endpt_release_pool( mod_ua.endpt, mod_ua.pool );
|
|
}
|
|
return PJ_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* mod_ua_on_tsx_stats()
|
|
*
|
|
* Called on changed on transaction state.
|
|
*/
|
|
static void mod_ua_on_tsx_state( pjsip_transaction *tsx, pjsip_event *e)
|
|
{
|
|
pjsip_dialog *dlg;
|
|
|
|
/* Get the dialog where this transaction belongs. */
|
|
dlg = (pjsip_dialog*) tsx->mod_data[mod_ua.mod.id];
|
|
|
|
/* If dialog instance has gone, it could mean that the dialog
|
|
* may has been destroyed.
|
|
*/
|
|
if (dlg == NULL)
|
|
return;
|
|
|
|
/* Hand over the event to the dialog. */
|
|
pjsip_dlg_on_tsx_state(dlg, tsx, e);
|
|
}
|
|
|
|
|
|
/*
|
|
* Init user agent module and register it to the endpoint.
|
|
*/
|
|
PJ_DEF(pj_status_t) pjsip_ua_init_module( pjsip_endpoint *endpt,
|
|
const pjsip_ua_init_param *prm)
|
|
{
|
|
pj_status_t status;
|
|
|
|
/* Check if module already registered. */
|
|
PJ_ASSERT_RETURN(mod_ua.mod.id == -1, PJ_EINVALIDOP);
|
|
|
|
/* Copy param, if exists. */
|
|
if (prm)
|
|
pj_memcpy(&mod_ua.param, prm, sizeof(pjsip_ua_init_param));
|
|
|
|
/* Register the module. */
|
|
status = pjsip_endpt_register_module(endpt, &mod_ua.mod);
|
|
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* Get the instance of the user agent.
|
|
*
|
|
*/
|
|
PJ_DEF(pjsip_user_agent*) pjsip_ua_instance(void)
|
|
{
|
|
return &mod_ua.mod;
|
|
}
|
|
|
|
|
|
/*
|
|
* Get the endpoint where this UA is currently registered.
|
|
*/
|
|
PJ_DEF(pjsip_endpoint*) pjsip_ua_get_endpt(pjsip_user_agent *ua)
|
|
{
|
|
PJ_UNUSED_ARG(ua);
|
|
pj_assert(ua == &mod_ua.mod);
|
|
return mod_ua.endpt;
|
|
}
|
|
|
|
|
|
/*
|
|
* Destroy the user agent layer.
|
|
*/
|
|
PJ_DEF(pj_status_t) pjsip_ua_destroy(void)
|
|
{
|
|
/* Check if module already destroyed. */
|
|
PJ_ASSERT_RETURN(mod_ua.mod.id != -1, PJ_EINVALIDOP);
|
|
|
|
return pjsip_endpt_unregister_module(mod_ua.endpt, &mod_ua.mod);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Create key to identify dialog set.
|
|
*/
|
|
/*
|
|
PJ_DEF(void) pjsip_ua_create_dlg_set_key( pj_pool_t *pool,
|
|
pj_str_t *set_key,
|
|
const pj_str_t *call_id,
|
|
const pj_str_t *local_tag)
|
|
{
|
|
PJ_ASSERT_ON_FAIL(pool && set_key && call_id && local_tag, return;);
|
|
|
|
set_key->slen = call_id->slen + local_tag->slen + 1;
|
|
set_key->ptr = (char*) pj_pool_alloc(pool, set_key->slen);
|
|
pj_assert(set_key->ptr != NULL);
|
|
|
|
pj_memcpy(set_key->ptr, call_id->ptr, call_id->slen);
|
|
set_key->ptr[call_id->slen] = '$';
|
|
pj_memcpy(set_key->ptr + call_id->slen + 1,
|
|
local_tag->ptr, local_tag->slen);
|
|
}
|
|
*/
|
|
|
|
/*
|
|
* Acquire one dlg_set node to be put in the hash table.
|
|
* This will first look in the free nodes list, then allocate
|
|
* a new one from UA's pool when one is not available.
|
|
*/
|
|
static struct dlg_set *alloc_dlgset_node(void)
|
|
{
|
|
struct dlg_set *set;
|
|
|
|
if (!pj_list_empty(&mod_ua.free_dlgset_nodes)) {
|
|
set = mod_ua.free_dlgset_nodes.next;
|
|
pj_list_erase(set);
|
|
return set;
|
|
} else {
|
|
set = PJ_POOL_ALLOC_T(mod_ua.pool, struct dlg_set);
|
|
return set;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Register new dialog. Called by pjsip_dlg_create_uac() and
|
|
* pjsip_dlg_create_uas();
|
|
*/
|
|
PJ_DEF(pj_status_t) pjsip_ua_register_dlg( pjsip_user_agent *ua,
|
|
pjsip_dialog *dlg )
|
|
{
|
|
/* Sanity check. */
|
|
PJ_ASSERT_RETURN(ua && dlg, PJ_EINVAL);
|
|
|
|
/* For all dialogs, local tag (inc hash) must has been initialized. */
|
|
PJ_ASSERT_RETURN(dlg->local.info && dlg->local.info->tag.slen &&
|
|
dlg->local.tag_hval != 0, PJ_EBUG);
|
|
|
|
/* For UAS dialog, remote tag (inc hash) must have been initialized. */
|
|
//PJ_ASSERT_RETURN(dlg->role==PJSIP_ROLE_UAC ||
|
|
// (dlg->role==PJSIP_ROLE_UAS && dlg->remote.info->tag.slen
|
|
// && dlg->remote.tag_hval != 0), PJ_EBUG);
|
|
|
|
/* Lock the user agent. */
|
|
pj_mutex_lock(mod_ua.mutex);
|
|
|
|
/* For UAC, check if there is existing dialog in the same set. */
|
|
if (dlg->role == PJSIP_ROLE_UAC) {
|
|
struct dlg_set *dlg_set;
|
|
|
|
dlg_set = (struct dlg_set*)
|
|
pj_hash_get( mod_ua.dlg_table, dlg->local.info->tag.ptr,
|
|
dlg->local.info->tag.slen,
|
|
&dlg->local.tag_hval);
|
|
|
|
if (dlg_set) {
|
|
/* This is NOT the first dialog in the dialog set.
|
|
* Just add this dialog in the list.
|
|
*/
|
|
pj_assert(dlg_set->dlg_list.next != (void*)&dlg_set->dlg_list);
|
|
pj_list_push_back(&dlg_set->dlg_list, dlg);
|
|
|
|
dlg->dlg_set = dlg_set;
|
|
|
|
} else {
|
|
/* This is the first dialog in the dialog set.
|
|
* Create the dialog set and add this dialog to it.
|
|
*/
|
|
dlg_set = alloc_dlgset_node();
|
|
pj_list_init(&dlg_set->dlg_list);
|
|
pj_list_push_back(&dlg_set->dlg_list, dlg);
|
|
|
|
dlg->dlg_set = dlg_set;
|
|
|
|
/* Register the dialog set in the hash table. */
|
|
pj_hash_set_np(mod_ua.dlg_table,
|
|
dlg->local.info->tag.ptr, dlg->local.info->tag.slen,
|
|
dlg->local.tag_hval, dlg_set->ht_entry, dlg_set);
|
|
}
|
|
|
|
} else {
|
|
/* For UAS, create the dialog set with a single dialog as member. */
|
|
struct dlg_set *dlg_set;
|
|
|
|
dlg_set = alloc_dlgset_node();
|
|
pj_list_init(&dlg_set->dlg_list);
|
|
pj_list_push_back(&dlg_set->dlg_list, dlg);
|
|
|
|
dlg->dlg_set = dlg_set;
|
|
|
|
pj_hash_set_np(mod_ua.dlg_table,
|
|
dlg->local.info->tag.ptr, dlg->local.info->tag.slen,
|
|
dlg->local.tag_hval, dlg_set->ht_entry, dlg_set);
|
|
}
|
|
|
|
/* Unlock user agent. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
|
|
/* Done. */
|
|
return PJ_SUCCESS;
|
|
}
|
|
|
|
|
|
PJ_DEF(pj_status_t) pjsip_ua_unregister_dlg( pjsip_user_agent *ua,
|
|
pjsip_dialog *dlg )
|
|
{
|
|
struct dlg_set *dlg_set;
|
|
pjsip_dialog *d;
|
|
|
|
/* Sanity-check arguments. */
|
|
PJ_ASSERT_RETURN(ua && dlg, PJ_EINVAL);
|
|
|
|
/* Check that dialog has been registered. */
|
|
PJ_ASSERT_RETURN(dlg->dlg_set, PJ_EINVALIDOP);
|
|
|
|
/* Lock user agent. */
|
|
pj_mutex_lock(mod_ua.mutex);
|
|
|
|
/* Find this dialog from the dialog set. */
|
|
dlg_set = (struct dlg_set*) dlg->dlg_set;
|
|
d = dlg_set->dlg_list.next;
|
|
while (d != (pjsip_dialog*)&dlg_set->dlg_list && d != dlg) {
|
|
d = d->next;
|
|
}
|
|
|
|
if (d != dlg) {
|
|
pj_assert(!"Dialog is not registered!");
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
return PJ_EINVALIDOP;
|
|
}
|
|
|
|
/* Remove this dialog from the list. */
|
|
pj_list_erase(dlg);
|
|
|
|
/* If dialog list is empty, remove the dialog set from the hash table. */
|
|
if (pj_list_empty(&dlg_set->dlg_list)) {
|
|
pj_hash_set(NULL, mod_ua.dlg_table, dlg->local.info->tag.ptr,
|
|
dlg->local.info->tag.slen, dlg->local.tag_hval, NULL);
|
|
|
|
/* Return dlg_set to free nodes. */
|
|
pj_list_push_back(&mod_ua.free_dlgset_nodes, dlg_set);
|
|
}
|
|
|
|
/* Unlock user agent. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
|
|
/* Done. */
|
|
return PJ_SUCCESS;
|
|
}
|
|
|
|
|
|
PJ_DEF(pjsip_dialog*) pjsip_rdata_get_dlg( pjsip_rx_data *rdata )
|
|
{
|
|
return (pjsip_dialog*) rdata->endpt_info.mod_data[mod_ua.mod.id];
|
|
}
|
|
|
|
PJ_DEF(pjsip_dialog*) pjsip_tsx_get_dlg( pjsip_transaction *tsx )
|
|
{
|
|
return (pjsip_dialog*) tsx->mod_data[mod_ua.mod.id];
|
|
}
|
|
|
|
|
|
/*
|
|
* Find a dialog.
|
|
*/
|
|
PJ_DEF(pjsip_dialog*) pjsip_ua_find_dialog(const pj_str_t *call_id,
|
|
const pj_str_t *local_tag,
|
|
const pj_str_t *remote_tag,
|
|
pj_bool_t lock_dialog)
|
|
{
|
|
struct dlg_set *dlg_set;
|
|
pjsip_dialog *dlg;
|
|
|
|
PJ_ASSERT_RETURN(call_id && local_tag && remote_tag, NULL);
|
|
|
|
/* Lock user agent. */
|
|
pj_mutex_lock(mod_ua.mutex);
|
|
|
|
/* Lookup the dialog set. */
|
|
dlg_set = (struct dlg_set*)
|
|
pj_hash_get(mod_ua.dlg_table, local_tag->ptr, local_tag->slen,
|
|
NULL);
|
|
if (dlg_set == NULL) {
|
|
/* Not found */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
return NULL;
|
|
}
|
|
|
|
/* Dialog set is found, now find the matching dialog based on the
|
|
* remote tag.
|
|
*/
|
|
dlg = dlg_set->dlg_list.next;
|
|
while (dlg != (pjsip_dialog*)&dlg_set->dlg_list) {
|
|
if (pj_strcmp(&dlg->remote.info->tag, remote_tag) == 0)
|
|
break;
|
|
dlg = dlg->next;
|
|
}
|
|
|
|
if (dlg == (pjsip_dialog*)&dlg_set->dlg_list) {
|
|
/* Not found */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
return NULL;
|
|
}
|
|
|
|
/* Dialog has been found. It SHOULD have the right Call-ID!! */
|
|
PJ_ASSERT_ON_FAIL(pj_strcmp(&dlg->call_id->id, call_id)==0,
|
|
{pj_mutex_unlock(mod_ua.mutex); return NULL;});
|
|
|
|
if (lock_dialog) {
|
|
if (pjsip_dlg_try_inc_lock(dlg) != PJ_SUCCESS) {
|
|
|
|
/*
|
|
* Unable to acquire dialog's lock while holding the user
|
|
* agent's mutex. Release the UA mutex before retrying once
|
|
* more.
|
|
*
|
|
* THIS MAY CAUSE RACE CONDITION!
|
|
*/
|
|
|
|
/* Unlock user agent. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
/* Lock dialog */
|
|
pjsip_dlg_inc_lock(dlg);
|
|
|
|
} else {
|
|
/* Unlock user agent. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
}
|
|
|
|
} else {
|
|
/* Unlock user agent. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
}
|
|
|
|
return dlg;
|
|
}
|
|
|
|
|
|
/*
|
|
* Find the first dialog in dialog set in hash table for an incoming message.
|
|
*/
|
|
static struct dlg_set *find_dlg_set_for_msg( pjsip_rx_data *rdata )
|
|
{
|
|
/* CANCEL message doesn't have To tag, so we must lookup the dialog
|
|
* by finding the INVITE UAS transaction being cancelled.
|
|
*/
|
|
if (rdata->msg_info.cseq->method.id == PJSIP_CANCEL_METHOD) {
|
|
|
|
pjsip_dialog *dlg;
|
|
|
|
/* Create key for the rdata, but this time, use INVITE as the
|
|
* method.
|
|
*/
|
|
pj_str_t key;
|
|
pjsip_role_e role;
|
|
pjsip_transaction *tsx;
|
|
|
|
if (rdata->msg_info.msg->type == PJSIP_REQUEST_MSG)
|
|
role = PJSIP_ROLE_UAS;
|
|
else
|
|
role = PJSIP_ROLE_UAC;
|
|
|
|
pjsip_tsx_create_key(rdata->tp_info.pool, &key, role,
|
|
pjsip_get_invite_method(), rdata);
|
|
|
|
/* Lookup the INVITE transaction */
|
|
tsx = pjsip_tsx_layer_find_tsx(&key, PJ_TRUE);
|
|
|
|
/* We should find the dialog attached to the INVITE transaction */
|
|
if (tsx) {
|
|
dlg = (pjsip_dialog*) tsx->mod_data[mod_ua.mod.id];
|
|
pj_mutex_unlock(tsx->mutex);
|
|
|
|
/* Dlg may be NULL on some extreme condition
|
|
* (e.g. during debugging where initially there is a dialog)
|
|
*/
|
|
return dlg ? (struct dlg_set*) dlg->dlg_set : NULL;
|
|
|
|
} else {
|
|
return NULL;
|
|
}
|
|
|
|
|
|
} else {
|
|
pj_str_t *tag;
|
|
struct dlg_set *dlg_set;
|
|
|
|
if (rdata->msg_info.msg->type == PJSIP_REQUEST_MSG)
|
|
tag = &rdata->msg_info.to->tag;
|
|
else
|
|
tag = &rdata->msg_info.from->tag;
|
|
|
|
/* Lookup the dialog set. */
|
|
dlg_set = (struct dlg_set*)
|
|
pj_hash_get(mod_ua.dlg_table, tag->ptr, tag->slen, NULL);
|
|
return dlg_set;
|
|
}
|
|
}
|
|
|
|
/* On received requests. */
|
|
static pj_bool_t mod_ua_on_rx_request(pjsip_rx_data *rdata)
|
|
{
|
|
struct dlg_set *dlg_set;
|
|
pj_str_t *from_tag;
|
|
pjsip_dialog *dlg;
|
|
pj_status_t status;
|
|
|
|
/* Optimized path: bail out early if request is not CANCEL and it doesn't
|
|
* have To tag
|
|
*/
|
|
if (rdata->msg_info.to->tag.slen == 0 &&
|
|
rdata->msg_info.msg->line.req.method.id != PJSIP_CANCEL_METHOD)
|
|
{
|
|
return PJ_FALSE;
|
|
}
|
|
|
|
retry_on_deadlock:
|
|
|
|
/* Lock user agent before looking up the dialog hash table. */
|
|
pj_mutex_lock(mod_ua.mutex);
|
|
|
|
/* Lookup the dialog set, based on the To tag header. */
|
|
dlg_set = find_dlg_set_for_msg(rdata);
|
|
|
|
/* If dialog is not found, respond with 481 (Call/Transaction
|
|
* Does Not Exist).
|
|
*/
|
|
if (dlg_set == NULL) {
|
|
/* Unable to find dialog. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
|
|
if (rdata->msg_info.msg->line.req.method.id != PJSIP_ACK_METHOD) {
|
|
PJ_LOG(5,(THIS_FILE,
|
|
"Unable to find dialogset for %s, answering with 481",
|
|
pjsip_rx_data_get_info(rdata)));
|
|
|
|
/* Respond with 481 . */
|
|
pjsip_endpt_respond_stateless( mod_ua.endpt, rdata, 481, NULL,
|
|
NULL, NULL );
|
|
}
|
|
return PJ_TRUE;
|
|
}
|
|
|
|
/* Dialog set has been found.
|
|
* Find the dialog in the dialog set based on the content of the remote
|
|
* tag.
|
|
*/
|
|
from_tag = &rdata->msg_info.from->tag;
|
|
dlg = dlg_set->dlg_list.next;
|
|
while (dlg != (pjsip_dialog*)&dlg_set->dlg_list) {
|
|
|
|
if (pj_strcmp(&dlg->remote.info->tag, from_tag) == 0)
|
|
break;
|
|
|
|
dlg = dlg->next;
|
|
}
|
|
|
|
/* Dialog may not be found, e.g. in this case:
|
|
* - UAC sends SUBSCRIBE, then UAS sends NOTIFY before answering
|
|
* SUBSCRIBE request with 2xx.
|
|
*
|
|
* In this case, we can accept the request ONLY when the original
|
|
* dialog still has empty To tag.
|
|
*/
|
|
if (dlg == (pjsip_dialog*)&dlg_set->dlg_list) {
|
|
|
|
pjsip_dialog *first_dlg = dlg_set->dlg_list.next;
|
|
|
|
if (first_dlg->remote.info->tag.slen != 0) {
|
|
/* Not found. Mulfunction UAC? */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
|
|
if (rdata->msg_info.msg->line.req.method.id != PJSIP_ACK_METHOD) {
|
|
PJ_LOG(5,(THIS_FILE,
|
|
"Unable to find dialog for %s, answering with 481",
|
|
pjsip_rx_data_get_info(rdata)));
|
|
|
|
pjsip_endpt_respond_stateless(mod_ua.endpt, rdata,
|
|
PJSIP_SC_CALL_TSX_DOES_NOT_EXIST,
|
|
NULL, NULL, NULL);
|
|
} else {
|
|
PJ_LOG(5,(THIS_FILE,
|
|
"Unable to find dialog for %s",
|
|
pjsip_rx_data_get_info(rdata)));
|
|
}
|
|
return PJ_TRUE;
|
|
}
|
|
|
|
dlg = first_dlg;
|
|
}
|
|
|
|
/* Mark the dialog id of the request. */
|
|
rdata->endpt_info.mod_data[mod_ua.mod.id] = dlg;
|
|
|
|
/* Try to lock the dialog */
|
|
PJ_LOG(6,(dlg->obj_name, "UA layer acquiring dialog lock for request"));
|
|
status = pjsip_dlg_try_inc_lock(dlg);
|
|
if (status != PJ_SUCCESS) {
|
|
/* Failed to acquire dialog mutex immediately, this could be
|
|
* because of deadlock. Release UA mutex, yield, and retry
|
|
* the whole thing once again.
|
|
*/
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
pj_thread_sleep(0);
|
|
goto retry_on_deadlock;
|
|
}
|
|
|
|
/* Done with processing in UA layer, release lock */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
|
|
/* Pass to dialog. */
|
|
pjsip_dlg_on_rx_request(dlg, rdata);
|
|
|
|
/* Unlock the dialog. This may destroy the dialog */
|
|
pjsip_dlg_dec_lock(dlg);
|
|
|
|
/* Report as handled. */
|
|
return PJ_TRUE;
|
|
}
|
|
|
|
|
|
/* On rx response notification.
|
|
*/
|
|
static pj_bool_t mod_ua_on_rx_response(pjsip_rx_data *rdata)
|
|
{
|
|
pjsip_transaction *tsx;
|
|
struct dlg_set *dlg_set;
|
|
pjsip_dialog *dlg;
|
|
pj_status_t status;
|
|
|
|
/*
|
|
* Find the dialog instance for the response.
|
|
* All outgoing dialog requests are sent statefully, which means
|
|
* there will be an UAC transaction associated with this response,
|
|
* and the dialog instance will be recorded in that transaction.
|
|
*
|
|
* But even when transaction is found, there is possibility that
|
|
* the response is a forked response.
|
|
*/
|
|
|
|
retry_on_deadlock:
|
|
|
|
dlg = NULL;
|
|
|
|
/* Lock user agent dlg table before we're doing anything. */
|
|
pj_mutex_lock(mod_ua.mutex);
|
|
|
|
/* Check if transaction is present. */
|
|
tsx = pjsip_rdata_get_tsx(rdata);
|
|
if (tsx) {
|
|
/* Check if dialog is present in the transaction. */
|
|
dlg = pjsip_tsx_get_dlg(tsx);
|
|
if (!dlg) {
|
|
/* Unlock dialog hash table. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
return PJ_FALSE;
|
|
}
|
|
|
|
/* Get the dialog set. */
|
|
dlg_set = (struct dlg_set*) dlg->dlg_set;
|
|
|
|
/* Even if transaction is found and (candidate) dialog has been
|
|
* identified, it's possible that the request has forked.
|
|
*/
|
|
|
|
} else {
|
|
/* Transaction is not present.
|
|
* Check if this is a 2xx/OK response to INVITE, which in this
|
|
* case the response will be handled directly by the
|
|
* dialog.
|
|
*/
|
|
pjsip_cseq_hdr *cseq_hdr = rdata->msg_info.cseq;
|
|
|
|
if (cseq_hdr->method.id != PJSIP_INVITE_METHOD ||
|
|
rdata->msg_info.msg->line.status.code / 100 != 2)
|
|
{
|
|
/* Not a 2xx response to INVITE.
|
|
* This must be some stateless response sent by other modules,
|
|
* or a very late response.
|
|
*/
|
|
/* Unlock dialog hash table. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
return PJ_FALSE;
|
|
}
|
|
|
|
|
|
/* Get the dialog set. */
|
|
dlg_set = (struct dlg_set*)
|
|
pj_hash_get(mod_ua.dlg_table,
|
|
rdata->msg_info.from->tag.ptr,
|
|
rdata->msg_info.from->tag.slen,
|
|
NULL);
|
|
|
|
if (!dlg_set) {
|
|
/* Unlock dialog hash table. */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
|
|
/* Strayed 2xx response!! */
|
|
PJ_LOG(4,(THIS_FILE,
|
|
"Received strayed 2xx response (no dialog is found)"
|
|
" from %s:%d: %s",
|
|
rdata->pkt_info.src_name, rdata->pkt_info.src_port,
|
|
pjsip_rx_data_get_info(rdata)));
|
|
|
|
return PJ_TRUE;
|
|
}
|
|
}
|
|
|
|
/* At this point, we must have the dialog set, and the dialog set
|
|
* must have a dialog in the list.
|
|
*/
|
|
pj_assert(dlg_set && !pj_list_empty(&dlg_set->dlg_list));
|
|
|
|
/* Check for forked response.
|
|
* Request will fork only for the initial INVITE request.
|
|
*/
|
|
|
|
//This doesn't work when there is authentication challenge, since
|
|
//first_cseq evaluation will yield false.
|
|
//if (rdata->msg_info.cseq->method.id == PJSIP_INVITE_METHOD &&
|
|
// rdata->msg_info.cseq->cseq == dlg_set->dlg_list.next->local.first_cseq)
|
|
|
|
if (rdata->msg_info.cseq->method.id == PJSIP_INVITE_METHOD) {
|
|
|
|
int st_code = rdata->msg_info.msg->line.status.code;
|
|
pj_str_t *to_tag = &rdata->msg_info.to->tag;
|
|
|
|
dlg = dlg_set->dlg_list.next;
|
|
|
|
while (dlg != (pjsip_dialog*)&dlg_set->dlg_list) {
|
|
|
|
/* If there is dialog with no remote tag (i.e. dialog has not
|
|
* been established yet), then send this response to that
|
|
* dialog.
|
|
*/
|
|
if (dlg->remote.info->tag.slen == 0)
|
|
break;
|
|
|
|
/* Otherwise find the one with matching To tag. */
|
|
if (pj_strcmp(to_tag, &dlg->remote.info->tag) == 0)
|
|
break;
|
|
|
|
dlg = dlg->next;
|
|
}
|
|
|
|
/* If no dialog with matching remote tag is found, this must be
|
|
* a forked response. Respond to this ONLY when response is non-100
|
|
* provisional response OR a 2xx response.
|
|
*/
|
|
if (dlg == (pjsip_dialog*)&dlg_set->dlg_list &&
|
|
((st_code/100==1 && st_code!=100) || st_code/100==2))
|
|
{
|
|
|
|
PJ_LOG(5,(THIS_FILE,
|
|
"Received forked %s for existing dialog %s",
|
|
pjsip_rx_data_get_info(rdata),
|
|
dlg_set->dlg_list.next->obj_name));
|
|
|
|
/* Report to application about forked condition.
|
|
* Application can either create a dialog or ignore the response.
|
|
*/
|
|
if (mod_ua.param.on_dlg_forked) {
|
|
dlg = (*mod_ua.param.on_dlg_forked)(dlg_set->dlg_list.next,
|
|
rdata);
|
|
} else {
|
|
dlg = dlg_set->dlg_list.next;
|
|
|
|
PJ_LOG(4,(THIS_FILE,
|
|
"Unhandled forked %s from %s:%d, response will be "
|
|
"handed over to the first dialog",
|
|
pjsip_rx_data_get_info(rdata),
|
|
rdata->pkt_info.src_name, rdata->pkt_info.src_port));
|
|
}
|
|
|
|
} else if (dlg == (pjsip_dialog*)&dlg_set->dlg_list) {
|
|
|
|
/* For 100 or non-2xx response which has different To tag,
|
|
* pass the response to the first dialog.
|
|
*/
|
|
|
|
dlg = dlg_set->dlg_list.next;
|
|
|
|
}
|
|
|
|
} else {
|
|
/* Either this is a non-INVITE response, or subsequent INVITE
|
|
* within dialog. The dialog should have been identified when
|
|
* the transaction was found.
|
|
*/
|
|
pj_assert(tsx != NULL);
|
|
pj_assert(dlg != NULL);
|
|
}
|
|
|
|
/* The dialog must have been found. */
|
|
pj_assert(dlg != NULL);
|
|
|
|
/* Put the dialog instance in the rdata. */
|
|
rdata->endpt_info.mod_data[mod_ua.mod.id] = dlg;
|
|
|
|
/* Attempt to acquire lock to the dialog. */
|
|
PJ_LOG(6,(dlg->obj_name, "UA layer acquiring dialog lock for response"));
|
|
status = pjsip_dlg_try_inc_lock(dlg);
|
|
if (status != PJ_SUCCESS) {
|
|
/* Failed to acquire dialog mutex. This could indicate a deadlock
|
|
* situation, and for safety, try to avoid deadlock by releasing
|
|
* UA mutex, yield, and retry the whole processing once again.
|
|
*/
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
pj_thread_sleep(0);
|
|
goto retry_on_deadlock;
|
|
}
|
|
|
|
/* We're done with processing in the UA layer, we can release the mutex */
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
|
|
/* Pass the response to the dialog. */
|
|
pjsip_dlg_on_rx_response(dlg, rdata);
|
|
|
|
/* Unlock the dialog. This may destroy the dialog. */
|
|
pjsip_dlg_dec_lock(dlg);
|
|
|
|
/* Done. */
|
|
return PJ_TRUE;
|
|
}
|
|
|
|
|
|
#if PJ_LOG_MAX_LEVEL >= 3
|
|
static void print_dialog( const char *title,
|
|
pjsip_dialog *dlg, char *buf, pj_size_t size)
|
|
{
|
|
int len;
|
|
char userinfo[128];
|
|
|
|
len = pjsip_hdr_print_on(dlg->remote.info, userinfo, sizeof(userinfo));
|
|
if (len < 1)
|
|
pj_ansi_strcpy(userinfo, "<--uri too long-->");
|
|
else
|
|
userinfo[len] = '\0';
|
|
|
|
len = pj_ansi_snprintf(buf, size, "%s[%s] %s",
|
|
title,
|
|
(dlg->state==PJSIP_DIALOG_STATE_NULL ? " - " :
|
|
"est"),
|
|
userinfo);
|
|
if (len < 1 || len >= (int)size) {
|
|
pj_ansi_strcpy(buf, "<--uri too long-->");
|
|
} else
|
|
buf[len] = '\0';
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Dump user agent contents (e.g. all dialogs).
|
|
*/
|
|
PJ_DEF(void) pjsip_ua_dump(pj_bool_t detail)
|
|
{
|
|
#if PJ_LOG_MAX_LEVEL >= 3
|
|
pj_hash_iterator_t itbuf, *it;
|
|
char dlginfo[128];
|
|
|
|
pj_mutex_lock(mod_ua.mutex);
|
|
|
|
PJ_LOG(3, (THIS_FILE, "Number of dialog sets: %u",
|
|
pj_hash_count(mod_ua.dlg_table)));
|
|
|
|
if (detail && pj_hash_count(mod_ua.dlg_table)) {
|
|
PJ_LOG(3, (THIS_FILE, "Dumping dialog sets:"));
|
|
it = pj_hash_first(mod_ua.dlg_table, &itbuf);
|
|
for (; it != NULL; it = pj_hash_next(mod_ua.dlg_table, it)) {
|
|
struct dlg_set *dlg_set;
|
|
pjsip_dialog *dlg;
|
|
const char *title;
|
|
|
|
dlg_set = (struct dlg_set*) pj_hash_this(mod_ua.dlg_table, it);
|
|
if (!dlg_set || pj_list_empty(&dlg_set->dlg_list)) continue;
|
|
|
|
/* First dialog in dialog set. */
|
|
dlg = dlg_set->dlg_list.next;
|
|
if (dlg->role == PJSIP_ROLE_UAC)
|
|
title = " [out] ";
|
|
else
|
|
title = " [in] ";
|
|
|
|
print_dialog(title, dlg, dlginfo, sizeof(dlginfo));
|
|
PJ_LOG(3,(THIS_FILE, "%s", dlginfo));
|
|
|
|
/* Next dialog in dialog set (forked) */
|
|
dlg = dlg->next;
|
|
while (dlg != (pjsip_dialog*) &dlg_set->dlg_list) {
|
|
print_dialog(" [forked] ", dlg, dlginfo, sizeof(dlginfo));
|
|
dlg = dlg->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
pj_mutex_unlock(mod_ua.mutex);
|
|
#endif
|
|
}
|
|
|