int pres_htable_restore(void)
{
/* query all records from presentity table and insert records
* in presentity table */
db_key_t result_cols[6];
db_res_t *result= NULL;
db_row_t *rows= NULL ;
db_val_t *row_vals;
int i;
str user, domain, ev_str, uri, body;
int n_result_cols= 0;
int user_col, domain_col, event_col, expires_col, body_col = 0, etag_col;
int event;
event_t ev;
char* sphere= NULL;
int nr_rows;
str etag;
int no_rows = 10;
result_cols[user_col= n_result_cols++]= &str_username_col;
result_cols[domain_col= n_result_cols++]= &str_domain_col;
result_cols[event_col= n_result_cols++]= &str_event_col;
result_cols[expires_col= n_result_cols++]= &str_expires_col;
result_cols[etag_col= n_result_cols++]= &str_etag_col;
if(sphere_enable)
result_cols[body_col= n_result_cols++]= &str_body_col;
if (pa_dbf.use_table(pa_db, &presentity_table) < 0)
{
LM_ERR("unsuccessful use table sql operation\n");
goto error;
}
/* select the whole tabel and all the columns */
if (DB_CAPABILITY(pa_dbf, DB_CAP_FETCH))
{
if(pa_dbf.query(pa_db,0,0,0,result_cols, 0,
n_result_cols, result_cols[user_col], 0) < 0)
{
LM_ERR("Error while querying (fetch) database\n");
return -1;
}
no_rows = estimate_available_rows( 32+32+32+4+64, n_result_cols);
if (no_rows==0) no_rows = 10;
if(pa_dbf.fetch_result(pa_db,&result, no_rows)<0)
{
LM_ERR("fetching rows failed\n");
return -1;
}
} else
{
if (pa_dbf.query (pa_db, 0, 0, 0,result_cols,0, n_result_cols,
result_cols[user_col], &result) < 0)
{
LM_ERR("querying presentity\n");
goto error;
}
}
nr_rows = RES_ROW_N(result);
do {
LM_DBG("loading information from database for %i records\n", nr_rows);
rows = RES_ROWS(result);
/* for every row */
for(i=0; i<nr_rows; i++)
{
row_vals = ROW_VALUES(rows + i);
if (VAL_NULL(row_vals) || VAL_NULL(row_vals+1))
{
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
str_username_col.len, str_username_col.s,
str_domain_col.len, str_domain_col.s);
continue;
}
if (VAL_NULL(row_vals+2) || VAL_NULL(row_vals+3))
{
LM_ERR("columns %.*s or/and %.*s cannot be null -> skipping\n",
str_event_col.len, str_event_col.s,
str_domain_col.len, str_domain_col.s);
continue;
}
if(row_vals[expires_col].val.int_val< (int)time(NULL))
continue;
sphere= NULL;
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);
ev_str.s= (char*)row_vals[event_col].val.string_val;
ev_str.len= strlen(ev_str.s);
etag.s= (char*)row_vals[etag_col].val.string_val;
etag.len= strlen(etag.s);
if(event_parser(ev_str.s, ev_str.len, &ev)< 0)
{
LM_ERR("parsing event\n");
free_event_params(ev.params, PKG_MEM_TYPE);
goto error;
}
event= ev.parsed;
free_event_params(ev.params, PKG_MEM_TYPE);
if(uandd_to_uri(user, domain, &uri)< 0)
{
LM_ERR("constructing uri\n");
goto error;
}
/* insert in hash_table*/
if(sphere_enable && event== EVENT_PRESENCE )
{
body.s= (char*)row_vals[body_col].val.string_val;
body.len= strlen(body.s);
sphere= extract_sphere(body);
}
if(insert_phtable(&uri, event, &etag, sphere, 0)== NULL)
{
LM_ERR("inserting record in presentity hash table");
pkg_free(uri.s);
if(sphere)
pkg_free(sphere);
goto error;
}
if(sphere)
pkg_free(sphere);
pkg_free(uri.s);
}
/* any more data to be fetched ?*/
if (DB_CAPABILITY(pa_dbf, DB_CAP_FETCH))
{
if (pa_dbf.fetch_result( pa_db, &result, no_rows) < 0)
{
LM_ERR("fetching more rows failed\n");
goto error;
}
nr_rows = RES_ROW_N(result);
} else
nr_rows = 0;
}while (nr_rows>0);
pa_dbf.free_result(pa_db, result);
return 0;
error:
if(result)
pa_dbf.free_result(pa_db, result);
return -1;
}
int update_phtable(presentity_t* presentity, str pres_uri, str body)
{
char* sphere= NULL;
unsigned int hash_code;
pres_entry_t* p;
int ret= 0;
str* xcap_doc= NULL;
/* get new sphere */
sphere= extract_sphere(body);
if(sphere==NULL)
{
LM_DBG("no sphere defined in new body\n");
return 0;
}
/* search for record in hash table */
hash_code= core_hash(&pres_uri, NULL, phtable_size);
lock_get(&pres_htable[hash_code].lock);
p= search_phtable(&pres_uri, presentity->event->evp->parsed, hash_code);
if(p== NULL)
{
lock_release(&pres_htable[hash_code].lock);
goto done;
}
if(p->sphere)
{
if(strcmp(p->sphere, sphere)!= 0)
{
/* new sphere definition */
shm_free(p->sphere);
}
else
{
/* no change in sphere definition */
lock_release(&pres_htable[hash_code].lock);
pkg_free(sphere);
return 0;
}
}
p->sphere= (char*)shm_malloc(strlen(sphere)+ 1);
if(p->sphere== NULL)
{
lock_release(&pres_htable[hash_code].lock);
ret= -1;
goto done;
}
strcpy(p->sphere, sphere);
lock_release(&pres_htable[hash_code].lock);
/* call for watchers status update */
if(presentity->event->get_rules_doc(&presentity->user, &presentity->domain,
&xcap_doc)< 0)
{
LM_ERR("failed to retreive xcap document\n");
ret= -1;
goto done;
}
update_watchers_status(pres_uri, presentity->event, xcap_doc);
done:
if(xcap_doc)
{
if(xcap_doc->s)
pkg_free(xcap_doc->s);
pkg_free(xcap_doc);
}
if(sphere)
pkg_free(sphere);
return ret;
}
char* get_sphere(str* pres_uri)
{
// static db_ps_t my_ps = NULL;
unsigned int hash_code;
char* sphere= NULL;
pres_entry_t* p;
db_key_t query_cols[6];
db_val_t query_vals[6];
db_key_t result_cols[6];
db_res_t *result = NULL;
db_row_t *row= NULL ;
db_val_t *row_vals;
int n_result_cols = 0;
int n_query_cols = 0;
struct sip_uri uri;
str body;
static str query_str = str_init("received_time");
if(!sphere_enable)
return NULL;
/* search in hash table*/
hash_code= core_hash(pres_uri, NULL, phtable_size);
lock_get(&pres_htable[hash_code].lock);
p= search_phtable(pres_uri, EVENT_PRESENCE, hash_code);
if(p)
{
if(p->sphere)
{
sphere= (char*)pkg_malloc(strlen(p->sphere));
if(sphere== NULL)
{
lock_release(&pres_htable[hash_code].lock);
ERR_MEM(PKG_MEM_STR);
}
strcpy(sphere, p->sphere);
}
lock_release(&pres_htable[hash_code].lock);
return sphere;
}
lock_release(&pres_htable[hash_code].lock);
/* if record not found and fallback2db query database*/
if(!fallback2db)
{
return NULL;
}
if(parse_uri(pres_uri->s, pres_uri->len, &uri)< 0)
{
LM_ERR("failed to parse presentity uri\n");
goto error;
}
query_cols[n_query_cols] = &str_domain_col;
query_vals[n_query_cols].type = DB_STR;
query_vals[n_query_cols].nul = 0;
query_vals[n_query_cols].val.str_val = uri.host;
n_query_cols++;
query_cols[n_query_cols] = &str_username_col;
query_vals[n_query_cols].type = DB_STR;
query_vals[n_query_cols].nul = 0;
query_vals[n_query_cols].val.str_val = uri.user;
n_query_cols++;
query_cols[n_query_cols] = &str_event_col;
query_vals[n_query_cols].type = DB_STR;
query_vals[n_query_cols].nul = 0;
query_vals[n_query_cols].val.str_val.s= "presence";
query_vals[n_query_cols].val.str_val.len= 8;
n_query_cols++;
result_cols[n_result_cols++] = &str_body_col;
result_cols[n_result_cols++] = &str_extra_hdrs_col;
if (pa_dbf.use_table(pa_db, &presentity_table) < 0)
{
LM_ERR("in use_table\n");
return NULL;
}
// CON_PS_REFERENCE(pa_db) = &my_ps;
if (pa_dbf.query (pa_db, query_cols, 0, query_vals,
result_cols, n_query_cols, n_result_cols, &query_str , &result) < 0)
{
LM_ERR("failed to query %.*s table\n", presentity_table.len, presentity_table.s);
if(result)
pa_dbf.free_result(pa_db, result);
return NULL;
}
if(result== NULL)
return NULL;
if (result->n<=0 )
{
LM_DBG("no published record found in database\n");
pa_dbf.free_result(pa_db, result);
return NULL;
}
row = &result->rows[result->n-1];
row_vals = ROW_VALUES(row);
if(row_vals[0].val.string_val== NULL)
{
LM_ERR("NULL notify body record\n");
goto error;
}
body.s= (char*)row_vals[0].val.string_val;
body.len= strlen(body.s);
if(body.len== 0)
{
LM_ERR("Empty notify body record\n");
goto error;
}
sphere= extract_sphere(body);
pa_dbf.free_result(pa_db, result);
return sphere;
error:
if(result)
pa_dbf.free_result(pa_db, result);
return NULL;
}
