static void hashT_clean(unsigned int ticks,void *param)
{
int i;
time_t now;
ua_pres_t* p= NULL, *q= NULL;
now = time(NULL);
for(i= 0;i< HASH_SIZE; i++)
{
lock_get(&HashT->p_records[i].lock);
p= HashT->p_records[i].entity->next;
while(p)
{
print_ua_pres(p);
LM_DBG("---\n");
if(p->expires -update_period < now )
{
if((p->desired_expires> p->expires + 5) ||
(p->desired_expires== 0 ))
{
LM_DBG("Desired expires greater than expires -> send a "
"refresh PUBLISH desired_expires=%d - expires=%d\n",
p->desired_expires, p->expires);
if(update_pua(p, i, 0)< 0)
{
LM_ERR("while updating record\n");
lock_release(&HashT->p_records[i].lock);
return;
}
p= p->next;
continue;
}
LM_DBG("Found expired: uri= %.*s\n", p->pres_uri->len,
p->pres_uri->s);
if(update_pua(p, i, 1)< 0)
{
LM_ERR("while updating record\n");
}
/* delete it */
q = p->next;
delete_htable_safe(p, p->hash_index);
p = q;
}
else
p= p->next;
}
lock_release(&HashT->p_records[i].lock);
}
}
void subs_cback_func(struct cell *t, int cb_type, struct tmcb_params *ps)
{
struct sip_msg* msg= NULL;
int lexpire= 0;
unsigned int cseq;
ua_pres_t* presentity= NULL, *hentity= NULL;
struct to_body *pto= NULL, *pfrom = NULL;
int size= 0;
int flag ;
str record_route= {0, 0};
int rt;
str contact;
int initial_request = 0;
if(ps==NULL || ps->param== NULL || *ps->param== NULL )
{
LM_ERR("null callback parameter\n");
return;
}
LM_DBG("completed with status %d\n",ps->code) ;
hentity= (ua_pres_t*)(*ps->param);
flag= hentity->flag;
if(hentity->flag & XMPP_INITIAL_SUBS)
hentity->flag= XMPP_SUBSCRIBE;
/* get dialog information from reply message: callid, to_tag, from_tag */
msg= ps->rpl;
if(msg == NULL)
{
LM_ERR("no reply message found\n ");
goto error;
}
if(msg== FAKED_REPLY)
{
/* delete record from hash_table and call registered functions */
if(hentity->call_id.s== NULL) /* if a new requets failed-> do nothing*/
{
LM_DBG("initial Subscribe request failed\n");
goto done;
}
lock_get(&HashT->p_records[hentity->hash_index].lock);
presentity = get_htable_safe(hentity->hash_index, hentity->local_index);
if(presentity)
{
delete_htable_safe(presentity, hentity->hash_index);
lock_release(&HashT->p_records[hentity->hash_index].lock);
}
lock_release(&HashT->p_records[hentity->hash_index].lock);
goto done;
}
if ( parse_headers(msg,HDR_EOH_F, 0)==-1 )
{
LM_ERR("when parsing headers\n");
goto done;
}
/*if initial request */
if(hentity->call_id.s== NULL)
{
initial_request = 1;
if(ps->code>= 300)
{
LM_DBG("initial Subscribe request failed\n");
goto done;
}
if( msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot parse callid header\n");
goto done;
}
if (!msg->from || !msg->from->body.s)
{
LM_ERR("cannot find 'from' header!\n");
goto done;
}
if (msg->from->parsed == NULL)
{
if ( parse_from_header( msg )<0 )
{
LM_ERR("cannot parse From header\n");
goto done;
}
}
pfrom = (struct to_body*)msg->from->parsed;
if( pfrom->tag_value.s ==NULL || pfrom->tag_value.len == 0)
{
LM_ERR("no from tag value present\n");
goto done;
}
if( msg->to==NULL || msg->to->body.s==NULL)
{
LM_ERR("cannot parse TO header\n");
goto done;
}
pto = get_to(msg);
if (pto == NULL || pto->error != PARSE_OK) {
LM_ERR("failed to parse TO header\n");
goto done;
}
if( pto->tag_value.s ==NULL || pto->tag_value.len == 0)
{
LM_ERR("no to tag value present\n");
goto done;
}
hentity->call_id= msg->callid->body;
hentity->to_tag= pto->tag_value;
hentity->from_tag= pfrom->tag_value;
}
/* extract the other necesary information for inserting a new record */
if(ps->rpl->expires && msg->expires->body.len > 0)
{
if (!msg->expires->parsed && (parse_expires(msg->expires) < 0))
{
LM_ERR("cannot parse Expires header\n");
goto done;
}
lexpire = ((exp_body_t*)msg->expires->parsed)->val;
LM_DBG("lexpire= %d\n", lexpire);
}
if(ps->code >= 300 )
{ /* if an error code and a stored dialog delete it and try to send
a subscription with type= INSERT_TYPE, else return*/
if(!initial_request)
{
subs_info_t subs;
lock_get(&HashT->p_records[hentity->hash_index].lock);
presentity = get_htable_safe(hentity->hash_index, hentity->local_index);
if(presentity)
{
hentity->event= presentity->event;
delete_htable_safe(presentity, hentity->hash_index);
lock_release(&HashT->p_records[hentity->hash_index].lock);
}
lock_release(&HashT->p_records[hentity->hash_index].lock);
memset(&subs, 0, sizeof(subs_info_t));
subs.pres_uri= hentity->pres_uri;
subs.to_uri = hentity->to_uri;
subs.watcher_uri= hentity->watcher_uri;
subs.contact= &hentity->contact;
if(hentity->remote_contact.s)
subs.remote_target= &hentity->remote_contact;
if(hentity->desired_expires== 0)
subs.expires= -1;
else
if(hentity->desired_expires< (int)time(NULL))
subs.expires= 0;
else
subs.expires= hentity->desired_expires- (int)time(NULL)+ 3;
subs.flag= INSERT_TYPE;
subs.source_flag= flag;
subs.event= hentity->event;
subs.id= hentity->id;
subs.outbound_proxy= hentity->outbound_proxy;
subs.extra_headers= &hentity->extra_headers;
subs.cb_param= hentity->cb_param;
if(send_subscribe(&subs)< 0)
{
LM_ERR("when trying to send SUBSCRIBE\n");
goto done;
}
}
goto done;
}
/*if a 2XX reply handle the two cases- an existing dialog and a new one*/
/* extract the contact */
if(msg->contact== NULL || msg->contact->body.s== NULL)
{
LM_ERR("no contact header found");
goto error;
}
if( parse_contact(msg->contact) <0 )
{
LM_ERR(" cannot parse contact header\n");
goto error;
}
if(msg->contact->parsed == NULL)
{
LM_ERR("cannot parse contact header\n");
goto error;
}
contact = ((contact_body_t* )msg->contact->parsed)->contacts->uri;
if(!initial_request)
{
/* do not delete the dialog - allow Notifies to be recognized as
* inside a known dialog */
if (lexpire == 0)
lexpire = 5;
LM_DBG("*** Update expires\n");
update_htable(hentity->hash_index, hentity->local_index, lexpire, NULL, &contact);
goto done;
}
/* if a new dialog -> insert */
if(lexpire== 0)
{
LM_DBG("expires= 0: no not insert\n");
goto done;
}
if( msg->cseq==NULL || msg->cseq->body.s==NULL)
{
LM_ERR("cannot parse cseq header\n");
goto done;
}
if( str2int( &(get_cseq(msg)->number), &cseq)< 0)
{
LM_ERR("while converting str to int\n");
goto done;
}
/*process record route and add it to a string*/
if (msg->record_route!=NULL)
{
rt = print_rr_body(msg->record_route, &record_route, 1, 0);
if(rt != 0)
{
LM_ERR("parsing record route [%d]\n", rt);
record_route.s=NULL;
record_route.len=0;
}
}
size= sizeof(ua_pres_t)+ 2*sizeof(str)+(hentity->pres_uri->len+ pto->uri.len+
pfrom->uri.len+ pto->tag_value.len+ pfrom->tag_value.len
+msg->callid->body.len+ record_route.len+ hentity->contact.len+
hentity->id.len )*sizeof(char);
presentity= (ua_pres_t*)shm_malloc(size);
if(presentity== NULL)
{
LM_ERR("no more share memory\n");
if(record_route.s)
pkg_free(record_route.s);
goto done;
}
memset(presentity, 0, size);
size= sizeof(ua_pres_t);
presentity->pres_uri= (str*)( (char*)presentity+ size);
size+= sizeof(str);
presentity->pres_uri->s= (char*)presentity+ size;
memcpy(presentity->pres_uri->s, hentity->pres_uri->s, hentity->pres_uri->len);
presentity->pres_uri->len= hentity->pres_uri->len;
size+= hentity->pres_uri->len;
presentity->to_uri.s= (char*)presentity+ size;
memcpy(presentity->to_uri.s, pto->uri.s, pto->uri.len);
presentity->to_uri.len= pto->uri.len;
size+= pto->uri.len;
presentity->watcher_uri= (str*)( (char*)presentity+ size);
size+= sizeof(str);
presentity->watcher_uri->s= (char*)presentity+ size;
memcpy(presentity->watcher_uri->s, pfrom->uri.s, pfrom->uri.len);
presentity->watcher_uri->len= pfrom->uri.len;
size+= pfrom->uri.len;
presentity->call_id.s= (char*)presentity + size;
memcpy(presentity->call_id.s,msg->callid->body.s,
msg->callid->body.len);
presentity->call_id.len= msg->callid->body.len;
size+= presentity->call_id.len;
presentity->to_tag.s= (char*)presentity + size;
memcpy(presentity->to_tag.s,pto->tag_value.s,
pto->tag_value.len);
presentity->to_tag.len= pto->tag_value.len;
size+= pto->tag_value.len;
presentity->from_tag.s= (char*)presentity + size;
memcpy(presentity->from_tag.s,pfrom->tag_value.s,
pfrom->tag_value.len);
presentity->from_tag.len= pfrom->tag_value.len;
size+= pfrom->tag_value.len;
if(record_route.len && record_route.s)
{
presentity->record_route.s= (char*)presentity + size;
memcpy(presentity->record_route.s, record_route.s, record_route.len);
presentity->record_route.len= record_route.len;
size+= record_route.len;
pkg_free(record_route.s);
}
presentity->contact.s= (char*)presentity + size;
memcpy(presentity->contact.s, hentity->contact.s, hentity->contact.len);
presentity->contact.len= hentity->contact.len;
size+= hentity->contact.len;
if(hentity->id.s)
{
presentity->id.s=(char*)presentity+ size;
memcpy(presentity->id.s, hentity->id.s,
hentity->id.len);
presentity->id.len= hentity->id.len;
size+= presentity->id.len;
}
if(hentity->extra_headers.s && hentity->extra_headers.len)
{
presentity->extra_headers.s= (char*)shm_malloc(hentity->extra_headers.len* sizeof(char));
if(presentity->extra_headers.s== NULL)
{
ERR_MEM(SHARE_MEM);
}
memcpy(presentity->extra_headers.s, hentity->extra_headers.s, hentity->extra_headers.len);
presentity->extra_headers.len= hentity->extra_headers.len;
}
/* write the remote contact filed */
presentity->remote_contact.s= (char*)shm_malloc(contact.len* sizeof(char));
if(presentity->remote_contact.s== NULL)
{
ERR_MEM(SHARE_MEM);
}
memcpy(presentity->remote_contact.s, contact.s, contact.len);
presentity->remote_contact.len= contact.len;
presentity->event|= hentity->event;
presentity->flag= hentity->flag;
presentity->etag.s= NULL;
presentity->cseq= cseq;
presentity->desired_expires= hentity->desired_expires;
presentity->expires= lexpire+ (int)time(NULL);
if(BLA_SUBSCRIBE & presentity->flag)
{
LM_DBG("BLA_SUBSCRIBE FLAG inserted\n");
}
LM_DBG("record for subscribe from %.*s to %.*s inserted in datatbase\n",
presentity->watcher_uri->len, presentity->watcher_uri->s,
presentity->pres_uri->len, presentity->pres_uri->s);
insert_htable(presentity);
done:
if(hentity->ua_flag == REQ_OTHER)
{
hentity->flag= flag;
run_pua_callbacks( hentity, msg);
}
error:
if(hentity)
{
if(presentity)
{
if(presentity->extra_headers.s)
shm_free(presentity->extra_headers.s);
if(presentity->remote_contact.s)
shm_free(presentity->remote_contact.s);
}
shm_free(hentity);
hentity= NULL;
}
return;
}
int send_publish_int(ua_pres_t* presentity, publ_info_t* publ, pua_event_t* ev,
int hash_index)
{
unsigned long pres_id= 0;
int ret = ERR_PUBLISH_GENERIC;
char etag_buf[256];
char tuple_buf[128];
str tuple_id= {0, 0};
str etag= {0, 0};
int ver= 0;
str* body= NULL;
str* str_hdr = NULL;
str met = {"PUBLISH", 7};
LM_DBG("start\n");
if(presentity)
{
LM_DBG("presentity exists\n");
pres_id = PRES_HASH_ID(presentity);
ver= ++presentity->version;
/* copy etag */
if(presentity->etag.s)
{
etag.s = etag_buf;
memcpy(etag.s, presentity->etag.s, presentity->etag.len);
etag.len = presentity->etag.len;
}
/* tuple id */
if(presentity->tuple_id.s)
{
tuple_id.s = tuple_buf;
memcpy(tuple_id.s, presentity->tuple_id.s, presentity->tuple_id.len);
tuple_id.len = presentity->tuple_id.len;
}
presentity->desired_expires= publ->expires + (int)time(NULL);
presentity->waiting_reply = 1;
presentity->cb_param = publ->cb_param;
if(publ->expires== 0)
{
LM_DBG("expires= 0- delete from hash table\n");
delete_htable_safe(presentity, hash_index);
}
}
lock_release(&HashT->p_records[hash_index].lock);
/* handle body */
if(publ->body && publ->body->s)
{
if(ev->process_body)
{
if(ev->process_body(publ, &body, ver, &tuple_id)< 0 || body== NULL)
{
LM_ERR("while processing body\n");
goto error;
}
}
else
body = publ->body;
LM_DBG("Handled body [%.*s]\n", body->len, body->s);
}
if(publ->expires!= 0 && publ->expires< min_expires)
publ->expires = min_expires;
if(presentity== NULL)
{
if(publ->expires== 0)
{
LM_DBG("request for a publish with expires 0 and"
" no record found\n");
ret = ERR_PUBLISH_NO_RECORD;
goto error;
}
if(publ->body== NULL)
{
if (ev->content_type.s && ev->content_type.len) {
LM_ERR("New '%.*s' PUBLISH and no body found - invalid request\n",
ev->name.len, ev->name.s);
ret = ERR_PUBLISH_NO_BODY;
goto error;
}
}
pres_id = new_publ_record(publ, ev, &tuple_id);
}
str_hdr = publ_build_hdr(((publ->expires< 0)?3600:publ->expires), ev, &publ->content_type,
(etag.s?&etag:NULL), publ->extra_headers, ((body)?1:0));
if(str_hdr == NULL)
{
LM_ERR("while building extra_headers\n");
goto error;
}
LM_DBG("publ->pres_uri:\n%.*s\n ", publ->pres_uri->len, publ->pres_uri->s);
LM_DBG("str_hdr:\n%.*s %d\n ", str_hdr->len, str_hdr->s, str_hdr->len);
if(body && body->len && body->s )
LM_DBG("body:\n%.*s\n ", body->len, body->s);
LM_DBG("cback param = %ld\n", pres_id);
tmb.t_request(&met, /* Type of the message */
publ->pres_uri, /* Request-URI */
publ->pres_uri, /* To */
publ->pres_uri, /* From */
str_hdr, /* Optional headers */
body, /* Message body */
((publ->outbound_proxy.s)?&publ->outbound_proxy:0),/*Outbound proxy*/
publ->expires?publ_cback_func:0, /* Callback function */
(void*)pres_id, /* Callback parameter */
0
);
pkg_free(str_hdr);
if(body && ev->process_body)
{
if(body->s)
xmlFree(body->s);
pkg_free(body);
}
return ERR_PUBLISH_NO_ERROR;
error:
if(body && ev->process_body)
{
if(body->s)
xmlFree(body->s);
pkg_free(body);
}
if(str_hdr)
pkg_free(str_hdr);
return ret;
}
