/* Wrapper for terminating dialog from API - from other modules */
static void rpc_end_dlg_entry_id(rpc_t *rpc, void *c) {
unsigned int h_entry, h_id;
struct dlg_cell * dlg = NULL;
str rpc_extra_hdrs = {NULL,0};
int n;
n = rpc->scan(c, "dd", &h_entry, &h_id);
if (n < 2) {
LM_ERR("unable to read the parameters (%d)\n", n);
rpc->fault(c, 500, "Invalid parameters");
return;
}
if(rpc->scan(c, "*S", &rpc_extra_hdrs)<1)
{
rpc_extra_hdrs.s = NULL;
rpc_extra_hdrs.len = 0;
}
dlg = lookup_dlg(h_entry, h_id);//increments ref count!
if(dlg==NULL) {
rpc->fault(c, 404, "Dialog not found");
return;
}
unref_dlg(dlg, 1);
dlg_terminate(dlg, NULL, NULL/*reason*/, 2, NULL);
}
/*parameters from MI: dialog ID of the requested dialog*/
mi_response_t *mi_terminate_dlg(const mi_params_t *params, str *extra_hdrs)
{
unsigned int h_entry, h_id;
unsigned long long d_id;
struct dlg_cell * dlg = NULL;
str dialog_id;
char *end;
char bkp;
int shtag_state = 1;
if( d_table ==NULL)
return init_mi_error(404, MI_SSTR(MI_DIALOG_NOT_FOUND));
h_entry = h_id = 0;
if (get_mi_string_param(params, "dialog_id", &dialog_id.s, &dialog_id.len) < 0)
return init_mi_param_error();
/* Get the dialog based of the dialog_id. This may be a
* numerical DID or a string SIP Call-ID */
/* make value null terminated (in an ugly way) */
bkp = dialog_id.s[dialog_id.len];
dialog_id.s[dialog_id.len] = 0;
/* conver to long long */
d_id = strtoll( dialog_id.s, &end, 10);
dialog_id.s[dialog_id.len] = bkp;
if (end-dialog_id.s==dialog_id.len) {
/* the ID is numeric, so let's consider it DID */
h_entry = (unsigned int)(d_id>>(8*sizeof(int)));
h_id = (unsigned int)(d_id &
(((unsigned long long)1<<(8*sizeof(int)))-1) );
LM_DBG("ID: %llu (h_entry %u h_id %u)\n", d_id, h_entry, h_id);
dlg = lookup_dlg(h_entry, h_id);
} else {
/* Wrapper for terminating dialog from API - from other modules */
int w_api_lookup_terminate_dlg(unsigned int h_entry, unsigned int h_id, str *hdrs) {
struct dlg_cell *dlg;
dlg = lookup_dlg(h_entry, h_id); //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);
}
int terminate_dlg(unsigned int h_entry, unsigned int h_id,str *reason)
{
struct dlg_cell * dlg = NULL;
int ret = 0;
dlg = lookup_dlg(h_entry, h_id);
if(!dlg)
return 0;
init_dlg_term_reason(dlg,reason->s,reason->len);
if ( dlg_end_dlg( dlg, 0) ) {
LM_ERR("Failed to end dialog");
ret = -1;
}
unref_dlg(dlg, 1);
return ret;
}
/*!
* \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;
}
/*parameters from MI: h_entry, h_id of the requested dialog*/
struct mi_root * mi_terminate_dlg(struct mi_root *cmd_tree, void *param ){
struct mi_node* node;
unsigned int h_entry, h_id;
struct dlg_cell * dlg = NULL;
str *mi_extra_hdrs = NULL;
int status, msg_len;
char *msg;
if( d_table ==NULL)
goto end;
node = cmd_tree->node.kids;
h_entry = h_id = 0;
if (node==NULL || node->next==NULL)
return init_mi_tree( 400, MI_MISSING_PARM_S, MI_MISSING_PARM_LEN);
if (!node->value.s|| !node->value.len|| strno2int(&node->value,&h_entry)<0)
goto error;
node = node->next;
if ( !node->value.s || !node->value.len || strno2int(&node->value,&h_id)<0)
goto error;
if (node->next) {
node = node->next;
if (node->value.len && node->value.s)
mi_extra_hdrs = &node->value;
}
LM_DBG("h_entry %u h_id %u\n", h_entry, h_id);
dlg = lookup_dlg(h_entry, h_id);
/* lookup_dlg has incremented the reference count !! */
if(dlg){
init_dlg_term_reason(dlg,"MI Termination",sizeof("MI Termination")-1);
if ( dlg_end_dlg( dlg, mi_extra_hdrs) ) {
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);
}
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;
}
