int acc_db_request( struct sip_msg *rq, struct sip_msg *rpl,
query_list_t **ins_list)
{
static db_ps_t my_ps_ins = NULL;
static db_ps_t my_ps = NULL;
int m;
int n;
int i;
/* formated database columns */
m = core2strar( rq, val_arr );
for(i = 0; i < m; i++)
VAL_STR(db_vals+i) = val_arr[i];
/* time value */
VAL_TIME(db_vals+(m++)) = acc_env.ts;
/* extra columns */
m += extra2strar( db_extra, rq, rpl, val_arr+m, 0);
for( i++; i < m; i++)
VAL_STR(db_vals+i) = val_arr[i];
acc_dbf.use_table(db_handle, &acc_env.text/*table*/);
CON_PS_REFERENCE(db_handle) = ins_list? &my_ps_ins : &my_ps;
/* multi-leg columns */
if ( !leg_info ) {
if (con_set_inslist(&acc_dbf,db_handle,ins_list,db_keys,m) < 0 )
CON_RESET_INSLIST(db_handle);
if (acc_dbf.insert(db_handle, db_keys, db_vals, m) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
} else {
n = legs2strar(leg_info,rq,val_arr+m,1);
do {
for ( i = m; i < m + n; i++)
VAL_STR(db_vals+i)=val_arr[i];
if (con_set_inslist(&acc_dbf,db_handle,ins_list,db_keys,m+n) < 0 )
CON_RESET_INSLIST(db_handle);
if (acc_dbf.insert(db_handle, db_keys, db_vals, m+n) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
}while ( (n = legs2strar(leg_info,rq,val_arr+m,0))!=0 );
}
return 1;
}
static inline int insert_siptrace_avp(struct usr_avp *avp,
int_str *first_val,db_key_t *keys,db_val_t *vals)
{
int_str avp_value;
if (avp == 0)
return 0;
if (!is_avp_str_val(avp)) {
avp_value.s.s=int2str(first_val->n,&avp_value.s.len);
LM_DBG("int val [%.*s]\n",avp_value.s.len,avp_value.s.s);
} else {
avp_value = *first_val;
LM_DBG("str val [%.*s]\n",avp_value.s.len,avp_value.s.s);
}
db_vals[13].val.str_val.s = avp_value.s.s;
db_vals[13].val.str_val.len = avp_value.s.len;
LM_DBG("storing info 14...\n");
CON_PS_REFERENCE(db_con) = &siptrace_ps;
if (con_set_inslist(&db_funcs,db_con,&ins_list,keys,NR_KEYS) < 0 )
CON_RESET_INSLIST(db_con);
if(db_funcs.insert(db_con, keys, vals, NR_KEYS) < 0) {
LM_ERR("error storing trace\n");
return -1;
}
avp = search_next_avp( avp, &avp_value);
while(avp!=NULL)
{
if (!is_avp_str_val(avp))
avp_value.s.s=int2str(avp_value.n,&avp_value.s.len);
db_vals[13].val.str_val.s = avp_value.s.s;
db_vals[13].val.str_val.len = avp_value.s.len;
LM_DBG("### - storing info 14 \n");
CON_PS_REFERENCE(db_con) = &siptrace_ps;
if (con_set_inslist(&db_funcs,db_con,&ins_list,keys,NR_KEYS) < 0 )
CON_RESET_INSLIST(db_con);
if(db_funcs.insert(db_con, keys, vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
return -1;
}
avp = search_next_avp( avp, &avp_value);
}
return 0;
}
int log_request(struct sip_msg *rq, str* ouri, struct hdr_field *to, char *table, unsigned int code, time_t req_timestamp)
{
int cnt;
if (skip_cancel(rq)) return 1;
cnt = fmt2strar(log_fmt, rq, ouri, to, code, req_timestamp);
if (cnt == 0) {
LOG(L_ERR, "ERROR:acc:log_request: fmt2strar failed\n");
return -1;
}
if (!db_url.len) {
LOG(L_ERR, "ERROR:acc:log_request: can't log -- no db_url set\n");
return -1;
}
if (acc_dbf.use_table(db_handle, table) < 0) {
LOG(L_ERR, "ERROR:acc:log_request:Error in use_table\n");
return -1;
}
if (acc_dbf.insert(db_handle, keys, vals, cnt) < 0) {
LOG(L_ERR, "ERROR:acc:log_request:acc_request: Error while inserting to database\n");
return -1;
}
return 1;
}
int acc_db_request( struct sip_msg *rq)
{
int m;
int n;
int i;
/* formated database columns */
m = core2strar( rq, val_arr, int_arr, type_arr );
for(i=0; i<m; i++)
VAL_STR(db_vals+i) = val_arr[i];
/* time value */
VAL_TIME(db_vals+(m++)) = acc_env.ts;
/* extra columns */
m += extra2strar( db_extra, rq, val_arr+m, int_arr+m, type_arr+m);
for( i++ ; i<m; i++)
VAL_STR(db_vals+i) = val_arr[i];
if (acc_dbf.use_table(db_handle, &acc_env.text/*table*/) < 0) {
LM_ERR("error in use_table\n");
return -1;
}
/* multi-leg columns */
if ( !leg_info ) {
if (acc_dbf.insert(db_handle, db_keys, db_vals, m) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
} else {
n = legs2strar(leg_info,rq,val_arr+m,int_arr+m,type_arr+m,1);
do {
for (i=m; i<m+n; i++)
VAL_STR(db_vals+i)=val_arr[i];
if (acc_dbf.insert(db_handle, db_keys, db_vals, m+n) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
}while ( (n=legs2strar(leg_info,rq,val_arr+m,int_arr+m,
type_arr+m,0))!=0 );
}
return 1;
}
static inline int insert_siptrace_flag(struct sip_msg *msg,
db_key_t *keys,db_val_t *vals)
{
db_vals[13].val.str_val.s = "";
db_vals[13].val.str_val.len = 0;
LM_DBG("storing info 1...\n");
if (con_set_inslist(&db_funcs,db_con,&ins_list,keys,NR_KEYS) < 0 )
CON_RESET_INSLIST(db_con);
CON_PS_REFERENCE(db_con) = &siptrace_ps;
if(db_funcs.insert(db_con, keys, vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
return -1;
}
return 0;
}
int acc_db_request( struct sip_msg *rq)
{
int m;
int n;
int i;
struct tm *t;
/* formated database columns */
m = core2strar( rq, val_arr, int_arr, type_arr );
for(i=0; i<m; i++)
VAL_STR(db_vals+i) = val_arr[i];
/* time value */
VAL_TIME(db_vals+(m++)) = acc_env.ts;
/* extra time value */
if(acc_time_mode==1) {
VAL_INT(db_vals+(m++)) = (int)acc_env.tv.tv_sec;
i++;
VAL_INT(db_vals+(m++)) = (int)acc_env.tv.tv_usec;
i++;
} else if(acc_time_mode==2) {
VAL_DOUBLE(db_vals+(m++)) = ((double)(acc_env.tv.tv_sec * 1000)
+ (acc_env.tv.tv_usec / 1000)) / 1000;
i++;
} else if(acc_time_mode==3 || acc_time_mode==4) {
if(acc_time_mode==3) {
t = localtime(&acc_env.ts);
} else {
t = gmtime(&acc_env.ts);
}
if(strftime(acc_time_format_buf, ACC_TIME_FORMAT_SIZE,
acc_time_format, t)<=0) {
acc_time_format_buf[0] = '\0';
}
VAL_STRING(db_vals+(m++)) = acc_time_format_buf;
i++;
}
/* extra columns */
m += extra2strar( db_extra, rq, val_arr+m, int_arr+m, type_arr+m);
for( i++ ; i<m; i++)
VAL_STR(db_vals+i) = val_arr[i];
if (acc_dbf.use_table(db_handle, &acc_env.text/*table*/) < 0) {
LM_ERR("error in use_table\n");
return -1;
}
/* multi-leg columns */
if ( !leg_info ) {
if(acc_db_insert_mode==1 && acc_dbf.insert_delayed!=NULL) {
if (acc_dbf.insert_delayed(db_handle, db_keys, db_vals, m) < 0) {
LM_ERR("failed to insert delayed into database\n");
return -1;
}
} else if(acc_db_insert_mode==2 && acc_dbf.insert_async!=NULL) {
if (acc_dbf.insert_async(db_handle, db_keys, db_vals, m) < 0) {
LM_ERR("failed to insert async into database\n");
return -1;
}
} else {
if (acc_dbf.insert(db_handle, db_keys, db_vals, m) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
}
} else {
n = legs2strar(leg_info,rq,val_arr+m,int_arr+m,type_arr+m,1);
do {
for (i=m; i<m+n; i++)
VAL_STR(db_vals+i)=val_arr[i];
if(acc_db_insert_mode==1 && acc_dbf.insert_delayed!=NULL) {
if(acc_dbf.insert_delayed(db_handle,db_keys,db_vals,m+n)<0) {
LM_ERR("failed to insert delayed into database\n");
return -1;
}
} else if(acc_db_insert_mode==2 && acc_dbf.insert_async!=NULL) {
if(acc_dbf.insert_async(db_handle,db_keys,db_vals,m+n)<0) {
LM_ERR("failed to insert async into database\n");
return -1;
}
} else {
if (acc_dbf.insert(db_handle, db_keys, db_vals, m+n) < 0) {
LM_ERR("failed to insert into database\n");
return -1;
}
}
}while ( (n=legs2strar(leg_info,rq,val_arr+m,int_arr+m,
type_arr+m,0))!=0 );
}
return 1;
}
int acc_db_cdrs(struct dlg_cell *dlg, struct sip_msg *msg)
{
int total, nr_vals, i, j, ret, res = -1;
time_t created, start_time;
str core_s, leg_s, extra_s, table;
short nr_legs;
static db_ps_t my_ps = NULL;
static query_list_t *ins_list = NULL;
core_s.s = extra_s.s = leg_s.s = 0;
ret = prebuild_core_arr(dlg, &core_s, &start_time);
if (ret < 0) {
LM_ERR("cannot copy core arguments\n");
goto end;
}
ret = prebuild_extra_arr(dlg, msg, &extra_s,
&db_extra_str, db_extra_bye, ret);
if (ret < 0) {
LM_ERR("cannot copy extra arguments\n");
goto end;
}
/* here starts the extra leg */
nr_vals = prebuild_leg_arr(dlg, &leg_s, &nr_legs);
if (nr_vals < 0) {
LM_ERR("cannot compute leg values\n");
goto end;
}
if (!(created = acc_get_created(dlg))) {
LM_ERR("cannot get created\n");
goto end;
}
if (dlg_api.fetch_dlg_value(dlg, &table_str, &table, 0) < 0) {
LM_ERR("error getting table name\n");
return -1;
}
for (i=0;i<ACC_CORE_LEN;i++)
VAL_STR(db_vals+i) = val_arr[i];
for (i=ACC_CORE_LEN; i<ret; i++)
VAL_STR(db_vals+i+1) = val_arr[i];
VAL_TIME(db_vals+ACC_CORE_LEN) = start_time;
VAL_INT(db_vals+ret+nr_vals+1) = time(NULL) - start_time;
VAL_INT(db_vals+ret+nr_vals+2) = start_time - created;
VAL_TIME(db_vals+ret+nr_vals+3) = created;
total = ret + 4;
acc_dbf.use_table(db_handle, &table);
CON_PS_REFERENCE(db_handle) = &my_ps;
if (!leg_info) {
if (con_set_inslist(&acc_dbf,db_handle,&ins_list,db_keys,total) < 0 )
CON_RESET_INSLIST(db_handle);
if (acc_dbf.insert(db_handle, db_keys, db_vals, total) < 0) {
LM_ERR("failed to insert into database\n");
goto end;
}
} else {
total += nr_vals;
leg_s.len = 4;
for (i=0;i<nr_legs;i++) {
complete_dlg_values(&leg_s,val_arr+ret,nr_vals);
for (j = 0; j<nr_vals; j++)
VAL_STR(db_vals+ret+j+1) = val_arr[ret+j];
if (con_set_inslist(&acc_dbf,db_handle,&ins_list,db_keys,total) < 0 )
CON_RESET_INSLIST(db_handle);
if (acc_dbf.insert(db_handle,db_keys,db_vals,total) < 0) {
LM_ERR("failed inserting into database\n");
goto end;
}
}
}
res = 1;
end:
if (core_s.s)
pkg_free(core_s.s);
if (extra_s.s)
pkg_free(extra_s.s);
if (leg_s.s)
pkg_free(leg_s.s);
return res;
}
static void trace_onreply_out(struct cell* t, int type, struct tmcb_params *ps)
{
db_key_t db_keys[NR_KEYS];
db_val_t db_vals[NR_KEYS];
int faked = 0;
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+12];
struct sip_msg* msg;
struct sip_msg* req;
int_str avp_value;
struct usr_avp *avp;
struct ip_addr to_ip;
int len;
char statusbuf[8];
str *sbuf;
struct dest_info *dst;
if (t==NULL || t->uas.request==0 || ps==NULL)
{
LM_DBG("no uas request, local transaction\n");
return;
}
avp = NULL;
if(traced_user_avp.n!=0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
if((avp==NULL) && trace_is_off(t->uas.request))
{
LM_DBG("trace off...\n");
return;
}
req = ps->req;
msg = ps->rpl;
if(msg==NULL || msg==FAKED_REPLY)
{
msg = t->uas.request;
faked = 1;
}
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0)
{
LM_ERR("cannot parse call-id\n");
return;
}
db_keys[0] = msg_column;
db_vals[0].type = DB_BLOB;
db_vals[0].nul = 0;
sbuf = (str*)ps->extra1;
if(faked==0)
{
if(sbuf!=0 && sbuf->len>0) {
db_vals[0].val.blob_val.s = sbuf->s;
db_vals[0].val.blob_val.len = sbuf->len;
} else if(t->uas.response.buffer.s!=NULL) {
db_vals[0].val.blob_val.s = t->uas.response.buffer.s;
db_vals[0].val.blob_val.len = t->uas.response.buffer.len;
} else if(msg->len>0) {
db_vals[0].val.blob_val.s = msg->buf;
db_vals[0].val.blob_val.len = msg->len;
} else {
db_vals[0].val.blob_val.s = "No reply buffer";
db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1;
}
} else {
if(sbuf!=0 && sbuf->len>0) {
db_vals[0].val.blob_val.s = sbuf->s;
db_vals[0].val.blob_val.len = sbuf->len;
} else if(t->uas.response.buffer.s==NULL) {
db_vals[0].val.blob_val.s = "No reply buffer";
db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1;
} else {
db_vals[0].val.blob_val.s = t->uas.response.buffer.s;
db_vals[0].val.blob_val.len = t->uas.response.buffer.len;
}
}
/* check Call-ID header */
if(msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot find Call-ID header!\n");
goto error;
}
db_keys[1] = callid_column;
db_vals[1].type = DB_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
db_keys[2] = method_column;
db_vals[2].type = DB_STR;
db_vals[2].nul = 0;
db_vals[2].val.str_val.s = t->method.s;
db_vals[2].val.str_val.len = t->method.len;
db_keys[4] = fromip_column;
db_vals[4].type = DB_STRING;
db_vals[4].nul = 0;
if(trace_local_ip)
db_vals[4].val.string_val = trace_local_ip;
else {
siptrace_copy_proto(msg->rcv.proto, fromip_buff);
strcat(fromip_buff, ip_addr2a(&req->rcv.dst_ip));
strcat(fromip_buff,":");
strcat(fromip_buff, int2str(req->rcv.dst_port, NULL));
db_vals[4].val.string_val = fromip_buff;
}
db_keys[3] = status_column;
db_vals[3].type = DB_STRING;
db_vals[3].nul = 0;
strcpy(statusbuf, int2str(ps->code, NULL));
db_vals[3].val.string_val = statusbuf;
db_keys[5] = toip_column;
db_vals[5].type = DB_STRING;
db_vals[5].nul = 0;
memset(&to_ip, 0, sizeof(struct ip_addr));
dst = (struct dest_info*)ps->extra2;
if(dst==0)
{
db_vals[5].val.string_val = "any:255.255.255.255";
} else {
su2ip_addr(&to_ip, &dst->to);
siptrace_copy_proto(dst->proto, toip_buff);
strcat(toip_buff, ip_addr2a(&to_ip));
strcat(toip_buff, ":");
strcat(toip_buff,
int2str((unsigned long)su_getport(&dst->to), &len));
LM_DBG("dest [%s]\n", toip_buff);
db_vals[5].val.string_val = toip_buff;
}
db_keys[6] = date_column;
db_vals[6].type = DB_DATETIME;
db_vals[6].nul = 0;
db_vals[6].val.time_val = time(NULL);
db_keys[7] = direction_column;
db_vals[7].type = DB_STRING;
db_vals[7].nul = 0;
db_vals[7].val.string_val = "out";
db_keys[8] = fromtag_column;
db_vals[8].type = DB_STR;
db_vals[8].nul = 0;
db_vals[8].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[8].val.str_val.len = get_from(msg)->tag_value.len;
db_funcs.use_table(db_con, siptrace_get_table());
db_keys[9] = traced_user_column;
db_vals[9].type = DB_STR;
db_vals[9].nul = 0;
if( !trace_is_off(req) ) {
db_vals[9].val.str_val.s = "";
db_vals[9].val.str_val.len = 0;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
#ifdef STATISTICS
update_stat(siptrace_rpl, 1);
#endif
}
if(avp==NULL)
goto done;
trace_send_duplicate(db_vals[0].val.blob_val.s,
db_vals[0].val.blob_val.len);
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
while(avp!=NULL)
{
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("### - storing info (%d) ...\n", faked);
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
}
done:
return;
error:
return;
}
/**
* save hash table content back to database
*/
int ht_db_save_table(ht_t *ht, str *dbtable)
{
db_key_t db_cols[5] = {&ht_db_name_column, &ht_db_ktype_column,
&ht_db_vtype_column, &ht_db_value_column, &ht_db_expires_column};
db_val_t db_vals[5];
ht_cell_t *it;
str tmp;
int i;
time_t now;
int ncols;
if(ht_db_con==NULL)
{
LM_ERR("no db connection\n");
return -1;
}
if (ht_dbf.use_table(ht_db_con, dbtable) < 0)
{
LM_ERR("failed to use_table\n");
return -1;
}
LM_DBG("save the content of hash table [%.*s] to database in [%.*s]\n",
ht->name.len, ht->name.s, dbtable->len, dbtable->s);
now = time(NULL);
for(i=0; i<ht->htsize; i++)
{
lock_get(&ht->entries[i].lock);
it = ht->entries[i].first;
while(it)
{
if(it->flags&AVP_VAL_STR) {
LM_DBG("entry key: [%.*s] value: [%.*s] (str)\n",
it->name.len, it->name.s, it->value.s.len, it->value.s.s);
} else {
LM_DBG("entry key: [%.*s] value: [%d] (int)\n",
it->name.len, it->name.s, it->value.n);
}
if(ht->htexpire > 0) {
if (it->expire <= now) {
LM_DBG("skipping expired entry");
it = it->next;
continue;
}
}
db_vals[0].type = DB1_STR;
db_vals[0].nul = 0;
db_vals[0].val.str_val.s = it->name.s;
db_vals[0].val.str_val.len = it->name.len;
db_vals[1].type = DB1_INT;
db_vals[1].nul = 0;
db_vals[1].val.int_val = 0;
db_vals[2].type = DB1_INT;
db_vals[2].nul = 0;
db_vals[3].type = DB1_STR;
db_vals[3].nul = 0;
if(it->flags&AVP_VAL_STR) {
db_vals[2].val.int_val = 0;
db_vals[3].val.str_val.s = it->value.s.s;
db_vals[3].val.str_val.len = it->value.s.len;
} else {
db_vals[2].val.int_val = 1;
tmp.s = sint2str((long)it->value.n, &tmp.len);
db_vals[3].val.str_val.s = tmp.s;
db_vals[3].val.str_val.len = tmp.len;
}
ncols = 4;
if(ht_db_expires_flag!=0 && ht->htexpire > 0) {
db_vals[4].type = DB1_INT;
db_vals[4].nul = 0;
db_vals[4].val.int_val = (int)it->expire;
ncols = 5;
}
if(ht_dbf.insert(ht_db_con, db_cols, db_vals, ncols) < 0)
{
LM_ERR("failed to store key [%.*s] in table [%.*s]\n",
it->name.len, it->name.s,
dbtable->len, dbtable->s);
}
it = it->next;
}
}
return 0;
}
static int sip_trace(struct sip_msg *msg, char *s1, char *s2)
{
db_key_t db_keys[NR_KEYS];
db_val_t db_vals[NR_KEYS];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+6];
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+6];
int_str avp_value;
struct usr_avp *avp;
if(msg==NULL)
{
LM_DBG("no uas request, local transaction\n");
return -1;
}
avp = NULL;
if(traced_user_avp.n!=0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
if((avp==NULL) && (trace_on_flag==NULL || *trace_on_flag==0))
{
LM_DBG("trace off...\n");
return -1;
}
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0 || msg->callid==NULL
|| msg->callid->body.s==NULL)
{
LM_ERR("cannot parse call-id\n");
goto error;
}
db_keys[0] = msg_column;
db_vals[0].type = DB_BLOB;
db_vals[0].nul = 0;
db_vals[0].val.blob_val.s = msg->buf;
db_vals[0].val.blob_val.len = msg->len;
db_keys[1] = callid_column;
db_vals[1].type = DB_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
db_keys[2] = method_column;
db_vals[2].type = DB_STR;
db_vals[2].nul = 0;
if(msg->first_line.type==SIP_REQUEST)
{
db_vals[2].val.str_val.s = msg->first_line.u.request.method.s;
db_vals[2].val.str_val.len = msg->first_line.u.request.method.len;
} else {
db_vals[2].val.str_val.s = "";
db_vals[2].val.str_val.len = 0;
}
db_keys[3] = status_column;
db_vals[3].type = DB_STR;
db_vals[3].nul = 0;
if(msg->first_line.type==SIP_REPLY)
{
db_vals[3].val.str_val.s = msg->first_line.u.reply.status.s;
db_vals[3].val.str_val.len = msg->first_line.u.reply.status.len;
} else {
db_vals[3].val.str_val.s = "";
db_vals[3].val.str_val.len = 0;
}
db_keys[4] = fromip_column;
db_vals[4].type = DB_STRING;
db_vals[4].nul = 0;
siptrace_copy_proto(msg->rcv.proto, fromip_buff);
strcat(fromip_buff, ip_addr2a(&msg->rcv.src_ip));
strcat(fromip_buff,":");
strcat(fromip_buff, int2str(msg->rcv.src_port, NULL));
db_vals[4].val.string_val = fromip_buff;
db_keys[5] = toip_column;
db_vals[5].type = DB_STRING;
db_vals[5].nul = 0;
// db_vals[5].val.string_val = ip_addr2a(&msg->rcv.dst_ip);;
siptrace_copy_proto(msg->rcv.proto, toip_buff);
strcat(toip_buff, ip_addr2a(&msg->rcv.dst_ip));
strcat(toip_buff,":");
strcat(toip_buff, int2str(msg->rcv.dst_port, NULL));
db_vals[5].val.string_val = toip_buff;
db_keys[6] = date_column;
db_vals[6].type = DB_DATETIME;
db_vals[6].nul = 0;
db_vals[6].val.time_val = time(NULL);
db_keys[7] = direction_column;
db_vals[7].type = DB_STRING;
db_vals[7].nul = 0;
db_vals[7].val.string_val = "in";
db_keys[8] = fromtag_column;
db_vals[8].type = DB_STR;
db_vals[8].nul = 0;
db_vals[8].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[8].val.str_val.len = get_from(msg)->tag_value.len;
db_funcs.use_table(db_con, siptrace_get_table());
db_keys[9] = traced_user_column;
db_vals[9].type = DB_STR;
db_vals[9].nul = 0;
if(trace_on_flag!=NULL && *trace_on_flag!=0) {
db_vals[9].val.str_val.s = "";
db_vals[9].val.str_val.len = 0;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
#ifdef STATISTICS
if(msg->first_line.type==SIP_REPLY)
{
update_stat(siptrace_rpl, 1);
} else {
update_stat(siptrace_req, 1);
}
#endif
}
if(avp==NULL)
goto done;
trace_send_duplicate(db_vals[0].val.blob_val.s,
db_vals[0].val.blob_val.len);
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
while(avp!=NULL)
{
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
}
done:
return 1;
error:
return -1;
}
static void trace_onreply_in(struct cell* t, int type, struct tmcb_params *ps)
{
db_key_t db_keys[NR_KEYS];
db_val_t db_vals[NR_KEYS];
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+12];
struct sip_msg* msg;
struct sip_msg* req;
int_str avp_value;
struct usr_avp *avp;
char statusbuf[8];
if(t==NULL || t->uas.request==0 || ps==NULL)
{
LM_DBG("no uas request, local transaction\n");
return;
}
req = ps->req;
msg = ps->rpl;
if(msg==NULL || req==NULL)
{
LM_DBG("no reply\n");
return;
}
avp = NULL;
if(traced_user_avp.n!=0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
if((avp==NULL) && trace_is_off(req))
{
LM_DBG("trace off...\n");
return;
}
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0)
{
LM_ERR("cannot parse call-id\n");
return;
}
db_keys[0] = msg_column;
db_vals[0].type = DB_BLOB;
db_vals[0].nul = 0;
if(msg->len>0) {
db_vals[0].val.blob_val.s = msg->buf;
db_vals[0].val.blob_val.len = msg->len;
} else {
db_vals[0].val.blob_val.s = "No reply buffer";
db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1;
}
/* check Call-ID header */
if(msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot find Call-ID header!\n");
goto error;
}
db_keys[1] = callid_column;
db_vals[1].type = DB_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
db_keys[2] = method_column;
db_vals[2].type = DB_STR;
db_vals[2].nul = 0;
db_vals[2].val.str_val.s = t->method.s;
db_vals[2].val.str_val.len = t->method.len;
db_keys[3] = status_column;
db_vals[3].type = DB_STRING;
db_vals[3].nul = 0;
strcpy(statusbuf, int2str(ps->code, NULL));
db_vals[3].val.string_val = statusbuf;
db_keys[4] = fromip_column;
db_vals[4].type = DB_STRING;
db_vals[4].nul = 0;
siptrace_copy_proto(msg->rcv.proto, fromip_buff);
strcat(fromip_buff, ip_addr2a(&msg->rcv.src_ip));
strcat(fromip_buff,":");
strcat(fromip_buff, int2str(msg->rcv.src_port, NULL));
db_vals[4].val.string_val = fromip_buff;
db_keys[5] = toip_column;
db_vals[5].type = DB_STRING;
db_vals[5].nul = 0;
// db_vals[5].val.string_val = ip_addr2a(&msg->rcv.dst_ip);;
if(trace_local_ip)
db_vals[5].val.string_val = trace_local_ip;
else {
siptrace_copy_proto(msg->rcv.proto, toip_buff);
strcat(toip_buff, ip_addr2a(&msg->rcv.dst_ip));
strcat(toip_buff,":");
strcat(toip_buff, int2str(msg->rcv.dst_port, NULL));
db_vals[5].val.string_val = toip_buff;
}
db_keys[6] = date_column;
db_vals[6].type = DB_DATETIME;
db_vals[6].nul = 0;
db_vals[6].val.time_val = time(NULL);
db_keys[7] = direction_column;
db_vals[7].type = DB_STRING;
db_vals[7].nul = 0;
db_vals[7].val.string_val = "in";
db_keys[8] = fromtag_column;
db_vals[8].type = DB_STR;
db_vals[8].nul = 0;
db_vals[8].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[8].val.str_val.len = get_from(msg)->tag_value.len;
db_funcs.use_table(db_con, siptrace_get_table());
db_keys[9] = traced_user_column;
db_vals[9].type = DB_STR;
db_vals[9].nul = 0;
if( !trace_is_off(req) ) {
db_vals[9].val.str_val.s = "";
db_vals[9].val.str_val.len = 0;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
#ifdef STATISTICS
update_stat(siptrace_rpl, 1);
#endif
}
if(avp==NULL)
goto done;
trace_send_duplicate(db_vals[0].val.blob_val.s,
db_vals[0].val.blob_val.len);
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
while(avp!=NULL)
{
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("storing info ...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
}
done:
return;
error:
return;
}
int insert_sca_info_into_db(b2b_sca_record_t *record)
{
b2b_sca_call_t *call = NULL;
unsigned int n_q_cols = 0;
unsigned int i;
unsigned int appearance_index = MAX_APPEARANCE_INDEX;
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;
/* FIXME: get all the watchers */
if (record->watchers) {
q_vals[watchers_col].val.str_val = record->watchers->watcher;
}
for (i=0; i<MAX_APPEARANCE_INDEX; i++) {
if (record->call[i]) {
if (call) {
LM_ERR("This should be an UPDATE not an INSERT\n");
return -1;
}
call = record->call[i];
appearance_index = i;
}
}
if (call) {
q_vals[app_shared_entity_col[appearance_index]].val.int_val = call->shared_entity;
q_vals[app_call_state_col[appearance_index]].val.int_val = call->call_state;
q_vals[app_call_info_uri_col[appearance_index]].val.str_val = call->call_info_uri;
q_vals[app_call_info_appearance_uri_col[appearance_index]].val.str_val =
call->call_info_apperance_uri;
q_vals[app_b2bl_key_col[appearance_index]].val.str_val = call->b2bl_key;
if((sca_dbf.insert(sca_db_handle, q_cols, q_vals, SCA_TABLE_TOTAL_COL_NO)) != 0) {
LM_ERR("could not add record\n");
return -1;
}
} else {
LM_ERR("Empty record?\n");
return -1;
}
return 0;
}
static int sip_trace_store_db(struct _siptrace_data *sto)
{
if(db_con==NULL) {
LM_DBG("database connection not initialized\n");
return -1;
}
if(trace_to_database_flag==NULL || *trace_to_database_flag==0)
goto done;
db_key_t db_keys[NR_KEYS];
db_val_t db_vals[NR_KEYS];
db_keys[0] = &msg_column;
db_vals[0].type = DB1_BLOB;
db_vals[0].nul = 0;
db_vals[0].val.blob_val = sto->body;
db_keys[1] = &callid_column;
db_vals[1].type = DB1_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val = sto->callid;
db_keys[2] = &method_column;
db_vals[2].type = DB1_STR;
db_vals[2].nul = 0;
db_vals[2].val.str_val = sto->method;
db_keys[3] = &status_column;
db_vals[3].type = DB1_STR;
db_vals[3].nul = 0;
db_vals[3].val.str_val = sto->status;
db_keys[4] = &fromip_column;
db_vals[4].type = DB1_STR;
db_vals[4].nul = 0;
db_vals[4].val.str_val = sto->fromip;
db_keys[5] = &toip_column;
db_vals[5].type = DB1_STR;
db_vals[5].nul = 0;
db_vals[5].val.str_val = sto->toip;
db_keys[6] = &date_column;
db_vals[6].type = DB1_DATETIME;
db_vals[6].nul = 0;
db_vals[6].val.time_val = sto->tv.tv_sec;
db_keys[7] = &direction_column;
db_vals[7].type = DB1_STRING;
db_vals[7].nul = 0;
db_vals[7].val.string_val = sto->dir;
db_keys[8] = &fromtag_column;
db_vals[8].type = DB1_STR;
db_vals[8].nul = 0;
db_vals[8].val.str_val = sto->fromtag;
db_keys[9] = &traced_user_column;
db_vals[9].type = DB1_STR;
db_vals[9].nul = 0;
db_keys[10] = &time_us_column;
db_vals[10].type = DB1_INT;
db_vals[10].nul = 0;
db_vals[10].val.int_val = sto->tv.tv_usec;
db_keys[11] = &totag_column;
db_vals[11].type = DB1_STR;
db_vals[11].nul = 0;
db_vals[11].val.str_val = sto->totag;
db_funcs.use_table(db_con, siptrace_get_table());
if(trace_on_flag!=NULL && *trace_on_flag!=0) {
db_vals[9].val.str_val.s = "";
db_vals[9].val.str_val.len = 0;
LM_DBG("storing info...\n");
if(trace_delayed!=0 && db_funcs.insert_delayed!=NULL)
{
if(db_funcs.insert_delayed(db_con, db_keys, db_vals, NR_KEYS)<0) {
LM_ERR("error storing trace\n");
goto error;
}
} else {
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) {
LM_ERR("error storing trace\n");
goto error;
}
}
#ifdef STATISTICS
update_stat(sto->stat, 1);
#endif
}
if(sto->avp==NULL)
goto done;
db_vals[9].val.str_val = sto->avp_value.s;
LM_DBG("storing info...\n");
if(trace_delayed!=0 && db_funcs.insert_delayed!=NULL)
{
if(db_funcs.insert_delayed(db_con, db_keys, db_vals, NR_KEYS) < 0) {
LM_ERR("error storing trace\n");
goto error;
}
} else {
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) {
LM_ERR("error storing trace\n");
goto error;
}
}
sto->avp = search_next_avp(&sto->state, &sto->avp_value);
while(sto->avp!=NULL) {
db_vals[9].val.str_val = sto->avp_value.s;
LM_DBG("storing info...\n");
if(trace_delayed!=0 && db_funcs.insert_delayed!=NULL)
{
if(db_funcs.insert_delayed(db_con, db_keys, db_vals, NR_KEYS) < 0) {
LM_ERR("error storing trace\n");
goto error;
}
} else {
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) {
LM_ERR("error storing trace\n");
goto error;
}
}
sto->avp = search_next_avp(&sto->state, &sto->avp_value);
}
done:
return 1;
error:
return -1;
}
/**
* "pdt_add" syntax :
* sdomain
* prefix
* domain
*/
struct mi_root* pdt_mi_add(struct mi_root* cmd_tree, void* param)
{
db_key_t db_keys[NR_KEYS] = {&sdomain_column, &prefix_column, &domain_column};
db_val_t db_vals[NR_KEYS];
db_op_t db_ops[NR_KEYS] = {OP_EQ, OP_EQ};
int i= 0;
str sd, sp, sdomain;
struct mi_node* node= NULL;
if(_ptree==NULL)
{
LM_ERR("strange situation\n");
return init_mi_tree( 500, MI_INTERNAL_ERR_S, MI_INTERNAL_ERR_LEN);
}
/* read sdomain */
node = cmd_tree->node.kids;
if(node == NULL)
goto error1;
sdomain = node->value;
if(sdomain.s == NULL || sdomain.len== 0)
return init_mi_tree( 404, "domain not found", 16);
if(*sdomain.s=='.' )
return init_mi_tree( 400, "empty param",11);
/* read prefix */
node = node->next;
if(node == NULL)
goto error1;
sp= node->value;
if(sp.s== NULL || sp.len==0)
{
LM_ERR("could not read prefix\n");
return init_mi_tree( 404, "prefix not found", 16);
}
if(*sp.s=='.')
return init_mi_tree(400, "empty param", 11);
while(i< sp.len)
{
if(strpos(pdt_char_list.s,sp.s[i]) < 0)
return init_mi_tree(400, "bad prefix", 10);
i++;
}
/* read domain */
node= node->next;
if(node == NULL || node->next!=NULL)
goto error1;
sd= node->value;
if(sd.s== NULL || sd.len==0)
{
LM_ERR("could not read domain\n");
return init_mi_tree( 400, "domain not found", 16);
}
if(*sd.s=='.')
return init_mi_tree(400, "empty param", 11);
if(pdt_check_domain!=0 && *_ptree!=NULL
&& pdt_check_pd(*_ptree, &sdomain, &sp, &sd)==1)
{
LM_ERR("(sdomain,prefix,domain) exists\n");
return init_mi_tree(400,
"(sdomain,prefix,domain) exists already", 38);
}
db_vals[0].type = DB_STR;
db_vals[0].nul = 0;
db_vals[0].val.str_val.s = sdomain.s;
db_vals[0].val.str_val.len = sdomain.len;
db_vals[1].type = DB_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = sp.s;
db_vals[1].val.str_val.len = sp.len;
db_vals[2].type = DB_STR;
db_vals[2].nul = 0;
db_vals[2].val.str_val.s = sd.s;
db_vals[2].val.str_val.len = sd.len;
/* insert a new domain into database */
if(pdt_dbf.insert(db_con, db_keys, db_vals, NR_KEYS)<0)
{
LM_ERR("failed to store new prefix/domain\n");
return init_mi_tree( 500,"Cannot store prefix/domain", 26);
}
/* re-loading all information from database */
if(pdt_load_db()!=0)
{
LM_ERR("cannot re-load info from database\n");
goto error;
}
LM_DBG("new prefix added %.*s-%.*s => %.*s\n",
sdomain.len, sdomain.s, sp.len, sp.s, sd.len, sd.s);
return init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
error:
if(pdt_dbf.delete(db_con, db_keys, db_ops, db_vals, NR_KEYS)<0)
LM_ERR("database/cache are inconsistent\n");
return init_mi_tree( 500, "could not add to cache", 23 );
error1:
return init_mi_tree( 400, MI_MISSING_PARM_S, MI_MISSING_PARM_LEN);
}
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;
}
int acc_db_request( struct sip_msg *rq, struct hdr_field *to,
str *phrase, char *table, char *fmt)
{
db_val_t vals[ALL_LOG_FMT_LEN+1];
str* val_arr[ALL_LOG_FMT_LEN+1];
str atr_arr[ALL_LOG_FMT_LEN+1];
/* caution: keys need to be aligned to formatting strings */
db_key_t keys[] = {acc_from_uri, acc_to_uri,
acc_sip_method_col, acc_i_uri_col,
acc_o_uri_col, acc_sip_from_col, acc_sip_callid_col,
acc_sip_to_col, acc_sip_status_col, acc_user_col,
acc_totag_col, acc_fromtag_col, acc_domain_col, acc_time_col };
struct tm *tm;
time_t timep;
char time_s[20];
int attr_cnt;
int i;
int dummy_len;
if (skip_cancel(rq)) return 1;
/* database columns:
* "sip_method", "i_uri", "o_uri", "sip_from", "sip_callid",
* "sip_to", "sip_status", "user", "time"
*/
attr_cnt=fmt2strar( fmt, rq, to, phrase,
&dummy_len, &dummy_len, val_arr, atr_arr);
if (!attr_cnt) {
LOG(L_ERR, "ERROR: acc_db_request: fmt2strar failed\n");
return -1;
}
if (!acc_db_url) {
LOG(L_ERR, "ERROR: can't log -- no db_url set\n");
return -1;
}
timep = time(NULL);
tm = db_localtime ? localtime(&timep) : gmtime(&timep);
strftime(time_s, 20, "%Y-%m-%d %H:%M:%S", tm);
for(i=0; i<attr_cnt; i++) {
VAL_TYPE(vals+i)=DB_STR;
VAL_NULL(vals+i)=0;
VAL_STR(vals+i)=*val_arr[i];
}
/* time */
VAL_TYPE(vals+i)=DB_STRING;
VAL_NULL(vals+i)=0;
VAL_STRING(vals+i)=time_s;
if (acc_dbf.use_table(db_handle, table) < 0) {
LOG(L_ERR, "ERROR: acc_request: "
"Error in use_table\n");
return -1;
}
if (acc_dbf.insert(db_handle, keys, vals, i+1) < 0) {
LOG(L_ERR, "ERROR: acc_request: "
"Error while inserting to database\n");
return -1;
}
return 1;
}
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 ;
}
static void trace_sl_onreply_out( unsigned int types, struct sip_msg* req,
struct sl_cb_param *sl_param)
{
db_key_t db_keys[NR_KEYS];
db_val_t db_vals[NR_KEYS];
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+12];
int faked = 0;
struct sip_msg* msg;
int_str avp_value;
struct usr_avp *avp;
struct ip_addr to_ip;
int len;
char statusbuf[5];
if(req==NULL || sl_param==NULL)
{
LM_ERR("bad parameters\n");
goto error;
}
avp = NULL;
if(traced_user_avp.n!=0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
if((avp==NULL) && trace_is_off(req))
{
LM_DBG("trace off...\n");
return;
}
msg = req;
faked = 1;
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0)
{
LM_ERR("cannot parse call-id\n");
return;
}
db_keys[0] = msg_column;
db_vals[0].type = DB_BLOB;
db_vals[0].nul = 0;
db_vals[0].val.blob_val.s = (sl_param->buffer)?sl_param->buffer->s:"";
db_vals[0].val.blob_val.len = (sl_param->buffer)?sl_param->buffer->len:0;
/* check Call-ID header */
if(msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot find Call-ID header!\n");
goto error;
}
db_keys[1] = callid_column;
db_vals[1].type = DB_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
db_keys[2] = method_column;
db_vals[2].type = DB_STR;
db_vals[2].nul = 0;
db_vals[2].val.str_val.s = msg->first_line.u.request.method.s;
db_vals[2].val.str_val.len = msg->first_line.u.request.method.len;
db_keys[4] = fromip_column;
db_vals[4].type = DB_STRING;
db_vals[4].nul = 0;
if(trace_local_ip)
db_vals[4].val.string_val = trace_local_ip;
else {
siptrace_copy_proto(msg->rcv.proto, fromip_buff);
strcat(fromip_buff, ip_addr2a(&req->rcv.dst_ip));
strcat(fromip_buff,":");
strcat(fromip_buff, int2str(req->rcv.dst_port, NULL));
db_vals[4].val.string_val = fromip_buff;
}
db_keys[3] = status_column;
db_vals[3].type = DB_STRING;
db_vals[3].nul = 0;
strcpy(statusbuf, int2str(sl_param->code, NULL));
db_vals[3].val.string_val = statusbuf;
db_keys[5] = toip_column;
db_vals[5].type = DB_STRING;
db_vals[5].nul = 0;
memset(&to_ip, 0, sizeof(struct ip_addr));
if(sl_param->dst==0)
{
db_vals[5].val.string_val = "any:255.255.255.255";
} else {
su2ip_addr(&to_ip, sl_param->dst);
siptrace_copy_proto(req->rcv.proto, toip_buff);
strcat(toip_buff, ip_addr2a(&to_ip));
strcat(toip_buff, ":");
strcat(toip_buff,
int2str((unsigned long)su_getport(sl_param->dst), &len));
LM_DBG("dest [%s]\n", toip_buff);
db_vals[5].val.string_val = toip_buff;
}
db_keys[6] = date_column;
db_vals[6].type = DB_DATETIME;
db_vals[6].nul = 0;
db_vals[6].val.time_val = time(NULL);
db_keys[7] = direction_column;
db_vals[7].type = DB_STRING;
db_vals[7].nul = 0;
db_vals[7].val.string_val = "out";
db_keys[8] = fromtag_column;
db_vals[8].type = DB_STR;
db_vals[8].nul = 0;
db_vals[8].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[8].val.str_val.len = get_from(msg)->tag_value.len;
db_funcs.use_table(db_con, siptrace_get_table());
db_keys[9] = traced_user_column;
db_vals[9].type = DB_STR;
db_vals[9].nul = 0;
if( !trace_is_off(msg) ) {
db_vals[9].val.str_val.s = "";
db_vals[9].val.str_val.len = 0;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
#ifdef STATISTICS
update_stat(siptrace_rpl, 1);
#endif
}
if(avp==NULL)
goto done;
trace_send_duplicate(db_vals[0].val.blob_val.s,
db_vals[0].val.blob_val.len);
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
while(avp!=NULL)
{
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("### - storing info (%d) ...\n", faked);
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
}
done:
return;
error:
return;
}
/**
* destroy module
*/
static void destroy(void)
{
imc_room_p irp = NULL;
imc_member_p member = NULL;
int i;
db_key_t mq_cols[4];
db_val_t mq_vals[4];
db_key_t rq_cols[4];
db_val_t rq_vals[4];
if(imc_db==NULL)
goto done;
mq_cols[0] = &imc_col_username;
mq_vals[0].type = DB1_STR;
mq_vals[0].nul = 0;
mq_cols[1] = &imc_col_domain;
mq_vals[1].type = DB1_STR;
mq_vals[1].nul = 0;
mq_cols[2] = &imc_col_flag;
mq_vals[2].type = DB1_INT;
mq_vals[2].nul = 0;
mq_cols[3] = &imc_col_room;
mq_vals[3].type = DB1_STR;
mq_vals[3].nul = 0;
rq_cols[0] = &imc_col_name;
rq_vals[0].type = DB1_STR;
rq_vals[0].nul = 0;
rq_cols[1] = &imc_col_domain;
rq_vals[1].type = DB1_STR;
rq_vals[1].nul = 0;
rq_cols[2] = &imc_col_flag;
rq_vals[2].type = DB1_INT;
rq_vals[2].nul = 0;
for(i=0; i<imc_hash_size; i++)
{
irp = _imc_htable[i].rooms;
while(irp)
{
rq_vals[0].val.str_val = irp->name;
rq_vals[1].val.str_val = irp->domain;
rq_vals[2].val.int_val = irp->flags;
if(imc_dbf.use_table(imc_db, &rooms_table)< 0)
{
LM_ERR("use_table failed\n");
return;
}
if(imc_dbf.insert(imc_db, rq_cols, rq_vals, 3)<0)
{
LM_ERR("failed to insert into table imc_rooms\n");
return;
}
LM_DBG("room %d %.*s\n", i, irp->name.len, irp->name.s);
member = irp->members;
while(member)
{
mq_vals[0].val.str_val = member->user;
mq_vals[1].val.str_val = member->domain;
mq_vals[2].val.int_val = member->flags;
mq_vals[3].val.str_val = irp->uri;
if(imc_dbf.use_table(imc_db, &members_table)< 0)
{
LM_ERR("use_table failed\n");
return;
}
if(imc_dbf.insert(imc_db, mq_cols, mq_vals, 4)<0)
{
LM_ERR("failed to insert into table imc_rooms\n");
return;
}
member = member->next;
}
irp = irp->next;
}
}
done:
imc_htable_destroy();
}
static void rpc_add(rpc_t* rpc, void* c)
{
db_key_t db_keys[NR_KEYS] = {prefix_column, domain_column};
db_val_t db_vals[NR_KEYS];
db_op_t db_ops[NR_KEYS] = {OP_EQ, OP_EQ};
pd_t* cell;
pd_op_t *ito, *tmp;
str sd, sp;
char* t;
if(_dhash==NULL) {
LOG(L_ERR, "PDT:pdt_fifo_add: strange situation\n");
rpc->fault(c, 500, "Server Error");
return;
}
/* Use 's' to make sure strings are zero terminated */
if (rpc->scan(c, "ss", &sp.s, &sd.s) < 2) {
rpc->fault(c, 400, "Invalid Parameter Value");
return;
}
sp.len = strlen(sp.s);
sd.len = strlen(sd.s);
t = sp.s;
while(t!=NULL && *t!='\0') {
if(*t < '0' || *t > '9') {
LOG(L_ERR, "PDT:pdt_fifo_add: bad prefix [%s]\n", sp.s);
rpc->fault(c, 400, "Bad Prefix");
return;
}
t++;
}
if(pdt_check_pd(_dhash, &sp, &sd)!=0) {
LOG(L_ERR, "PDT:pdt_fifo_add: prefix or domain exists\n");
rpc->fault(c, 400, "Prefix Or Domain Exists");
return;
}
db_vals[0].type = DB_STR;
db_vals[0].nul = 0;
db_vals[0].val.str_val = sp;
db_vals[1].type = DB_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val= sd;
DBG("PDT:pdt_fifo_add: [%.*s] <%.*s>\n", sp.len, sp.s, sd.len, sd.s);
/* insert a new domain into database */
if(pdt_dbf.insert(db_con, db_keys, db_vals, NR_KEYS)<0) {
LOG(L_ERR, "PDT:pdt_fifo_add: error storing new prefix/domain\n");
rpc->fault(c, 430, "Cannot Store Prefix/domain");
return;
}
/* insert the new domain into hashtables, too */
cell = new_cell(&sp, &sd);
if(cell==NULL) {
LOG(L_ERR, "PDT:pdt_fifo_add: no more shm\n");
rpc->fault(c, 431, "Out Of Shared Memory");
goto error1;
}
tmp = new_pd_op(cell, 0, PDT_ADD);
if(tmp==NULL) {
LOG(L_ERR, "PDT:pdt_fifo_add: no more shm!\n");
rpc->fault(c, 431, "Out Of Shared Memory");
goto error2;
}
lock_get(&_dhash->diff_lock);
if(pdt_add_to_hash(_dhash, &sp, &sd)!=0) {
LOG(L_ERR, "PDT:pdt_fifo_add: could not add to cache\n");
rpc->fault(c, 431, "Could Not Add To Cache");
goto error3;
}
_dhash->max_id++;
tmp->id = _dhash->max_id;
if(_dhash->diff==NULL) {
_dhash->diff = tmp;
goto done;
}
ito = _dhash->diff;
while(ito->n!=NULL)
ito = ito->n;
ito->n = tmp;
tmp->p = ito;
done:
DBG("PDT:pdt_fifo_add: op[%d]=%d...\n", tmp->id, tmp->op);
lock_release(&_dhash->diff_lock);
return;
error3:
lock_release(&_dhash->diff_lock);
free_pd_op(tmp);
error2:
free_cell(cell);
error1:
if(pdt_dbf.delete(db_con, db_keys, db_ops, db_vals, NR_KEYS)<0)
LOG(L_ERR,"PDT:pdt_fifo_add: database/cache are inconsistent\n");
}
