/**
* replicates the remote deletion of a dialog locally
* by reading the relevant information using the Binary Packet Interface
*/
int dlg_replicated_delete(void)
{
str call_id, from_tag, to_tag;
unsigned int dir, dst_leg;
struct dlg_cell *dlg;
int old_state, new_state, unref, ret;
bin_pop_str(&call_id);
bin_pop_str(&from_tag);
bin_pop_str(&to_tag);
LM_DBG("Deleting dialog with callid: %.*s\n", call_id.len, call_id.s);
dlg = get_dlg(&call_id, &from_tag, &to_tag, &dir, &dst_leg);
if (!dlg) {
LM_ERR("dialog not found (callid: |%.*s| ftag: |%.*s|\n",
call_id.len, call_id.s, from_tag.len, from_tag.s);
return -1;
}
destroy_linkers(dlg->profile_links);
dlg->profile_links = NULL;
next_state_dlg(dlg, DLG_EVENT_REQBYE, &old_state, &new_state, &unref);
if (old_state == new_state) {
LM_ERR("duplicate dialog delete request (callid: |%.*s|"
"ftag: |%.*s|\n", call_id.len, call_id.s, from_tag.len, from_tag.s);
return -1;
}
ret = remove_dlg_timer(&dlg->tl);
if (ret < 0) {
LM_CRIT("unable to unlink the timer on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
} else if (ret > 0) {
LM_DBG("dlg expired (not in timer list) on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
} else {
/* dialog sucessfully removed from timer -> unref */
unref++;
}
unref_dlg(dlg, 1 + unref);
if_update_stat(dlg_enable_stats, active_dlgs, -1);
return 0;
}
static int w_dlg_get(struct sip_msg *msg, char *ci, char *ft, char *tt)
{
dlg_cell_t *dlg = NULL;
str sc = {0,0};
str sf = {0,0};
str st = {0,0};
unsigned int dir = 0;
if(ci==0 || ft==0 || tt==0)
{
LM_ERR("invalid parameters\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)ci, &sc)!=0)
{
LM_ERR("unable to get Call-ID\n");
return -1;
}
if(sc.s==NULL || sc.len == 0)
{
LM_ERR("invalid Call-ID parameter\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)ft, &sf)!=0)
{
LM_ERR("unable to get From tag\n");
return -1;
}
if(sf.s==NULL || sf.len == 0)
{
LM_ERR("invalid From tag parameter\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)tt, &st)!=0)
{
LM_ERR("unable to get To Tag\n");
return -1;
}
if(st.s==NULL || st.len == 0)
{
LM_ERR("invalid To tag parameter\n");
return -1;
}
dlg = get_dlg(&sc, &sf, &st, &dir);
if(dlg==NULL)
return -1;
/* set shorcut to dialog internal unique id */
_dlg_ctx.iuid.h_entry = dlg->h_entry;
_dlg_ctx.iuid.h_id = dlg->h_id;
_dlg_ctx.dir = dir;
dlg_release(dlg);
return 1;
}
static int w_dlg_get(struct sip_msg *msg, char *ci, char *ft, char *tt)
{
struct dlg_cell *dlg = NULL;
str sc = {0,0};
str sf = {0,0};
str st = {0,0};
unsigned int dir = 0;
if(ci==0 || ft==0 || tt==0)
{
LM_ERR("invalid parameters\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)ci, &sc)!=0)
{
LM_ERR("unable to get Call-ID\n");
return -1;
}
if(sc.s==NULL || sc.len == 0)
{
LM_ERR("invalid Call-ID parameter\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)ft, &sf)!=0)
{
LM_ERR("unable to get From tag\n");
return -1;
}
if(sf.s==NULL || sf.len == 0)
{
LM_ERR("invalid From tag parameter\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)tt, &st)!=0)
{
LM_ERR("unable to get To Tag\n");
return -1;
}
if(st.s==NULL || st.len == 0)
{
LM_ERR("invalid To tag parameter\n");
return -1;
}
dlg = get_dlg(&sc, &sf, &st, &dir);
if(dlg==NULL)
return -1;
unref_dlg(dlg, 1);
set_current_dialog(msg, dlg);
_dlg_ctx.dlg = dlg;
_dlg_ctx.dir = dir;
return 1;
}
str * api_get_dlg_variable(str *callid, str *ftag, str *ttag, str *key) {
struct dlg_cell *dlg;
unsigned int dir = DLG_DIR_NONE;
dlg = get_dlg(callid, ftag, ttag, &dir); //increments ref count!
if (!dlg) {
LM_ERR("Asked to tear down non existent dialog\n");
return NULL;
}
unref_dlg(dlg, 1);
return get_dlg_variable(dlg, key);
}
/* Wrapper for terminating dialog from API - from other modules */
int w_api_terminate_dlg(str *callid, str *ftag, str *ttag, str *hdrs, str* reason) {
struct dlg_cell *dlg;
unsigned int dir = DLG_DIR_NONE;
dlg = get_dlg(callid, ftag, ttag, &dir); //increments ref count!
if (!dlg) {
LM_ERR("Asked to tear down non existent dialog\n");
return -1;
}
unref_dlg(dlg, 1);
return dlg_terminate(dlg, NULL, NULL/*reason*/, 2, hdrs);
}
/*!
*
*/
dlg_cell_t *dlg_lookup_msg_dialog(sip_msg_t *msg, unsigned int *dir)
{
dlg_cell_t *dlg = NULL;
str callid;
str ftag;
str ttag;
unsigned int vdir;
/* Retrieve the current dialog */
dlg = dlg_get_ctx_dialog();
if(dlg!=NULL) {
if(dir) {
if (pre_match_parse(msg, &callid, &ftag, &ttag, 0)<0) {
dlg_release(dlg);
return NULL;
}
if (dlg->tag[DLG_CALLER_LEG].len == ftag.len &&
strncmp(dlg->tag[DLG_CALLER_LEG].s, ftag.s, ftag.len)==0 &&
strncmp(dlg->callid.s, callid.s, callid.len)==0) {
*dir = DLG_DIR_DOWNSTREAM;
} else {
if (ttag.len>0 && dlg->tag[DLG_CALLER_LEG].len == ttag.len &&
strncmp(dlg->tag[DLG_CALLER_LEG].s, ttag.s, ttag.len)==0 &&
strncmp(dlg->callid.s, callid.s, callid.len)==0) {
*dir = DLG_DIR_UPSTREAM;
}
}
}
return dlg;
}
if (pre_match_parse(msg, &callid, &ftag, &ttag, 0)<0)
return NULL;
vdir = DLG_DIR_NONE;
dlg = get_dlg(&callid, &ftag, &ttag, &vdir);
if (dlg==NULL){
LM_DBG("dlg with callid '%.*s' not found\n",
msg->callid->body.len, msg->callid->body.s);
return NULL;
}
if(dir) *dir = vdir;
return dlg;
}
int register_dlgcb_nodlg(str *callid, str *ftag, str *ttag,
int types, dialog_cb f,
void *param, param_free_cb ff )
{
struct dlg_cell *dlg;
unsigned int dir = DLG_DIR_NONE;
dlg = get_dlg(callid, ftag, ttag, &dir); //increments ref count!
if (!dlg) {
LM_ERR("Can't find dialog to register callback\n");
return -1;
}
int ret = register_dlgcb(dlg, types, f, param, ff);
unref_dlg(dlg, 1);
return ret;
}
struct dlg_cell *dlg_get_msg_dialog(sip_msg_t *msg)
{
struct dlg_cell *dlg = NULL;
str callid;
str ftag;
str ttag;
unsigned int dir;
/* Retrieve the current dialog */
dlg = dlg_get_ctx_dialog();
if (dlg != NULL )
return dlg;
if (pre_match_parse(msg, &callid, &ftag, &ttag, 0) < 0)
return NULL ;
dir = DLG_DIR_NONE;
dlg = get_dlg(&callid, &ftag, &ttag, &dir);
if (dlg == NULL ) {
LM_DBG("dlg with callid '%.*s' not found\n",
msg->callid->body.len, msg->callid->body.s);
return NULL ;
}
return dlg;
}
/*!
* \brief Function that is registered as RR callback for dialog tracking
*
* Function that is registered as RR callback for dialog tracking. It
* sets the appropriate events after the SIP method and run the state
* machine to update the dialog state. It updates then the saved
* dialogs and also the statistics.
* \param req SIP request
* \param route_params record-route parameter
* \param param unused
*/
void dlg_onroute(struct sip_msg* req, str *route_params, void *param)
{
dlg_cell_t *dlg;
dlg_iuid_t *iuid;
str val, callid, ftag, ttag;
int h_entry, h_id, new_state, old_state, unref, event, timeout, reset;
unsigned int dir;
int ret = 0;
dlg = dlg_get_ctx_dialog();
if (dlg!=NULL) {
dlg_release(dlg);
return;
}
/* skip initial requests - they may end up here because of the
* preloaded route */
if ( (!req->to && parse_headers(req, HDR_TO_F,0)<0) || !req->to ) {
LM_ERR("bad request or missing TO hdr :-/\n");
return;
}
if ( get_to(req)->tag_value.len==0 )
return;
dlg = 0;
dir = DLG_DIR_NONE;
if ( seq_match_mode!=SEQ_MATCH_NO_ID ) {
if( d_rrb.get_route_param( req, &rr_param, &val)!=0) {
LM_DBG("Route param '%.*s' not found\n", rr_param.len,rr_param.s);
if (seq_match_mode==SEQ_MATCH_STRICT_ID )
return;
} else {
LM_DBG("route param is '%.*s' (len=%d)\n",val.len,val.s,val.len);
if ( parse_dlg_rr_param( val.s, val.s+val.len, &h_entry, &h_id)<0 )
return;
dlg = dlg_lookup(h_entry, h_id);
if (dlg==0) {
LM_WARN("unable to find dialog for %.*s "
"with route param '%.*s' [%u:%u]\n",
req->first_line.u.request.method.len,
req->first_line.u.request.method.s,
val.len,val.s, h_entry, h_id);
if (seq_match_mode==SEQ_MATCH_STRICT_ID )
return;
} else {
if (pre_match_parse( req, &callid, &ftag, &ttag, 1)<0) {
// lookup_dlg has incremented the ref count by 1
dlg_release(dlg);
return;
}
if (match_dialog( dlg, &callid, &ftag, &ttag, &dir )==0) {
LM_WARN("tight matching failed for %.*s with callid='%.*s'/%d, "
"ftag='%.*s'/%d, ttag='%.*s'/%d and direction=%d\n",
req->first_line.u.request.method.len,
req->first_line.u.request.method.s,
callid.len, callid.s, callid.len,
ftag.len, ftag.s, ftag.len,
ttag.len, ttag.s, ttag.len, dir);
LM_WARN("dialog identification elements are callid='%.*s'/%d, "
"caller tag='%.*s'/%d, callee tag='%.*s'/%d\n",
dlg->callid.len, dlg->callid.s, dlg->callid.len,
dlg->tag[DLG_CALLER_LEG].len, dlg->tag[DLG_CALLER_LEG].s,
dlg->tag[DLG_CALLER_LEG].len,
dlg->tag[DLG_CALLEE_LEG].len, dlg->tag[DLG_CALLEE_LEG].s,
dlg->tag[DLG_CALLEE_LEG].len);
// lookup_dlg has incremented the ref count by 1
dlg_release(dlg);
// Reset variables in order to do a lookup based on SIP-Elements.
dlg = 0;
dir = DLG_DIR_NONE;
if (seq_match_mode==SEQ_MATCH_STRICT_ID )
return;
}
}
}
}
if (dlg==0) {
if (pre_match_parse( req, &callid, &ftag, &ttag, 1)<0)
return;
/* TODO - try to use the RR dir detection to speed up here the
* search -bogdan */
dlg = get_dlg(&callid, &ftag, &ttag, &dir);
if (dlg==0){
LM_DBG("Callid '%.*s' not found\n",
req->callid->body.len, req->callid->body.s);
return;
}
}
/* set current dialog - re-use ref increment from dlg_get() above */
set_current_dialog( req, dlg);
_dlg_ctx.iuid.h_entry = dlg->h_entry;
_dlg_ctx.iuid.h_id = dlg->h_id;
if (req->first_line.u.request.method_value != METHOD_ACK) {
iuid = dlg_get_iuid_shm_clone(dlg);
if(iuid!=NULL)
{
/* register callback for the replies of this request */
if ( d_tmb.register_tmcb( req, 0, TMCB_RESPONSE_IN|TMCB_ON_FAILURE,
dlg_onreply, (void*)iuid, dlg_iuid_sfree)<0 ) {
LM_ERR("failed to register TMCB (3)\n");
shm_free(iuid);
}
iuid = NULL;
}
}
/* run state machine */
switch ( req->first_line.u.request.method_value ) {
case METHOD_PRACK:
event = DLG_EVENT_REQPRACK; break;
case METHOD_ACK:
event = DLG_EVENT_REQACK; break;
case METHOD_BYE:
event = DLG_EVENT_REQBYE; break;
default:
event = DLG_EVENT_REQ;
}
next_state_dlg( dlg, event, &old_state, &new_state, &unref);
CURR_DLG_ID = req->id;
CURR_DLG_LIFETIME = (unsigned int)(time(0))-dlg->start_ts;
CURR_DLG_STATUS = new_state;
dlg_run_event_route(dlg, req, old_state, new_state);
/* delay deletion of dialog until transaction has died off in order
* to absorb in-air messages */
if (new_state==DLG_STATE_DELETED && old_state!=DLG_STATE_DELETED) {
iuid = dlg_get_iuid_shm_clone(dlg);
if(iuid!=NULL) {
if ( d_tmb.register_tmcb(req, NULL, TMCB_DESTROY,
unref_dlg_from_cb, (void*)iuid, dlg_iuid_sfree)<0 ) {
LM_ERR("failed to register deletion delay function\n");
shm_free(iuid);
} else {
dlg_ref(dlg, 1);
}
}
}
if (new_state==DLG_STATE_CONFIRMED && old_state!=DLG_STATE_CONFIRMED)
dlg_ka_add(dlg);
/* run actions for the transition */
if (event==DLG_EVENT_REQBYE && new_state==DLG_STATE_DELETED &&
old_state!=DLG_STATE_DELETED) {
LM_DBG("BYE successfully processed\n");
/* remove from timer */
ret = remove_dialog_timer(&dlg->tl);
if (ret < 0) {
LM_CRIT("unable to unlink the timer on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->tag[DLG_CALLER_LEG].len, dlg->tag[DLG_CALLER_LEG].s,
dlg->tag[DLG_CALLEE_LEG].len, dlg->tag[DLG_CALLEE_LEG].s);
} else if (ret > 0) {
LM_WARN("inconsitent dlg timer data on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->tag[DLG_CALLER_LEG].len, dlg->tag[DLG_CALLER_LEG].s,
dlg->tag[DLG_CALLEE_LEG].len, dlg->tag[DLG_CALLEE_LEG].s);
} else {
/* one extra unref due to removal from timer list */
unref++;
}
/* dialog terminated (BYE) */
dlg_terminated( req, dlg, dir);
dlg_unref(dlg, unref);
_dlg_ctx.cpid = my_pid();
_dlg_ctx.expect_t = 1;
dlg_set_ctx_iuid(dlg);
if_update_stat( dlg_enable_stats, active_dlgs, -1);
goto done;
}
if ( (event==DLG_EVENT_REQ || event==DLG_EVENT_REQACK)
&& (new_state==DLG_STATE_CONFIRMED || new_state==DLG_STATE_EARLY)) {
timeout = get_dlg_timeout(req);
if (timeout!=default_timeout) {
dlg->lifetime = timeout;
}
reset = !((dlg->iflags & DLG_IFLAG_TIMER_NORESET) || dlg_timeout_noreset);
if ((new_state!=DLG_STATE_EARLY) && (old_state!=DLG_STATE_CONFIRMED || reset)) {
if (update_dlg_timer( &dlg->tl, dlg->lifetime )==-1) {
LM_ERR("failed to update dialog lifetime\n");
} else {
dlg->dflags |= DLG_FLAG_CHANGED;
}
}
if(event != DLG_EVENT_REQACK) {
if(dlg_refresh_contacts(dlg, req, dir)!=0) {
LM_ERR("contacts update failed\n");
} else {
dlg->dflags |= DLG_FLAG_CHANGED;
}
if(update_cseqs(dlg, req, dir)!=0) {
LM_ERR("cseqs update failed\n");
} else {
dlg->dflags |= DLG_FLAG_CHANGED;
}
}
if(dlg_db_mode==DB_MODE_REALTIME && (dlg->dflags&DLG_FLAG_CHANGED)) {
update_dialog_dbinfo(dlg);
}
if (old_state==DLG_STATE_CONFIRMED_NA) {
LM_DBG("confirming ACK successfully processed\n");
/* confirming ACK request */
run_dlg_callbacks( DLGCB_CONFIRMED, dlg, req, NULL, dir, 0);
} else {
LM_DBG("sequential request successfully processed\n");
/* within dialog request */
run_dlg_callbacks( DLGCB_REQ_WITHIN, dlg, req, NULL, dir, 0);
if ( (event!=DLG_EVENT_REQACK) &&
(dlg->cbs.types)&DLGCB_RESPONSE_WITHIN ) {
iuid = dlg_get_iuid_shm_clone(dlg);
if(iuid!=NULL)
{
/* register callback for the replies of this request */
if ( d_tmb.register_tmcb( req, 0, TMCB_RESPONSE_FWDED,
(dir==DLG_DIR_UPSTREAM)?dlg_seq_down_onreply:
dlg_seq_up_onreply,
(void*)iuid, dlg_iuid_sfree)<0 ) {
LM_ERR("failed to register TMCB (2)\n");
shm_free(iuid);
}
}
}
}
}
if(new_state==DLG_STATE_CONFIRMED && old_state==DLG_STATE_CONFIRMED_NA){
dlg->dflags |= DLG_FLAG_CHANGED;
if(dlg_db_mode == DB_MODE_REALTIME)
update_dialog_dbinfo(dlg);
}
done:
dlg_release(dlg);
return;
}
/**
* replicates a confirmed dialog from another OpenSIPS instance
* by reading the relevant information using the Binary Packet Interface
*/
int dlg_replicated_create(struct dlg_cell *cell, str *ftag, str *ttag, int safe)
{
int next_id, h_entry;
unsigned int dir, dst_leg;
str callid, from_uri, to_uri, from_tag, to_tag;
str cseq1,cseq2,contact1,contact2,rroute1,rroute2,mangled_fu,mangled_tu;
str sock, vars, profiles;
struct dlg_cell *dlg = NULL;
struct socket_info *caller_sock, *callee_sock;
struct dlg_entry *d_entry;
if_update_stat(dlg_enable_stats, processed_dlgs, 1);
LM_DBG("Received replicated dialog!\n");
if (!cell) {
bin_pop_str(&callid);
bin_pop_str(&from_tag);
bin_pop_str(&to_tag);
bin_pop_str(&from_uri);
bin_pop_str(&to_uri);
dlg = get_dlg(&callid, &from_tag, &to_tag, &dir, &dst_leg);
h_entry = dlg_hash(&callid);
d_entry = &d_table->entries[h_entry];
if (safe)
dlg_lock(d_table, d_entry);
if (dlg) {
LM_DBG("Dialog with ci '%.*s' is already created\n",
callid.len, callid.s);
unref_dlg_unsafe(dlg, 1, d_entry);
dlg_unlock(d_table, d_entry);
return 0;
}
dlg = build_new_dlg(&callid, &from_uri, &to_uri, &from_tag);
if (!dlg) {
LM_ERR("Failed to create replicated dialog!\n");
goto pre_linking_error;
}
} else {
h_entry = dlg_hash(&cell->callid);
d_entry = &d_table->entries[h_entry];
if (safe)
dlg_lock(d_table, d_entry);
from_tag = *ftag;
to_tag = *ttag;
dlg = cell;
}
bin_pop_int(&dlg->h_id);
bin_pop_int(&dlg->start_ts);
bin_pop_int(&dlg->state);
next_id = d_table->entries[dlg->h_entry].next_id;
d_table->entries[dlg->h_entry].next_id =
(next_id <= dlg->h_id) ? (dlg->h_id + 1) : next_id;
if (bin_pop_str(&sock))
goto pre_linking_error;
caller_sock = fetch_socket_info(&sock);
if (bin_pop_str(&sock))
goto pre_linking_error;
callee_sock = fetch_socket_info(&sock);
if (!caller_sock || !callee_sock) {
LM_ERR("Dialog in DB doesn't match any listening sockets\n");
goto pre_linking_error;
}
bin_pop_str(&cseq1);
bin_pop_str(&cseq2);
bin_pop_str(&rroute1);
bin_pop_str(&rroute2);
bin_pop_str(&contact1);
bin_pop_str(&contact2);
bin_pop_str(&mangled_fu);
bin_pop_str(&mangled_tu);
/* add the 2 legs */
if (dlg_add_leg_info(dlg, &from_tag, &rroute1, &contact1,
&cseq1, caller_sock, 0, 0) != 0 ||
dlg_add_leg_info(dlg, &to_tag, &rroute2, &contact2,
&cseq2, callee_sock, &mangled_fu, &mangled_tu) != 0) {
LM_ERR("dlg_set_leg_info failed\n");
goto pre_linking_error;
}
dlg->legs_no[DLG_LEG_200OK] = DLG_FIRST_CALLEE_LEG;
/* link the dialog into the hash */
dlg->h_id = d_entry->next_id++;
if (!d_entry->first)
d_entry->first = d_entry->last = dlg;
else {
d_entry->last->next = dlg;
dlg->prev = d_entry->last;
d_entry->last = dlg;
}
dlg->ref++;
d_entry->cnt++;
bin_pop_str(&vars);
bin_pop_str(&profiles);
bin_pop_int(&dlg->user_flags);
bin_pop_int(&dlg->flags);
bin_pop_int((void *)&dlg->tl.timeout);
bin_pop_int(&dlg->legs[DLG_CALLER_LEG].last_gen_cseq);
bin_pop_int(&dlg->legs[callee_idx(dlg)].last_gen_cseq);
if (dlg->tl.timeout <= (unsigned int)time(0))
dlg->tl.timeout = 0;
else
dlg->tl.timeout -= (unsigned int)time(0);
/* restore the timer values */
if (insert_dlg_timer(&dlg->tl, (int)dlg->tl.timeout) != 0) {
LM_CRIT("Unable to insert dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
goto error;
}
if (dlg->state == DLG_STATE_CONFIRMED_NA ||
dlg->state == DLG_STATE_CONFIRMED)
active_dlgs_cnt++;
/* reference the dialog as kept in the timer list */
ref_dlg_unsafe(dlg, 1);
LM_DBG("Received initial timeout of %d for dialog %.*s, safe = %d\n",dlg->tl.timeout,callid.len,callid.s,safe);
dlg->lifetime = 0;
/*
Do not replicate the pinging - we might terminate dialogs badly when running
as backup
if (dlg->flags & DLG_FLAG_PING_CALLER || dlg->flags & DLG_FLAG_PING_CALLEE) {
if (insert_ping_timer(dlg) != 0)
LM_CRIT("Unable to insert dlg %p into ping timer\n",dlg);
else {
ref_dlg_unsafe(dlg, 1);
}
}
*/
if (dlg_db_mode == DB_MODE_DELAYED) {
/* to be later removed by timer */
ref_dlg_unsafe(dlg, 1);
}
if (vars.s && vars.len != 0)
read_dialog_vars(vars.s, vars.len, dlg);
dlg_unlock(d_table, d_entry);
if (profiles.s && profiles.len != 0)
read_dialog_profiles(profiles.s, profiles.len, dlg, 0, 1);
if_update_stat(dlg_enable_stats, active_dlgs, 1);
run_load_callback_per_dlg(dlg);
return 0;
pre_linking_error:
dlg_unlock(d_table, d_entry);
if (dlg)
destroy_dlg(dlg);
return -1;
error:
dlg_unlock(d_table, d_entry);
if (dlg)
unref_dlg(dlg, 1);
return -1;
}
/**
* replicates the remote update of an ongoing dialog locally
* by reading the relevant information using the Binary Packet Interface
*/
int dlg_replicated_update(void)
{
struct dlg_cell *dlg;
str call_id, from_tag, to_tag, from_uri, to_uri, vars, profiles;
unsigned int dir, dst_leg;
int timeout, h_entry;
str st;
struct dlg_entry *d_entry;
bin_pop_str(&call_id);
bin_pop_str(&from_tag);
bin_pop_str(&to_tag);
bin_pop_str(&from_uri);
bin_pop_str(&to_uri);
LM_DBG("replicated update for ['%.*s' '%.*s' '%.*s' '%.*s' '%.*s']\n",
call_id.len, call_id.s, from_tag.len, from_tag.s, to_tag.len, to_tag.s,
from_uri.len, from_uri.s, to_uri.len, to_uri.s);
dlg = get_dlg(&call_id, &from_tag, &to_tag, &dir, &dst_leg);
h_entry = dlg_hash(&call_id);
d_entry = &d_table->entries[h_entry];
dlg_lock(d_table, d_entry);
if (!dlg) {
/* TODO: change to LM_DBG */
LM_ERR("dialog not found, building new\n");
dlg = build_new_dlg(&call_id, &from_uri, &to_uri, &from_tag);
if (!dlg) {
LM_ERR("Failed to create replicated dialog!\n");
goto error;
}
return dlg_replicated_create(dlg, &from_tag, &to_tag, 0);
}
bin_skip_int(2);
bin_pop_int(&dlg->state);
bin_skip_str(2);
bin_pop_str(&st);
if (dlg_update_cseq(dlg, DLG_CALLER_LEG, &st, 0) != 0) {
LM_ERR("failed to update caller cseq\n");
goto error;
}
bin_pop_str(&st);
if (dlg_update_cseq(dlg, callee_idx(dlg), &st, 0) != 0) {
LM_ERR("failed to update callee cseq\n");
goto error;
}
bin_skip_str(6);
bin_pop_str(&vars);
bin_pop_str(&profiles);
bin_pop_int(&dlg->user_flags);
bin_pop_int(&dlg->flags);
bin_pop_int(&timeout);
bin_skip_int(2);
timeout -= time(0);
LM_DBG("Received updated timeout of %d for dialog %.*s\n",timeout,call_id.len,call_id.s);
if (dlg->lifetime != timeout) {
dlg->lifetime = timeout;
if (update_dlg_timer(&dlg->tl, dlg->lifetime) == -1)
LM_ERR("failed to update dialog lifetime!\n");
}
unref_dlg_unsafe(dlg, 1, d_entry);
if (vars.s && vars.len != 0)
read_dialog_vars(vars.s, vars.len, dlg);
dlg_unlock(d_table, d_entry);
if (profiles.s && profiles.len != 0)
read_dialog_profiles(profiles.s, profiles.len, dlg, 1, 1);
return 0;
error:
dlg_unlock(d_table, d_entry);
return -1;
}
/**
* replicates a confirmed dialog from another OpenSIPS instance
* by reading the relevant information using the Binary Packet Interface
*/
int dlg_replicated_create(bin_packet_t *packet, struct dlg_cell *cell, str *ftag,
str *ttag, int safe)
{
int h_entry;
unsigned int dir, dst_leg;
str callid = { NULL, 0 }, from_uri, to_uri, from_tag, to_tag;
str cseq1, cseq2, contact1, contact2, rroute1, rroute2, mangled_fu, mangled_tu;
str sock, vars, profiles;
struct dlg_cell *dlg = NULL;
struct socket_info *caller_sock, *callee_sock;
struct dlg_entry *d_entry;
LM_DBG("Received replicated dialog!\n");
if (!cell) {
DLG_BIN_POP(str, packet, callid, malformed);
DLG_BIN_POP(str, packet, from_tag, malformed);
DLG_BIN_POP(str, packet, to_tag, malformed);
DLG_BIN_POP(str, packet, from_uri, malformed);
DLG_BIN_POP(str, packet, to_uri, malformed);
dlg = get_dlg(&callid, &from_tag, &to_tag, &dir, &dst_leg);
h_entry = dlg_hash(&callid);
d_entry = &d_table->entries[h_entry];
if (safe)
dlg_lock(d_table, d_entry);
if (dlg) {
LM_DBG("Dialog with ci '%.*s' is already created\n",
callid.len, callid.s);
unref_dlg_unsafe(dlg, 1, d_entry);
/* unmark dlg as loaded from DB (otherwise it would have been
* dropped later when syncing from cluster is done) */
dlg->flags &= ~DLG_FLAG_FROM_DB;
dlg_unlock(d_table, d_entry);
return 0;
}
dlg = build_new_dlg(&callid, &from_uri, &to_uri, &from_tag);
if (!dlg) {
LM_ERR("Failed to create replicated dialog!\n");
goto pre_linking_error;
}
} else {
h_entry = dlg_hash(&cell->callid);
d_entry = &d_table->entries[h_entry];
if (safe)
dlg_lock(d_table, d_entry);
from_tag = *ftag;
to_tag = *ttag;
dlg = cell;
}
if_update_stat(dlg_enable_stats, processed_dlgs, 1);
DLG_BIN_POP(int, packet, dlg->h_id, pre_linking_error);
DLG_BIN_POP(int, packet, dlg->start_ts, pre_linking_error);
DLG_BIN_POP(int, packet, dlg->state, pre_linking_error);
/* next_id follows the max value of all replicated ids */
if (d_table->entries[dlg->h_entry].next_id <= dlg->h_id)
d_table->entries[dlg->h_entry].next_id = dlg->h_id + 1;
DLG_BIN_POP(str, packet, sock, pre_linking_error);
caller_sock = fetch_socket_info(&sock);
DLG_BIN_POP(str, packet, sock, pre_linking_error);
callee_sock = fetch_socket_info(&sock);
if (!caller_sock || !callee_sock) {
LM_ERR("Replicated dialog doesn't match any listening sockets\n");
goto pre_linking_error;
}
DLG_BIN_POP(str, packet, cseq1, pre_linking_error);
DLG_BIN_POP(str, packet, cseq2, pre_linking_error);
DLG_BIN_POP(str, packet, rroute1, pre_linking_error);
DLG_BIN_POP(str, packet, rroute2, pre_linking_error);
DLG_BIN_POP(str, packet, contact1, pre_linking_error);
DLG_BIN_POP(str, packet, contact2, pre_linking_error);
DLG_BIN_POP(str, packet, mangled_fu, pre_linking_error);
DLG_BIN_POP(str, packet, mangled_tu, pre_linking_error);
/* add the 2 legs */
/* TODO - sdp here */
if (dlg_update_leg_info(0, dlg, &from_tag, &rroute1, &contact1,
&cseq1, caller_sock, 0, 0,0) != 0 ||
dlg_update_leg_info(1, dlg, &to_tag, &rroute2, &contact2,
&cseq2, callee_sock, &mangled_fu, &mangled_tu,0) != 0) {
LM_ERR("dlg_set_leg_info failed\n");
goto pre_linking_error;
}
dlg->legs_no[DLG_LEG_200OK] = DLG_FIRST_CALLEE_LEG;
/* link the dialog into the hash */
if (!d_entry->first)
d_entry->first = d_entry->last = dlg;
else {
d_entry->last->next = dlg;
dlg->prev = d_entry->last;
d_entry->last = dlg;
}
dlg->ref++;
d_entry->cnt++;
DLG_BIN_POP(str, packet, vars, pre_linking_error);
DLG_BIN_POP(str, packet, profiles, pre_linking_error);
DLG_BIN_POP(int, packet, dlg->user_flags, pre_linking_error);
DLG_BIN_POP(int, packet, dlg->mod_flags, pre_linking_error);
DLG_BIN_POP(int, packet, dlg->flags, pre_linking_error);
/* also save the dialog into the DB on this instance */
dlg->flags |= DLG_FLAG_NEW;
DLG_BIN_POP(int, packet, dlg->tl.timeout, pre_linking_error);
DLG_BIN_POP(int, packet, dlg->legs[DLG_CALLER_LEG].last_gen_cseq, pre_linking_error);
DLG_BIN_POP(int, packet, dlg->legs[callee_idx(dlg)].last_gen_cseq, pre_linking_error);
if (dlg->tl.timeout <= (unsigned int) time(0))
dlg->tl.timeout = 0;
else
dlg->tl.timeout -= (unsigned int) time(0);
/* restore the timer values */
if (insert_dlg_timer(&dlg->tl, (int) dlg->tl.timeout) != 0) {
LM_CRIT("Unable to insert dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
goto error;
}
if (dlg->state == DLG_STATE_CONFIRMED_NA ||
dlg->state == DLG_STATE_CONFIRMED)
active_dlgs_cnt++;
/* reference the dialog as kept in the timer list */
ref_dlg_unsafe(dlg, 1);
LM_DBG("Received initial timeout of %d for dialog %.*s, safe = %d\n",
dlg->tl.timeout, callid.len, callid.s, safe);
dlg->lifetime = 0;
if (dlg->flags & DLG_FLAG_PING_CALLER || dlg->flags & DLG_FLAG_PING_CALLEE) {
if (insert_ping_timer(dlg) != 0)
LM_CRIT("Unable to insert dlg %p into ping timer\n",dlg);
else {
ref_dlg_unsafe(dlg, 1);
}
}
if (dlg_db_mode == DB_MODE_DELAYED) {
/* to be later removed by timer */
ref_dlg_unsafe(dlg, 1);
}
if (vars.s && vars.len != 0)
read_dialog_vars(vars.s, vars.len, dlg);
dlg_unlock(d_table, d_entry);
if (profiles.s && profiles.len != 0)
read_dialog_profiles(profiles.s, profiles.len, dlg, 0, 1);
if_update_stat(dlg_enable_stats, active_dlgs, 1);
run_load_callback_per_dlg(dlg);
return 0;
pre_linking_error:
dlg_unlock(d_table, d_entry);
if (dlg)
destroy_dlg(dlg);
return -1;
error:
dlg_unlock(d_table, d_entry);
if (dlg)
unref_dlg(dlg, 1);
malformed:
return -1;
}
/**
* replicates the remote deletion of a dialog locally
* by reading the relevant information using the Binary Packet Interface
*/
int dlg_replicated_delete(bin_packet_t *packet)
{
str call_id, from_tag, to_tag;
unsigned int dir, dst_leg;
struct dlg_cell *dlg;
int old_state, new_state, unref, ret;
DLG_BIN_POP(str, packet, call_id, malformed);
DLG_BIN_POP(str, packet, from_tag, malformed);
DLG_BIN_POP(str, packet, to_tag, malformed);
LM_DBG("Deleting dialog with callid: %.*s\n", call_id.len, call_id.s);
dlg = get_dlg(&call_id, &from_tag, &to_tag, &dir, &dst_leg);
if (!dlg) {
/* may be already deleted due to timeout */
LM_DBG("dialog not found (callid: |%.*s| ftag: |%.*s|\n",
call_id.len, call_id.s, from_tag.len, from_tag.s);
return 0;
}
dlg_lock_dlg(dlg);
destroy_linkers(dlg->profile_links, 1);
dlg->profile_links = NULL;
dlg_unlock_dlg(dlg);
/* simulate BYE received from caller */
next_state_dlg(dlg, DLG_EVENT_REQBYE, DLG_DIR_DOWNSTREAM, &old_state,
&new_state, &unref, dlg->legs_no[DLG_LEG_200OK], 0);
if (old_state == new_state) {
LM_ERR("duplicate dialog delete request (callid: |%.*s|"
"ftag: |%.*s|\n", call_id.len, call_id.s, from_tag.len, from_tag.s);
return -1;
}
ret = remove_dlg_timer(&dlg->tl);
if (ret < 0) {
LM_CRIT("unable to unlink the timer on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
} else if (ret > 0) {
LM_DBG("dlg expired (not in timer list) on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
} else {
/* dialog successfully removed from timer -> unref */
unref++;
}
unref_dlg(dlg, 1 + unref);
if_update_stat(dlg_enable_stats, active_dlgs, -1);
return 0;
malformed:
return -1;
}
/**
* replicates the remote update of an ongoing dialog locally
* by reading the relevant information using the Binary Packet Interface
*/
int dlg_replicated_update(bin_packet_t *packet)
{
struct dlg_cell *dlg;
str call_id, from_tag, to_tag, from_uri, to_uri, vars, profiles;
unsigned int dir, dst_leg;
int timeout, h_entry;
str st;
struct dlg_entry *d_entry;
int rcv_flags, save_new_flag;
bin_pop_str(packet, &call_id);
bin_pop_str(packet, &from_tag);
bin_pop_str(packet, &to_tag);
bin_pop_str(packet, &from_uri);
bin_pop_str(packet, &to_uri);
LM_DBG("replicated update for ['%.*s' '%.*s' '%.*s' '%.*s' '%.*s']\n",
call_id.len, call_id.s, from_tag.len, from_tag.s, to_tag.len, to_tag.s,
from_uri.len, from_uri.s, to_uri.len, to_uri.s);
dlg = get_dlg(&call_id, &from_tag, &to_tag, &dir, &dst_leg);
h_entry = dlg_hash(&call_id);
d_entry = &d_table->entries[h_entry];
dlg_lock(d_table, d_entry);
if (!dlg) {
LM_DBG("dialog not found, building new\n");
dlg = build_new_dlg(&call_id, &from_uri, &to_uri, &from_tag);
if (!dlg) {
LM_ERR("Failed to create replicated dialog!\n");
goto error;
}
return dlg_replicated_create(packet ,dlg, &from_tag, &to_tag, 0);
}
bin_skip_int(packet, 2);
bin_pop_int(packet, &dlg->state);
bin_skip_str(packet, 2);
bin_pop_str(packet, &st);
if (dlg_update_cseq(dlg, DLG_CALLER_LEG, &st, 0) != 0) {
LM_ERR("failed to update caller cseq\n");
goto error;
}
bin_pop_str(packet, &st);
if (dlg_update_cseq(dlg, callee_idx(dlg), &st, 0) != 0) {
LM_ERR("failed to update callee cseq\n");
goto error;
}
bin_skip_str(packet, 6);
bin_pop_str(packet, &vars);
bin_pop_str(packet, &profiles);
bin_pop_int(packet, &dlg->user_flags);
bin_pop_int(packet, &dlg->mod_flags);
bin_pop_int(packet, &rcv_flags);
/* make sure an update received immediately after a create can't
* incorrectly erase the DLG_FLAG_NEW before locally writing to DB */
save_new_flag = dlg->flags & DLG_FLAG_NEW;
dlg->flags = rcv_flags;
dlg->flags |= ((save_new_flag ? DLG_FLAG_NEW : 0) | DLG_FLAG_CHANGED);
bin_pop_int(packet, &timeout);
bin_skip_int(packet, 2);
timeout -= time(0);
LM_DBG("Received updated timeout of %d for dialog %.*s\n",
timeout, call_id.len, call_id.s);
if (dlg->lifetime != timeout) {
dlg->lifetime = timeout;
switch (update_dlg_timer(&dlg->tl, dlg->lifetime) ) {
case -1:
LM_ERR("failed to update dialog lifetime!\n");
/* continue */
case 0:
/* timeout value was updated */
break;
case 1:
/* dlg inserted in timer list with new expire (reference it)*/
ref_dlg(dlg,1);
}
}
unref_dlg_unsafe(dlg, 1, d_entry);
if (vars.s && vars.len != 0)
read_dialog_vars(vars.s, vars.len, dlg);
dlg->flags |= DLG_FLAG_VP_CHANGED;
dlg_unlock(d_table, d_entry);
if (profiles.s && profiles.len != 0)
read_dialog_profiles(profiles.s, profiles.len, dlg, 1, 1);
return 0;
error:
dlg_unlock(d_table, d_entry);
return -1;
}
static int w_dlg_get(struct sip_msg *msg, char *ci, char *ft, char *tt)
{
struct dlg_cell *dlg = NULL;
str sc = {0,0};
str sf = {0,0};
str st = {0,0};
unsigned int dir = 0;
if(ci==0 || ft==0 || tt==0)
{
LM_ERR("invalid parameters\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)ci, &sc)!=0)
{
LM_ERR("unable to get Call-ID\n");
return -1;
}
if(sc.s==NULL || sc.len == 0)
{
LM_ERR("invalid Call-ID parameter\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)ft, &sf)!=0)
{
LM_ERR("unable to get From tag\n");
return -1;
}
if(sf.s==NULL || sf.len == 0)
{
LM_ERR("invalid From tag parameter\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)tt, &st)!=0)
{
LM_ERR("unable to get To Tag\n");
return -1;
}
if(st.s==NULL || st.len == 0)
{
LM_ERR("invalid To tag parameter\n");
return -1;
}
dlg = get_dlg(&sc, &sf, &st, &dir);
if(dlg==NULL)
return -1;
/*
note: we should unref the dlg here (from get_dlg). BUT, because we are setting the current dialog
we can ignore the unref... instead of unreffing and reffing again for the set_current_dialog. NB.
this function is generally called from the cfg file. If used via API, remember to unref the dlg
afterwards
*/
set_current_dialog(msg, dlg);
_dlg_ctx.dlg = dlg;
_dlg_ctx.dir = dir;
return 1;
}
void PluginCheckBoxBinding::save_() const
{
intptr_t Selected = psi().SendDlgMessage(get_dlg(), DM_GETCHECK, get_index(), 0);
*Value = Selected;
LogDebug(L"dlg: %p, index: %Id, value: %Id\n", get_dlg(), get_index(), *Value);
}
void dlg_onroute(struct sip_msg* req, str *route_params, void *param)
{
struct dlg_cell *dlg;
str val = {0,0};
str callid;
str ftag;
str ttag;
int h_entry;
int h_id;
int new_state;
int old_state;
int unref;
int event;
int timeout;
unsigned int update_val;
unsigned int dir,dst_leg,src_leg;
int ret = 0,ok = 1;
struct dlg_entry *d_entry;
str *msg_cseq;
char *final_cseq;
/* as this callback is triggered from loose_route, which can be
accidentaly called more than once from script, we need to be sure
we do this only once !*/
if (current_dlg_pointer)
return;
/* skip initial requests - they may end up here because of the
* preloaded route */
if ( (!req->to && parse_headers(req, HDR_TO_F,0)<0) || !req->to ) {
LM_ERR("bad request or missing TO hdr :-/\n");
return;
}
if ( get_to(req)->tag_value.len==0 )
return;
dlg = 0;
dir = DLG_DIR_NONE;
dst_leg = -1;
/* From RR callback, param will be NULL
* From match_dialog, param might have a value, if we
* are in the topology hiding case & we were able to extract the
* DID from the R-URI */
if (param)
val = *((str *)param);
if ( seq_match_mode!=SEQ_MATCH_NO_ID ) {
if( val.s == NULL && d_rrb.get_route_param( req, &rr_param, &val)!=0) {
LM_DBG("Route param '%.*s' not found\n", rr_param.len,rr_param.s);
if (seq_match_mode==SEQ_MATCH_STRICT_ID )
return;
} else {
LM_DBG("route param is '%.*s' (len=%d)\n",val.len,val.s,val.len);
if ( parse_dlg_rr_param( val.s, val.s+val.len, &h_entry, &h_id)<0 )
return;
dlg = lookup_dlg( h_entry, h_id);
if (dlg==0) {
LM_DBG("unable to find dialog for %.*s "
"with route param '%.*s'\n",
req->first_line.u.request.method.len,
req->first_line.u.request.method.s,
val.len,val.s);
} else {
/* lookup_dlg has incremented the ref count by 1 */
if (pre_match_parse( req, &callid, &ftag, &ttag)<0) {
unref_dlg(dlg, 1);
return;
}
if (match_dialog(dlg,&callid,&ftag,&ttag,&dir, &dst_leg )==0){
LM_WARN("tight matching failed for %.*s with "
"callid='%.*s'/%d,"
" ftag='%.*s'/%d, ttag='%.*s'/%d and direction=%d\n",
req->first_line.u.request.method.len,
req->first_line.u.request.method.s,
callid.len, callid.s, callid.len,
ftag.len, ftag.s, ftag.len,
ttag.len, ttag.s, ttag.len, dir);
LM_WARN("dialog identification elements are "
"callid='%.*s'/%d, "
"caller tag='%.*s'/%d, callee tag='%.*s'/%d\n",
dlg->callid.len, dlg->callid.s, dlg->callid.len,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s),
dlg->legs[callee_idx(dlg)].tag.len);
unref_dlg(dlg, 1);
dlg = NULL;
}
}
if (dlg==NULL && seq_match_mode==SEQ_MATCH_STRICT_ID )
return;
}
}
if (dlg==0) {
if (pre_match_parse( req, &callid, &ftag, &ttag)<0)
return;
/* TODO - try to use the RR dir detection to speed up here the
* search -bogdan */
dlg = get_dlg(&callid, &ftag, &ttag, &dir, &dst_leg);
if (!dlg){
LM_DBG("Callid '%.*s' not found\n",
req->callid->body.len, req->callid->body.s);
return;
}
}
/* run state machine */
switch ( req->first_line.u.request.method_value ) {
case METHOD_PRACK:
event = DLG_EVENT_REQPRACK; break;
case METHOD_ACK:
event = DLG_EVENT_REQACK; break;
case METHOD_BYE:
event = DLG_EVENT_REQBYE; break;
default:
event = DLG_EVENT_REQ;
}
/* save last_dst_leg before running state machine
* helpful for logging various bogus cases according to the RFC */
last_dst_leg = dst_leg;
next_state_dlg( dlg, event, &old_state, &new_state, &unref);
/* set current dialog - it will keep a ref! */
set_current_dialog(dlg);
log_bogus_dst_leg(dlg);
d_entry = &(d_table->entries[dlg->h_entry]);
if(dlg->flags & DLG_FLAG_TOPHIDING) {
dlg_th_onroute(dlg, req, dir);
}
/* run actions for the transition */
if (event==DLG_EVENT_REQBYE && new_state==DLG_STATE_DELETED &&
old_state!=DLG_STATE_DELETED) {
/*destroy linkers */
destroy_linkers(dlg->profile_links);
dlg->profile_links = NULL;
if (!dlg->terminate_reason.s) {
if (last_dst_leg == 0)
init_dlg_term_reason(dlg,"Upstream BYE",sizeof("Upstream BYE")-1);
else
init_dlg_term_reason(dlg,"Downstream BYE",sizeof("Downstream BYE")-1);
}
LM_DBG("BYE successfully processed - dst_leg = %d\n",last_dst_leg);
if (dlg->flags & DLG_FLAG_PING_CALLER || dlg->flags & DLG_FLAG_PING_CALLEE) {
dlg_lock (d_table,d_entry);
if (dlg->legs[dst_leg].last_gen_cseq) {
update_val = ++(dlg->legs[dst_leg].last_gen_cseq);
dlg_unlock (d_table,d_entry);
if (update_msg_cseq(req,0,update_val) != 0)
LM_ERR("failed to update BYE msg cseq\n");
msg_cseq = &((struct cseq_body *)req->cseq->parsed)->number;
final_cseq = shm_malloc(msg_cseq->len + 1);
if (final_cseq == 0) {
LM_ERR("no more shm mem\n");
goto after_unlock5;
}
memcpy(final_cseq,msg_cseq->s,msg_cseq->len);
final_cseq[msg_cseq->len] = 0;
if ( d_tmb.register_tmcb( req, 0, TMCB_RESPONSE_FWDED,
fix_final_cseq,
(void*)final_cseq, 0)<0 ) {
LM_ERR("failed to register TMCB (2)\n");
}
}
else
dlg_unlock (d_table,d_entry);
}
after_unlock5:
/* remove from timer */
ret = remove_dlg_timer(&dlg->tl);
if (ret < 0) {
LM_CRIT("unable to unlink the timer on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
} else if (ret > 0) {
LM_DBG("dlg expired (not in timer list) on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->legs[DLG_CALLER_LEG].tag.len,
dlg->legs[DLG_CALLER_LEG].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
ZSW(dlg->legs[callee_idx(dlg)].tag.s));
} else {
/* dialog sucessfully removed from timer -> unref */
unref++;
}
/* dialog terminated (BYE) */
run_dlg_callbacks( DLGCB_TERMINATED, dlg, req, dir, 0);
/* delete the dialog from DB */
if (should_remove_dlg_db())
remove_dialog_from_db(dlg);
/* destroy dialog */
unref_dlg(dlg, unref);
if_update_stat( dlg_enable_stats, active_dlgs, -1);
return;
}
if ( (event==DLG_EVENT_REQ || event==DLG_EVENT_REQACK)
&& new_state==DLG_STATE_CONFIRMED) {
LM_DBG("sequential request successfully processed (dst_leg=%d)\n",
dst_leg);
/* within dialog request */
run_dlg_callbacks( DLGCB_REQ_WITHIN, dlg, req, dir, 0);
timeout = get_dlg_timeout_update(req);
/* update timer during sequential request? */
if (timeout != 0) {
dlg->lifetime = timeout;
if (update_dlg_timer( &dlg->tl, dlg->lifetime )==-1)
LM_ERR("failed to update dialog lifetime\n");
}
if ( event!=DLG_EVENT_REQACK ) {
if (dst_leg==-1 || switch_cseqs(dlg, dst_leg) != 0 ||
update_cseqs(dlg,req,dst_leg,0)) {
ok = 0;
LM_ERR("cseqs update failed on leg=%d\n",dst_leg);
}
if (req->first_line.u.request.method_value == METHOD_INVITE) {
if (dst_leg == DLG_CALLER_LEG)
src_leg = callee_idx(dlg);
else
src_leg = DLG_CALLER_LEG;
if (update_cseqs(dlg,req,src_leg,1) != 0) {
ok=0;
LM_ERR("failed to update inv cseq on leg %d\n",src_leg);
}
}
if (dlg->flags & DLG_FLAG_PING_CALLER ||
dlg->flags & DLG_FLAG_PING_CALLEE) {
dlg_lock (d_table, d_entry);
if (dlg->legs[dst_leg].last_gen_cseq) {
update_val = ++(dlg->legs[dst_leg].last_gen_cseq);
dlg_unlock( d_table, d_entry );
if (update_msg_cseq(req,0,update_val) != 0) {
LM_ERR("failed to update sequential request msg cseq\n");
ok = 0;
}
}
else
dlg_unlock( d_table, d_entry );
}
if (ok) {
dlg->flags |= DLG_FLAG_CHANGED;
if ( dlg_db_mode==DB_MODE_REALTIME )
update_dialog_dbinfo(dlg);
if (replication_dests)
replicate_dialog_updated(dlg);
}
}
else
{
if (dlg->flags & DLG_FLAG_PING_CALLER ||
dlg->flags & DLG_FLAG_PING_CALLEE) {
dlg_lock (d_table, d_entry);
if (dlg->legs[dst_leg].last_gen_cseq) {
update_val = dlg->legs[dst_leg].last_gen_cseq;
dlg_unlock( d_table, d_entry );
if (update_msg_cseq(req,0,update_val) != 0) {
LM_ERR("failed to update ACK msg cseq\n");
}
}
else
dlg_unlock( d_table, d_entry );
}
}
if ( event!=DLG_EVENT_REQACK) {
/* register callback for the replies of this request */
if (dlg->flags & DLG_FLAG_PING_CALLER || dlg->flags & DLG_FLAG_PING_CALLEE) {
dlg_lock( d_table, d_entry);
if (dlg->legs[dst_leg].last_gen_cseq) {
/* ref the dialog as registered into the transaction callback.
* unref will be done when the callback will be destroyed */
ref_dlg_unsafe( dlg, 1);
dlg_unlock( d_table,d_entry);
if(parse_headers(req, HDR_CSEQ_F, 0) <0 ) {
LM_ERR("failed to parse cseq header \n");
unref_dlg(dlg,1);
goto early_check;
}
msg_cseq = &((struct cseq_body *)req->cseq->parsed)->number;
dlg_cseq_wrapper *wrap = shm_malloc(sizeof(dlg_cseq_wrapper) +
msg_cseq->len);
if (wrap == 0){
LM_ERR("No more shm mem\n");
unref_dlg(dlg, 1);
goto early_check;
}
wrap->dlg = dlg;
wrap->cseq.s = (char *)(wrap + 1);
wrap->cseq.len = msg_cseq->len;
memcpy(wrap->cseq.s,msg_cseq->s,msg_cseq->len);
if ( d_tmb.register_tmcb( req, 0, TMCB_RESPONSE_FWDED,
(dir==DLG_DIR_UPSTREAM)?dlg_seq_down_onreply_mod_cseq:dlg_seq_up_onreply_mod_cseq,
(void*)wrap, unreference_dialog_cseq)<0 ) {
LM_ERR("failed to register TMCB (2)\n");
unref_dlg( dlg , 1);
shm_free(wrap);
}
}
else {
/* dialog is in ping timer list
* but no pings have been generated yet */
dlg_unlock ( d_table, d_entry );
goto regular_indlg_req;
}
} else {
regular_indlg_req:
if (dlg->cbs.types & DLGCB_RESPONSE_WITHIN)
{
ref_dlg( dlg , 1);
if ( d_tmb.register_tmcb( req, 0, TMCB_RESPONSE_FWDED,
(dir==DLG_DIR_UPSTREAM)?dlg_seq_down_onreply:dlg_seq_up_onreply,
(void*)dlg, unreference_dialog)<0 ) {
LM_ERR("failed to register TMCB (2)\n");
unref_dlg( dlg , 1);
}
}
}
}
}
early_check:
if ( (event==DLG_EVENT_REQPRACK || event == DLG_EVENT_REQ)
&& new_state==DLG_STATE_EARLY) {
/* within dialog request */
run_dlg_callbacks( DLGCB_REQ_WITHIN, dlg, req, dir, 0);
LM_DBG("EARLY event %d successfully processed (dst_leg=%d)\n",event,dst_leg);
if (dst_leg==-1 || switch_cseqs(dlg, dst_leg) != 0 ||
update_cseqs(dlg,req,dst_leg,0))
LM_ERR("cseqs update failed on leg=%d\n",dst_leg);
}
if(new_state==DLG_STATE_CONFIRMED && old_state==DLG_STATE_CONFIRMED_NA){
dlg->flags |= DLG_FLAG_CHANGED;
if(dlg_db_mode == DB_MODE_REALTIME)
update_dialog_dbinfo(dlg);
if (replication_dests)
replicate_dialog_updated(dlg);
}
return;
}
void PluginRadioButtonBinding::save_() const
{
if (psi().SendDlgMessage(get_dlg(), DM_GETCHECK, get_index(), nullptr)) {
*Value = m_rg_index;
}
}
/*!
* \brief Function that is registered as RR callback for dialog tracking
*
* Function that is registered as RR callback for dialog tracking. It
* sets the appropriate events after the SIP method and run the state
* machine to update the dialog state. It updates then the saved
* dialogs and also the statistics.
* \param req SIP request
* \param route_params record-route parameter
* \param param unused
*/
void dlg_onroute(struct sip_msg* req, str *route_params, void *param) {
struct dlg_cell *dlg;
str val, callid, ftag, ttag;
int h_entry, h_id, new_state, old_state, unref, event, timeout;
unsigned int dir;
int ret = 0;
if (current_dlg_pointer != NULL)
return;
/* skip initial requests - they may end up here because of the
* preloaded route */
if ((!req->to && parse_headers(req, HDR_TO_F, 0) < 0) || !req->to) {
LM_ERR("bad request or missing TO hdr :-/\n");
return;
}
if (get_to(req)->tag_value.len == 0)
return;
dlg = 0;
dir = DLG_DIR_NONE;
if (seq_match_mode != SEQ_MATCH_NO_ID) {
if (d_rrb.get_route_param(req, &rr_param, &val) != 0) {
LM_DBG("Route param '%.*s' not found\n", rr_param.len, rr_param.s);
if (seq_match_mode == SEQ_MATCH_STRICT_ID)
return;
} else {
LM_DBG("route param is '%.*s' (len=%d)\n", val.len, val.s, val.len);
if (parse_dlg_rr_param(val.s, val.s + val.len, &h_entry, &h_id) < 0)
return;
dlg = lookup_dlg(h_entry, h_id);
if (dlg == 0) {
LM_WARN("unable to find dialog for %.*s "
"with route param '%.*s' [%u:%u]\n",
req->first_line.u.request.method.len,
req->first_line.u.request.method.s,
val.len, val.s, h_entry, h_id);
if (seq_match_mode == SEQ_MATCH_STRICT_ID)
return;
} else {
if (pre_match_parse(req, &callid, &ftag, &ttag, 1) < 0) {
// lookup_dlg has incremented the ref count by 1
unref_dlg(dlg, 1);
return;
}
if (match_dialog(dlg, &callid, &ftag, &ttag, &dir) == 0) {
LM_WARN("tight matching failed for %.*s with callid='%.*s'/%d, "
"ftag='%.*s'/%d, ttag='%.*s'/%d and direction=%d\n",
req->first_line.u.request.method.len,
req->first_line.u.request.method.s,
callid.len, callid.s, callid.len,
ftag.len, ftag.s, ftag.len,
ttag.len, ttag.s, ttag.len, dir);
LM_WARN("dialog identification elements are callid='%.*s'/%d, "
"caller tag='%.*s'/%d\n",
dlg->callid.len, dlg->callid.s, dlg->callid.len,
dlg->from_tag.len, dlg->from_tag.s,
dlg->from_tag.len);
// lookup_dlg has incremented the ref count by 1
unref_dlg(dlg, 1);
// Reset variables in order to do a lookup based on SIP-Elements.
dlg = 0;
dir = DLG_DIR_NONE;
if (seq_match_mode == SEQ_MATCH_STRICT_ID)
return;
}
}
}
}
if (dlg == 0) {
if (pre_match_parse(req, &callid, &ftag, &ttag, 1) < 0)
return;
/* TODO - try to use the RR dir detection to speed up here the
* search -bogdan */
dlg = get_dlg(&callid, &ftag, &ttag, &dir);
if (!dlg) {
LM_DBG("Callid '%.*s' not found\n",
req->callid->body.len, req->callid->body.s);
return;
}
}
/* set current dialog - re-use ref increment from dlg_get() above */
set_current_dialog(req, dlg);
_dlg_ctx.dlg = dlg;
if (d_tmb.register_tmcb(req, NULL, TMCB_REQUEST_FWDED,
store_dlg_in_tm_cb, (void*) dlg, NULL) < 0) {
LM_ERR("failed to store dialog in transaction during dialog creation for later reference\n");
}
/* run state machine */
switch (req->first_line.u.request.method_value) {
case METHOD_PRACK:
event = DLG_EVENT_REQPRACK;
break;
case METHOD_ACK:
event = DLG_EVENT_REQACK;
break;
case METHOD_BYE:
event = DLG_EVENT_REQBYE;
break;
default:
event = DLG_EVENT_REQ;
}
next_state_dlg(dlg, event, &old_state, &new_state, &unref, 0);
LM_DBG("unref after next state is %i\n", unref);
CURR_DLG_ID = req->id;
CURR_DLG_LIFETIME = (unsigned int) (time(0)) - dlg->start_ts;
CURR_DLG_STATUS = new_state;
/* run actions for the transition */
if (event == DLG_EVENT_REQBYE && new_state == DLG_STATE_DELETED &&
old_state != DLG_STATE_DELETED) {
LM_DBG("BYE successfully processed\n");
/* remove from timer */
ret = remove_dialog_timer(&dlg->tl);
if (ret < 0) {
LM_CRIT("unable to unlink the timer on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->from_tag.len, dlg->from_tag.s);
} else if (ret > 0) {
LM_WARN("inconsitent dlg timer data on dlg %p [%u:%u] "
"with clid '%.*s' and tags '%.*s' \n",
dlg, dlg->h_entry, dlg->h_id,
dlg->callid.len, dlg->callid.s,
dlg->from_tag.len, dlg->from_tag.s);
} else {
unref++;
}
/* dialog terminated (BYE) */
dlg_terminated(req, dlg, dir);
unref_dlg(dlg, unref);
return;
}
if ((event == DLG_EVENT_REQ || event == DLG_EVENT_REQACK)
&& new_state == DLG_STATE_CONFIRMED) {
timeout = get_dlg_timeout(req);
if (timeout != default_timeout) {
dlg->lifetime = timeout;
}
if (update_dlg_timer(&dlg->tl, dlg->lifetime) == -1) {
LM_ERR("failed to update dialog lifetime\n");
}
if (update_cseqs(dlg, req, dir, &ttag) != 0) {
LM_ERR("cseqs update failed\n");
} else {
dlg->dflags |= DLG_FLAG_CHANGED;
}
if (old_state != DLG_STATE_CONFIRMED) {
LM_DBG("confirming ACK successfully processed\n");
/* confirming ACK request */
run_dlg_callbacks(DLGCB_CONFIRMED, dlg, req, NULL, dir, 0);
} else {
LM_DBG("sequential request successfully processed\n");
/* within dialog request */
run_dlg_callbacks(DLGCB_REQ_WITHIN, dlg, req, NULL, dir, 0);
if ((event != DLG_EVENT_REQACK) &&
(dlg->cbs.types) & DLGCB_RESPONSE_WITHIN) {
/* ref the dialog as registered into the transaction callback.
* unref will be done when the callback will be destroyed */
ref_dlg(dlg, 1);
/* register callback for the replies of this request */
if (d_tmb.register_tmcb(req, 0, TMCB_RESPONSE_FWDED,
(dir == DLG_DIR_UPSTREAM) ? dlg_seq_down_onreply : dlg_seq_up_onreply,
(void*) dlg, unreference_dialog) < 0) {
LM_ERR("failed to register TMCB (2)\n");
unref_dlg(dlg, 1);
}
}
}
}
if (new_state == DLG_STATE_CONFIRMED && old_state != DLG_STATE_CONFIRMED) {
dlg->dflags |= DLG_FLAG_CHANGED;
}
return;
}
/* TODO: add reason parameter to mi interface */
struct mi_root * mi_terminate_dlg(struct mi_root *cmd_tree, void *param) {
struct mi_node* node;
struct dlg_cell * dlg = NULL;
str mi_extra_hdrs = {NULL, 0};
int status, msg_len;
char *msg;
str callid = {NULL, 0};
str ftag = {NULL, 0};
str ttag = {NULL, 0};
if (d_table == NULL)
goto end;
node = cmd_tree->node.kids;
if (node == NULL || node->next == NULL || node->next->next == NULL)
return init_mi_tree(400, MI_MISSING_PARM_S, MI_MISSING_PARM_LEN);
if (!node->value.s || !node->value.len) {
goto error;
} else {
callid = node->value;
}
node = node->next;
if (!node->value.s || !node->value.len) {
goto error;
} else {
ftag = node->value;
}
node = node->next;
if (!node->value.s || !node->value.len) {
goto error;
} else {
ttag = node->value;
}
if (node->next) {
node = node->next;
if (node->value.len && node->value.s)
mi_extra_hdrs = node->value;
}
unsigned int dir = DLG_DIR_NONE;
LM_DBG("Looking for callid [%.*s]\n", callid.len, callid.s);
dlg = get_dlg(&callid, &ftag, &ttag, &dir); //increments ref count!
if (dlg) {
LM_DBG("Found dialog to terminate and it is in state [%i]\n", dlg->state);
if (dlg_terminate(dlg, 0, NULL/*reson*/, /* all sides of a dialog*/ 2, &mi_extra_hdrs) < 0) {
status = 500;
msg = MI_DLG_OPERATION_ERR;
msg_len = MI_DLG_OPERATION_ERR_LEN;
} else {
status = 200;
msg = MI_OK_S;
msg_len = MI_OK_LEN;
}
unref_dlg(dlg, 1);
return init_mi_tree(status, msg, msg_len);
}
end:
return init_mi_tree(404, MI_DIALOG_NOT_FOUND, MI_DIALOG_NOT_FOUND_LEN);
error:
return init_mi_tree(400, MI_BAD_PARM_S, MI_BAD_PARM_LEN);
}
/*!
* \brief Create a new dialog from a sip message
*
* Create a new dialog from a SIP message, register a callback
* to keep track of the dialog with help of the tm module.
* This function is either called from the request callback, or
* from the dlg_manage function in the configuration script.
* \see dlg_onreq
* \see w_dlg_manage
* \param msg SIP message
* \param t transaction
* \return 0 on success, -1 on failure
*/
int dlg_new_dialog(struct sip_msg *req, struct cell *t, const int run_initial_cbs) {
struct dlg_cell *dlg;
str s;
str callid;
str ftag;
str ttag;
str req_uri;
unsigned int dir;
LM_DBG("starting dlg_new_dialog and method is [%.*s]\n", req->first_line.u.request.method.len, req->first_line.u.request.method.s);
if (current_dlg_pointer != NULL)
return -1;
if (req->first_line.u.request.method_value == METHOD_CANCEL)
return -1;
if (pre_match_parse(req, &callid, &ftag, &ttag, 0) < 0) {
LM_WARN("pre-matching failed\n");
return -1;
}
if (ttag.s != 0 && ttag.len != 0)
return -1;
if (pv_printf_s(req, ruri_param_model, &req_uri) < 0) {
LM_ERR("error - cannot print the r-uri format\n");
return -1;
}
trim(&req_uri);
if (detect_spirals) {
if (spiral_detected == 1)
return 0;
dir = DLG_DIR_NONE;
dlg = get_dlg(&callid, &ftag, &ttag, &dir);
if (dlg) {
LM_DBG("Callid '%.*s' found, must be a spiraled request\n",
callid.len, callid.s);
spiral_detected = 1;
if (run_initial_cbs)
run_dlg_callbacks(DLGCB_SPIRALED, dlg, req, NULL, DLG_DIR_DOWNSTREAM, 0);
//Add did to rr header for all spiralled requested INVITEs
if (req->first_line.u.request.method_value == METHOD_INVITE) {
if (add_dlg_rr_param(dlg, req, dlg->h_entry, dlg->h_id) < 0) {
LM_ERR("failed to add RR param\n");
}
}
// get_dlg has incremented the ref count by 1
unref_dlg(dlg, 1);
goto finish;
}
}
spiral_detected = 0;
LM_DBG("Building new Dialog for call-id %.*s\n", callid.len, callid.s);
LM_DBG("SIP Method: %.*s \n", req->first_line.u.request.method.len, req->first_line.u.request.method.s);
dlg = build_new_dlg(&callid /*callid*/,
&(get_from(req)->uri) /*from uri*/,
&ftag/*from_tag*/,
&req_uri /*r-uri*/);
if (dlg == 0) {
LM_ERR("failed to create new dialog\n");
return -1;
}
/* save caller's tag, cseq, contact and record route*/
if (populate_leg_info(dlg, req, t, DLG_CALLER_LEG,
&(get_from(req)->tag_value)) != 0) {
LM_ERR("could not add further info to the dialog\n");
lock_destroy(dlg->dlg_out_entries_lock);
lock_dealloc(dlg->dlg_out_entries_lock);
shm_free(dlg);
return -1;
}
dlg->transaction = t;
/* Populate initial varlist: */
dlg->vars = get_local_varlist_pointer(req, 1);
link_dlg(dlg, 0);
if (run_initial_cbs) run_create_callbacks(dlg, req);
//Dialog will *always* use DID cookie so no need for match mode anymore
if (add_dlg_rr_param(dlg, req, dlg->h_entry, dlg->h_id) < 0) {
LM_ERR("failed to add RR param\n");
goto error;
}
if (d_tmb.register_tmcb(req, t,
TMCB_RESPONSE_READY | TMCB_RESPONSE_FWDED | TMCB_RESPONSE_OUT,
dlg_onreply, (void*) dlg, unref_new_dialog) < 0) {
LM_ERR("failed to register TMCB\n");
goto error;
}
// increase reference counter because of registered callback
ref_dlg(dlg, 1);
dlg->lifetime = get_dlg_timeout(req);
s.s = _dlg_ctx.to_route_name;
s.len = strlen(s.s);
dlg_set_toroute(dlg, &s);
dlg->sflags |= _dlg_ctx.flags;
if (_dlg_ctx.to_bye != 0)
dlg->dflags |= DLG_FLAG_TOBYE;
finish:
if (t) {
// transaction exists ==> keep ref counter large enough to
// avoid premature cleanup and ensure proper dialog referencing
if (store_dlg_in_tm(req, t, dlg) < 0) {
LM_ERR("failed to store dialog in transaction\n");
goto error;
}
} else {
// no transaction exists ==> postpone work until we see the
// request being forwarded statefully
if (d_tmb.register_tmcb(req, NULL, TMCB_REQUEST_FWDED,
store_dlg_in_tm_cb, (void*) dlg, NULL) < 0) {
LM_ERR("failed to register callback for storing dialog in transaction\n");
goto error;
}
}
LM_DBG("Setting current dialog\n");
set_current_dialog(req, dlg);
_dlg_ctx.dlg = dlg;
ref_dlg(dlg, 1);
return 0;
error:
LM_DBG("Error in build_new_dlg");
if (!spiral_detected)
unref_dlg(dlg, 1); // undo ref regarding linking
return -1;
}
/*!
* \brief Create a new dialog from a sip message
*
* Create a new dialog from a SIP message, register a callback
* to keep track of the dialog with help of the tm module.
* This function is either called from the request callback, or
* from the dlg_manage function in the configuration script.
* \see dlg_onreq
* \see w_dlg_manage
* \param req SIP message
* \param t transaction
* \param run_initial_cbs if set zero, initial callbacks are not executed
* \return 0 on success, -1 on failure
*/
int dlg_new_dialog(sip_msg_t *req, struct cell *t, const int run_initial_cbs)
{
dlg_cell_t *dlg;
str s;
str callid;
str ftag;
str ttag;
str req_uri;
unsigned int dir;
dlg = dlg_get_ctx_dialog();
if(dlg != NULL) {
dlg_release(dlg);
return -1;
}
if(req->first_line.u.request.method_value != METHOD_INVITE)
return -1;
if(pre_match_parse( req, &callid, &ftag, &ttag, 0)<0) {
LM_WARN("pre-matching failed\n");
return -1;
}
if(ttag.s!=0 && ttag.len!=0)
return -1;
if(pv_printf_s(req, ruri_param_model, &req_uri)<0) {
LM_ERR("error - cannot print the r-uri format\n");
return -1;
}
trim(&req_uri);
if (detect_spirals)
{
if (spiral_detected == 1)
return 0;
dir = DLG_DIR_NONE;
dlg = get_dlg(&callid, &ftag, &ttag, &dir);
if (dlg)
{
if ( dlg->state != DLG_STATE_DELETED )
{
LM_DBG("Callid '%.*s' found, must be a spiraled request\n",
callid.len, callid.s);
spiral_detected = 1;
if (run_initial_cbs)
run_dlg_callbacks( DLGCB_SPIRALED, dlg, req, NULL,
DLG_DIR_DOWNSTREAM, 0);
/* get_dlg() has incremented the ref count by 1
* - it's ok, dlg will be unref at the end of function */
goto finish;
}
dlg_release(dlg);
}
}
spiral_detected = 0;
dlg = build_new_dlg (&callid /*callid*/,
&(get_from(req)->uri) /*from uri*/,
&(get_to(req)->uri) /*to uri*/,
&ftag/*from_tag*/,
&req_uri /*r-uri*/ );
if (dlg==0)
{
LM_ERR("failed to create new dialog\n");
return -1;
}
/* save caller's tag, cseq, contact and record route*/
if (populate_leg_info(dlg, req, t, DLG_CALLER_LEG,
&(get_from(req)->tag_value)) !=0)
{
LM_ERR("could not add further info to the dialog\n");
shm_free(dlg);
return -1;
}
/* Populate initial varlist: */
dlg->vars = get_local_varlist_pointer(req, 1);
link_dlg(dlg, 0);
dlg->lifetime = get_dlg_timeout(req);
s.s = _dlg_ctx.to_route_name;
s.len = strlen(s.s);
dlg_set_toroute(dlg, &s);
dlg->sflags |= _dlg_ctx.flags;
dlg->iflags |= _dlg_ctx.iflags;
if (dlg_send_bye!=0 || _dlg_ctx.to_bye!=0)
dlg->iflags |= DLG_IFLAG_TIMEOUTBYE;
if (run_initial_cbs) run_create_callbacks( dlg, req);
/* first INVITE seen (dialog created, unconfirmed) */
if ( seq_match_mode!=SEQ_MATCH_NO_ID &&
add_dlg_rr_param( req, dlg->h_entry, dlg->h_id)<0 ) {
LM_ERR("failed to add RR param\n");
goto error;
}
/* new dlg - reference it once more for current dialog iuid shortcut */
dlg_ref(dlg, 1);
if_update_stat( dlg_enable_stats, processed_dlgs, 1);
finish:
_dlg_ctx.iuid.h_entry = dlg->h_entry;
_dlg_ctx.iuid.h_id = dlg->h_id;
set_current_dialog(req, dlg);
dlg_release(dlg);
return 0;
error:
if (!spiral_detected)
dlg_unref(dlg, 1); // undo ref regarding linking
return -1;
}
