int update_db_state(int state) {
db_key_t node_id_key = &id_col;
db_val_t node_id_val;
db_key_t update_key;
db_val_t update_val;
VAL_TYPE(&node_id_val) = DB_INT;
VAL_NULL(&node_id_val) = 0;
VAL_INT(&node_id_val) = current_id;
update_key = &state_col;
CON_OR_RESET(db_hdl);
if (dr_dbf.use_table(db_hdl, &db_table) < 0) {
LM_ERR("cannot select table: \"%.*s\"\n", db_table.len, db_table.s);
return -1;
}
VAL_TYPE(&update_val) = DB_INT;
VAL_NULL(&update_val) = 0;
VAL_INT(&update_val) = state;
if (dr_dbf.update(db_hdl, &node_id_key, 0, &node_id_val, &update_key,
&update_val, 1, 1) < 0)
return -1;
return 0;
}
int update_sca_info_to_db(b2b_sca_record_t *record, unsigned int appearance_index)
{
b2b_sca_call_t *call;
unsigned int i;
unsigned int n_q_cols = 0, n_q_vals = 0;
unsigned int shared_line_col, watchers_col;
unsigned int app_shared_entity_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_state_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_info_uri_col[MAX_APPEARANCE_INDEX];
unsigned int app_call_info_appearance_uri_col[MAX_APPEARANCE_INDEX];
unsigned int app_b2bl_key_col[MAX_APPEARANCE_INDEX];
db_key_t q_cols[SCA_TABLE_TOTAL_COL_NO];
db_val_t q_vals[SCA_TABLE_TOTAL_COL_NO];
LM_DBG("\n");
if(use_sca_table()) return -1;
memset(q_vals, 0, SCA_TABLE_TOTAL_COL_NO * sizeof(db_val_t));
q_cols[shared_line_col = n_q_cols++] = &shared_line_column;
q_vals[shared_line_col].type = DB_STR;
q_cols[watchers_col = n_q_cols++] = &watchers_column;
q_vals[watchers_col].type = DB_STR;
for (i=0; i<MAX_APPEARANCE_INDEX; i++) {
q_cols[app_shared_entity_col[i] = n_q_cols++] = &app_shared_entity_column[i];
q_vals[app_shared_entity_col[i]].type = DB_INT;
q_cols[app_call_state_col[i] = n_q_cols++] = &app_call_state_column[i];
q_vals[app_call_state_col[i]].type = DB_INT;
q_cols[app_call_info_uri_col[i] = n_q_cols++] = &app_call_info_uri_column[i];
q_vals[app_call_info_uri_col[i]].type = DB_STR;
q_cols[app_call_info_appearance_uri_col[i] = n_q_cols++] =
&app_call_info_appearance_uri_column[i];
q_vals[app_call_info_appearance_uri_col[i]].type = DB_STR;
q_cols[app_b2bl_key_col[i] = n_q_cols++] = &app_b2bl_key_column[i];
q_vals[app_b2bl_key_col[i]].type = DB_STR;
}
q_vals[shared_line_col].val.str_val = record->shared_line;
i = appearance_index - 1;
if (i >= MAX_APPEARANCE_INDEX) {
LM_ERR("Non matching call\n");
return -1;
}
call = record->call[i];
if (call) {
LM_DBG("update shared_entity [%d] and call_state [%d] for call[%d][%.*s]\n",
call->shared_entity, call->call_state, i,
call->b2bl_key.len, call->b2bl_key.s);
switch(call->call_state) {
case ALERTING_STATE:
q_vals[app_call_info_uri_col[i]].val.str_val = call->call_info_uri;
q_vals[app_call_info_appearance_uri_col[i]].val.str_val =
call->call_info_apperance_uri;
q_vals[app_b2bl_key_col[i]].val.str_val = call->b2bl_key;
LM_DBG("update [%.*s][%.*s][%.*s]\n",
call->call_info_uri.len, call->call_info_uri.s,
call->call_info_apperance_uri.len, call->call_info_apperance_uri.s,
call->b2bl_key.len, call->b2bl_key.s);
n_q_vals += 3;
default:
q_vals[app_shared_entity_col[i]].val.int_val = call->shared_entity;
q_vals[app_call_state_col[i]].val.int_val = call->call_state;
n_q_vals += 2;
}
} else {
n_q_vals = 5;
}
if(sca_dbf.update(sca_db_handle, q_cols, 0, q_vals,
q_cols + app_shared_entity_col[i],
q_vals + app_shared_entity_col[i], 1, n_q_vals) != 0) {
LM_ERR("failed to update record\n");
return -1;
}
return 0;
}
static void db_update(unsigned int ticks,void *param)
{
ua_pres_t* p= NULL;
db_key_t q_cols[20], result_cols[1];
db1_res_t *res= NULL;
db_key_t db_cols[5];
db_val_t q_vals[20], db_vals[5];
db_op_t db_ops[1] ;
int n_query_cols= 0, n_query_update= 0;
int n_update_cols= 0;
int i;
int puri_col,pid_col,expires_col,flag_col,etag_col,tuple_col,event_col;
int watcher_col,callid_col,totag_col,fromtag_col,record_route_col,cseq_col;
int no_lock= 0, contact_col, desired_expires_col, extra_headers_col;
int remote_contact_col, version_col;
if (dbmode==PUA_DB_ONLY) return;
if(ticks== 0 && param == NULL)
no_lock= 1;
/* cols and values used for insert */
q_cols[puri_col= n_query_cols] = &str_pres_uri_col;
q_vals[puri_col].type = DB1_STR;
q_vals[puri_col].nul = 0;
n_query_cols++;
q_cols[pid_col= n_query_cols] = &str_pres_id_col;
q_vals[pid_col].type = DB1_STR;
q_vals[pid_col].nul = 0;
n_query_cols++;
q_cols[flag_col= n_query_cols] = &str_flag_col;
q_vals[flag_col].type = DB1_INT;
q_vals[flag_col].nul = 0;
n_query_cols++;
q_cols[event_col= n_query_cols] = &str_event_col;
q_vals[event_col].type = DB1_INT;
q_vals[event_col].nul = 0;
n_query_cols++;
q_cols[watcher_col= n_query_cols] = &str_watcher_uri_col;
q_vals[watcher_col].type = DB1_STR;
q_vals[watcher_col].nul = 0;
n_query_cols++;
q_cols[callid_col= n_query_cols] = &str_call_id_col;
q_vals[callid_col].type = DB1_STR;
q_vals[callid_col].nul = 0;
n_query_cols++;
q_cols[totag_col= n_query_cols] = &str_to_tag_col;
q_vals[totag_col].type = DB1_STR;
q_vals[totag_col].nul = 0;
n_query_cols++;
q_cols[fromtag_col= n_query_cols] = &str_from_tag_col;
q_vals[fromtag_col].type = DB1_STR;
q_vals[fromtag_col].nul = 0;
n_query_cols++;
q_cols[etag_col= n_query_cols] = &str_etag_col;
q_vals[etag_col].type = DB1_STR;
q_vals[etag_col].nul = 0;
n_query_cols++;
q_cols[tuple_col= n_query_cols] = &str_tuple_id_col;
q_vals[tuple_col].type = DB1_STR;
q_vals[tuple_col].nul = 0;
n_query_cols++;
q_cols[cseq_col= n_query_cols]= &str_cseq_col;
q_vals[cseq_col].type = DB1_INT;
q_vals[cseq_col].nul = 0;
n_query_cols++;
q_cols[expires_col= n_query_cols] = &str_expires_col;
q_vals[expires_col].type = DB1_INT;
q_vals[expires_col].nul = 0;
n_query_cols++;
q_cols[desired_expires_col= n_query_cols] = &str_desired_expires_col;
q_vals[desired_expires_col].type = DB1_INT;
q_vals[desired_expires_col].nul = 0;
n_query_cols++;
q_cols[record_route_col= n_query_cols] = &str_record_route_col;
q_vals[record_route_col].type = DB1_STR;
q_vals[record_route_col].nul = 0;
n_query_cols++;
q_cols[contact_col= n_query_cols] = &str_contact_col;
q_vals[contact_col].type = DB1_STR;
q_vals[contact_col].nul = 0;
n_query_cols++;
q_cols[remote_contact_col= n_query_cols] = &str_remote_contact_col;
q_vals[remote_contact_col].type = DB1_STR;
q_vals[remote_contact_col].nul = 0;
n_query_cols++;
q_cols[version_col= n_query_cols] = &str_version_col;
q_vals[version_col].type = DB1_INT;
q_vals[version_col].nul = 0;
n_query_cols++;
/* must keep this the last column to be inserted */
q_cols[extra_headers_col= n_query_cols] = &str_extra_headers_col;
q_vals[extra_headers_col].type = DB1_STR;
q_vals[extra_headers_col].nul = 0;
n_query_cols++;
/* cols and values used for update */
db_cols[0]= &str_expires_col;
db_vals[0].type = DB1_INT;
db_vals[0].nul = 0;
db_cols[1]= &str_cseq_col;
db_vals[1].type = DB1_INT;
db_vals[1].nul = 0;
db_cols[2]= &str_etag_col;
db_vals[2].type = DB1_STR;
db_vals[2].nul = 0;
db_cols[3]= &str_desired_expires_col;
db_vals[3].type = DB1_INT;
db_vals[3].nul = 0;
db_cols[4]= &str_version_col;
db_vals[4].type = DB1_INT;
db_vals[4].nul = 0;
result_cols[0]= &str_expires_col;
if(pua_db== NULL)
{
LM_ERR("null database connection\n");
return;
}
if(pua_dbf.use_table(pua_db, &db_table)< 0)
{
LM_ERR("in use table\n");
return ;
}
for(i=0; i<HASH_SIZE; i++)
{
if(!no_lock)
lock_get(&HashT->p_records[i].lock);
p = HashT->p_records[i].entity->next;
while(p)
{
if(p->expires - (int)time(NULL)< 0)
{
p= p->next;
continue;
}
switch(p->db_flag)
{
case NO_UPDATEDB_FLAG:
{
LM_DBG("NO_UPDATEDB_FLAG\n");
break;
}
case UPDATEDB_FLAG:
{
LM_DBG("UPDATEDB_FLAG\n");
n_update_cols= 0;
n_query_update= 0;
q_vals[puri_col].val.str_val = *(p->pres_uri);
n_query_update++;
q_vals[pid_col].val.str_val = p->id;
n_query_update++;
q_vals[flag_col].val.int_val = p->flag;
n_query_update++;
q_vals[event_col].val.int_val = p->event;
n_query_update++;
if(p->watcher_uri)
{
q_vals[watcher_col].val.str_val = *(p->watcher_uri);
n_query_update++;
q_vals[callid_col].val.str_val = p->call_id;
n_query_update++;
q_vals[totag_col].val.str_val = p->to_tag;
n_query_update++;
q_vals[fromtag_col].val.str_val = p->from_tag;
n_query_update++;
}
db_vals[0].val.int_val= p->expires;
n_update_cols++;
db_vals[1].val.int_val= p->cseq ;
n_update_cols++;
db_vals[2].val.str_val= p->etag ;
n_update_cols++;
db_vals[3].val.int_val= p->desired_expires;
n_update_cols++;
db_vals[4].val.int_val= p->version;
n_update_cols++;
LM_DBG("Updating:n_query_update= %d\tn_update_cols= %d\n",
n_query_update, n_update_cols);
if(pua_dbf.query(pua_db, q_cols, 0, q_vals,
result_cols, n_query_update, 1, 0, &res)< 0)
{
LM_ERR("while querying db table pua\n");
if(!no_lock)
lock_release(&HashT->p_records[i].lock);
if(res)
pua_dbf.free_result(pua_db, res);
return ;
}
if(res && res->n> 0)
{
if(pua_dbf.update(pua_db, q_cols, 0, q_vals, db_cols,
db_vals, n_query_update, n_update_cols)<0)
{
LM_ERR("while updating in database\n");
if(!no_lock)
lock_release(&HashT->p_records[i].lock);
pua_dbf.free_result(pua_db, res);
res= NULL;
return ;
}
pua_dbf.free_result(pua_db, res);
res= NULL;
}
else
{
if(res)
{
pua_dbf.free_result(pua_db, res);
res= NULL;
}
LM_DBG("UPDATEDB_FLAG and no record found\n");
// p->db_flag= INSERTDB_FLAG;
}
break;
}
case INSERTDB_FLAG:
{
LM_DBG("INSERTDB_FLAG\n");
q_vals[puri_col].val.str_val = *(p->pres_uri);
q_vals[pid_col].val.str_val = p->id;
q_vals[flag_col].val.int_val = p->flag;
q_vals[callid_col].val.str_val = p->call_id;
q_vals[fromtag_col].val.str_val = p->from_tag;
q_vals[cseq_col].val.int_val= p->cseq;
q_vals[expires_col].val.int_val = p->expires;
q_vals[desired_expires_col].val.int_val = p->desired_expires;
q_vals[event_col].val.int_val = p->event;
q_vals[version_col].val.int_val = p->version;
if((p->watcher_uri))
q_vals[watcher_col].val.str_val = *(p->watcher_uri);
else
{
q_vals[watcher_col].val.str_val.s = "";
q_vals[watcher_col].val.str_val.len = 0;
}
if(p->tuple_id.s == NULL)
{
q_vals[tuple_col].val.str_val.s="";
q_vals[tuple_col].val.str_val.len=0;
}
else
q_vals[tuple_col].val.str_val = p->tuple_id;
if(p->etag.s == NULL)
{
q_vals[etag_col].val.str_val.s="";
q_vals[etag_col].val.str_val.len=0;
}
else
q_vals[etag_col].val.str_val = p->etag;
if (p->to_tag.s == NULL)
{
q_vals[totag_col].val.str_val.s="";
q_vals[totag_col].val.str_val.len=0;
}
else
q_vals[totag_col].val.str_val = p->to_tag;
if(p->record_route.s== NULL)
{
q_vals[record_route_col].val.str_val.s= "";
q_vals[record_route_col].val.str_val.len = 0;
}
else
q_vals[record_route_col].val.str_val = p->record_route;
if(p->contact.s == NULL)
{
q_vals[contact_col].val.str_val.s = "";
q_vals[contact_col].val.str_val.len = 0;
}
else
q_vals[contact_col].val.str_val = p->contact;
if(p->remote_contact.s)
{
q_vals[remote_contact_col].val.str_val = p->remote_contact;
LM_DBG("p->remote_contact = %.*s\n", p->remote_contact.len, p->remote_contact.s);
}
else
{
q_vals[remote_contact_col].val.str_val.s = "";
q_vals[remote_contact_col].val.str_val.len = 0;
}
if(p->extra_headers)
q_vals[extra_headers_col].val.str_val = *(p->extra_headers);
else
{
q_vals[extra_headers_col].val.str_val.s = "";
q_vals[extra_headers_col].val.str_val.len = 0;
}
if(pua_dbf.insert(pua_db, q_cols, q_vals,n_query_cols )<0)
{
LM_ERR("while inserting in db table pua\n");
if(!no_lock)
lock_release(&HashT->p_records[i].lock);
return ;
}
break;
}
}
p->db_flag= NO_UPDATEDB_FLAG;
p= p->next;
}
if(!no_lock)
lock_release(&HashT->p_records[i].lock);
}
db_vals[0].val.int_val= (int)time(NULL)- 10;
db_ops[0]= OP_LT;
if(pua_dbf.delete(pua_db, db_cols, db_ops, db_vals, 1) < 0)
{
LM_ERR("while deleting from db table pua\n");
}
return ;
}
/* synchronize backend with the db */
static void update_db_handler(unsigned int ticks, void* param)
{
/* data */
table_entry_t *head_table;
table_entry_value_t *value;
table_entry_info_t *info;
/* columns to be compared ( clusterer_id_col ) */
db_key_t key_cmp;
/* with values */
db_val_t val_cmp;
/* columns to be set */
db_key_t key_set[3];
/* with values */
db_val_t val_set[3];
int i;
CON_OR_RESET(db_hdl);
/* table to use*/
if (dr_dbf.use_table(db_hdl, &db_table) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", db_table.len, db_table.s);
return;
}
val_cmp.type = DB_INT;
val_cmp.nul = 0;
for (i = 0; i < 2; ++i) {
val_set[i].type = DB_INT;
val_set[i].nul = 0;
}
val_set[2].type = DB_BIGINT;
val_set[2].nul = 0;
key_cmp = &id_col;
key_set[0] = &state_col;
key_set[1] = &no_tries_col;
key_set[2] = &last_attempt_col;
lock_start_write(ref_lock);
head_table = *tdata;
/* iterating through backend storage to find all data that
* must be synchronized with the db */
while (head_table != NULL) {
info = head_table->info;
while (info != NULL) {
value = info->value;
while (value != NULL) {
if (value->dirty_bit == 1) {
LM_DBG("setting row with primary key %d the status %d\n",
value->id, value->state);
val_cmp.val.int_val = value->id;
val_set[0].val.int_val = value->state;
val_set[1].val.int_val = value->no_tries;
val_set[2].val.int_val = value->last_attempt;
/* updating */
if (dr_dbf.update(db_hdl, &key_cmp, &op_eq, &val_cmp, key_set, val_set, 1, 3) < 0) {
LM_ERR("DB update failed\n");
} else {
/* only if the query is successful the data is synchronized */
value->dirty_bit = 0;
}
}
value = value->next;
}
info = info->next;
}
head_table = head_table->next;
}
lock_stop_write(ref_lock);
}
void query_xcap_update(unsigned int ticks, void* param)
{
db_key_t query_cols[3], update_cols[3];
db_val_t query_vals[3], update_vals[3];
db_key_t result_cols[7];
int n_result_cols = 0, n_query_cols= 0, n_update_cols= 0;
db_res_t* result= NULL;
int user_col, domain_col, doc_type_col, etag_col, doc_uri_col, port_col;
db_row_t *row ;
db_val_t *row_vals ;
unsigned int port;
char* etag, *path, *new_etag= NULL, *doc= NULL;
int u_doc_col, u_etag_col;
str user, domain, uri;
int i;
/* query the ones I have to handle */
query_cols[n_query_cols] = "source";
query_vals[n_query_cols].type = DB_INT;
query_vals[n_query_cols].nul = 0;
query_vals[n_query_cols].val.int_val= XCAP_CL_MOD;
n_query_cols++;
query_cols[n_query_cols] = "path";
query_vals[n_query_cols].type = DB_STR;
query_vals[n_query_cols].nul = 0;
update_cols[u_doc_col=n_update_cols] = "doc";
update_vals[n_update_cols].type = DB_STRING;
update_vals[n_update_cols].nul = 0;
n_update_cols++;
update_cols[u_etag_col=n_update_cols] = "etag";
update_vals[n_update_cols].type = DB_STRING;
update_vals[n_update_cols].nul = 0;
n_update_cols++;
result_cols[user_col= n_result_cols++] = "username";
result_cols[domain_col=n_result_cols++] = "domain";
result_cols[doc_type_col=n_result_cols++] = "doc_type";
result_cols[etag_col=n_result_cols++] = "etag";
result_cols[doc_uri_col= n_result_cols++] = "doc_uri";
result_cols[port_col= n_result_cols++] = "port";
if (xcap_dbf.use_table(xcap_db, xcap_db_table) < 0)
{
LM_ERR("in use_table-[table]= %s\n", xcap_db_table);
goto error;
}
if(xcap_dbf.query(xcap_db, query_cols, 0, query_vals, result_cols, 1,
n_result_cols, 0, &result)< 0)
{
LM_ERR("in sql query\n");
goto error;
}
if(result== NULL)
{
LM_ERR("in sql query- null result\n");
return;
}
if(result->n<= 0)
{
xcap_dbf.free_result(xcap_db, result);
return;
}
n_query_cols++;
/* ask if updated */
for(i= 0; i< result->n; i++)
{
row = &result->rows[i];
row_vals = ROW_VALUES(row);
path= (char*)row_vals[doc_uri_col].val.string_val;
port= row_vals[port_col].val.int_val;
etag= (char*)row_vals[etag_col].val.string_val;
user.s= (char*)row_vals[user_col].val.string_val;
user.len= strlen(user.s);
domain.s= (char*)row_vals[domain_col].val.string_val;
domain.len= strlen(domain.s);
/* send HTTP request */
doc= send_http_get(path, port, etag, IF_NONE_MATCH, &new_etag);
if(doc== NULL)
{
LM_DBG("document not update\n");
continue;
}
if(new_etag== NULL)
{
LM_ERR("etag not found\n");
pkg_free(doc);
goto error;
}
/* update in xcap db table */
update_vals[u_doc_col].val.string_val= doc;
update_vals[u_etag_col].val.string_val= etag;
if(xcap_dbf.update(xcap_db, query_cols, 0, query_vals, update_cols,
update_vals, n_query_cols, n_update_cols)< 0)
{
LM_ERR("in sql update\n");
pkg_free(doc);
goto error;
}
/* call registered callbacks */
if(uandd_to_uri(user, domain, &uri)< 0)
{
LM_ERR("converting user and domain to uri\n");
pkg_free(doc);
goto error;
}
run_xcap_update_cb(row_vals[doc_type_col].val.int_val, uri, doc);
pkg_free(doc);
}
xcap_dbf.free_result(xcap_db, result);
return;
error:
if(result)
xcap_dbf.free_result(xcap_db, result);
}
int pres_update_status(subs_t subs, str reason, db_key_t* query_cols,
db_val_t* query_vals, int n_query_cols, subs_t** subs_array)
{
db_key_t update_cols[5];
db_val_t update_vals[5];
int n_update_cols= 0;
int u_status_col, u_reason_col, q_wuser_col, q_wdomain_col;
int status;
query_cols[q_wuser_col=n_query_cols]= &str_watcher_username_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
n_query_cols++;
query_cols[q_wdomain_col=n_query_cols]= &str_watcher_domain_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
n_query_cols++;
update_cols[u_status_col= n_update_cols]= &str_status_col;
update_vals[u_status_col].nul= 0;
update_vals[u_status_col].type= DB1_INT;
n_update_cols++;
update_cols[u_reason_col= n_update_cols]= &str_reason_col;
update_vals[u_reason_col].nul= 0;
update_vals[u_reason_col].type= DB1_STR;
n_update_cols++;
status= subs.status;
if(subs.event->get_auth_status(&subs)< 0)
{
LM_ERR( "getting status from rules document\n");
return -1;
}
LM_DBG("subs.status= %d\n", subs.status);
if(get_status_str(subs.status)== NULL)
{
LM_ERR("wrong status: %d\n", subs.status);
return -1;
}
if(subs.status!= status || reason.len!= subs.reason.len ||
(reason.s && subs.reason.s && strncmp(reason.s, subs.reason.s,
reason.len)))
{
/* update in watchers_table */
query_vals[q_wuser_col].val.str_val= subs.watcher_user;
query_vals[q_wdomain_col].val.str_val= subs.watcher_domain;
update_vals[u_status_col].val.int_val= subs.status;
update_vals[u_reason_col].val.str_val= subs.reason;
if (pa_dbf.use_table(pa_db, &watchers_table) < 0)
{
LM_ERR( "in use_table\n");
return -1;
}
if(pa_dbf.update(pa_db, query_cols, 0, query_vals, update_cols,
update_vals, n_query_cols, n_update_cols)< 0)
{
LM_ERR( "in sql update\n");
return -1;
}
/* save in the list all affected dialogs */
/* if status switches to terminated -> delete dialog */
if(update_pw_dialogs(&subs, subs.db_flag, subs_array)< 0)
{
LM_ERR( "extracting dialogs from [watcher]=%.*s@%.*s to"
" [presentity]=%.*s\n", subs.watcher_user.len, subs.watcher_user.s,
subs.watcher_domain.len, subs.watcher_domain.s, subs.pres_uri.len,
subs.pres_uri.s);
return -1;
}
}
return 0;
}
static int update_pw_dialogs_dbonlymode(subs_t* subs, subs_t** subs_array)
{
db_key_t query_cols[5], db_cols[3];
db_val_t query_vals[5], db_vals[3];
db_key_t result_cols[24];
int n_query_cols=0, n_result_cols=0, n_update_cols=0;
int event_col, pres_uri_col, watcher_user_col, watcher_domain_col;
int r_pres_uri_col,r_to_user_col,r_to_domain_col;
int r_from_user_col,r_from_domain_col,r_callid_col;
int r_to_tag_col,r_from_tag_col,r_sockinfo_col;
int r_event_id_col,r_local_contact_col,r_contact_col;
int r_record_route_col, r_reason_col;
int r_event_col, r_local_cseq_col, r_remote_cseq_col;
int r_status_col, r_version_col;
int r_expires_col, r_watcher_user_col, r_watcher_domain_col;
db1_res_t *result= NULL;
db_val_t *row_vals;
db_row_t *rows;
int nr_rows, loop;
subs_t s, *cs;
str ev_sname;
if(pa_db == NULL)
{
LM_ERR("null database connection\n");
return(-1);
}
if (pa_dbf.use_table(pa_db, &active_watchers_table) < 0)
{
LM_ERR("use table failed\n");
return(-1);
}
query_cols[event_col=n_query_cols]= &str_event_col;
query_vals[event_col].nul= 0;
query_vals[event_col].type= DB1_STR;
query_vals[event_col].val.str_val= subs->event->name ;
n_query_cols++;
query_cols[pres_uri_col=n_query_cols]= &str_presentity_uri_col;
query_vals[pres_uri_col].nul= 0;
query_vals[pres_uri_col].type= DB1_STR;
query_vals[pres_uri_col].val.str_val= subs->pres_uri;
n_query_cols++;
query_cols[watcher_user_col=n_query_cols]= &str_watcher_username_col;
query_vals[watcher_user_col].nul= 0;
query_vals[watcher_user_col].type= DB1_STR;
query_vals[watcher_user_col].val.str_val= subs->watcher_user;
n_query_cols++;
query_cols[watcher_domain_col=n_query_cols]= &str_watcher_domain_col;
query_vals[watcher_domain_col].nul= 0;
query_vals[watcher_domain_col].type= DB1_STR;
query_vals[watcher_domain_col].val.str_val= subs->watcher_domain;
n_query_cols++;
result_cols[r_to_user_col=n_result_cols++] = &str_to_user_col;
result_cols[r_to_domain_col=n_result_cols++] = &str_to_domain_col;
result_cols[r_from_user_col=n_result_cols++] = &str_from_user_col;
result_cols[r_from_domain_col=n_result_cols++] = &str_from_domain_col;
result_cols[r_watcher_user_col=n_result_cols++] = &str_watcher_username_col;
result_cols[r_watcher_domain_col=n_result_cols++] = &str_watcher_domain_col;
result_cols[r_callid_col=n_result_cols++] = &str_callid_col;
result_cols[r_to_tag_col=n_result_cols++] = &str_to_tag_col;
result_cols[r_from_tag_col=n_result_cols++] = &str_from_tag_col;
result_cols[r_sockinfo_col=n_result_cols++] = &str_socket_info_col;
result_cols[r_event_id_col=n_result_cols++] = &str_event_id_col;
result_cols[r_local_contact_col=n_result_cols++] = &str_local_contact_col;
result_cols[r_record_route_col=n_result_cols++] = &str_record_route_col;
result_cols[r_reason_col=n_result_cols++] = &str_reason_col;
result_cols[r_local_cseq_col=n_result_cols++] = &str_local_cseq_col;
result_cols[r_version_col=n_result_cols++] = &str_version_col;
result_cols[r_expires_col=n_result_cols++] = &str_expires_col;
result_cols[r_event_col=n_result_cols++] = &str_event_col;
result_cols[r_pres_uri_col=n_result_cols++] = &str_presentity_uri_col;
result_cols[r_contact_col=n_result_cols++] = &str_contact_col;
/* these ones are unused for some reason !!! */
result_cols[r_remote_cseq_col=n_result_cols++] = &str_remote_cseq_col;
result_cols[r_status_col=n_result_cols++] = &str_status_col;
/*********************************************/
if(pa_dbf.query(pa_db, query_cols, 0, query_vals, result_cols,
n_query_cols, n_result_cols, 0, &result )< 0)
{
LM_ERR("Can't query db\n");
if(result) pa_dbf.free_result(pa_db, result);
return(-1);
}
if(result == NULL) return(-1);
nr_rows = RES_ROW_N(result);
LM_DBG("found %d matching dialogs\n", nr_rows);
if (nr_rows <= 0)
{
pa_dbf.free_result(pa_db, result);
return 0;
}
rows = RES_ROWS(result);
/* get the results and fill in return data structure */
for (loop=0; loop <nr_rows; loop++)
{
row_vals = ROW_VALUES(&rows[loop]);
memset(&s, 0, sizeof(subs_t));
s.status= subs->status;
s.reason.s= subs->reason.s;
s.reason.len= s.reason.s?strlen(s.reason.s):0; //>>>>>>>>>>
s.pres_uri.s= (char*)row_vals[r_pres_uri_col].val.string_val;
s.pres_uri.len= s.pres_uri.s?strlen(s.pres_uri.s):0;
s.to_user.s= (char*)row_vals[r_to_user_col].val.string_val;
s.to_user.len= s.to_user.s?strlen(s.to_user.s):0;
s.to_domain.s= (char*)row_vals[r_to_domain_col].val.string_val;
s.to_domain.len= s.to_domain.s?strlen(s.to_domain.s):0;
s.from_user.s= (char*)row_vals[r_from_user_col].val.string_val;
s.from_user.len= s.from_user.s?strlen(s.from_user.s):0;
s.from_domain.s= (char*)row_vals[r_from_domain_col].val.string_val;
s.from_domain.len= s.from_domain.s?strlen(s.from_domain.s):0;
s.watcher_user.s= (char*)row_vals[r_watcher_user_col].val.string_val;
s.watcher_user.len= s.watcher_user.s?strlen(s.watcher_user.s):0;
s.watcher_domain.s= (char*)row_vals[r_watcher_domain_col].val.string_val;
s.watcher_domain.len= s.watcher_domain.s?strlen(s.watcher_domain.s):0;
s.event_id.s=(char*)row_vals[r_event_id_col].val.string_val;
s.event_id.len= (s.event_id.s)?strlen(s.event_id.s):0;
s.to_tag.s= (char*)row_vals[r_to_tag_col].val.string_val;
s.to_tag.len= s.to_tag.s?strlen(s.to_tag.s):0;
s.from_tag.s= (char*)row_vals[r_from_tag_col].val.string_val;
s.from_tag.len= s.from_tag.s?strlen(s.from_tag.s):0;
s.callid.s= (char*)row_vals[r_callid_col].val.string_val;
s.callid.len= s.callid.s?strlen(s.callid.s):0;
s.record_route.s= (char*)row_vals[r_record_route_col].val.string_val;
s.record_route.len= (s.record_route.s)?strlen(s.record_route.s):0;
s.contact.s= (char*)row_vals[r_contact_col].val.string_val;
s.contact.len= s.contact.s?strlen(s.contact.s):0;
s.sockinfo_str.s = (char*)row_vals[r_sockinfo_col].val.string_val;
s.sockinfo_str.len = s.sockinfo_str.s?strlen(s.sockinfo_str.s):0;
s.local_contact.s = (char*)row_vals[r_local_contact_col].val.string_val;
s.local_contact.len = s.local_contact.s?strlen(s.local_contact.s):0;
ev_sname.s= (char*)row_vals[r_event_col].val.string_val;
ev_sname.len= ev_sname.s?strlen(ev_sname.s):0;
s.event = contains_event(&ev_sname, NULL);
if(s.event == NULL)
{
LM_ERR("event not found and set to NULL\n");
}
s.local_cseq = row_vals[r_local_cseq_col].val.int_val;
s.expires = row_vals[r_expires_col].val.int_val;
if( s.expires > (int)time(NULL) + expires_offset)
s.expires -= (int)time(NULL);
else
s.expires = 0;
s.version = row_vals[r_version_col].val.int_val;
cs = mem_copy_subs(&s, PKG_MEM_TYPE);
if (cs == NULL)
{
LM_ERR("while copying subs_t structure\n");
/* tidy up and return */
pa_dbf.free_result(pa_db, result);
return(-1);
}
cs->local_cseq++;
cs->next= (*subs_array);
(*subs_array)= cs;
printf_subs(cs);
}
pa_dbf.free_result(pa_db, result);
if (pres_notifier_processes == 0 && subs->status == TERMINATED_STATUS)
{
/* delete the records */
if(pa_dbf.delete(pa_db, query_cols, 0, query_vals, n_query_cols)< 0)
{
LM_ERR("sql delete failed\n");
return(-1);
}
return(0);
}
/* otherwise we update the records */
db_cols[n_update_cols] = &str_status_col;
db_vals[n_update_cols].type = DB1_INT;
db_vals[n_update_cols].nul = 0;
db_vals[n_update_cols].val.int_val = subs->status;
n_update_cols++;
db_cols[n_update_cols] = &str_reason_col;
db_vals[n_update_cols].type = DB1_STR;
db_vals[n_update_cols].nul = 0;
db_vals[n_update_cols].val.str_val= subs->reason;
n_update_cols++;
db_cols[n_update_cols] = &str_updated_col;
db_vals[n_update_cols].type = DB1_INT;
db_vals[n_update_cols].nul = 0;
if (subs->callid.len == 0 || subs->from_tag.len == 0)
{
db_vals[n_update_cols].val.int_val = (int) ((rand() / (RAND_MAX + 1.0)) *
(pres_waitn_time * pres_notifier_poll_rate
* pres_notifier_processes));
} else {
db_vals[n_update_cols].val.int_val =
core_case_hash(&subs->callid, &subs->from_tag, 0) %
(pres_waitn_time * pres_notifier_poll_rate
* pres_notifier_processes);
}
n_update_cols++;
if(pa_dbf.update(pa_db, query_cols, 0, query_vals,
db_cols,db_vals,n_query_cols,n_update_cols) < 0)
{
LM_ERR("DB update failed\n");
return(-1);
}
return(0);
}
int update_dialog_dbinfo(struct dlg_cell * cell)
{
static db_ps_t my_ps_insert = NULL;
static db_ps_t my_ps_update = NULL;
static db_ps_t my_ps_update_vp = NULL;
struct dlg_entry entry;
db_val_t values[DIALOG_TABLE_TOTAL_COL_NO];
int callee_leg;
db_key_t insert_keys[DIALOG_TABLE_TOTAL_COL_NO] = { &h_entry_column,
&h_id_column, &call_id_column, &from_uri_column,
&from_tag_column, &to_uri_column, &to_tag_column,
&from_sock_column, &to_sock_column,
&start_time_column, &mangled_fu_column, &mangled_tu_column,
&state_column, &timeout_column,
&from_cseq_column, &to_cseq_column, &from_ping_cseq_column,
&to_ping_cseq_column,&flags_column,
&vars_column, &profiles_column, &sflags_column,
&from_route_column,
&to_route_column, &from_contact_column,&to_contact_column};
if(use_dialog_table()!=0)
return -1;
callee_leg= callee_idx(cell);
if((cell->flags & DLG_FLAG_NEW) != 0){
/* save all the current dialogs information*/
VAL_TYPE(values) = VAL_TYPE(values+1) = VAL_TYPE(values+9) =
VAL_TYPE(values+12) = VAL_TYPE(values+13) = VAL_TYPE(values+16) =
VAL_TYPE(values+17) = VAL_TYPE(values+18) =
VAL_TYPE(values+21) = DB_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+10) = VAL_TYPE(values+11) =
VAL_TYPE(values+14) = VAL_TYPE(values+15) =
VAL_TYPE(values+19) = VAL_TYPE(values+20) = VAL_TYPE(values+22) =
VAL_TYPE(values+23) = VAL_TYPE(values+24) =
VAL_TYPE(values+25) = DB_STR;
/* lock the entry */
entry = (d_table->entries)[cell->h_entry];
dlg_lock( d_table, &entry);
SET_INT_VALUE(values, cell->h_entry);
SET_INT_VALUE(values+1, cell->h_id);
SET_STR_VALUE(values+2, cell->callid);
SET_STR_VALUE(values+3, cell->from_uri);
SET_STR_VALUE(values+4, cell->legs[DLG_CALLER_LEG].tag);
SET_STR_VALUE(values+5, cell->to_uri);
SET_STR_VALUE(values+6, cell->legs[callee_leg].tag);
SET_STR_VALUE(values+7, cell->legs[DLG_CALLER_LEG].bind_addr->sock_str);
if (cell->legs[callee_leg].bind_addr) {
SET_STR_VALUE(values+8,
cell->legs[callee_leg].bind_addr->sock_str);
} else {
VAL_NULL(values+8) = 1;
}
SET_INT_VALUE(values+9, cell->start_ts);
SET_STR_VALUE(values+10,cell->legs[callee_leg].from_uri);
SET_STR_VALUE(values+11,cell->legs[callee_leg].to_uri);
SET_INT_VALUE(values+12, cell->state);
SET_INT_VALUE(values+13, (unsigned int)( (unsigned int)time(0) +
cell->tl.timeout - get_ticks()) );
SET_STR_VALUE(values+14, cell->legs[DLG_CALLER_LEG].r_cseq);
SET_STR_VALUE(values+15, cell->legs[callee_leg].r_cseq);
SET_INT_VALUE(values+16,cell->legs[DLG_CALLER_LEG].last_gen_cseq);
SET_INT_VALUE(values+17,cell->legs[callee_leg].last_gen_cseq);
SET_INT_VALUE(values+18, cell->flags & ~(DLG_FLAG_NEW|DLG_FLAG_CHANGED|DLG_FLAG_VP_CHANGED));
set_final_update_cols(values+19, cell, 0);
SET_STR_VALUE(values+22, cell->legs[DLG_CALLER_LEG].route_set);
SET_STR_VALUE(values+23, cell->legs[callee_leg].route_set);
SET_STR_VALUE(values+24, cell->legs[DLG_CALLER_LEG].contact);
SET_STR_VALUE(values+25, cell->legs[callee_leg].contact);
CON_PS_REFERENCE(dialog_db_handle) = &my_ps_insert;
if((dialog_dbf.insert(dialog_db_handle, insert_keys, values,
DIALOG_TABLE_TOTAL_COL_NO)) !=0){
LM_ERR("could not add another dialog to db\n");
goto error;
}
/* dialog saved */
run_dlg_callbacks( DLGCB_SAVED, cell, 0, DLG_DIR_NONE, 0);
cell->flags &= ~(DLG_FLAG_NEW|DLG_FLAG_CHANGED|DLG_FLAG_VP_CHANGED);
} else if((cell->flags & DLG_FLAG_CHANGED) != 0) {
/* save only dialog's state and timeout */
VAL_TYPE(values) = VAL_TYPE(values+1) =
VAL_TYPE(values+12) = VAL_TYPE(values+13) = VAL_TYPE(values+16) =
VAL_TYPE(values+17) = VAL_TYPE(values+18) =
VAL_TYPE(values+21) =DB_INT;
VAL_TYPE(values+14) = VAL_TYPE(values+15) =
VAL_TYPE(values+19) = VAL_TYPE(values+20) = DB_STR;
/* lock the entry */
entry = (d_table->entries)[cell->h_entry];
dlg_lock( d_table, &entry);
SET_INT_VALUE(values, cell->h_entry);
SET_INT_VALUE(values+1, cell->h_id);
SET_INT_VALUE(values+12, cell->state);
SET_INT_VALUE(values+13, (unsigned int)( (unsigned int)time(0) +
cell->tl.timeout - get_ticks()) );
SET_STR_VALUE(values+14, cell->legs[DLG_CALLER_LEG].r_cseq);
SET_STR_VALUE(values+15, cell->legs[callee_leg].r_cseq);
SET_INT_VALUE(values+16,cell->legs[DLG_CALLER_LEG].last_gen_cseq);
SET_INT_VALUE(values+17,cell->legs[callee_leg].last_gen_cseq);
SET_INT_VALUE(values+18, cell->flags);
set_final_update_cols(values+19, cell, 1);
CON_PS_REFERENCE(dialog_db_handle) = &my_ps_update;
if((dialog_dbf.update(dialog_db_handle, (insert_keys), 0,
(values), (insert_keys+12), (values+12), 2, 10)) !=0){
LM_ERR("could not update database info\n");
goto error;
}
/* dialog saved */
run_dlg_callbacks( DLGCB_SAVED, cell, 0, DLG_DIR_NONE, 0);
cell->flags &= ~(DLG_FLAG_CHANGED|DLG_FLAG_VP_CHANGED);
} else if (cell->flags & DLG_FLAG_VP_CHANGED) {
cell->flags |= DLG_FLAG_VP_CHANGED;
VAL_TYPE(values) = VAL_TYPE(values+1) = VAL_TYPE(values+21) = DB_INT;
VAL_TYPE(values+19) = VAL_TYPE(values+20) = DB_STR;
/* lock the entry */
entry = (d_table->entries)[cell->h_entry];
dlg_lock( d_table, &entry);
SET_INT_VALUE(values, cell->h_entry);
SET_INT_VALUE(values+1, cell->h_id);
set_final_update_cols(values+19, cell, 0);
CON_PS_REFERENCE(dialog_db_handle) = &my_ps_update_vp;
if((dialog_dbf.update(dialog_db_handle, (insert_keys), 0,
(values), (insert_keys+19), (values+19), 2, 3)) !=0){
LM_ERR("could not update database info\n");
goto error;
}
run_dlg_callbacks( DLGCB_SAVED, cell, 0, DLG_DIR_NONE, 0);
cell->flags &= ~DLG_FLAG_VP_CHANGED;
} else {
return 0;
}
dlg_unlock( d_table, &entry);
return 0;
error:
dlg_unlock( d_table, &entry);
return -1;
}
void dialog_update_db(unsigned int ticks, void * param)
{
static db_ps_t my_ps_update = NULL;
static db_ps_t my_ps_insert = NULL;
static db_ps_t my_ps_update_vp = NULL;
int index;
db_val_t values[DIALOG_TABLE_TOTAL_COL_NO];
struct dlg_entry entry;
struct dlg_cell * cell;
unsigned char on_shutdown;
int callee_leg,ins_done=0;
static query_list_t *ins_list = NULL;
db_key_t insert_keys[DIALOG_TABLE_TOTAL_COL_NO] = { &h_entry_column,
&h_id_column, &call_id_column, &from_uri_column,
&from_tag_column, &to_uri_column, &to_tag_column,
&from_sock_column, &to_sock_column, &start_time_column,
&from_route_column, &to_route_column, &from_contact_column,
&to_contact_column, &mangled_fu_column, &mangled_tu_column,
/*update chunk */
&state_column, &timeout_column, &from_cseq_column,
&to_cseq_column, &from_ping_cseq_column, &to_ping_cseq_column,
&vars_column, &profiles_column, &sflags_column, &flags_column};
if (dialog_db_handle==0 || use_dialog_table()!=0)
return;
on_shutdown = (ticks==0);
/*save the current dialogs information*/
VAL_TYPE(values) = VAL_TYPE(values+1) = VAL_TYPE(values+9) =
VAL_TYPE(values+16) = VAL_TYPE(values+17) = VAL_TYPE(values+20) =
VAL_TYPE(values+21) = VAL_TYPE(values+24) = VAL_TYPE(values+25)= DB_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+10) = VAL_TYPE(values+11) =
VAL_TYPE(values+12) = VAL_TYPE(values+13) = VAL_TYPE(values+14) =
VAL_TYPE(values+15) = VAL_TYPE(values+18) = VAL_TYPE(values+19) =
VAL_TYPE(values+22) = VAL_TYPE(values+23) = DB_STR;
for(index = 0; index< d_table->size; index++){
/* lock the whole entry */
entry = (d_table->entries)[index];
dlg_lock( d_table, &entry);
for(cell = entry.first; cell != NULL; cell = cell->next){
callee_leg = callee_idx(cell);
if( (cell->flags & DLG_FLAG_NEW) != 0 ) {
if ( cell->state == DLG_STATE_DELETED ) {
/* don't need to insert dialogs already terminated */
continue;
}
LM_DBG("inserting new dialog %p\n",cell);
SET_INT_VALUE(values, cell->h_entry);
SET_INT_VALUE(values+1, cell->h_id);
SET_STR_VALUE(values+2, cell->callid);
SET_STR_VALUE(values+3, cell->from_uri);
SET_STR_VALUE(values+4, cell->legs[DLG_CALLER_LEG].tag);
SET_STR_VALUE(values+5, cell->to_uri);
SET_STR_VALUE(values+6, cell->legs[callee_leg].tag);
SET_STR_VALUE(values+7,
cell->legs[DLG_CALLER_LEG].bind_addr->sock_str);
if (cell->legs[callee_leg].bind_addr) {
SET_STR_VALUE(values+8,
cell->legs[callee_leg].bind_addr->sock_str);
} else {
VAL_NULL(values+8) = 1;
}
SET_INT_VALUE(values+9, cell->start_ts);
SET_STR_VALUE(values+10, cell->legs[DLG_CALLER_LEG].route_set);
SET_STR_VALUE(values+11,
cell->legs[callee_leg].route_set);
SET_STR_VALUE(values+12, cell->legs[DLG_CALLER_LEG].contact);
SET_STR_VALUE(values+13,
cell->legs[callee_leg].contact);
SET_STR_VALUE(values+14,cell->legs[callee_leg].from_uri);
SET_STR_VALUE(values+15,cell->legs[callee_leg].to_uri);
SET_INT_VALUE(values+16, cell->state);
SET_INT_VALUE(values+17, (unsigned int)((unsigned int)time(0)
+ cell->tl.timeout - get_ticks()) );
SET_STR_VALUE(values+18, cell->legs[DLG_CALLER_LEG].r_cseq);
SET_STR_VALUE(values+19, cell->legs[callee_leg].r_cseq);
SET_INT_VALUE(values+20, cell->legs[DLG_CALLER_LEG].last_gen_cseq);
SET_INT_VALUE(values+21, cell->legs[callee_leg].last_gen_cseq);
set_final_update_cols(values+22, cell, on_shutdown);
SET_INT_VALUE(values+25, cell->flags & ~(DLG_FLAG_NEW|DLG_FLAG_CHANGED|DLG_FLAG_VP_CHANGED));
CON_PS_REFERENCE(dialog_db_handle) = &my_ps_insert;
if (con_set_inslist(&dialog_dbf,dialog_db_handle,
&ins_list,insert_keys,DIALOG_TABLE_TOTAL_COL_NO) < 0 )
CON_RESET_INSLIST(dialog_db_handle);
if((dialog_dbf.insert(dialog_db_handle, insert_keys,
values, DIALOG_TABLE_TOTAL_COL_NO)) !=0){
LM_ERR("could not add another dialog to db\n");
goto error;
}
if (ins_done==0)
ins_done=1;
/* dialog saved */
run_dlg_callbacks( DLGCB_SAVED, cell, 0, DLG_DIR_NONE, 0);
cell->flags &= ~(DLG_FLAG_NEW |DLG_FLAG_CHANGED|DLG_FLAG_VP_CHANGED);
} else if ( (cell->flags & DLG_FLAG_CHANGED)!=0 || on_shutdown ){
LM_DBG("updating existing dialog %p\n",cell);
SET_INT_VALUE(values, cell->h_entry);
SET_INT_VALUE(values+1, cell->h_id);
SET_INT_VALUE(values+16, cell->state);
SET_INT_VALUE(values+17, (unsigned int)((unsigned int)time(0)
+ cell->tl.timeout - get_ticks()) );
SET_STR_VALUE(values+18, cell->legs[DLG_CALLER_LEG].r_cseq);
SET_STR_VALUE(values+19, cell->legs[callee_leg].r_cseq);
SET_INT_VALUE(values+20, cell->legs[DLG_CALLER_LEG].last_gen_cseq);
SET_INT_VALUE(values+21, cell->legs[callee_leg].last_gen_cseq);
set_final_update_cols(values+22, cell, 1);
SET_INT_VALUE(values+25, cell->flags);
CON_PS_REFERENCE(dialog_db_handle) = &my_ps_update;
if((dialog_dbf.update(dialog_db_handle, (insert_keys), 0,
(values), (insert_keys+16), (values+16), 2, 10)) !=0) {
LM_ERR("could not update database info\n");
goto error;
}
/* dialog saved */
run_dlg_callbacks( DLGCB_SAVED, cell, 0, DLG_DIR_NONE, 0);
cell->flags &= ~(DLG_FLAG_CHANGED|DLG_FLAG_VP_CHANGED);
} else if (cell->flags & DLG_FLAG_VP_CHANGED) {
SET_INT_VALUE(values, cell->h_entry);
SET_INT_VALUE(values+1, cell->h_id);
set_final_update_cols(values+22, cell, 0);
CON_PS_REFERENCE(dialog_db_handle) = &my_ps_update_vp;
if((dialog_dbf.update(dialog_db_handle, (insert_keys), 0,
(values), (insert_keys+22), (values+22), 2, 3)) !=0) {
LM_ERR("could not update database info\n");
goto error;
}
run_dlg_callbacks( DLGCB_SAVED, cell, 0, DLG_DIR_NONE, 0);
cell->flags &= ~DLG_FLAG_VP_CHANGED;
}
}
dlg_unlock( d_table, &entry);
}
if (ins_done) {
LM_DBG("dlg timer attempting to flush rows to DB\n");
/* flush everything to DB
* so that next-time timer fires
* we are sure that DB updates will be succesful */
if (ql_flush_rows(&dialog_dbf,dialog_db_handle,ins_list) < 0)
LM_ERR("failed to flush rows to DB\n");
}
return;
error:
dlg_unlock( d_table, &entry);
}
static int xcaps_put_db(str* user, str *domain, xcap_uri_t *xuri, str *etag,
str* doc)
{
db_key_t qcols[9], rcols[2], ucols[5];
db_val_t qvals[9], uvals[5];
db1_res_t *res = NULL;
int ncols = 0, num_ucols = 0, nrows = 0;
if(xcaps_check_doc_validity(doc)<0)
{
LM_ERR("invalid xml doc to insert in database\n");
goto error;
}
qcols[ncols] = &str_username_col;
qvals[ncols].type = DB1_STR;
qvals[ncols].nul = 0;
qvals[ncols].val.str_val = *user;
ncols++;
qcols[ncols] = &str_domain_col;
qvals[ncols].type = DB1_STR;
qvals[ncols].nul = 0;
qvals[ncols].val.str_val = *domain;
ncols++;
qcols[ncols] = &str_doc_type_col;
qvals[ncols].type = DB1_INT;
qvals[ncols].nul = 0;
qvals[ncols].val.int_val= xuri->type;
ncols++;
qcols[ncols] = &str_doc_uri_col;
qvals[ncols].type = DB1_STR;
qvals[ncols].nul = 0;
qvals[ncols].val.str_val= xuri->adoc;
ncols++;
rcols[0] = &str_id_col;
if (xcaps_dbf.use_table(xcaps_db, &xcaps_db_table) < 0)
{
LM_ERR("in use_table-[table]= %.*s\n", xcaps_db_table.len,
xcaps_db_table.s);
goto error;
}
if (xcaps_dbf.query(xcaps_db, qcols, 0, qvals, rcols, ncols, 1, 0, &res) < 0)
{
LM_ERR("in sql query\n");
goto error;
}
nrows = RES_ROW_N(res);
xcaps_dbf.free_result(xcaps_db, res);
if (nrows == 0)
{
qcols[ncols] = &str_doc_col;
qvals[ncols].type = DB1_BLOB;
qvals[ncols].nul = 0;
qvals[ncols].val.str_val= *doc;
ncols++;
qcols[ncols] = &str_etag_col;
qvals[ncols].type = DB1_STR;
qvals[ncols].nul = 0;
qvals[ncols].val.str_val= *etag;
ncols++;
qcols[ncols] = &str_source_col;
qvals[ncols].type = DB1_INT;
qvals[ncols].nul = 0;
qvals[ncols].val.int_val = 0;
ncols++;
qcols[ncols] = &str_port_col;
qvals[ncols].type = DB1_INT;
qvals[ncols].nul = 0;
qvals[ncols].val.int_val = 0;
ncols++;
if(xcaps_dbf.insert(xcaps_db, qcols, qvals, ncols)< 0)
{
LM_ERR("in sql insert\n");
goto error;
}
}
else if (nrows == 1)
{
ucols[num_ucols] = &str_doc_col;
uvals[num_ucols].type = DB1_BLOB;
uvals[num_ucols].nul = 0;
uvals[num_ucols].val.str_val= *doc;
num_ucols++;
ucols[num_ucols] = &str_etag_col;
uvals[num_ucols].type = DB1_STR;
uvals[num_ucols].nul = 0;
uvals[num_ucols].val.str_val= *etag;
num_ucols++;
ucols[num_ucols] = &str_source_col;
uvals[num_ucols].type = DB1_INT;
uvals[num_ucols].nul = 0;
uvals[num_ucols].val.int_val = 0;
num_ucols++;
ucols[num_ucols] = &str_port_col;
uvals[num_ucols].type = DB1_INT;
uvals[num_ucols].nul = 0;
uvals[num_ucols].val.int_val = 0;
num_ucols++;
if (xcaps_dbf.update(xcaps_db, qcols, 0, qvals, ucols, uvals, ncols, num_ucols) < 0)
{
LM_ERR("in sql update\n");
goto error;
}
}
else
{
LM_ERR("found %d copies of the same document in XCAP Server\n", nrows);
goto error;
}
return 0;
error:
return -1;
}
