int pres_auth_status(struct sip_msg* msg, str watcher_uri, str presentity_uri)
{
str event;
struct sip_uri uri;
pres_ev_t* ev;
str* rules_doc = NULL;
subs_t subs;
int res;
event.s = "presence";
event.len = 8;
ev = contains_event(&event, NULL);
if (ev == NULL) {
LM_ERR("event is not registered\n");
return -1;
}
if (ev->get_rules_doc == NULL) {
LM_DBG("event does not require authorization");
return ACTIVE_STATUS;
}
if (parse_uri(presentity_uri.s, presentity_uri.len, &uri) < 0) {
LM_ERR("failed to parse presentity uri\n");
return -1;
}
res = ev->get_rules_doc(&uri.user, &uri.host, &rules_doc);
if ((res < 0) || (rules_doc == NULL) || (rules_doc->s == NULL)) {
LM_DBG( "no xcap rules doc found for presentity uri\n");
return PENDING_STATUS;
}
if (parse_uri(watcher_uri.s, watcher_uri.len, &uri) < 0) {
LM_ERR("failed to parse watcher uri\n");
goto err;
}
subs.watcher_user = uri.user;
subs.watcher_domain = uri.host;
subs.pres_uri = presentity_uri;
subs.auth_rules_doc = rules_doc;
if (ev->get_auth_status(&subs) < 0) {
LM_ERR( "getting status from rules document\n");
goto err;
}
LM_DBG("auth status of watcher <%.*s> on presentity <%.*s> is %d\n",
watcher_uri.len, watcher_uri.s, presentity_uri.len, presentity_uri.s,
subs.status);
pkg_free(rules_doc->s);
pkg_free(rules_doc);
if ((subs.reason.len == 12) && (strncmp(subs.reason.s, "polite-block", 12) == 0))
return POLITE_BLOCK_STATUS;
return subs.status;
err:
pkg_free(rules_doc->s);
pkg_free(rules_doc);
return -1;
}
static int ki_pres_has_subscribers(sip_msg_t *msg, str *pres_uri, str *wevent)
{
pres_ev_t *ev;
ev = contains_event(wevent, NULL);
if(ev == NULL) {
LM_ERR("event is not registered\n");
return -1;
}
return get_subscribers_count(msg, *pres_uri, *wevent) > 0 ? 1 : -1;
}
/**
* wrapper for update_watchers_status to use via kemi
*/
static int ki_pres_update_watchers(struct sip_msg *msg, str *pres_uri,
str *event)
{
pres_ev_t* ev;
struct sip_uri uri;
str* rules_doc = NULL;
int ret;
ev = contains_event(event, NULL);
if(ev==NULL)
{
LM_ERR("event %.*s is not registered\n",
event->len, event->s);
return -1;
}
if(ev->get_rules_doc==NULL)
{
LM_DBG("event %.*s does not provide rules doc API\n",
event->len, event->s);
return -1;
}
if(parse_uri(pres_uri->s, pres_uri->len, &uri)<0)
{
LM_ERR("failed to parse presentity uri [%.*s]\n",
pres_uri->len, pres_uri->s);
return -1;
}
ret = ev->get_rules_doc(&uri.user, &uri.host, &rules_doc);
if((ret < 0) || (rules_doc==NULL) || (rules_doc->s==NULL))
{
LM_DBG("no xcap rules doc found for presentity uri [%.*s]\n",
pres_uri->len, pres_uri->s);
if(rules_doc != NULL)
pkg_free(rules_doc);
return -1;
}
ret = 1;
if(update_watchers_status(*pres_uri, ev, rules_doc)<0)
{
LM_ERR("updating watchers in presence\n");
ret = -1;
}
pkg_free(rules_doc->s);
pkg_free(rules_doc);
return ret;
}
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 update_watchers_status(str pres_uri, pres_ev_t* ev, str* rules_doc)
{
subs_t subs;
db_key_t query_cols[6], result_cols[5];
db_val_t query_vals[6];
int n_result_cols= 0, n_query_cols = 0;
db1_res_t* result= NULL;
db_row_t *row;
db_val_t *row_vals ;
int i;
str w_user, w_domain, reason= {0, 0};
unsigned int status;
int status_col, w_user_col, w_domain_col, reason_col;
subs_t* subs_array= NULL,* s;
unsigned int hash_code;
int err_ret= -1;
int n= 0;
typedef struct ws
{
int status;
str reason;
str w_user;
str w_domain;
}ws_t;
ws_t* ws_list= NULL;
LM_DBG("start\n");
if(ev->content_type.s== NULL)
{
ev= contains_event(&ev->name, NULL);
if(ev== NULL)
{
LM_ERR("wrong event parameter\n");
return 0;
}
}
memset(&subs, 0, sizeof(subs_t));
subs.pres_uri= pres_uri;
subs.event= ev;
subs.auth_rules_doc= rules_doc;
/* update in watchers_table */
query_cols[n_query_cols]= &str_presentity_uri_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
query_vals[n_query_cols].val.str_val= pres_uri;
n_query_cols++;
query_cols[n_query_cols]= &str_event_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
query_vals[n_query_cols].val.str_val= ev->name;
n_query_cols++;
result_cols[status_col= n_result_cols++]= &str_status_col;
result_cols[reason_col= n_result_cols++]= &str_reason_col;
result_cols[w_user_col= n_result_cols++]= &str_watcher_username_col;
result_cols[w_domain_col= n_result_cols++]= &str_watcher_domain_col;
if (pa_dbf.use_table(pa_db, &watchers_table) < 0)
{
LM_ERR( "in use_table\n");
goto done;
}
if(pa_dbf.query(pa_db, query_cols, 0, query_vals, result_cols,n_query_cols,
n_result_cols, 0, &result)< 0)
{
LM_ERR( "in sql query\n");
goto done;
}
if(result== NULL)
return 0;
if(result->n<= 0)
{
err_ret= 0;
goto done;
}
LM_DBG("found %d record-uri in watchers_table\n", result->n);
hash_code= core_case_hash(&pres_uri, &ev->name, shtable_size);
subs.db_flag= hash_code;
/*must do a copy as sphere_check requires database queries */
if(sphere_enable)
{
n= result->n;
ws_list= (ws_t*)pkg_malloc(n * sizeof(ws_t));
if(ws_list== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memset(ws_list, 0, n * sizeof(ws_t));
for(i= 0; i< result->n ; i++)
{
row= &result->rows[i];
row_vals = ROW_VALUES(row);
status= row_vals[status_col].val.int_val;
reason.s= (char*)row_vals[reason_col].val.string_val;
reason.len= reason.s?strlen(reason.s):0;
w_user.s= (char*)row_vals[w_user_col].val.string_val;
w_user.len= strlen(w_user.s);
w_domain.s= (char*)row_vals[w_domain_col].val.string_val;
w_domain.len= strlen(w_domain.s);
if(reason.len)
{
ws_list[i].reason.s = (char*)pkg_malloc(reason.len* sizeof(char));
if(ws_list[i].reason.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].reason.s, reason.s, reason.len);
ws_list[i].reason.len= reason.len;
}
else
ws_list[i].reason.s= NULL;
ws_list[i].w_user.s = (char*)pkg_malloc(w_user.len* sizeof(char));
if(ws_list[i].w_user.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].w_user.s, w_user.s, w_user.len);
ws_list[i].w_user.len= w_user.len;
ws_list[i].w_domain.s = (char*)pkg_malloc(w_domain.len* sizeof(char));
if(ws_list[i].w_domain.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].w_domain.s, w_domain.s, w_domain.len);
ws_list[i].w_domain.len= w_domain.len;
ws_list[i].status= status;
}
pa_dbf.free_result(pa_db, result);
result= NULL;
for(i=0; i< n; i++)
{
subs.watcher_user = ws_list[i].w_user;
subs.watcher_domain = ws_list[i].w_domain;
subs.status = ws_list[i].status;
memset(&subs.reason, 0, sizeof(str));
if( pres_update_status(subs, reason, query_cols, query_vals,
n_query_cols, &subs_array)< 0)
{
LM_ERR("failed to update watcher status\n");
goto done;
}
}
for(i=0; i< n; i++)
{
pkg_free(ws_list[i].w_user.s);
pkg_free(ws_list[i].w_domain.s);
if(ws_list[i].reason.s)
pkg_free(ws_list[i].reason.s);
}
ws_list= NULL;
goto send_notify;
}
for(i = 0; i< result->n; i++)
{
row= &result->rows[i];
row_vals = ROW_VALUES(row);
status= row_vals[status_col].val.int_val;
reason.s= (char*)row_vals[reason_col].val.string_val;
reason.len= reason.s?strlen(reason.s):0;
w_user.s= (char*)row_vals[w_user_col].val.string_val;
w_user.len= strlen(w_user.s);
w_domain.s= (char*)row_vals[w_domain_col].val.string_val;
w_domain.len= strlen(w_domain.s);
subs.watcher_user= w_user;
subs.watcher_domain= w_domain;
subs.status= status;
memset(&subs.reason, 0, sizeof(str));
if( pres_update_status(subs,reason, query_cols, query_vals,
n_query_cols, &subs_array)< 0)
{
LM_ERR("failed to update watcher status\n");
goto done;
}
}
pa_dbf.free_result(pa_db, result);
result= NULL;
send_notify:
if (pres_notifier_processes == 0)
{
s= subs_array;
while(s)
{
if(notify(s, NULL, NULL, 0)< 0)
{
LM_ERR( "sending Notify request\n");
goto done;
}
/* delete from database also */
if(s->status== TERMINATED_STATUS)
{
if(pres_db_delete_status(s)<0)
{
LM_ERR("failed to delete terminated "
"dialog from database\n");
goto done;
}
}
s= s->next;
}
}
free_subs_list(subs_array, PKG_MEM_TYPE, 0);
return 0;
done:
if(result)
pa_dbf.free_result(pa_db, result);
free_subs_list(subs_array, PKG_MEM_TYPE, 0);
if(ws_list)
{
for(i= 0; i< n; i++)
{
if(ws_list[i].w_user.s)
pkg_free(ws_list[i].w_user.s);
else
break;
if(ws_list[i].w_domain.s)
pkg_free(ws_list[i].w_domain.s);
if(ws_list[i].reason.s)
pkg_free(ws_list[i].reason.s);
}
}
return err_ret;
}
int pres_refresh_watchers(str *pres, str *event, int type, str *file_uri, str *filename)
{
pres_ev_t *ev;
struct sip_uri uri;
str *rules_doc= NULL;
int result;
ev= contains_event(event, NULL);
if(ev==NULL)
{
LM_ERR("wrong event parameter\n");
return -1;
}
if(type==0)
{
/* if a request to refresh watchers authorization */
if(ev->get_rules_doc==NULL)
{
LM_ERR("wrong request for a refresh watchers authorization status"
"for an event that does not require authorization\n");
goto error;
}
if(parse_uri(pres->s, pres->len, &uri)<0)
{
LM_ERR("parsing uri [%.*s]\n", pres->len, pres->s);
goto error;
}
result= ev->get_rules_doc(&uri.user, &uri.host, &rules_doc);
if(result<0 || rules_doc==NULL || rules_doc->s==NULL)
{
LM_ERR("no rules doc found for the user\n");
goto error;
}
if(update_watchers_status(*pres, ev, rules_doc)<0)
{
LM_ERR("failed to update watchers\n");
goto error;
}
pkg_free(rules_doc->s);
pkg_free(rules_doc);
rules_doc = NULL;
} else {
if (type == 2) {
if (update_hard_presentity(pres, ev, file_uri, filename) < 0)
{
LM_ERR("updating hard presentity\n");
goto error;
}
}
/* if a request to refresh notified info */
if(query_db_notify(pres, ev, NULL)< 0)
{
LM_ERR("sending Notify requests\n");
goto error;
}
}
return 0;
error:
if(rules_doc)
{
if(rules_doc->s)
pkg_free(rules_doc->s);
pkg_free(rules_doc);
}
return -1;
}
/**
* wrapper for update_watchers_status to use in config
*/
static int w_pres_update_watchers(struct sip_msg *msg, char *puri,
char *pevent)
{
str pres_uri;
str event;
pres_ev_t* ev;
struct sip_uri uri;
str* rules_doc = NULL;
int ret;
if(fixup_get_svalue(msg, (gparam_p)puri, &pres_uri)!=0)
{
LM_ERR("invalid uri parameter");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)pevent, &event)!=0)
{
LM_ERR("invalid uri parameter");
return -1;
}
ev = contains_event(&event, NULL);
if(ev==NULL)
{
LM_ERR("event %.*s is not registered\n",
event.len, event.s);
return -1;
}
if(ev->get_rules_doc==NULL)
{
LM_DBG("event %.*s does not provide rules doc API\n",
event.len, event.s);
return -1;
}
if(parse_uri(pres_uri.s, pres_uri.len, &uri)<0)
{
LM_ERR("failed to parse presentity uri [%.*s]\n",
pres_uri.len, pres_uri.s);
return -1;
}
ret = ev->get_rules_doc(&uri.user, &uri.host, &rules_doc);
if((ret < 0) || (rules_doc==NULL) || (rules_doc->s==NULL))
{
LM_DBG("no xcap rules doc found for presentity uri [%.*s]\n",
pres_uri.len, pres_uri.s);
if(rules_doc != NULL)
pkg_free(rules_doc);
return -1;
}
ret = 1;
if(update_watchers_status(pres_uri, ev, rules_doc)<0)
{
LM_ERR("updating watchers in presence\n");
ret = -1;
}
pkg_free(rules_doc->s);
pkg_free(rules_doc);
return ret;
}
static int update_pw_dialogs_dbonlymode(subs_t* subs, subs_t** subs_array)
{
db_key_t query_cols[5], db_cols[3];
db_val_t query_vals[5], db_vals[3];
db_key_t result_cols[24];
int n_query_cols=0, n_result_cols=0, n_update_cols=0;
int event_col, pres_uri_col, watcher_user_col, watcher_domain_col;
int r_pres_uri_col,r_to_user_col,r_to_domain_col;
int r_from_user_col,r_from_domain_col,r_callid_col;
int r_to_tag_col,r_from_tag_col,r_sockinfo_col;
int r_event_id_col,r_local_contact_col,r_contact_col;
int r_record_route_col, r_reason_col;
int r_event_col, r_local_cseq_col, r_remote_cseq_col;
int r_status_col, r_version_col;
int r_expires_col, r_watcher_user_col, r_watcher_domain_col;
db1_res_t *result= NULL;
db_val_t *row_vals;
db_row_t *rows;
int nr_rows, loop;
subs_t s, *cs;
str ev_sname;
if(pa_db == NULL)
{
LM_ERR("null database connection\n");
return(-1);
}
if (pa_dbf.use_table(pa_db, &active_watchers_table) < 0)
{
LM_ERR("use table failed\n");
return(-1);
}
query_cols[event_col=n_query_cols]= &str_event_col;
query_vals[event_col].nul= 0;
query_vals[event_col].type= DB1_STR;
query_vals[event_col].val.str_val= subs->event->name ;
n_query_cols++;
query_cols[pres_uri_col=n_query_cols]= &str_presentity_uri_col;
query_vals[pres_uri_col].nul= 0;
query_vals[pres_uri_col].type= DB1_STR;
query_vals[pres_uri_col].val.str_val= subs->pres_uri;
n_query_cols++;
query_cols[watcher_user_col=n_query_cols]= &str_watcher_username_col;
query_vals[watcher_user_col].nul= 0;
query_vals[watcher_user_col].type= DB1_STR;
query_vals[watcher_user_col].val.str_val= subs->watcher_user;
n_query_cols++;
query_cols[watcher_domain_col=n_query_cols]= &str_watcher_domain_col;
query_vals[watcher_domain_col].nul= 0;
query_vals[watcher_domain_col].type= DB1_STR;
query_vals[watcher_domain_col].val.str_val= subs->watcher_domain;
n_query_cols++;
result_cols[r_to_user_col=n_result_cols++] = &str_to_user_col;
result_cols[r_to_domain_col=n_result_cols++] = &str_to_domain_col;
result_cols[r_from_user_col=n_result_cols++] = &str_from_user_col;
result_cols[r_from_domain_col=n_result_cols++] = &str_from_domain_col;
result_cols[r_watcher_user_col=n_result_cols++] = &str_watcher_username_col;
result_cols[r_watcher_domain_col=n_result_cols++] = &str_watcher_domain_col;
result_cols[r_callid_col=n_result_cols++] = &str_callid_col;
result_cols[r_to_tag_col=n_result_cols++] = &str_to_tag_col;
result_cols[r_from_tag_col=n_result_cols++] = &str_from_tag_col;
result_cols[r_sockinfo_col=n_result_cols++] = &str_socket_info_col;
result_cols[r_event_id_col=n_result_cols++] = &str_event_id_col;
result_cols[r_local_contact_col=n_result_cols++] = &str_local_contact_col;
result_cols[r_record_route_col=n_result_cols++] = &str_record_route_col;
result_cols[r_reason_col=n_result_cols++] = &str_reason_col;
result_cols[r_local_cseq_col=n_result_cols++] = &str_local_cseq_col;
result_cols[r_version_col=n_result_cols++] = &str_version_col;
result_cols[r_expires_col=n_result_cols++] = &str_expires_col;
result_cols[r_event_col=n_result_cols++] = &str_event_col;
result_cols[r_pres_uri_col=n_result_cols++] = &str_presentity_uri_col;
result_cols[r_contact_col=n_result_cols++] = &str_contact_col;
/* these ones are unused for some reason !!! */
result_cols[r_remote_cseq_col=n_result_cols++] = &str_remote_cseq_col;
result_cols[r_status_col=n_result_cols++] = &str_status_col;
/*********************************************/
if(pa_dbf.query(pa_db, query_cols, 0, query_vals, result_cols,
n_query_cols, n_result_cols, 0, &result )< 0)
{
LM_ERR("Can't query db\n");
if(result) pa_dbf.free_result(pa_db, result);
return(-1);
}
if(result == NULL) return(-1);
nr_rows = RES_ROW_N(result);
LM_DBG("found %d matching dialogs\n", nr_rows);
if (nr_rows <= 0)
{
pa_dbf.free_result(pa_db, result);
return 0;
}
rows = RES_ROWS(result);
/* get the results and fill in return data structure */
for (loop=0; loop <nr_rows; loop++)
{
row_vals = ROW_VALUES(&rows[loop]);
memset(&s, 0, sizeof(subs_t));
s.status= subs->status;
s.reason.s= subs->reason.s;
s.reason.len= s.reason.s?strlen(s.reason.s):0; //>>>>>>>>>>
s.pres_uri.s= (char*)row_vals[r_pres_uri_col].val.string_val;
s.pres_uri.len= s.pres_uri.s?strlen(s.pres_uri.s):0;
s.to_user.s= (char*)row_vals[r_to_user_col].val.string_val;
s.to_user.len= s.to_user.s?strlen(s.to_user.s):0;
s.to_domain.s= (char*)row_vals[r_to_domain_col].val.string_val;
s.to_domain.len= s.to_domain.s?strlen(s.to_domain.s):0;
s.from_user.s= (char*)row_vals[r_from_user_col].val.string_val;
s.from_user.len= s.from_user.s?strlen(s.from_user.s):0;
s.from_domain.s= (char*)row_vals[r_from_domain_col].val.string_val;
s.from_domain.len= s.from_domain.s?strlen(s.from_domain.s):0;
s.watcher_user.s= (char*)row_vals[r_watcher_user_col].val.string_val;
s.watcher_user.len= s.watcher_user.s?strlen(s.watcher_user.s):0;
s.watcher_domain.s= (char*)row_vals[r_watcher_domain_col].val.string_val;
s.watcher_domain.len= s.watcher_domain.s?strlen(s.watcher_domain.s):0;
s.event_id.s=(char*)row_vals[r_event_id_col].val.string_val;
s.event_id.len= (s.event_id.s)?strlen(s.event_id.s):0;
s.to_tag.s= (char*)row_vals[r_to_tag_col].val.string_val;
s.to_tag.len= s.to_tag.s?strlen(s.to_tag.s):0;
s.from_tag.s= (char*)row_vals[r_from_tag_col].val.string_val;
s.from_tag.len= s.from_tag.s?strlen(s.from_tag.s):0;
s.callid.s= (char*)row_vals[r_callid_col].val.string_val;
s.callid.len= s.callid.s?strlen(s.callid.s):0;
s.record_route.s= (char*)row_vals[r_record_route_col].val.string_val;
s.record_route.len= (s.record_route.s)?strlen(s.record_route.s):0;
s.contact.s= (char*)row_vals[r_contact_col].val.string_val;
s.contact.len= s.contact.s?strlen(s.contact.s):0;
s.sockinfo_str.s = (char*)row_vals[r_sockinfo_col].val.string_val;
s.sockinfo_str.len = s.sockinfo_str.s?strlen(s.sockinfo_str.s):0;
s.local_contact.s = (char*)row_vals[r_local_contact_col].val.string_val;
s.local_contact.len = s.local_contact.s?strlen(s.local_contact.s):0;
ev_sname.s= (char*)row_vals[r_event_col].val.string_val;
ev_sname.len= ev_sname.s?strlen(ev_sname.s):0;
s.event = contains_event(&ev_sname, NULL);
if(s.event == NULL)
{
LM_ERR("event not found and set to NULL\n");
}
s.local_cseq = row_vals[r_local_cseq_col].val.int_val;
s.expires = row_vals[r_expires_col].val.int_val;
if( s.expires > (int)time(NULL) + expires_offset)
s.expires -= (int)time(NULL);
else
s.expires = 0;
s.version = row_vals[r_version_col].val.int_val;
cs = mem_copy_subs(&s, PKG_MEM_TYPE);
if (cs == NULL)
{
LM_ERR("while copying subs_t structure\n");
/* tidy up and return */
pa_dbf.free_result(pa_db, result);
return(-1);
}
cs->local_cseq++;
cs->next= (*subs_array);
(*subs_array)= cs;
printf_subs(cs);
}
pa_dbf.free_result(pa_db, result);
if (pres_notifier_processes == 0 && subs->status == TERMINATED_STATUS)
{
/* delete the records */
if(pa_dbf.delete(pa_db, query_cols, 0, query_vals, n_query_cols)< 0)
{
LM_ERR("sql delete failed\n");
return(-1);
}
return(0);
}
/* otherwise we update the records */
db_cols[n_update_cols] = &str_status_col;
db_vals[n_update_cols].type = DB1_INT;
db_vals[n_update_cols].nul = 0;
db_vals[n_update_cols].val.int_val = subs->status;
n_update_cols++;
db_cols[n_update_cols] = &str_reason_col;
db_vals[n_update_cols].type = DB1_STR;
db_vals[n_update_cols].nul = 0;
db_vals[n_update_cols].val.str_val= subs->reason;
n_update_cols++;
db_cols[n_update_cols] = &str_updated_col;
db_vals[n_update_cols].type = DB1_INT;
db_vals[n_update_cols].nul = 0;
if (subs->callid.len == 0 || subs->from_tag.len == 0)
{
db_vals[n_update_cols].val.int_val = (int) ((rand() / (RAND_MAX + 1.0)) *
(pres_waitn_time * pres_notifier_poll_rate
* pres_notifier_processes));
} else {
db_vals[n_update_cols].val.int_val =
core_case_hash(&subs->callid, &subs->from_tag, 0) %
(pres_waitn_time * pres_notifier_poll_rate
* pres_notifier_processes);
}
n_update_cols++;
if(pa_dbf.update(pa_db, query_cols, 0, query_vals,
db_cols,db_vals,n_query_cols,n_update_cols) < 0)
{
LM_ERR("DB update failed\n");
return(-1);
}
return(0);
}
int 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;
}