static int db_restore(void)
{
ua_pres_t* p= NULL;
db_key_t result_cols[19];
db1_res_t *res= NULL;
db_row_t *row = NULL;
db_val_t *row_vals= NULL;
str pres_uri, pres_id;
str etag, tuple_id;
str watcher_uri, call_id;
str to_tag, from_tag, remote_contact;
str record_route, contact, extra_headers;
int size= 0, i;
int n_result_cols= 0;
int puri_col,pid_col,expires_col,flag_col,etag_col, desired_expires_col;
int watcher_col,callid_col,totag_col,fromtag_col,cseq_col,remote_contact_col;
int event_col,contact_col,tuple_col,record_route_col, extra_headers_col;
int version_col;
if (dbmode==PUA_DB_ONLY)
{
LM_ERR( "db_restore shouldn't be called in PUA_DB_ONLY mode\n" );
return(-1);
}
result_cols[puri_col=n_result_cols++] = &str_pres_uri_col;
result_cols[pid_col=n_result_cols++] = &str_pres_id_col;
result_cols[expires_col=n_result_cols++]= &str_expires_col;
result_cols[flag_col=n_result_cols++] = &str_flag_col;
result_cols[etag_col=n_result_cols++] = &str_etag_col;
result_cols[tuple_col=n_result_cols++] = &str_tuple_id_col;
result_cols[watcher_col=n_result_cols++]= &str_watcher_uri_col;
result_cols[callid_col=n_result_cols++] = &str_call_id_col;
result_cols[totag_col=n_result_cols++] = &str_to_tag_col;
result_cols[fromtag_col=n_result_cols++]= &str_from_tag_col;
result_cols[cseq_col= n_result_cols++] = &str_cseq_col;
result_cols[event_col= n_result_cols++] = &str_event_col;
result_cols[record_route_col= n_result_cols++] = &str_record_route_col;
result_cols[contact_col= n_result_cols++] = &str_contact_col;
result_cols[remote_contact_col= n_result_cols++] = &str_remote_contact_col;
result_cols[extra_headers_col= n_result_cols++] = &str_extra_headers_col;
result_cols[desired_expires_col= n_result_cols++] = &str_desired_expires_col;
result_cols[version_col= n_result_cols++] = &str_version_col;
if(!pua_db)
{
LM_ERR("null database connection\n");
return -1;
}
if(pua_dbf.use_table(pua_db, &db_table)< 0)
{
LM_ERR("in use table\n");
return -1;
}
if(db_fetch_query(&pua_dbf, pua_fetch_rows, pua_db, 0, 0, 0, result_cols,
0, n_result_cols, 0, &res)< 0)
{
LM_ERR("while querrying table\n");
if(res)
{
pua_dbf.free_result(pua_db, res);
res = NULL;
}
return -1;
}
if(res==NULL)
return -1;
if(res->n<=0)
{
LM_INFO("the query returned no result\n");
pua_dbf.free_result(pua_db, res);
res = NULL;
return 0;
}
do {
LM_DBG("found %d db entries\n", res->n);
for(i =0 ; i< res->n ; i++)
{
row = &res->rows[i];
row_vals = ROW_VALUES(row);
pres_uri.s= (char*)row_vals[puri_col].val.string_val;
pres_uri.len = strlen(pres_uri.s);
LM_DBG("pres_uri= %.*s\n", pres_uri.len, pres_uri.s);
memset(&etag, 0, sizeof(str));
memset(&tuple_id, 0, sizeof(str));
memset(&watcher_uri, 0, sizeof(str));
memset(&call_id, 0, sizeof(str));
memset(&to_tag, 0, sizeof(str));
memset(&from_tag, 0, sizeof(str));
memset(&record_route, 0, sizeof(str));
memset(&pres_id, 0, sizeof(str));
memset(&contact, 0, sizeof(str));
memset(&remote_contact, 0, sizeof(str));
memset(&extra_headers, 0, sizeof(str));
pres_id.s= (char*)row_vals[pid_col].val.string_val;
if(pres_id.s)
pres_id.len = strlen(pres_id.s);
if(row_vals[etag_col].val.string_val)
{
etag.s= (char*)row_vals[etag_col].val.string_val;
etag.len = strlen(etag.s);
tuple_id.s= (char*)row_vals[tuple_col].val.string_val;
tuple_id.len = strlen(tuple_id.s);
}
if(row_vals[watcher_col].val.string_val)
{
watcher_uri.s= (char*)row_vals[watcher_col].val.string_val;
watcher_uri.len = strlen(watcher_uri.s);
call_id.s= (char*)row_vals[callid_col].val.string_val;
call_id.len = strlen(call_id.s);
to_tag.s= (char*)row_vals[totag_col].val.string_val;
to_tag.len = strlen(to_tag.s);
from_tag.s= (char*)row_vals[fromtag_col].val.string_val;
from_tag.len = strlen(from_tag.s);
if(row_vals[record_route_col].val.string_val)
{
record_route.s= (char*)row_vals[record_route_col].val.string_val;
record_route.len= strlen(record_route.s);
}
contact.s= (char*)row_vals[contact_col].val.string_val;
contact.len = strlen(contact.s);
remote_contact.s= (char*)row_vals[remote_contact_col].val.string_val;
remote_contact.len = strlen(remote_contact.s);
}
extra_headers.s= (char*)row_vals[extra_headers_col].val.string_val;
if(extra_headers.s)
extra_headers.len= strlen(extra_headers.s);
else
extra_headers.len= 0;
size= sizeof(ua_pres_t)+ sizeof(str)+ (pres_uri.len+ pres_id.len+
tuple_id.len)* sizeof(char);
if(extra_headers.s)
size+= sizeof(str)+ extra_headers.len* sizeof(char);
if(watcher_uri.s)
size+= sizeof(str)+ (watcher_uri.len+ call_id.len+ to_tag.len+
from_tag.len+ record_route.len+ contact.len)* sizeof(char);
p= (ua_pres_t*)shm_malloc(size);
if(p== NULL)
{
LM_ERR("no more share memmory");
goto error;
}
memset(p, 0, size);
size= sizeof(ua_pres_t);
p->pres_uri= (str*)((char*)p+ size);
size+= sizeof(str);
p->pres_uri->s= (char*)p + size;
memcpy(p->pres_uri->s, pres_uri.s, pres_uri.len);
p->pres_uri->len= pres_uri.len;
size+= pres_uri.len;
if(pres_id.s)
{
p->id.s= (char*)p + size;
memcpy(p->id.s, pres_id.s, pres_id.len);
p->id.len= pres_id.len;
size+= pres_id.len;
}
if(tuple_id.s && tuple_id.len)
{
p->tuple_id.s= (char*)p + size;
memcpy(p->tuple_id.s, tuple_id.s, tuple_id.len);
p->tuple_id.len= tuple_id.len;
size+= tuple_id.len;
}
if(watcher_uri.s && watcher_uri.len)
{
p->watcher_uri= (str*)((char*)p+ size);
size+= sizeof(str);
p->watcher_uri->s= (char*)p+ size;
memcpy(p->watcher_uri->s, watcher_uri.s, watcher_uri.len);
p->watcher_uri->len= watcher_uri.len;
size+= watcher_uri.len;
p->to_tag.s= (char*)p+ size;
memcpy(p->to_tag.s, to_tag.s, to_tag.len);
p->to_tag.len= to_tag.len;
size+= to_tag.len;
p->from_tag.s= (char*)p+ size;
memcpy(p->from_tag.s, from_tag.s, from_tag.len);
p->from_tag.len= from_tag.len;
size+= from_tag.len;
p->call_id.s= (char*)p + size;
memcpy(p->call_id.s, call_id.s, call_id.len);
p->call_id.len= call_id.len;
size+= call_id.len;
if(record_route.s && record_route.len)
{
p->record_route.s= (char*)p + size;
memcpy(p->record_route.s, record_route.s, record_route.len);
p->record_route.len= record_route.len;
size+= record_route.len;
}
p->contact.s= (char*)p + size;
memcpy(p->contact.s, contact.s, contact.len);
p->contact.len= contact.len;
size+= contact.len;
p->cseq= row_vals[cseq_col].val.int_val;
p->remote_contact.s= (char*)shm_malloc(remote_contact.len* sizeof(char));
if(p->remote_contact.s== NULL)
{
LM_ERR("No more shared memory\n");
goto error;
}
memcpy(p->remote_contact.s, remote_contact.s, remote_contact.len);
p->remote_contact.len= remote_contact.len;
p->version= row_vals[version_col].val.int_val;
}
if(extra_headers.s)
{
p->extra_headers= (str*)((char*)p+ size);
size+= sizeof(str);
p->extra_headers->s= (char*)p+ size;
memcpy(p->extra_headers->s, extra_headers.s, extra_headers.len);
p->extra_headers->len= extra_headers.len;
size+= extra_headers.len;
}
LM_DBG("size= %d\n", size);
p->event= row_vals[event_col].val.int_val;
p->expires= row_vals[expires_col].val.int_val;
p->desired_expires= row_vals[desired_expires_col].val.int_val;
p->flag|= row_vals[flag_col].val.int_val;
memset(&p->etag, 0, sizeof(str));
if(etag.s && etag.len)
{
/* alloc separately */
p->etag.s= (char*)shm_malloc(etag.len* sizeof(char));
if(p->etag.s== NULL)
{
LM_ERR("no more share memory\n");
goto error;
}
memcpy(p->etag.s, etag.s, etag.len);
p->etag.len= etag.len;
}
print_ua_pres(p);
insert_htable(p);
}
} while((db_fetch_next(&pua_dbf, pua_fetch_rows, pua_db, &res)==1)
&& (RES_ROW_N(res)>0));
pua_dbf.free_result(pua_db, res);
res = NULL;
if(pua_dbf.delete(pua_db, 0, 0 , 0, 0) < 0)
{
LM_ERR("while deleting information from db\n");
goto error;
}
return 0;
error:
if(res)
pua_dbf.free_result(pua_db, res);
if(p)
shm_free(p);
return -1;
}
int rls_restore_db_subs(void)
{
db_key_t result_cols[24];
db1_res_t *res= NULL;
db_row_t *row = NULL;
db_val_t *row_vals= NULL;
int i;
int n_result_cols= 0;
int pres_uri_col, expires_col, from_user_col, from_domain_col,to_user_col;
int callid_col,totag_col,fromtag_col,to_domain_col,sockinfo_col,reason_col;
int event_col,contact_col,record_route_col, event_id_col, status_col;
int remote_cseq_col, local_cseq_col, local_contact_col, version_col;
int watcher_user_col, watcher_domain_col;
subs_t s;
str ev_sname;
pres_ev_t* event= NULL;
event_t parsed_event;
unsigned int expires;
unsigned int hash_code;
result_cols[pres_uri_col=n_result_cols++] = &str_presentity_uri_col;
result_cols[expires_col=n_result_cols++] = &str_expires_col;
result_cols[event_col=n_result_cols++] = &str_event_col;
result_cols[event_id_col=n_result_cols++] = &str_event_id_col;
result_cols[to_user_col=n_result_cols++] = &str_to_user_col;
result_cols[to_domain_col=n_result_cols++] = &str_to_domain_col;
result_cols[watcher_user_col=n_result_cols++] = &str_watcher_username_col;
result_cols[watcher_domain_col=n_result_cols++] = &str_watcher_domain_col;
result_cols[from_user_col=n_result_cols++] = &str_from_user_col;
result_cols[from_domain_col=n_result_cols++] = &str_from_domain_col;
result_cols[callid_col=n_result_cols++] = &str_callid_col;
result_cols[totag_col=n_result_cols++] = &str_to_tag_col;
result_cols[fromtag_col=n_result_cols++] = &str_from_tag_col;
result_cols[local_cseq_col= n_result_cols++] = &str_local_cseq_col;
result_cols[remote_cseq_col= n_result_cols++] = &str_remote_cseq_col;
result_cols[record_route_col= n_result_cols++] = &str_record_route_col;
result_cols[sockinfo_col= n_result_cols++] = &str_socket_info_col;
result_cols[contact_col= n_result_cols++] = &str_contact_col;
result_cols[local_contact_col= n_result_cols++] = &str_local_contact_col;
result_cols[version_col= n_result_cols++] = &str_version_col;
result_cols[status_col= n_result_cols++] = &str_status_col;
result_cols[reason_col= n_result_cols++] = &str_reason_col;
if(!rls_db)
{
LM_ERR("null database connection\n");
return -1;
}
if(rls_dbf.use_table(rls_db, &rlsubs_table)< 0)
{
LM_ERR("in use table\n");
return -1;
}
if(db_fetch_query(&rls_dbf, rls_fetch_rows, rls_db, 0, 0, 0,
result_cols,0, n_result_cols, 0, &res)< 0)
{
LM_ERR("while querrying table\n");
if(res)
{
rls_dbf.free_result(rls_db, res);
res = NULL;
}
return -1;
}
if(res== NULL)
return -1;
if(res->n<=0)
{
LM_INFO("The query returned no result\n");
rls_dbf.free_result(rls_db, res);
res = NULL;
return 0;
}
do {
LM_DBG("found %d db entries\n", res->n);
for(i =0 ; i< res->n ; i++)
{
row = &res->rows[i];
row_vals = ROW_VALUES(row);
memset(&s, 0, sizeof(subs_t));
expires= row_vals[expires_col].val.int_val;
if(expires< (int)time(NULL))
continue;
s.pres_uri.s= (char*)row_vals[pres_uri_col].val.string_val;
s.pres_uri.len= strlen(s.pres_uri.s);
s.to_user.s=(char*)row_vals[to_user_col].val.string_val;
s.to_user.len= strlen(s.to_user.s);
s.to_domain.s=(char*)row_vals[to_domain_col].val.string_val;
s.to_domain.len= strlen(s.to_domain.s);
s.from_user.s=(char*)row_vals[from_user_col].val.string_val;
s.from_user.len= strlen(s.from_user.s);
s.from_domain.s=(char*)row_vals[from_domain_col].val.string_val;
s.from_domain.len= strlen(s.from_domain.s);
s.watcher_user.s=(char*)row_vals[watcher_user_col].val.string_val;
s.watcher_user.len= strlen(s.watcher_user.s);
s.watcher_domain.s=(char*)row_vals[watcher_domain_col].val.string_val;
s.watcher_domain.len= strlen(s.watcher_domain.s);
s.to_tag.s=(char*)row_vals[totag_col].val.string_val;
s.to_tag.len= strlen(s.to_tag.s);
s.from_tag.s=(char*)row_vals[fromtag_col].val.string_val;
s.from_tag.len= strlen(s.from_tag.s);
s.callid.s=(char*)row_vals[callid_col].val.string_val;
s.callid.len= strlen(s.callid.s);
ev_sname.s= (char*)row_vals[event_col].val.string_val;
ev_sname.len= strlen(ev_sname.s);
event= pres_contains_event(&ev_sname, &parsed_event);
if(event== NULL)
{
LM_ERR("event not found in list\n");
goto error;
}
s.event= event;
s.event_id.s=(char*)row_vals[event_id_col].val.string_val;
if(s.event_id.s)
s.event_id.len= strlen(s.event_id.s);
s.remote_cseq= row_vals[remote_cseq_col].val.int_val;
s.local_cseq= row_vals[local_cseq_col].val.int_val;
s.version= row_vals[version_col].val.int_val;
s.expires= expires- (int)time(NULL);
s.status= row_vals[status_col].val.int_val;
s.reason.s= (char*)row_vals[reason_col].val.string_val;
if(s.reason.s)
s.reason.len= strlen(s.reason.s);
s.contact.s=(char*)row_vals[contact_col].val.string_val;
s.contact.len= strlen(s.contact.s);
s.local_contact.s=(char*)row_vals[local_contact_col].val.string_val;
s.local_contact.len= strlen(s.local_contact.s);
s.record_route.s=(char*)row_vals[record_route_col].val.string_val;
if(s.record_route.s)
s.record_route.len= strlen(s.record_route.s);
s.sockinfo_str.s=(char*)row_vals[sockinfo_col].val.string_val;
s.sockinfo_str.len= strlen(s.sockinfo_str.s);
hash_code= core_hash(&s.pres_uri, &s.event->name, hash_size);
if(pres_insert_shtable(rls_table, hash_code, &s)< 0)
{
LM_ERR("adding new record in hash table\n");
goto error;
}
}
} while((db_fetch_next(&rls_dbf, rls_fetch_rows, rls_db, &res)==1)
&& (RES_ROW_N(res)>0));
rls_dbf.free_result(rls_db, res);
/* delete all records */
if(rls_dbf.delete(rls_db, 0,0,0,0)< 0)
{
LM_ERR("deleting all records from database table\n");
return -1;
}
return 0;
error:
if(res)
rls_dbf.free_result(rls_db, res);
return -1;
}