Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
997 lines (844 sloc) 28.2 KB
/*
* Copyright (C) 2007 Voice System SRL
* Copyright (C) 2011 Carsten Bock, carsten@ng-voice.com
*
* This file is part of Kamailio, a free SIP server.
*
* Kamailio is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version
*
* Kamailio is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/*!
* \file
* \brief Database interface
* \ingroup dialog
* Module: \ref dialog
*/
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include "../../core/dprint.h"
#include "../../core/ut.h"
#include "../../core/timer.h"
#include "../../lib/srdb1/db.h"
#include "../../core/str.h"
#include "../../core/socket_info.h"
#include "../../core/counters.h"
#include "dlg_hash.h"
#include "dlg_var.h"
#include "dlg_profile.h"
#include "dlg_db_handler.h"
str call_id_column = str_init(CALL_ID_COL);
str from_uri_column = str_init(FROM_URI_COL);
str from_tag_column = str_init(FROM_TAG_COL);
str to_uri_column = str_init(TO_URI_COL);
str to_tag_column = str_init(TO_TAG_COL);
str h_id_column = str_init(HASH_ID_COL);
str h_entry_column = str_init(HASH_ENTRY_COL);
str state_column = str_init(STATE_COL);
str start_time_column = str_init(START_TIME_COL);
str timeout_column = str_init(TIMEOUT_COL);
str to_cseq_column = str_init(TO_CSEQ_COL);
str from_cseq_column = str_init(FROM_CSEQ_COL);
str to_route_column = str_init(TO_ROUTE_COL);
str from_route_column = str_init(FROM_ROUTE_COL);
str to_contact_column = str_init(TO_CONTACT_COL);
str from_contact_column = str_init(FROM_CONTACT_COL);
str to_sock_column = str_init(TO_SOCK_COL);
str from_sock_column = str_init(FROM_SOCK_COL);
str sflags_column = str_init(SFLAGS_COL);
str iflags_column = str_init(IFLAGS_COL);
str toroute_name_column = str_init(TOROUTE_NAME_COL);
str req_uri_column = str_init(REQ_URI_COL);
str xdata_column = str_init(XDATA_COL);
str dialog_table_name = str_init(DIALOG_TABLE_NAME);
int dlg_db_mode = DB_MODE_NONE;
str vars_h_id_column = str_init(VARS_HASH_ID_COL);
str vars_h_entry_column = str_init(VARS_HASH_ENTRY_COL);
str vars_key_column = str_init(VARS_KEY_COL);
str vars_value_column = str_init(VARS_VALUE_COL);
str dialog_vars_table_name = str_init(DIALOG_VARS_TABLE_NAME);
static db1_con_t* dialog_db_handle = 0; /* database connection handle */
static db_func_t dialog_dbf;
extern int dlg_enable_stats;
extern int dlg_h_id_start;
extern int dlg_h_id_step;
#define SET_STR_VALUE(_val, _str)\
do{\
VAL_STR((_val)).s = (_str).s;\
VAL_STR((_val)).len = (_str).len;\
}while(0);
#define SET_NULL_FLAG(_vals, _i, _max, _flag)\
do{\
for((_i) = 0;(_i)<(_max); (_i)++)\
VAL_NULL((_vals)+(_i)) = (_flag);\
}while(0);
#define SET_PROPER_NULL_FLAG(_str, _vals, _index)\
do{\
if( (_str).len == 0)\
VAL_NULL( (_vals)+(_index) ) = 1;\
else\
VAL_NULL( (_vals)+(_index) ) = 0;\
}while(0);
#define GET_STR_VALUE(_res, _values, _index, _not_null, _unref)\
do{\
if (VAL_NULL((_values)+ (_index))) { \
if (_not_null) {\
if (_unref) dlg_unref(dlg,1);\
goto next_dialog; \
} else { \
(_res).s = 0; \
(_res).len = 0; \
}\
} else { \
(_res).s = VAL_STR((_values)+ (_index)).s;\
(_res).len = strlen(VAL_STR((_values)+ (_index)).s);\
} \
}while(0);
static int load_dialog_vars_from_db(int fetch_num_rows, int mode,
dlg_iuid_t *mval);
int dlg_connect_db(const str *db_url)
{
if (dialog_db_handle) {
LM_CRIT("BUG - db connection found already open\n");
return -1;
}
if ((dialog_db_handle = dialog_dbf.init(db_url)) == 0)
return -1;
return 0;
}
int init_dlg_db(const str *db_url, int dlg_hash_size , int db_update_period, int fetch_num_rows, int db_skip_load)
{
/* Find a database module */
if (db_bind_mod(db_url, &dialog_dbf) < 0){
LM_ERR("Unable to bind to a database driver\n");
return -1;
}
if (dlg_connect_db(db_url)!=0){
LM_ERR("Unable to connect to the database\n");
return -1;
}
if(db_check_table_version(&dialog_dbf, dialog_db_handle, &dialog_table_name, DLG_TABLE_VERSION) < 0) {
DB_TABLE_VERSION_ERROR(dialog_table_name);
goto dberror;
}
if(db_check_table_version(&dialog_dbf, dialog_db_handle, &dialog_vars_table_name, DLG_VARS_TABLE_VERSION) < 0) {
DB_TABLE_VERSION_ERROR(dialog_vars_table_name);
goto dberror;
}
if( (dlg_db_mode==DB_MODE_DELAYED) && (register_timer( dialog_update_db, 0, db_update_period)<0 )) {
LM_ERR("Failed to register update db timer\n");
goto dberror;
}
if ( db_skip_load == 0 ) {
if( (load_dialog_info_from_db(dlg_hash_size, fetch_num_rows, 0, NULL) ) !=0 ){
LM_ERR("Unable to load the dialog data\n");
goto dberror;
}
if( (load_dialog_vars_from_db(fetch_num_rows, 0, NULL) ) !=0 ){
LM_ERR("Unable to load the dialog variable data\n");
goto dberror;
}
}
dialog_dbf.close(dialog_db_handle);
dialog_db_handle = 0;
return 0;
dberror:
dialog_dbf.close(dialog_db_handle);
dialog_db_handle = 0;
return -1;
}
void destroy_dlg_db(void)
{
/* close the DB connection */
if (dialog_db_handle) {
dialog_dbf.close(dialog_db_handle);
dialog_db_handle = 0;
}
}
static int use_dialog_table(void)
{
if(!dialog_db_handle){
LM_ERR("invalid database handle\n");
return -1;
}
if (dialog_dbf.use_table(dialog_db_handle, &dialog_table_name) < 0) {
LM_ERR("Error in use_table\n");
return -1;
}
return 0;
}
static int use_dialog_vars_table(void)
{
if(!dialog_db_handle){
LM_ERR("invalid database handle for dialog_vars\n");
return -1;
}
if (dialog_dbf.use_table(dialog_db_handle, &dialog_vars_table_name) < 0) {
LM_ERR("Error in use_table for dialog_vars\n");
return -1;
}
return 0;
}
struct socket_info * create_socket_info(db_val_t * vals, int n){
struct socket_info * sock;
char* p;
str host;
int port, proto;
/* socket name */
p = (VAL_STR(vals+n)).s;
if (VAL_NULL(vals+n) || p==0 || p[0]==0){
sock = 0;
} else {
if (parse_phostport( p, &host.s, &host.len,
&port, &proto)!=0) {
LM_ERR("bad socket <%s>\n", p);
return 0;
}
sock = grep_sock_info( &host, (unsigned short)port, proto);
if (sock==0) {
LM_WARN("non-local socket <%s>...ignoring\n", p);
}
}
return sock;
}
int load_dialog_info_from_db(int dlg_hash_size, int fetch_num_rows,
int mode, str *mval)
{
db_key_t query_cols[DIALOG_TABLE_COL_NO] = { &h_entry_column,
&h_id_column, &call_id_column, &from_uri_column,
&from_tag_column, &to_uri_column, &to_tag_column,
&start_time_column, &state_column, &timeout_column,
&from_cseq_column, &to_cseq_column, &from_route_column,
&to_route_column, &from_contact_column, &to_contact_column,
&from_sock_column, &to_sock_column, &sflags_column,
&toroute_name_column, &req_uri_column, &xdata_column,
&iflags_column};
db_key_t match_cols[1] = { &call_id_column };
db_val_t match_vals[1];
int match_cols_no = 0;
db1_res_t * res;
db_val_t * values;
db_row_t * rows;
int i, nr_rows;
struct dlg_cell *dlg;
str callid, from_uri, to_uri, from_tag, to_tag, req_uri;
str cseq1, cseq2, contact1, contact2, rroute1, rroute2;
str toroute_name;
str xdata;
unsigned int next_id;
srjson_doc_t jdoc;
#define DLG_MAX_DB_LOAD_EXTRA 256
dlg_iuid_t dbuid[DLG_MAX_DB_LOAD_EXTRA];
int loaded_extra = 0;
int loaded_extra_more = 0;
dlg_cell_t *dit;
if(use_dialog_table() != 0){
return -1;
}
if(mode==1 && mval!=NULL && mval->len>0) {
match_vals[0].type = DB1_STR;
match_vals[0].nul = 0;
match_vals[0].val.str_val = *mval;
match_cols_no = 1;
}
res = 0;
if (DB_CAPABILITY(dialog_dbf, DB_CAP_FETCH) && (fetch_num_rows > 0)) {
if(dialog_dbf.query(dialog_db_handle, match_cols, 0, match_vals,
query_cols, match_cols_no, DIALOG_TABLE_COL_NO, 0, 0) < 0) {
LM_ERR("Error while querying (fetch) database\n");
goto error;
}
if(dialog_dbf.fetch_result(dialog_db_handle, &res, fetch_num_rows) < 0) {
LM_ERR("fetching rows failed\n");
goto error;
}
} else {
if(dialog_dbf.query(dialog_db_handle, match_cols, 0, match_vals,
query_cols, match_cols_no, DIALOG_TABLE_COL_NO, 0, &res) < 0) {
LM_ERR("Error while querying database\n");
goto error;
}
}
nr_rows = RES_ROW_N(res);
LM_DBG("the database has information about %i dialogs\n", nr_rows);
rows = RES_ROWS(res);
do {
/* for every row---dialog */
for(i=0; i<nr_rows; i++){
values = ROW_VALUES(rows + i);
if (VAL_NULL(values) || VAL_NULL(values+1)) {
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
h_entry_column.len, h_entry_column.s,
h_id_column.len, h_id_column.s);
continue;
}
if (VAL_NULL(values+7) || VAL_NULL(values+8)) {
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
start_time_column.len, start_time_column.s,
state_column.len, state_column.s);
continue;
}
/*restore the dialog info*/
GET_STR_VALUE(callid, values, 2, 1, 0);
GET_STR_VALUE(from_uri, values, 3, 1, 0);
GET_STR_VALUE(from_tag, values, 4, 1, 0);
GET_STR_VALUE(to_uri, values, 5, 1, 0);
GET_STR_VALUE(req_uri, values, 20, 1, 0);
if((dlg=build_new_dlg(&callid, &from_uri, &to_uri, &from_tag,
&req_uri))==0){
LM_ERR("failed to build new dialog\n");
goto error;
}
if(dlg->h_entry != VAL_INT(values)){
LM_ERR("inconsistent hash data in the dialog database: "
"you may have restarted Kamailio using a different "
"hash_size: please erase %.*s database and restart\n",
dialog_table_name.len, dialog_table_name.s);
shm_free(dlg);
goto error;
}
if(mode!=0) {
dlg_lock(d_table, &(d_table->entries[dlg->h_entry]));
/* loading at runtime - check dialog id conflicts */
dit = (d_table->entries)[dlg->h_entry].first;
while (dit) {
if (dit->h_id == VAL_INT(values+1)) {
break;
}
dit = dit->next;
}
if(dit) {
if(mode==1) {
LM_WARN("conflicting dialog id: %u/%u - skipping\n",
dlg->h_entry, (unsigned int)VAL_INT(values+1));
} else {
LM_DBG("conflicting dialog id: %u/%u - skipping\n",
dlg->h_entry, (unsigned int)VAL_INT(values+1));
}
dlg_unlock(d_table, &(d_table->entries[dlg->h_entry]));
shm_free(dlg);
continue;
}
}
/*link the dialog*/
link_dlg(dlg, 0, 0);
dlg->h_id = VAL_INT(values+1);
next_id = d_table->entries[dlg->h_entry].next_id;
if(dlg_h_id_step==1) {
d_table->entries[dlg->h_entry].next_id =
(next_id <= dlg->h_id) ? (dlg->h_id+1) : next_id;
} else {
/* update next id only if matches this instance series */
if((dlg->h_id - dlg_h_id_start) % dlg_h_id_step == 0) {
d_table->entries[dlg->h_entry].next_id =
(next_id <= dlg->h_id) ? (dlg->h_id + dlg_h_id_step)
: next_id;
}
}
if(mode!=0) {
dlg_unlock(d_table, &(d_table->entries[dlg->h_entry]));
}
GET_STR_VALUE(to_tag, values, 6, 1, 1);
dlg->start_ts = VAL_INT(values+7);
dlg->state = VAL_INT(values+8);
if (dlg->state==DLG_STATE_CONFIRMED_NA ||
dlg->state==DLG_STATE_CONFIRMED) {
if_update_stat(dlg_enable_stats, active_dlgs, 1);
} else if (dlg->state==DLG_STATE_EARLY) {
if_update_stat(dlg_enable_stats, early_dlgs, 1);
}
dlg->tl.timeout = (unsigned int)(VAL_INT(values+9));
LM_DBG("db dialog timeout is %u (%u/%u)\n", dlg->tl.timeout,
get_ticks(), (unsigned int)time(0));
if (dlg->tl.timeout<=(unsigned int)time(0)) {
dlg->tl.timeout = 0;
dlg->lifetime = 0;
} else {
dlg->lifetime = dlg->tl.timeout - dlg->start_ts;
dlg->tl.timeout -= (unsigned int)time(0);
}
GET_STR_VALUE(cseq1, values, 10 , 1, 1);
GET_STR_VALUE(cseq2, values, 11 , 1, 1);
GET_STR_VALUE(rroute1, values, 12, 0, 0);
GET_STR_VALUE(rroute2, values, 13, 0, 0);
GET_STR_VALUE(contact1, values, 14, 1, 1);
GET_STR_VALUE(contact2, values, 15, 1, 1);
if ( (dlg_set_leg_info( dlg, &from_tag, &rroute1, &contact1,
&cseq1, DLG_CALLER_LEG)!=0) ||
(dlg_set_leg_info( dlg, &to_tag, &rroute2, &contact2, &cseq2, DLG_CALLEE_LEG)!=0) ) {
LM_ERR("dlg_set_leg_info failed\n");
dlg_unref(dlg,1);
continue;
}
dlg->bind_addr[DLG_CALLER_LEG] = create_socket_info(values, 16);
dlg->bind_addr[DLG_CALLEE_LEG] = create_socket_info(values, 17);
dlg->sflags = (unsigned int)VAL_INT(values+18);
GET_STR_VALUE(toroute_name, values, 19, 0, 0);
dlg_set_toroute(dlg, &toroute_name);
GET_STR_VALUE(xdata, values, 21, 0, 0);
if(xdata.s!=NULL && dlg->state!=DLG_STATE_DELETED)
{
srjson_InitDoc(&jdoc, NULL);
jdoc.buf = xdata;
dlg_json_to_profiles(dlg, &jdoc);
srjson_DestroyDoc(&jdoc);
}
dlg->iflags = (unsigned int)VAL_INT(values+22);
if (dlg->state==DLG_STATE_CONFIRMED)
dlg_ka_add(dlg);
if (!dlg->bind_addr[DLG_CALLER_LEG] || !dlg->bind_addr[DLG_CALLEE_LEG]) {
/* non-local socket, probably not our dialog */
dlg->iflags &= ~DLG_IFLAG_DMQ_SYNC;
}
if(dlg->state==DLG_STATE_DELETED) {
/* end_ts used for force clean up not stored - set it to now */
dlg->end_ts = (unsigned int)time(0);
}
/*restore the timer values */
if (0 != insert_dlg_timer( &(dlg->tl), (int)dlg->tl.timeout )) {
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->tag[DLG_CALLER_LEG].len, dlg->tag[DLG_CALLER_LEG].s,
dlg->tag[DLG_CALLEE_LEG].len, dlg->tag[DLG_CALLEE_LEG].s);
dlg_unref(dlg,1);
continue;
}
dlg_ref(dlg,1);
LM_DBG("current dialog timeout is %u (%u)\n", dlg->tl.timeout,
get_ticks());
dlg->dflags = 0;
if(mode!=0) {
if(loaded_extra<DLG_MAX_DB_LOAD_EXTRA) {
dbuid[loaded_extra].h_entry = dlg->h_entry;
dbuid[loaded_extra].h_id = dlg->h_id;
loaded_extra++;
} else {
dlg->dflags |= DLG_FLAG_DB_LOAD_EXTRA;
loaded_extra_more = 1;
}
}
next_dialog:
;
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(dialog_dbf, DB_CAP_FETCH) && (fetch_num_rows > 0)) {
if(dialog_dbf.fetch_result(dialog_db_handle, &res, fetch_num_rows) < 0) {
LM_ERR("re-fetching rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(res);
rows = RES_ROWS(res);
} else {
nr_rows = 0;
}
} while (nr_rows>0);
if(mode!=0) {
for(i=0; i<loaded_extra; i++) {
load_dialog_vars_from_db(fetch_num_rows, 1, &dbuid[i]);
}
if(loaded_extra_more) {
/* more dialogs loaded - scan hash table */
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->dflags & DLG_FLAG_DB_LOAD_EXTRA) {
dbuid[0].h_entry = dlg->h_entry;
dbuid[0].h_id = dlg->h_id;
load_dialog_vars_from_db(fetch_num_rows, 1, &dbuid[0]);
dlg->dflags &= ~DLG_FLAG_DB_LOAD_EXTRA;
}
dlg = dlg->next;
}
dlg_unlock(d_table, &d_table->entries[i]);
}
}
goto end;
}
if (dlg_db_mode==DB_MODE_SHUTDOWN) {
if (dialog_dbf.delete(dialog_db_handle, 0, 0, 0, 0) < 0) {
LM_ERR("failed to clear dialog table\n");
goto error;
}
}
end:
dialog_dbf.free_result(dialog_db_handle, res);
return 0;
error:
if(res!=NULL) dialog_dbf.free_result(dialog_db_handle, res);
return -1;
}
static int load_dialog_vars_from_db(int fetch_num_rows, int mode,
dlg_iuid_t *mval)
{
db_key_t query_cols[DIALOG_VARS_TABLE_COL_NO] = { &vars_h_entry_column,
&vars_h_id_column, &vars_key_column, &vars_value_column };
db_key_t match_cols[2] = { &vars_h_entry_column, &vars_h_id_column};
db_val_t match_vals[2];
int match_cols_no = 0;
db1_res_t * res;
db_val_t * values;
db_row_t * rows;
struct dlg_cell * dlg;
int i, nr_rows;
if(use_dialog_vars_table() != 0){
return -1;
}
if(mode==1 && mval!=NULL) {
VAL_TYPE(match_vals) = VAL_TYPE(match_vals+1) = DB1_INT;
VAL_NULL(match_vals) = VAL_NULL(match_vals+1) = 0;
VAL_INT(match_vals) = mval->h_entry;
VAL_INT(match_vals+1) = mval->h_id;
match_cols_no = 2;
}
res = 0;
/* select the whole table and all the columns */
if (DB_CAPABILITY(dialog_dbf, DB_CAP_FETCH) && (fetch_num_rows > 0)) {
if(dialog_dbf.query(dialog_db_handle, match_cols, 0, match_vals,
query_cols, match_cols_no, DIALOG_VARS_TABLE_COL_NO, 0, 0)
< 0) {
LM_ERR("Error while querying (fetch) database\n");
goto error;
}
if(dialog_dbf.fetch_result(dialog_db_handle, &res, fetch_num_rows) < 0) {
LM_ERR("fetching rows failed\n");
goto error;
}
} else {
if(dialog_dbf.query(dialog_db_handle, match_cols, 0, match_vals,
query_cols, match_cols_no, DIALOG_VARS_TABLE_COL_NO, 0,
&res) < 0) {
LM_ERR("Error while querying database\n");
goto error;
}
}
nr_rows = RES_ROW_N(res);
LM_DBG("the database has information about %i dialog variables\n", nr_rows);
rows = RES_ROWS(res);
do {
/* for every row---dialog */
for(i=0; i<nr_rows; i++){
values = ROW_VALUES(rows + i);
if (VAL_NULL(values) || VAL_NULL(values+1)) {
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
vars_h_entry_column.len, vars_h_entry_column.s,
vars_h_id_column.len, vars_h_id_column.s);
continue;
}
if (VAL_NULL(values+2) || VAL_NULL(values+3)) {
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
vars_key_column.len, vars_key_column.s,
vars_value_column.len, vars_value_column.s);
continue;
}
if (VAL_INT(values) < d_table->size) {
if(mode==1 && mval!=NULL) {
dlg_lock(d_table, &(d_table->entries[VAL_INT(values)]));
}
dlg = (d_table->entries)[VAL_INT(values)].first;
while (dlg) {
if (dlg->h_id == VAL_INT(values+1)) {
str key = { VAL_STR(values+2).s, strlen(VAL_STRING(values+2)) };
str value = { VAL_STR(values+3).s, strlen(VAL_STRING(values+3)) };
set_dlg_variable_unsafe(dlg, &key, &value);
break;
}
dlg = dlg->next;
if (!dlg) {
LM_WARN("inconsistent data: the dialog h_entry/h_id does not exist!\n");
}
}
if(mode==1 && mval!=NULL) {
dlg_unlock(d_table, &(d_table->entries[VAL_INT(values)]));
}
} else {
LM_WARN("inconsistent data: the h_entry in the DB does not exist!\n");
}
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(dialog_dbf, DB_CAP_FETCH) && (fetch_num_rows > 0)) {
if(dialog_dbf.fetch_result(dialog_db_handle, &res, fetch_num_rows) < 0) {
LM_ERR("re-fetching rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(res);
rows = RES_ROWS(res);
} else {
nr_rows = 0;
}
}while (nr_rows>0);
if(mode!=0) {
goto end;
}
if (dlg_db_mode==DB_MODE_SHUTDOWN) {
if (dialog_dbf.delete(dialog_db_handle, 0, 0, 0, 0) < 0) {
LM_ERR("failed to clear dialog variable table\n");
goto error;
}
}
end:
dialog_dbf.free_result(dialog_db_handle, res);
return 0;
error:
if(res!=0) dialog_dbf.free_result(dialog_db_handle, res);
return -1;
}
/*this is only called from destroy_dlg, where the cell's entry lock is acquired*/
int remove_dialog_from_db(struct dlg_cell * cell)
{
db_val_t values[2];
db_key_t match_keys[2] = { &h_entry_column, &h_id_column};
db_key_t vars_match_keys[2] = { &vars_h_entry_column, &vars_h_id_column};
/*if the dialog hasn 't been yet inserted in the database*/
LM_DBG("trying to remove dialog [%.*s], update_flag is %i\n",
cell->callid.len, cell->callid.s,
cell->dflags);
if (cell->dflags & DLG_FLAG_NEW)
return 0;
if (use_dialog_table()!=0)
return -1;
VAL_TYPE(values) = VAL_TYPE(values+1) = DB1_INT;
VAL_NULL(values) = VAL_NULL(values+1) = 0;
VAL_INT(values) = cell->h_entry;
VAL_INT(values+1) = cell->h_id;
if(dialog_dbf.delete(dialog_db_handle, match_keys, 0, values, 2) < 0) {
LM_ERR("failed to delete database information\n");
return -1;
}
if (use_dialog_vars_table()!=0)
return -1;
if(dialog_dbf.delete(dialog_db_handle, vars_match_keys, 0, values, 2) < 0) {
LM_ERR("failed to delete database information\n");
return -1;
}
LM_DBG("callid was %.*s\n", cell->callid.len, cell->callid.s );
return 0;
}
int update_dialog_vars_dbinfo(struct dlg_cell * cell, struct dlg_var * var)
{
db_val_t values[DIALOG_VARS_TABLE_COL_NO];
db_key_t insert_keys[DIALOG_VARS_TABLE_COL_NO] = { &vars_h_entry_column,
&vars_h_id_column, &vars_key_column, &vars_value_column };
if(use_dialog_vars_table()!=0)
return -1;
VAL_TYPE(values) = VAL_TYPE(values+1) = DB1_INT;
VAL_TYPE(values+2) = VAL_TYPE(values+3) = DB1_STR;
VAL_NULL(values) = VAL_NULL(values+1) = VAL_NULL(values+2) = VAL_NULL(values+3) = 0;
SET_STR_VALUE(values+2, var->key);
VAL_INT(values) = cell->h_entry;
VAL_INT(values+1) = cell->h_id;
if((var->vflags & DLG_FLAG_DEL) != 0) {
/* delete the current variable */
db_key_t vars_match_keys[3] = { &vars_h_entry_column, &vars_h_id_column, &vars_key_column};
if (use_dialog_vars_table()!=0)
return -1;
if(dialog_dbf.delete(dialog_db_handle, vars_match_keys, 0, values, 3) < 0) {
LM_ERR("failed to delete database information\n");
return -1;
}
} else if((var->vflags & DLG_FLAG_NEW) != 0) {
/* save all the current dialogs information*/
SET_STR_VALUE(values+3, var->value);
if((dialog_dbf.insert(dialog_db_handle, insert_keys, values,
DIALOG_VARS_TABLE_COL_NO)) !=0){
LM_ERR("could not add another dialog-var to db\n");
goto error;
}
var->vflags &= ~(DLG_FLAG_NEW|DLG_FLAG_CHANGED);
} else if((var->vflags & DLG_FLAG_CHANGED) != 0) {
/* save only dialog's state and timeout */
SET_STR_VALUE(values+3, var->value);
if((dialog_dbf.update(dialog_db_handle, insert_keys, 0,
values, (insert_keys+3), (values+3), 3, 1)) !=0){
LM_ERR("could not update database info\n");
goto error;
}
var->vflags &= ~DLG_FLAG_CHANGED;
} else {
return 0;
}
return 0;
error:
return -1;
}
int update_dialog_dbinfo_unsafe(struct dlg_cell * cell)
{
int i;
struct dlg_var *var;
srjson_doc_t jdoc;
db_val_t values[DIALOG_TABLE_COL_NO];
db_key_t insert_keys[DIALOG_TABLE_COL_NO] = { &h_entry_column, /*0*/
&h_id_column, /*1*/ &call_id_column, /*2*/ &from_uri_column, /*3*/
&from_tag_column, /*4*/ &to_uri_column, /*5*/ &to_tag_column, /*6*/
&from_sock_column, /*7*/ &to_sock_column, /*8*/
&start_time_column, /*9*/ &state_column, /*10*/ &timeout_column, /*11*/
&from_cseq_column, /*12*/ &to_cseq_column, /*13*/ &from_contact_column, /*14*/
&to_contact_column, /*15*/ &from_route_column, /*16*/ &to_route_column, /*17*/
&sflags_column, /*18*/ &toroute_name_column, /*19*/ &req_uri_column, /*20*/
&xdata_column, /*21*/ &iflags_column /*22*/ };
if(cell->state<DLG_STATE_EARLY || cell->state==DLG_STATE_DELETED) {
LM_DBG("not storing dlg in db during initial or deleted states\n");
return 0;
}
i = 0;
if( (cell->dflags & DLG_FLAG_NEW) != 0
|| (cell->dflags & DLG_FLAG_CHANGED_VARS) != 0) {
/* iterate the list */
for(var=cell->vars ; var ; var=var->next) {
if (update_dialog_vars_dbinfo(cell, var) != 0)
return -1;
i++;
}
/* Remove the flag */
cell->dflags &= ~DLG_FLAG_CHANGED_VARS;
LM_DBG("updated %d vars for dlg [%d:%d]\n", i, cell->h_entry, cell->h_id);
}
if(use_dialog_table()!=0)
return -1;
srjson_InitDoc(&jdoc, NULL);
if((cell->dflags & DLG_FLAG_NEW) != 0){
/* save all the current dialogs information*/
VAL_TYPE(values) = VAL_TYPE(values+1) = VAL_TYPE(values+9) =
VAL_TYPE(values+10) = VAL_TYPE(values+11) = DB1_INT;
VAL_TYPE(values+2) = VAL_TYPE(values+3) = VAL_TYPE(values+4) =
VAL_TYPE(values+5) = VAL_TYPE(values+6) = VAL_TYPE(values+7) =
VAL_TYPE(values+8) = VAL_TYPE(values+12) = VAL_TYPE(values+13) =
VAL_TYPE(values+14) = VAL_TYPE(values+15) = VAL_TYPE(values+16)=
VAL_TYPE(values+17) = VAL_TYPE(values+20) = DB1_STR;
SET_NULL_FLAG(values, i, DIALOG_TABLE_COL_NO-6, 0);
VAL_TYPE(values+18) = DB1_INT;
VAL_TYPE(values+19) = DB1_STR;
VAL_TYPE(values+21) = DB1_STR;
VAL_TYPE(values+22) = DB1_INT;
VAL_INT(values) = cell->h_entry;
VAL_INT(values+1) = cell->h_id;
VAL_INT(values+9) = cell->start_ts;
VAL_INT(values+10) = cell->state;
VAL_INT(values+11) = (unsigned int)( (unsigned int)time(0) +
cell->tl.timeout - get_ticks() );
SET_STR_VALUE(values+2, cell->callid);
SET_STR_VALUE(values+3, cell->from_uri);
SET_STR_VALUE(values+4, cell->tag[DLG_CALLER_LEG]);
SET_STR_VALUE(values+5, cell->to_uri);
SET_STR_VALUE(values+6, cell->tag[DLG_CALLEE_LEG]);
SET_PROPER_NULL_FLAG(cell->tag[DLG_CALLEE_LEG], values, 6);
LM_DBG("sock_info is %.*s\n",
cell->bind_addr[DLG_CALLER_LEG]->sock_str.len,
cell->bind_addr[DLG_CALLEE_LEG]->sock_str.s);
SET_STR_VALUE(values+7, cell->bind_addr[DLG_CALLER_LEG]->sock_str);
SET_STR_VALUE(values+8, cell->bind_addr[DLG_CALLEE_LEG]->sock_str);
SET_STR_VALUE(values+12, cell->cseq[DLG_CALLER_LEG]);
SET_STR_VALUE(values+13, cell->cseq[DLG_CALLEE_LEG]);
SET_STR_VALUE(values+14, cell->contact[DLG_CALLER_LEG]);
SET_STR_VALUE(values+15, cell->contact[DLG_CALLEE_LEG]);
SET_STR_VALUE(values+16, cell->route_set[DLG_CALLER_LEG]);
SET_STR_VALUE(values+17, cell->route_set[DLG_CALLEE_LEG]);
SET_PROPER_NULL_FLAG(cell->contact[DLG_CALLER_LEG], values, 14);
SET_PROPER_NULL_FLAG(cell->contact[DLG_CALLEE_LEG], values, 15);
SET_PROPER_NULL_FLAG(cell->route_set[DLG_CALLER_LEG], values, 16);
SET_PROPER_NULL_FLAG(cell->route_set[DLG_CALLEE_LEG], values, 17);
VAL_NULL(values+18) = 0;
VAL_INT(values+18) = cell->sflags;
SET_STR_VALUE(values+19, cell->toroute_name);
SET_PROPER_NULL_FLAG(cell->toroute_name, values, 19);
SET_STR_VALUE(values+20, cell->req_uri);
SET_PROPER_NULL_FLAG(cell->req_uri, values, 20);
dlg_profiles_to_json(cell, &jdoc);
if(jdoc.buf.s!=NULL)
{
SET_STR_VALUE(values+21, jdoc.buf);
SET_PROPER_NULL_FLAG(jdoc.buf, values, 21);
} else {
VAL_NULL(values+21) = 1;
}
VAL_NULL(values+22) = 0;
VAL_INT(values+22) = cell->iflags;
if((dialog_dbf.insert(dialog_db_handle, insert_keys, values,
DIALOG_TABLE_COL_NO)) !=0){
LM_ERR("could not add another dialog to db\n");
goto error;
}
cell->dflags &= ~(DLG_FLAG_NEW|DLG_FLAG_CHANGED);
} else if((cell->dflags & DLG_FLAG_CHANGED) != 0) {
/* save only dialog's state and timeout */
VAL_TYPE(values) = VAL_TYPE(values+1) =
VAL_TYPE(values+10) = VAL_TYPE(values+11) = DB1_INT;
VAL_TYPE(values+12) = VAL_TYPE(values+13) =DB1_STR;
VAL_TYPE(values+14) = VAL_TYPE(values+15) =DB1_STR;
VAL_INT(values) = cell->h_entry;
VAL_INT(values+1) = cell->h_id;
VAL_INT(values+10) = cell->state;
VAL_INT(values+11) = (unsigned int)( (unsigned int)time(0) +
cell->tl.timeout - get_ticks() );
SET_STR_VALUE(values+12, cell->cseq[DLG_CALLER_LEG]);
SET_STR_VALUE(values+13, cell->cseq[DLG_CALLEE_LEG]);
SET_STR_VALUE(values+14, cell->contact[DLG_CALLER_LEG]);
SET_STR_VALUE(values+15, cell->contact[DLG_CALLEE_LEG]);
VAL_NULL(values) = VAL_NULL(values+1) =
VAL_NULL(values+10) = VAL_NULL(values+11) =
VAL_NULL(values+12) = VAL_NULL(values+13) =
VAL_NULL(values+14) = VAL_NULL(values+15) = 0;
if((dialog_dbf.update(dialog_db_handle, (insert_keys), 0,
(values), (insert_keys+10), (values+10), 2, 6)) !=0){
LM_ERR("could not update database info\n");
goto error;
}
cell->dflags &= ~(DLG_FLAG_CHANGED);
} else {
return 0;
}
if(jdoc.buf.s!=NULL) {
jdoc.free_fn(jdoc.buf.s);
jdoc.buf.s = NULL;
}
srjson_DestroyDoc(&jdoc);
return 0;
error:
if(jdoc.buf.s!=NULL) {
jdoc.free_fn(jdoc.buf.s);
jdoc.buf.s = NULL;
}
srjson_DestroyDoc(&jdoc);
return -1;
}
int update_dialog_dbinfo(struct dlg_cell * cell)
{
/* lock the entry */
dlg_lock(d_table, &d_table->entries[cell->h_entry]);
if (update_dialog_dbinfo_unsafe(cell) != 0) {
dlg_unlock(d_table, &d_table->entries[cell->h_entry]);
return -1;
}
dlg_unlock(d_table, &d_table->entries[cell->h_entry]);
return 0;
}
void dialog_update_db(unsigned int ticks, void * param)
{
int i;
struct dlg_cell *cell;
LM_DBG("saving current_info \n");
for(i = 0; i < d_table->size; i++){
/* lock the slot */
dlg_lock(d_table, &d_table->entries[i]);
for(cell = d_table->entries[i].first; cell != NULL; cell = cell->next){
/* if update fails for one dlg, still do it for the next ones */
update_dialog_dbinfo_unsafe(cell);
}
dlg_unlock(d_table, &d_table->entries[i]);
}
return;
}
You can’t perform that action at this time.