static void
free_event(kherr_event * e)
{
EnterCriticalSection(&cs_error);
assert(IS_KHERR_EVENT(e));
#ifdef DEBUG
assert(LNEXT(e) == NULL);
assert(LPREV(e) == NULL);
#endif
if(e->flags & KHERR_RF_FREE_SHORT_DESC) {
assert(e->short_desc);
PFREE((void *) e->short_desc);
}
if(e->flags & KHERR_RF_FREE_LONG_DESC) {
assert(e->long_desc);
PFREE((void *) e->long_desc);
}
if(e->flags & KHERR_RF_FREE_SUGGEST) {
assert(e->suggestion);
PFREE((void *) e->suggestion);
}
free_event_params(e);
ZeroMemory(e, sizeof(*e));
LPUSH(&evt_free_list, e);
LeaveCriticalSection(&cs_error);
}
/* MUST be called with cs_error held. */
void
resolve_event_strings(kherr_event * e)
{
DWORD_PTR args[8];
va_list vl = (va_list) args;
if ((e->flags & KHERR_RF_STR_RESOLVED) != 0)
return;
va_args_from_event(vl, e, sizeof(args));
resolve_string(e, &e->short_desc, vl,
KHERR_RFMASK_SHORT_DESC,
KHERR_RF_FREE_SHORT_DESC,
KHERR_RF_FREE_SHORT_DESC);
resolve_string(e, &e->long_desc, vl,
KHERR_RFMASK_LONG_DESC,
KHERR_RF_FREE_LONG_DESC,
KHERR_RF_FREE_LONG_DESC);
resolve_string(e, &e->suggestion, vl,
KHERR_RFMASK_SUGGEST,
KHERR_RF_FREE_SUGGEST,
KHERR_RF_FREE_SUGGEST);
resolve_string_resource(e, &e->short_desc, vl,
KHERR_RF_RES_SHORT_DESC,
KHERR_RF_FREE_SHORT_DESC);
resolve_string_resource(e, &e->long_desc, vl,
KHERR_RF_RES_LONG_DESC,
KHERR_RF_FREE_LONG_DESC);
resolve_string_resource(e, &e->suggestion, vl,
KHERR_RF_RES_SUGGEST,
KHERR_RF_FREE_SUGGEST);
resolve_msg_resource(e, &e->short_desc, vl,
KHERR_RF_MSG_SHORT_DESC,
KHERR_RF_FREE_SHORT_DESC);
resolve_msg_resource(e, &e->long_desc, vl,
KHERR_RF_MSG_LONG_DESC,
KHERR_RF_FREE_LONG_DESC);
resolve_msg_resource(e, &e->suggestion, vl,
KHERR_RF_MSG_SUGGEST,
KHERR_RF_FREE_SUGGEST);
/* get rid of dangling reference now that we have done everything
we can with it. Since we have already dealt with all the
parameter inserts, we don't need the parameters anymore
either. */
free_event_params(e);
e->h_module = NULL;
e->flags |= KHERR_RF_STR_RESOLVED;
}
void shm_free_event(event_t* ev)
{
if(ev== NULL)
return;
if(ev->text.s)
shm_free(ev->text.s);
free_event_params(ev->params, SHM_MEM_TYPE);
shm_free(ev);
}
void shm_free_event(event_t *ev)
{
if(ev == NULL)
return;
if(ev->name.s)
shm_free(ev->name.s);
free_event_params(ev->params.list, SHM_MEM_TYPE);
shm_free(ev);
}
pres_ev_t* contains_event(str* sname, event_t* parsed_event)
{
event_t event;
pres_ev_t* e;
memset(&event, 0, sizeof(event_t));
if(event_parser(sname->s, sname->len, &event)< 0)
{
LM_ERR("parsing event\n");
return NULL;
}
if(parsed_event)
*parsed_event= event;
else
{
free_event_params(event.params, PKG_MEM_TYPE);
}
e= search_event(&event);
return e;
}
pres_ev_t *contains_event(str *sname, event_t *parsed_event)
{
event_t event;
event_t *pe;
pres_ev_t *e;
pe = (parsed_event) ? parsed_event : &event;
memset(pe, 0, sizeof(event_t));
if(event_parser(sname->s, sname->len, pe) < 0) {
LM_ERR("parsing event\n");
return NULL;
}
e = search_event(pe);
if(parsed_event == 0) {
free_event_params(pe->params.list, PKG_MEM_TYPE);
pe->params.list = NULL;
}
return e;
}
int add_event(pres_ev_t* event)
{
pres_ev_t* ev= NULL;
event_t parsed_event;
str wipeer_name;
char* sep;
char buf[50];
int not_in_list= 0;
if(EvList == NULL)
{
LM_ERR("'presence' modules must be loaded before this module\n");
return -1;
}
memset(&parsed_event, 0, sizeof(event_t));
if(event->name.s== NULL || event->name.len== 0)
{
LM_ERR("NULL event name\n");
return -1;
}
if(event->content_type.s== NULL || event->content_type.len== 0)
{
if (event->mandatory_body)
{
LM_ERR("NULL content_type param\n");
return -1;
}
}
ev= contains_event(&event->name, &parsed_event);
if(ev== NULL)
{
not_in_list= 1;
ev= (pres_ev_t*)shm_malloc(sizeof(pres_ev_t));
if(ev== NULL)
{
free_event_params(parsed_event.params, PKG_MEM_TYPE);
ERR_MEM(SHARE_MEM);
}
memset(ev, 0, sizeof(pres_ev_t));
ev->name.s= (char*)shm_malloc(event->name.len);
if(ev->name.s== NULL)
{
free_event_params(parsed_event.params, PKG_MEM_TYPE);
ERR_MEM(SHARE_MEM);
}
memcpy(ev->name.s, event->name.s, event->name.len);
ev->name.len= event->name.len;
ev->evp= shm_copy_event(&parsed_event);
if(ev->evp== NULL)
{
LM_ERR("copying event_t structure\n");
free_event_params(parsed_event.params, PKG_MEM_TYPE);
goto error;
}
free_event_params(parsed_event.params, PKG_MEM_TYPE);
}
else
{
free_event_params(parsed_event.params, PKG_MEM_TYPE);
if(ev->content_type.s)
{
LM_DBG("Event already registered\n");
return 0;
}
}
ev->content_type.s = (char*)shm_malloc(event->content_type.len);
if(ev->content_type.s== NULL)
{
ERR_MEM(SHARE_MEM);
}
ev->content_type.len= event->content_type.len;
memcpy(ev->content_type.s, event->content_type.s, event->content_type.len);
sep= strchr(event->name.s, '.');
if(sep != NULL && strncasecmp(sep+1, "winfo", 5)== 0)
{
ev->type= WINFO_TYPE;
wipeer_name.s= event->name.s;
wipeer_name.len= sep - event->name.s;
ev->wipeer= contains_event(&wipeer_name, NULL);
}
else
{
ev->type= PUBL_TYPE;
wipeer_name.s= buf;
memcpy(wipeer_name.s, event->name.s, event->name.len);
wipeer_name.len= event->name.len;
memcpy(wipeer_name.s+ wipeer_name.len, ".winfo", 6);
wipeer_name.len+= 6;
ev->wipeer= contains_event(&wipeer_name, NULL);
}
if(ev->wipeer)
ev->wipeer->wipeer= ev;
if(event->req_auth &&
( event->get_auth_status==0 ||event->get_rules_doc== 0))
{
LM_ERR("bad event structure\n");
goto error;
}
ev->extra_hdrs= event->extra_hdrs;
ev->req_auth= event->req_auth;
ev->agg_nbody= event->agg_nbody;
ev->apply_auth_nbody= event->apply_auth_nbody;
ev->get_auth_status= event->get_auth_status;
ev->get_rules_doc= event->get_rules_doc;
ev->evs_publ_handl= event->evs_publ_handl;
ev->evs_subs_handl= event->evs_subs_handl;
ev->mandatory_body = event->mandatory_body;
ev->mandatory_timeout_notification = event->mandatory_timeout_notification;
ev->etag_not_new= event->etag_not_new;
ev->aux_body_processing= event->aux_body_processing;
ev->aux_free_body= event->aux_free_body;
ev->free_body= event->free_body;
ev->build_empty_pres_info= event->build_empty_pres_info;
ev->default_expires= event->default_expires;
if(not_in_list)
{
ev->next= EvList->events;
EvList->events= ev;
}
EvList->ev_count++;
LM_DBG("succesfully added event: %.*s - len= %d\n",ev->name.len,
ev->name.s, ev->name.len);
/* if event 'presence' set the pointer */
if(ev->evp->parsed == EVENT_PRESENCE)
*pres_event_p = ev;
/* if event 'dialog' set the pointer */
if(ev->evp->parsed == EVENT_DIALOG)
*dialog_event_p = ev;
return 0;
error:
if(ev && not_in_list)
{
free_pres_event(ev);
}
return -1;
}
int add_event(pres_ev_t* event)
{
pres_ev_t* ev= NULL;
event_t parsed_event;
str wipeer_name;
char* sep;
char buf[50];
int not_in_list= 0;
memset(&parsed_event, 0, sizeof(event_t));
if(event->name.s== NULL || event->name.len== 0)
{
LM_ERR("NULL event name\n");
return -1;
}
if(event->content_type.s== NULL || event->content_type.len== 0)
{
LM_ERR("NULL content_type param\n");
return -1;
}
ev= contains_event(&event->name, &parsed_event);
if(ev== NULL)
{
not_in_list= 1;
ev= (pres_ev_t*)shm_malloc(sizeof(pres_ev_t));
if(ev== NULL)
{
free_event_params(parsed_event.params, PKG_MEM_TYPE);
ERR_MEM(SHARE_MEM);
}
memset(ev, 0, sizeof(pres_ev_t));
ev->name.s= (char*)shm_malloc(event->name.len* sizeof(char));
if(ev->name.s== NULL)
{
free_event_params(parsed_event.params, PKG_MEM_TYPE);
ERR_MEM(SHARE_MEM);
}
memcpy(ev->name.s, event->name.s, event->name.len);
ev->name.len= event->name.len;
ev->evp= shm_copy_event(&parsed_event);
if(ev->evp== NULL)
{
LM_ERR("copying event_t structure\n");
free_event_params(parsed_event.params, PKG_MEM_TYPE);
goto error;
}
free_event_params(parsed_event.params, PKG_MEM_TYPE);
}
else
{
free_event_params(parsed_event.params, PKG_MEM_TYPE);
if(ev->content_type.s)
{
LM_DBG("Event already registered\n");
return 0;
}
}
ev->content_type.s=(char*)shm_malloc(event->content_type.len* sizeof(char)) ;
if(ev->content_type.s== NULL)
{
ERR_MEM(SHARE_MEM);
}
ev->content_type.len= event->content_type.len;
memcpy(ev->content_type.s, event->content_type.s, event->content_type.len);
sep= strchr(event->name.s, '.');
if(sep && strncmp(sep+1, "winfo", 5)== 0)
{
ev->type= WINFO_TYPE;
wipeer_name.s= event->name.s;
wipeer_name.len= sep - event->name.s;
ev->wipeer= contains_event(&wipeer_name, NULL);
}
else
{
ev->type= PUBL_TYPE;
wipeer_name.s= buf;
memcpy(wipeer_name.s, event->name.s, event->name.len);
wipeer_name.len= event->name.len;
memcpy(wipeer_name.s+ wipeer_name.len, ".winfo", 6);
wipeer_name.len+= 6;
ev->wipeer= contains_event(&wipeer_name, NULL);
}
if(ev->wipeer)
ev->wipeer->wipeer= ev;
if(event->req_auth &&
( event->get_auth_status==0 ||event->get_rules_doc== 0))
{
LM_ERR("bad event structure\n");
goto error;
}
ev->req_auth= event->req_auth;
ev->agg_nbody= event->agg_nbody;
ev->apply_auth_nbody= event->apply_auth_nbody;
ev->get_auth_status= event->get_auth_status;
ev->get_rules_doc= event->get_rules_doc;
ev->evs_publ_handl= event->evs_publ_handl;
ev->etag_not_new= event->etag_not_new;
ev->free_body= event->free_body;
ev->default_expires= event->default_expires;
if(not_in_list)
{
ev->next= EvList->events;
EvList->events= ev;
}
EvList->ev_count++;
LM_DBG("succesfully added event: %.*s - len= %d\n",ev->name.len,
ev->name.s, ev->name.len);
return 0;
error:
if(ev && not_in_list)
{
free_pres_event(ev);
}
return -1;
}
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;
}
