struct dlg_cell* get_dlg_by_callid( str *callid)
{
struct dlg_cell *dlg;
struct dlg_entry *d_entry;
unsigned int h_entry;
h_entry = dlg_hash(callid);
d_entry = &(d_table->entries[h_entry]);
dlg_lock( d_table, d_entry);
LM_DBG("input ci=<%.*s>(%d)\n", callid->len,callid->s, callid->len);
for( dlg = d_entry->first ; dlg ; dlg = dlg->next ) {
if ( dlg->state>DLG_STATE_CONFIRMED )
continue;
if ( dlg->callid.len==callid->len &&
strncmp( dlg->callid.s, callid->s, callid->len)==0 ) {
ref_dlg_unsafe( dlg, 1);
dlg_unlock( d_table, d_entry);
return dlg;
}
}
dlg_unlock( d_table, d_entry);
return NULL;
}
/* referred to as a dialog."*/
struct dlg_cell* get_dlg( str *callid, str *ftag, str *ttag,
unsigned int *dir, unsigned int *dst_leg)
{
struct dlg_cell *dlg;
struct dlg_entry *d_entry;
unsigned int h_entry;
h_entry = dlg_hash(callid);
d_entry = &(d_table->entries[h_entry]);
dlg_lock( d_table, d_entry);
LM_DBG("input ci=<%.*s>(%d), tt=<%.*s>(%d), ft=<%.*s>(%d)\n",
callid->len,callid->s, callid->len,
ftag->len, ftag->s, ftag->len,
ttag->len, ttag->s, ttag->len);
for( dlg = d_entry->first ; dlg ; dlg = dlg->next ) {
/* Check callid / fromtag / totag */
#ifdef EXTRA_DEBUG
LM_DBG("DLG (%p)(%d): ci=<%.*s>(%d), ft=<%.*s>(%d), tt=<%.*s>(%d),"
"ct_er=%d, ct_ee=%d\n",
dlg,dlg->state,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,dlg->legs[callee_idx(dlg)].tag.s,
dlg->legs[callee_idx(dlg)].tag.len,
dlg->legs[DLG_CALLER_LEG].contact.len,
dlg->legs[DLG_CALLER_LEG].contact.len);
#endif
if (match_dialog( dlg, callid, ftag, ttag, dir, dst_leg)==1) {
if (dlg->state==DLG_STATE_DELETED)
/* even if matched, skip the deleted dialogs as they may be
a previous unsuccessful attempt of established call
with the same callid and fromtag - like in auth/challenge
case -bogdan */
continue;
dlg->ref++;
LM_DBG("ref dlg %p with 1 -> %d\n", dlg, dlg->ref);
dlg_unlock( d_table, d_entry);
LM_DBG("dialog callid='%.*s' found\n on entry %u, dir=%d\n",
callid->len, callid->s,h_entry,*dir);
return dlg;
}
}
dlg_unlock( d_table, d_entry);
LM_DBG("no dialog callid='%.*s' found\n", callid->len, callid->s);
return 0;
}
struct dlg_cell* build_new_dlg( str *callid, str *from_uri, str *to_uri,
str *from_tag)
{
struct dlg_cell *dlg;
int len;
char *p;
len = sizeof(struct dlg_cell) + callid->len + from_uri->len +
to_uri->len;
dlg = (struct dlg_cell*)shm_malloc( len );
if (dlg==0) {
LM_ERR("no more shm mem (%d)\n",len);
return 0;
}
memset( dlg, 0, len);
dlg->state = DLG_STATE_UNCONFIRMED;
dlg->h_entry = dlg_hash( callid);
LM_DBG("new dialog %p (c=%.*s,f=%.*s,t=%.*s,ft=%.*s) on hash %u\n",
dlg, callid->len,callid->s, from_uri->len, from_uri->s,
to_uri->len,to_uri->s, from_tag->len, from_tag->s, dlg->h_entry);
p = (char*)(dlg+1);
dlg->callid.s = p;
dlg->callid.len = callid->len;
memcpy( p, callid->s, callid->len);
p += callid->len;
dlg->from_uri.s = p;
dlg->from_uri.len = from_uri->len;
memcpy( p, from_uri->s, from_uri->len);
p += from_uri->len;
dlg->to_uri.s = p;
dlg->to_uri.len = to_uri->len;
memcpy( p, to_uri->s, to_uri->len);
p += to_uri->len;
if ( p!=(((char*)dlg)+len) ) {
LM_CRIT("buffer overflow\n");
shm_free(dlg);
return 0;
}
return dlg;
}
/**
* 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 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;
}
/*
* IMPORTANT: if a dialog reference is returned, the dialog hash entry will
be kept locked when this function returns
NOTE: if a reply tree is returned, no dialog reference is returned.
*/
static inline struct mi_root* process_mi_params(struct mi_root *cmd_tree,
struct dlg_cell **dlg_p, unsigned int *idx, unsigned int *cnt)
{
struct mi_node* node;
struct dlg_entry *d_entry;
struct dlg_cell *dlg;
str *p1;
str *p2;
unsigned int h_entry;
node = cmd_tree->node.kids;
if (node == NULL) {
/* no parameters at all */
*dlg_p = NULL;
*idx = *cnt = 0;
return NULL;
}
/* we have params -> get p1 and p2 */
p1 = &node->value;
LM_DBG("p1='%.*s'\n", p1->len, p1->s);
node = node->next;
if ( !node || !node->value.s || !node->value.len) {
p2 = NULL;
} else {
p2 = &node->value;
LM_DBG("p2='%.*s'\n", p2->len, p2->s);
if ( node->next!=NULL )
return init_mi_tree( 400, MI_SSTR(MI_MISSING_PARM));
}
/* check the params */
if (p2 && str2int(p1,idx)==0 && str2int(p2,cnt)==0) {
/* 2 numerical params -> index and counter */
*dlg_p = NULL;
return NULL;
}
*idx = *cnt = 0;
if (!p1->s)
return init_mi_tree( 400, "Invalid Call-ID specified", 25);
h_entry = dlg_hash( p1/*callid*/ );
d_entry = &(d_table->entries[h_entry]);
dlg_lock( d_table, d_entry);
for( dlg = d_entry->first ; dlg ; dlg = dlg->next ) {
if (match_downstream_dialog( dlg, p1/*callid*/, p2/*from_tag*/)==1) {
if (dlg->state==DLG_STATE_DELETED) {
*dlg_p = NULL;
break;
} else {
*dlg_p = dlg;
return 0;
}
}
}
dlg_unlock( d_table, d_entry);
return init_mi_tree( 404, MI_SSTR("No such dialog"));
}