/**
* 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 inline void free_dlg_dlg(struct dlg_cell *dlg)
{
struct dlg_val *dv;
unsigned int i;
if (dlg->cbs.first)
destroy_dlg_callbacks_list(dlg->cbs.first);
if (dlg->profile_links)
destroy_linkers(dlg->profile_links);
if (dlg->legs) {
for( i=0 ; i<dlg->legs_no[DLG_LEGS_USED] ; i++) {
shm_free(dlg->legs[i].tag.s);
shm_free(dlg->legs[i].r_cseq.s);
if (dlg->legs[i].contact.s)
shm_free(dlg->legs[i].contact.s); /* + route_set */
}
shm_free(dlg->legs);
}
while (dlg->vals) {
dv = dlg->vals;
dlg->vals = dlg->vals->next;
shm_free(dv);
}
shm_free(dlg);
}
/*!
* \brief Cleanup a profile
* \param msg SIP message
* \param flags unused
* \param param unused
* \return 1
*/
int profile_cleanup( struct sip_msg *msg, unsigned int flags, void *param )
{
dlg_cell_t *dlg;
if(get_route_type()==LOCAL_ROUTE) {
return 1;
}
current_dlg_msg_id = 0;
current_dlg_msg_pid = 0;
dlg = dlg_get_ctx_dialog();
if (dlg!=NULL) {
if(dlg->dflags & DLG_FLAG_TM) {
dlg_unref(dlg, 1);
} else {
/* dialog didn't make it to tm */
dlg_unref(dlg, 2);
}
}
if (current_pending_linkers) {
destroy_linkers(current_pending_linkers);
current_pending_linkers = NULL;
}
/* need to return non-zero - 0 will break the exec of the request */
return 1;
}
/*!
* \brief Unset a dialog profile
* \param msg SIP message
* \param value value
* \param profile dialog profile table
* \return 1 on success, -1 on failure
*/
int unset_dlg_profile(sip_msg_t *msg, str *value,
dlg_profile_table_t *profile)
{
dlg_cell_t *dlg;
dlg_profile_link_t *linker;
dlg_profile_link_t *linker_prev;
dlg_entry_t *d_entry;
if (is_route_type(REQUEST_ROUTE)) {
LM_ERR("dialog delete profile cannot be used in request route\n");
return -1;
}
/* get current dialog */
dlg = dlg_get_msg_dialog(msg);
if (dlg==NULL) {
LM_WARN("dialog is NULL for delete profile\n");
return -1;
}
/* check the dialog linkers */
d_entry = &d_table->entries[dlg->h_entry];
dlg_lock( d_table, d_entry);
linker = dlg->profile_links;
linker_prev = NULL;
for( ; linker ; linker_prev=linker,linker=linker->next) {
if (linker->profile==profile) {
if (profile->has_value==0) {
goto found;
} else if (value && value->len==linker->hash_linker.value.len &&
memcmp(value->s,linker->hash_linker.value.s,value->len)==0){
goto found;
}
/* allow further search - maybe the dialog is inserted twice in
* the same profile, but with different values -bogdan
*/
}
}
atomic_or_int((volatile int*)&dlg->dflags, DLG_FLAG_CHANGED_PROF);
dlg_unlock( d_table, d_entry);
dlg_release(dlg);
return -1;
found:
/* table still locked */
/* remove the linker element from dialog */
if (linker_prev==NULL) {
dlg->profile_links = linker->next;
} else {
linker_prev->next = linker->next;
}
linker->next = NULL;
dlg_unlock( d_table, d_entry);
/* remove linker from profile table and free it */
destroy_linkers(linker);
dlg_release(dlg);
return 1;
}
/* When done, this function also has the job to unref the dialog as removed
* from timer list. This must be done in all cases!!
*/
void dlg_ontimeout( struct dlg_tl *tl)
{
struct dlg_cell *dlg;
int new_state;
int old_state;
int unref;
dlg = get_dlg_tl_payload(tl);
LM_DBG("byeontimeout ? %d , state = %d\n",dlg->flags,dlg->state);
if ( (dlg->flags&DLG_FLAG_BYEONTIMEOUT) &&
(dlg->state==DLG_STATE_CONFIRMED_NA || dlg->state==DLG_STATE_CONFIRMED)) {
init_dlg_term_reason(dlg,"Lifetime Timeout",sizeof("Lifetime Timeout")-1);
/* we just send the BYEs in both directions */
dlg_end_dlg( dlg, NULL);
/* dialog is no longer refed by timer; from now one it is refed
by the send_bye functions */
unref_dlg( dlg, 1);
/* is not 100% sure, but do it */
if_update_stat( dlg_enable_stats, expired_dlgs, 1);
return ;
}
next_state_dlg( dlg, DLG_EVENT_REQBYE, &old_state, &new_state, &unref);
if (new_state==DLG_STATE_DELETED && old_state!=DLG_STATE_DELETED) {
LM_DBG("timeout for dlg with CallID '%.*s' and tags '%.*s' '%.*s'\n",
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));
/*destroy linkers */
destroy_linkers(dlg->profile_links);
dlg->profile_links = NULL;
/* dialog timeout */
run_dlg_callbacks( DLGCB_EXPIRED, dlg, 0, DLG_DIR_NONE, 0);
/* delete the dialog from DB */
if (should_remove_dlg_db())
remove_dialog_from_db(dlg);
unref_dlg(dlg, unref + 1 /*timer list*/);
if_update_stat( dlg_enable_stats, expired_dlgs, 1);
if_update_stat( dlg_enable_stats, active_dlgs, -1);
} else {
unref_dlg(dlg, 1 /*just timer list*/);
}
return;
}
/*!
* \brief Callback for cleanup of profile local vars
* \param msg SIP message
* \param flags unused
* \param param unused
* \return 1
*/
int cb_profile_reset( struct sip_msg *msg, unsigned int flags, void *param )
{
current_dlg_msg_id = 0;
current_dlg_msg_pid = 0;
if (current_pending_linkers) {
destroy_linkers(current_pending_linkers);
current_pending_linkers = NULL;
}
/* need to return non-zero - 0 will break the exec of the request */
return 1;
}
/*!
* \brief Set the global variables to the current dialog
* \param msg SIP message
* \param dlg dialog cell
*/
void set_current_dialog(sip_msg_t *msg, dlg_cell_t *dlg)
{
struct dlg_profile_link *linker;
struct dlg_profile_link *tlinker;
LM_DBG("setting current dialog [%u:%u]\n", dlg->h_entry, dlg->h_id);
/* if linkers are not from current request, just discard them */
if (msg->id!=current_dlg_msg_id || msg->pid!=current_dlg_msg_pid) {
current_dlg_msg_id = msg->id;
current_dlg_msg_pid = msg->pid;
destroy_linkers(current_pending_linkers);
} else {
/* add the linker, one by one, to the dialog */
linker = current_pending_linkers;
while (linker) {
tlinker = linker;
linker = linker->next;
/* process tlinker */
tlinker->next = NULL;
link_dlg_profile( tlinker, dlg);
}
}
current_pending_linkers = NULL;
}
/**
* @brief ht dmq callback
*/
int dlg_dmq_handle_msg(struct sip_msg* msg, peer_reponse_t* resp, dmq_node_t* node)
{
int content_length;
str body;
dlg_cell_t *dlg;
int unref = 0;
int ret;
srjson_doc_t jdoc, prof_jdoc;
srjson_t *it = NULL;
dlg_dmq_action_t action = DLG_DMQ_NONE;
dlg_iuid_t iuid;
str profiles = {0, 0}, callid = {0, 0}, tag1 = {0,0}, tag2 = {0,0},
contact1 = {0,0}, contact2 = {0,0}, k={0,0}, v={0,0};
str cseq1 = {0,0}, cseq2 = {0,0}, route_set1 = {0,0}, route_set2 = {0,0},
from_uri = {0,0}, to_uri = {0,0}, req_uri = {0,0};
unsigned int init_ts = 0, start_ts = 0, lifetime = 0;
unsigned int state = 1;
srjson_t *vj;
/* received dmq message */
LM_DBG("dmq message received\n");
if(!msg->content_length) {
LM_ERR("no content length header found\n");
goto invalid2;
}
content_length = get_content_length(msg);
if(!content_length) {
LM_DBG("content length is 0\n");
goto invalid2;
}
body.s = get_body(msg);
body.len = content_length;
if (!body.s) {
LM_ERR("unable to get body\n");
goto error;
}
/* parse body */
LM_DBG("body: %.*s\n", body.len, body.s);
srjson_InitDoc(&jdoc, NULL);
jdoc.buf = body;
if(jdoc.root == NULL) {
jdoc.root = srjson_Parse(&jdoc, jdoc.buf.s);
if(jdoc.root == NULL)
{
LM_ERR("invalid json doc [[%s]]\n", jdoc.buf.s);
goto invalid;
}
}
for(it=jdoc.root->child; it; it = it->next)
{
if ((it->string == NULL) || (strcmp(it->string, "vars")==0)) continue;
LM_DBG("found field: %s\n", it->string);
if (strcmp(it->string, "action")==0) {
action = SRJSON_GET_UINT(it);
} else if (strcmp(it->string, "h_entry")==0) {
iuid.h_entry = SRJSON_GET_UINT(it);
} else if (strcmp(it->string, "h_id")==0) {
iuid.h_id = SRJSON_GET_UINT(it);
} else if (strcmp(it->string, "init_ts")==0) {
init_ts = SRJSON_GET_UINT(it);
} else if (strcmp(it->string, "start_ts")==0) {
start_ts = SRJSON_GET_UINT(it);
} else if (strcmp(it->string, "state")==0) {
state = SRJSON_GET_UINT(it);
} else if (strcmp(it->string, "lifetime")==0) {
lifetime = SRJSON_GET_UINT(it);
} else if (strcmp(it->string, "callid")==0) {
callid.s = it->valuestring;
callid.len = strlen(callid.s);
} else if (strcmp(it->string, "profiles")==0) {
profiles.s = it->valuestring;
profiles.len = strlen(profiles.s);
} else if (strcmp(it->string, "tag1")==0) {
tag1.s = it->valuestring;
tag1.len = strlen(tag1.s);
} else if (strcmp(it->string, "tag2")==0) {
tag2.s = it->valuestring;
tag2.len = strlen(tag2.s);
} else if (strcmp(it->string, "cseq1")==0) {
cseq1.s = it->valuestring;
cseq1.len = strlen(cseq1.s);
} else if (strcmp(it->string, "cseq2")==0) {
cseq2.s = it->valuestring;
cseq2.len = strlen(cseq2.s);
} else if (strcmp(it->string, "route_set1")==0) {
route_set1.s = it->valuestring;
route_set1.len = strlen(route_set1.s);
} else if (strcmp(it->string, "route_set2")==0) {
route_set2.s = it->valuestring;
route_set2.len = strlen(route_set2.s);
} else if (strcmp(it->string, "contact1")==0) {
contact1.s = it->valuestring;
contact1.len = strlen(contact1.s);
} else if (strcmp(it->string, "contact2")==0) {
contact2.s = it->valuestring;
contact2.len = strlen(contact2.s);
} else if (strcmp(it->string, "from_uri")==0) {
from_uri.s = it->valuestring;
from_uri.len = strlen(from_uri.s);
} else if (strcmp(it->string, "to_uri")==0) {
to_uri.s = it->valuestring;
to_uri.len = strlen(to_uri.s);
} else if (strcmp(it->string, "req_uri")==0) {
req_uri.s = it->valuestring;
req_uri.len = strlen(req_uri.s);
} else {
LM_ERR("unrecognized field in json object\n");
}
}
dlg = dlg_get_by_iuid(&iuid);
if (dlg) {
LM_DBG("found dialog [%u:%u] at %p\n", iuid.h_entry, iuid.h_id, dlg);
unref++;
}
switch(action) {
case DLG_DMQ_UPDATE:
LM_DBG("Updating dlg [%u:%u] with callid [%.*s]\n", iuid.h_entry, iuid.h_id,
callid.len, callid.s);
if (!dlg) {
dlg = build_new_dlg(&callid, &from_uri, &to_uri, &tag1, &req_uri);
if (!dlg) {
LM_ERR("failed to build new dialog\n");
goto error;
}
if(dlg->h_entry != iuid.h_entry){
LM_ERR("inconsistent hash data from peer: "
"make sure all Kamailio's use the same hash size\n");
shm_free(dlg);
goto error;
}
/* link the dialog */
link_dlg(dlg, 0, 0);
dlg_set_leg_info(dlg, &tag1, &route_set1, &contact1, &cseq1, 0);
/* override generated h_id */
dlg->h_id = iuid.h_id;
/* prevent DB sync */
dlg->dflags &= ~(DLG_FLAG_NEW|DLG_FLAG_CHANGED);
dlg->iflags |= DLG_IFLAG_DMQ_SYNC;
} else {
/* remove existing profiles */
if (dlg->profile_links!=NULL) {
destroy_linkers(dlg->profile_links);
dlg->profile_links = NULL;
}
}
dlg->init_ts = init_ts;
dlg->start_ts = start_ts;
vj = srjson_GetObjectItem(&jdoc, jdoc.root, "vars");
if(vj!=NULL) {
for(it=vj->child; it; it = it->next)
{
k.s = it->string; k.len = strlen(k.s);
v.s = it->valuestring; v.len = strlen(v.s);
set_dlg_variable(dlg, &k, &v);
}
}
/* add profiles */
if(profiles.s!=NULL) {
srjson_InitDoc(&prof_jdoc, NULL);
prof_jdoc.buf = profiles;
dlg_json_to_profiles(dlg, &prof_jdoc);
srjson_DestroyDoc(&prof_jdoc);
}
if (state == dlg->state) {
break;
}
/* intentional fallthrough */
case DLG_DMQ_STATE:
if (!dlg) {
LM_ERR("dialog [%u:%u] not found\n", iuid.h_entry, iuid.h_id);
goto error;
}
if (state < dlg->state) {
LM_NOTICE("Ignoring backwards state change on dlg [%u:%u]"
" with callid [%.*s] from state [%u] to state [%u]\n",
iuid.h_entry, iuid.h_id,
dlg->callid.len, dlg->callid.s, dlg->state, state);
break;
}
LM_DBG("State update dlg [%u:%u] with callid [%.*s] from state [%u]"
" to state [%u]\n", iuid.h_entry, iuid.h_id,
dlg->callid.len, dlg->callid.s, dlg->state, state);
switch (state) {
case DLG_STATE_EARLY:
dlg->start_ts = start_ts;
dlg->lifetime = lifetime;
dlg_set_leg_info(dlg, &tag1, &route_set1, &contact1, &cseq1, 0);
break;
case DLG_STATE_CONFIRMED:
dlg->start_ts = start_ts;
dlg->lifetime = lifetime;
dlg_set_leg_info(dlg, &tag1, &route_set1, &contact1, &cseq1, 0);
dlg_set_leg_info(dlg, &tag2, &route_set2, &contact2, &cseq2, 1);
if (insert_dlg_timer( &dlg->tl, dlg->lifetime ) != 0) {
LM_CRIT("Unable to insert dlg timer %p [%u:%u]\n",
dlg, dlg->h_entry, dlg->h_id);
} else {
/* dialog pointer inserted in timer list */
dlg_ref(dlg, 1);
}
break;
case DLG_STATE_DELETED:
if (dlg->state == DLG_STATE_CONFIRMED) {
ret = remove_dialog_timer(&dlg->tl);
if (ret == 0) {
/* one extra unref due to removal from timer list */
unref++;
} else if (ret < 0) {
LM_CRIT("unable to unlink the timer on dlg %p [%u:%u]\n",
dlg, dlg->h_entry, dlg->h_id);
}
}
/* prevent DB sync */
dlg->dflags |= DLG_FLAG_NEW;
/* keep dialog around for a bit, to prevent out-of-order
* syncs to reestablish the dlg */
dlg->init_ts = time(NULL);
break;
default:
LM_ERR("unhandled state update to state %u\n", state);
dlg_unref(dlg, unref);
goto error;
}
dlg->state = state;
break;
case DLG_DMQ_RM:
if (!dlg) {
LM_DBG("dialog [%u:%u] not found\n", iuid.h_entry, iuid.h_id);
goto error;
}
LM_DBG("Removed dlg [%u:%u] with callid [%.*s] int state [%u]\n",
iuid.h_entry, iuid.h_id,
dlg->callid.len, dlg->callid.s, dlg->state);
if (dlg->state==DLG_STATE_CONFIRMED
|| dlg->state==DLG_STATE_EARLY) {
ret = remove_dialog_timer(&dlg->tl);
if (ret == 0) {
/* one extra unref due to removal from timer list */
unref++;
} else if (ret < 0) {
LM_CRIT("unable to unlink the timer on dlg %p [%u:%u]\n",
dlg, dlg->h_entry, dlg->h_id);
}
}
/* prevent DB sync */
dlg->dflags |= DLG_FLAG_NEW;
unref++;
break;
case DLG_DMQ_SYNC:
dmq_send_all_dlgs(0);
break;
case DLG_DMQ_NONE:
break;
}
if (dlg && unref)
dlg_unref(dlg, unref);
srjson_DestroyDoc(&jdoc);
resp->reason = dmq_200_rpl;
resp->resp_code = 200;
return 0;
invalid:
srjson_DestroyDoc(&jdoc);
invalid2:
resp->reason = dmq_400_rpl;
resp->resp_code = 400;
return 0;
error:
srjson_DestroyDoc(&jdoc);
resp->reason = dmq_500_rpl;
resp->resp_code = 500;
return 0;
}
/*!
* \brief Set a dialog profile
* \param msg SIP message
* \param value value
* \param profile dialog profile table
* \return 0 on success, -1 on failure
*/
int set_dlg_profile(struct sip_msg *msg, str *value, struct dlg_profile_table *profile)
{
dlg_cell_t *dlg = NULL;
dlg_profile_link_t *linker;
/* get current dialog */
dlg = dlg_get_msg_dialog(msg);
if (dlg==NULL && !is_route_type(REQUEST_ROUTE)) {
LM_CRIT("BUG - dialog not found in a non REQUEST route (%d)\n",
REQUEST_ROUTE);
return -1;
}
/* build new linker */
linker = (struct dlg_profile_link*)shm_malloc(
sizeof(struct dlg_profile_link) + (profile->has_value?value->len:0) );
if (linker==NULL) {
LM_ERR("no more shm memory\n");
goto error;
}
memset(linker, 0, sizeof(struct dlg_profile_link));
/* set backpointers to profile and linker (itself) */
linker->profile = profile;
linker->hash_linker.linker = linker;
/* set the value */
if (profile->has_value) {
linker->hash_linker.value.s = (char*)(linker+1);
memcpy( linker->hash_linker.value.s, value->s, value->len);
linker->hash_linker.value.len = value->len;
}
sruid_next_safe(&_dlg_profile_sruid);
strcpy(linker->hash_linker.puid, _dlg_profile_sruid.uid.s);
linker->hash_linker.puid_len = _dlg_profile_sruid.uid.len;
if (dlg!=NULL) {
/* add linker directly to the dialog and profile */
link_dlg_profile( linker, dlg);
} else {
/* if existing linkers are not from current request, just discard them */
if (msg->id!=current_dlg_msg_id || msg->pid!=current_dlg_msg_pid) {
current_dlg_msg_id = msg->id;
current_dlg_msg_pid = msg->pid;
destroy_linkers(current_pending_linkers);
current_pending_linkers = NULL;
}
/* no dialog yet -> set linker as pending */
if (msg->id!=current_dlg_msg_id || msg->pid!=current_dlg_msg_pid) {
current_dlg_msg_id = msg->id;
current_dlg_msg_pid = msg->pid;
destroy_linkers(current_pending_linkers);
}
linker->next = current_pending_linkers;
current_pending_linkers = linker;
}
dlg_release(dlg);
return 0;
error:
dlg_release(dlg);
return -1;
}
static void dual_bye_event(struct dlg_cell* dlg, struct sip_msg *req, int extra_unref)
{
int event, old_state, new_state, unref, ret;
struct dlg_cell *curr;
event = DLG_EVENT_REQBYE;
last_dst_leg = dlg->legs_no[DLG_LEG_200OK];
next_state_dlg(dlg, event, DLG_DIR_DOWNSTREAM, &old_state, &new_state,
&unref, 0);
unref += extra_unref;
if(new_state == DLG_STATE_DELETED && old_state != DLG_STATE_DELETED){
LM_DBG("removing dialog with h_entry %u and h_id %u\n",
dlg->h_entry, dlg->h_id);
/*destroy linkers */
dlg_lock_dlg(dlg);
destroy_linkers(dlg->profile_links, 0);
dlg->profile_links = NULL;
dlg_unlock_dlg(dlg);
/* 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_leg_print_info( dlg, DLG_CALLER_LEG, tag),
dlg_leg_print_info( dlg, callee_idx(dlg), tag));
} else if (ret > 0) {
LM_DBG("dlg already expired (not in timer list) %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_leg_print_info( dlg, DLG_CALLER_LEG, tag),
dlg_leg_print_info( dlg, callee_idx(dlg), tag));
} else {
/* successfully removed from timer list */
unref++;
}
curr = current_dlg_pointer;
current_dlg_pointer = dlg;
/* dialog terminated (BYE) */
run_dlg_callbacks( DLGCB_TERMINATED, dlg, req, DLG_DIR_NONE, 0);
current_dlg_pointer = curr;
LM_DBG("first final reply\n");
/* derefering the dialog */
unref_dlg(dlg, unref);
if_update_stat( dlg_enable_stats, active_dlgs, -1);
}
if(new_state == DLG_STATE_DELETED && old_state == DLG_STATE_DELETED ) {
/* trash the dialog from DB and memory */
LM_DBG("second final reply\n");
/* delete the dialog from DB */
if (should_remove_dlg_db())
remove_dialog_from_db(dlg);
/* force delete from mem */
unref_dlg(dlg, unref);
}
}
/**
* 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;
}
static void dual_bye_event(struct dlg_cell* dlg, struct sip_msg *req, int extra_unref)
{
int event, old_state, new_state, unref, ret;
struct sip_msg *fake_msg=NULL;
context_p old_ctx;
context_p *new_ctx;
event = DLG_EVENT_REQBYE;
next_state_dlg(dlg, event, DLG_DIR_DOWNSTREAM, &old_state, &new_state,
&unref, dlg->legs_no[DLG_LEG_200OK], 0);
unref += extra_unref;
if(new_state == DLG_STATE_DELETED && old_state != DLG_STATE_DELETED){
LM_DBG("removing dialog with h_entry %u and h_id %u\n",
dlg->h_entry, dlg->h_id);
/*destroy linkers */
dlg_lock_dlg(dlg);
destroy_linkers(dlg->profile_links, 0);
dlg->profile_links = NULL;
dlg_unlock_dlg(dlg);
/* 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_leg_print_info( dlg, DLG_CALLER_LEG, tag),
dlg_leg_print_info( dlg, callee_idx(dlg), tag));
} else if (ret > 0) {
LM_DBG("dlg already expired (not in timer list) %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_leg_print_info( dlg, DLG_CALLER_LEG, tag),
dlg_leg_print_info( dlg, callee_idx(dlg), tag));
} else {
/* successfully removed from timer list */
unref++;
}
if (req==NULL) {
/* set new msg & processing context */
if (push_new_processing_context( dlg, &old_ctx, &new_ctx, &fake_msg)==0) {
/* dialog terminated (BYE) */
run_dlg_callbacks( DLGCB_TERMINATED, dlg, fake_msg,
DLG_DIR_NONE, NULL, 0);
/* reset the processing context */
if (current_processing_ctx == NULL)
*new_ctx = NULL;
else
context_destroy(CONTEXT_GLOBAL, *new_ctx);
current_processing_ctx = old_ctx;
} /* no CB run in case of failure FIXME */
} else {
/* we should have the msg and context from upper levels */
/* dialog terminated (BYE) */
run_dlg_callbacks( DLGCB_TERMINATED, dlg, req,
DLG_DIR_NONE, NULL, 0);
}
LM_DBG("first final reply\n");
/* derefering the dialog */
unref_dlg(dlg, unref);
if_update_stat( dlg_enable_stats, active_dlgs, -1);
}
if(new_state == DLG_STATE_DELETED && old_state == DLG_STATE_DELETED ) {
/* trash the dialog from DB and memory */
LM_DBG("second final reply\n");
/* delete the dialog from DB */
if (should_remove_dlg_db())
remove_dialog_from_db(dlg);
/* force delete from mem */
unref_dlg(dlg, unref);
}
}
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;
}
static void dlg_onreply(struct cell* t, int type, struct tmcb_params *param)
{
struct sip_msg *rpl,*req;
struct dlg_cell *dlg;
int new_state;
int old_state;
int unref;
int event;
str mangled_from = {0,0};
str mangled_to = {0,0};
str *req_out_buff;
dlg = (struct dlg_cell *)(*param->param);
if (shutdown_done || dlg==0)
return;
rpl = param->rpl;
req = param->req;
if (type==TMCB_RESPONSE_FWDED) {
/* this callback is under transaction lock (by TM), so it is save
to operate at write level, but we need to take care on write-read
conflicts -bogdan */
if (rpl!=FAKED_REPLY) {
if (req->msg_flags & (FL_USE_UAC_FROM | FL_USE_UAC_TO ) ) {
req_out_buff = &t->uac[d_tmb.get_branch_index()].request.buffer;
if (extract_ftc_hdrs(req_out_buff->s,req_out_buff->len,
(req->msg_flags & FL_USE_UAC_FROM )?&mangled_from:0,
(req->msg_flags & FL_USE_UAC_TO )?&mangled_to:0,0,0) != 0) {
LM_ERR("failed to extract mangled FROM and TO hdrs\n");
mangled_from.len = 0;
mangled_from.s = NULL;
mangled_to.len = 0;
mangled_to.s = NULL;
} else {
if ((req->msg_flags & FL_USE_UAC_FROM) && (mangled_from.len == 0 || mangled_from.s == NULL))
LM_CRIT("extract_ftc_hdrs ok but no from extracted : [%.*s]\n",req_out_buff->len,req_out_buff->s);
if ((req->msg_flags & FL_USE_UAC_TO) && (mangled_to.len == 0 || mangled_to.s == NULL))
LM_CRIT("extract_ftc_hdrs ok but no to extracted : [%.*s]\n",req_out_buff->len,req_out_buff->s);
}
}
push_reply_in_dialog( rpl, t, dlg,&mangled_from,&mangled_to);
if((dlg->flags & DLG_FLAG_TOPHIDING) &&
dlg_th_onreply(dlg, rpl,req, 1, DLG_DIR_UPSTREAM) < 0)
LM_ERR("Failed to transform the reply for topology hiding\n");
} else {
LM_DBG("dialog replied from script - cannot get callee info\n");
}
/* The state does not change, but the msg is mutable in this callback*/
run_dlg_callbacks(DLGCB_RESPONSE_FWDED, dlg, rpl, DLG_DIR_UPSTREAM, 0);
return;
}
if (type==TMCB_TRANS_CANCELLED) {
/* only if we did force match the Cancel to the
* dialog before ( from the script ) */
if (current_dlg_pointer == NULL) {
/* reference and attached to script */
ref_dlg(dlg,1);
current_dlg_pointer = t->dialog_ctx;
}
return;
}
if (type==TMCB_TRANS_DELETED)
event = DLG_EVENT_TDEL;
else if (param->code<200)
event = DLG_EVENT_RPL1xx;
else if (param->code<300)
event = DLG_EVENT_RPL2xx;
else
event = DLG_EVENT_RPL3xx;
next_state_dlg( dlg, event, &old_state, &new_state, &unref);
if (new_state==DLG_STATE_EARLY && old_state!=DLG_STATE_EARLY) {
run_dlg_callbacks(DLGCB_EARLY, dlg, rpl, DLG_DIR_UPSTREAM, 0);
if_update_stat(dlg_enable_stats, early_dlgs, 1);
return;
}
if (new_state==DLG_STATE_CONFIRMED_NA &&
old_state!=DLG_STATE_CONFIRMED_NA && old_state!=DLG_STATE_CONFIRMED ) {
LM_DBG("dialog %p confirmed\n",dlg);
/* set start time */
dlg->start_ts = (unsigned int)(time(0));
if (0 != insert_dlg_timer( &dlg->tl, dlg->lifetime )) {
LM_CRIT("Unable to insert dlg %p [%u:%u] on event %d [%d->%d] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id, event, old_state, new_state,
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 {
/* reference dialog as kept in timer list */
ref_dlg(dlg,1);
}
if (dlg->flags & DLG_FLAG_PING_CALLER || dlg->flags & DLG_FLAG_PING_CALLEE) {
if (0 != insert_ping_timer( dlg)) {
LM_CRIT("Unable to insert ping dlg %p [%u:%u] on event %d [%d->%d] "
"with clid '%.*s' and tags '%.*s' '%.*s'\n",
dlg, dlg->h_entry, dlg->h_id, event, old_state, new_state,
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 {
/* reference dialog as kept in ping timer list */
ref_dlg(dlg,1);
}
}
/* save the settings to the database,
* if realtime saving mode configured- save dialog now
* else: the next time the timer will fire the update*/
dlg->flags |= DLG_FLAG_NEW;
if ( dlg_db_mode==DB_MODE_REALTIME )
update_dialog_dbinfo(dlg);
/* dialog confirmed */
run_dlg_callbacks( DLGCB_CONFIRMED, dlg, rpl, DLG_DIR_UPSTREAM, 0);
if (replication_dests)
replicate_dialog_created(dlg);
if (old_state==DLG_STATE_EARLY)
if_update_stat(dlg_enable_stats, early_dlgs, -1);
if_update_stat(dlg_enable_stats, active_dlgs, 1);
return;
}
if ( old_state!=DLG_STATE_DELETED && new_state==DLG_STATE_DELETED ) {
LM_DBG("dialog %p failed (negative reply)\n", dlg);
/*destroy linkers */
destroy_linkers(dlg->profile_links);
dlg->profile_links = NULL;
/* dialog setup not completed (3456XX) */
run_dlg_callbacks( DLGCB_FAILED, dlg, rpl, DLG_DIR_UPSTREAM, 0);
/* do unref */
if (unref)
unref_dlg(dlg,unref);
if (old_state==DLG_STATE_EARLY)
if_update_stat(dlg_enable_stats, early_dlgs, -1);
if_update_stat(dlg_enable_stats, failed_dlgs, 1);
return;
}
/* in any other case, check if the dialog state machine
requests to unref the dialog */
if (unref)
unref_dlg(dlg,unref);
return;
}
/*!
* \brief Destroy a dialog, run callbacks and free memory
* \param dlg destroyed dialog
*/
void destroy_dlg(struct dlg_cell *dlg)
{
int ret = 0;
struct dlg_var *var;
LM_DBG("destroying dialog %p (ref %d)\n", dlg, dlg->ref);
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_DBG("removed timer for 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);
}
run_dlg_callbacks( DLGCB_DESTROY , dlg, NULL, NULL, DLG_DIR_NONE, 0);
/* delete the dialog from DB*/
if (dlg_db_mode)
remove_dialog_from_db(dlg);
if (dlg->cbs.first)
destroy_dlg_callbacks_list(dlg->cbs.first);
if (dlg->profile_links)
destroy_linkers(dlg->profile_links);
if (dlg->tag[DLG_CALLER_LEG].s)
shm_free(dlg->tag[DLG_CALLER_LEG].s);
if (dlg->tag[DLG_CALLEE_LEG].s)
shm_free(dlg->tag[DLG_CALLEE_LEG].s);
if (dlg->cseq[DLG_CALLER_LEG].s)
shm_free(dlg->cseq[DLG_CALLER_LEG].s);
if (dlg->cseq[DLG_CALLEE_LEG].s)
shm_free(dlg->cseq[DLG_CALLEE_LEG].s);
if (dlg->toroute_name.s)
shm_free(dlg->toroute_name.s);
while (dlg->vars) {
var = dlg->vars;
dlg->vars = dlg->vars->next;
shm_free(var->key.s);
shm_free(var->value.s);
shm_free(var);
}
shm_free(dlg);
dlg = 0;
}
/*!
* \brief Update a dialog state according a event and the old state
*
* This functions implement the main state machine that update a dialog
* state according a processed event and the current state. If necessary
* it will delete the processed dialog. The old and new state are also
* saved for reference.
* \param dlg updated dialog
* \param event current event
* \param old_state old dialog state
* \param new_state new dialog state
* \param unref set to 1 when the dialog was deleted, 0 otherwise
*/
void next_state_dlg(dlg_cell_t *dlg, int event,
int *old_state, int *new_state, int *unref)
{
dlg_entry_t *d_entry;
d_entry = &(d_table->entries[dlg->h_entry]);
*unref = 0;
dlg_lock( d_table, d_entry);
*old_state = dlg->state;
switch (event) {
case DLG_EVENT_TDEL:
switch (dlg->state) {
case DLG_STATE_UNCONFIRMED:
case DLG_STATE_EARLY:
dlg->state = DLG_STATE_DELETED;
unref_dlg_unsafe(dlg,1,d_entry);
*unref = 1;
break;
case DLG_STATE_CONFIRMED_NA:
case DLG_STATE_CONFIRMED:
unref_dlg_unsafe(dlg,1,d_entry);
break;
case DLG_STATE_DELETED:
*unref = 1;
break;
default:
log_next_state_dlg(event, dlg);
}
break;
case DLG_EVENT_RPL1xx:
switch (dlg->state) {
case DLG_STATE_UNCONFIRMED:
case DLG_STATE_EARLY:
dlg->state = DLG_STATE_EARLY;
break;
default:
log_next_state_dlg(event, dlg);
}
break;
case DLG_EVENT_RPL3xx:
switch (dlg->state) {
case DLG_STATE_UNCONFIRMED:
case DLG_STATE_EARLY:
dlg->state = DLG_STATE_DELETED;
*unref = 1;
break;
default:
log_next_state_dlg(event, dlg);
}
break;
case DLG_EVENT_RPL2xx:
switch (dlg->state) {
case DLG_STATE_DELETED:
if (dlg->dflags&DLG_FLAG_HASBYE) {
LM_CRIT("bogus event %d in state %d (with BYE) "
"for dlg %p [%u:%u] with clid '%.*s' and tags '%.*s' '%.*s'\n",
event, dlg->state, 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);
break;
}
ref_dlg_unsafe(dlg,1);
case DLG_STATE_UNCONFIRMED:
case DLG_STATE_EARLY:
dlg->state = DLG_STATE_CONFIRMED_NA;
break;
case DLG_STATE_CONFIRMED_NA:
case DLG_STATE_CONFIRMED:
break;
default:
log_next_state_dlg(event, dlg);
}
break;
case DLG_EVENT_REQACK:
switch (dlg->state) {
case DLG_STATE_CONFIRMED_NA:
dlg->state = DLG_STATE_CONFIRMED;
break;
case DLG_STATE_CONFIRMED:
break;
case DLG_STATE_DELETED:
break;
default:
log_next_state_dlg(event, dlg);
}
break;
case DLG_EVENT_REQBYE:
switch (dlg->state) {
case DLG_STATE_CONFIRMED_NA:
case DLG_STATE_CONFIRMED:
dlg->dflags |= DLG_FLAG_HASBYE;
dlg->state = DLG_STATE_DELETED;
*unref = 1;
break;
case DLG_STATE_EARLY:
case DLG_STATE_DELETED:
break;
default:
log_next_state_dlg(event, dlg);
}
break;
case DLG_EVENT_REQPRACK:
switch (dlg->state) {
case DLG_STATE_EARLY:
case DLG_STATE_CONFIRMED_NA:
case DLG_STATE_DELETED:
break;
default:
log_next_state_dlg(event, dlg);
}
break;
case DLG_EVENT_REQ:
switch (dlg->state) {
case DLG_STATE_EARLY:
case DLG_STATE_CONFIRMED_NA:
case DLG_STATE_CONFIRMED:
case DLG_STATE_DELETED:
break;
default:
log_next_state_dlg(event, dlg);
}
break;
default:
LM_CRIT("unknown event %d in state %d "
"for dlg %p [%u:%u] with clid '%.*s' and tags '%.*s' '%.*s'\n",
event, dlg->state, 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);
}
*new_state = dlg->state;
/* remove the dialog from profiles when is not no longer active */
if(*new_state==DLG_STATE_DELETED && dlg->profile_links!=NULL
&& *old_state!=*new_state) {
destroy_linkers(dlg->profile_links);
dlg->profile_links = NULL;
}
dlg_unlock( d_table, d_entry);
LM_DBG("dialog %p changed from state %d to "
"state %d, due event %d (ref %d)\n", dlg, *old_state, *new_state, event,
dlg->ref);
}
void rcv_cluster_event(enum clusterer_event ev, int node_id)
{
struct dlg_sharing_tag *tag;
struct n_send_info *ni;
int lock_old_flag;
struct dlg_cell *dlg, *next_dlg;
int i;
int ret;
int unref;
if (ev == SYNC_REQ_RCV && receive_sync_request(node_id) < 0)
LM_ERR("Failed to reply to sync request from node: %d\n", node_id);
else if (ev == SYNC_DONE) {
if (dlg_db_mode == DB_MODE_NONE)
return;
/* drop dialogs loaded from DB which have not been reconfirmed
* through syncing or SIP(updates) */
for (i = 0; i < d_table->size; i++) {
dlg_lock(d_table, &d_table->entries[i]);
dlg = d_table->entries[i].first;
while (dlg) {
if (!(dlg->flags & DLG_FLAG_FROM_DB)) {
dlg = dlg->next;
continue;
}
LM_DBG("Drop DB loaded dialog ID=%lld\n",
((long long)dlg->h_entry << 32) | (dlg->h_id));
unref = 1; /* unref from hash */
dlg->state = DLG_STATE_DELETED;
destroy_linkers(dlg->profile_links, 0);
dlg->profile_links = NULL;
/* remove from timer */
ret = remove_dlg_timer(&dlg->tl);
if (ret < 0) {
LM_ERR("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_leg_print_info(dlg, DLG_CALLER_LEG, tag),
dlg_leg_print_info(dlg, callee_idx(dlg), tag));
} else if (ret == 0)
/* successfully removed from timer list */
unref++;
if (dlg_db_mode != DB_MODE_SHUTDOWN) {
dlg->flags &= ~DLG_FLAG_NEW;
remove_dialog_from_db(dlg);
dlg->flags |= DLG_FLAG_DB_DELETED;
}
if (dlg_db_mode == DB_MODE_DELAYED)
unref++;
next_dlg = dlg->next;
unref_dlg_unsafe(dlg, unref, &d_table->entries[i]);
dlg = next_dlg;
}
dlg_unlock(d_table, &d_table->entries[i]);
}
} else if (ev == CLUSTER_NODE_UP) {
lock_start_sw_read(shtags_lock);
for (tag = *shtags_list; tag; tag = tag->next) {
if (!tag->send_active_msg)
continue;
/* send sharing tag active msg to nodes to which we didn't already */
for (ni = tag->active_msgs_sent; ni && ni->node_id != node_id;
ni = ni->next) ;
if (!ni) {
if (send_shtag_active_info(&tag->name, node_id) < 0) {
LM_ERR("Failed to send info about sharing tag\n");
continue;
}
ni = shm_malloc(sizeof *ni);
if (!ni) {
LM_ERR("No more shm memory!\n");
return;
}
ni->node_id = node_id;
ni->next = tag->active_msgs_sent;
lock_switch_write(shtags_lock, lock_old_flag);
tag->active_msgs_sent = ni;
lock_switch_read(shtags_lock, lock_old_flag);
}
}
lock_stop_sw_read(shtags_lock);
}
}
