@@ -33,6 +33,7 @@ Anca-Maria Vamanu

               1.3.8. expires_offset (int)

               1.3.9. max_expires (int)

               1.3.10. server_address (str)

+              1.3.11. fallback2db (int)

         1.4. Exported Functions

@@ -65,8 +66,9 @@ Anca-Maria Vamanu

    1-8. Set expires_offset parameter

    1-9. Set max_expires parameter

    1-10. Set server_address parameter

-   1-11. handle_publish usage

-   1-12. handle_subscribe usage

+   1-11. Set fallback2db parameter

+   1-12. handle_publish usage

+   1-13. handle_subscribe usage

    2-1. event_api_t structure

      _________________________________________________________

@@ -81,14 +83,23 @@ Chapter 1. User's Guide

    presence.winfo, dialog;sla from presence_xml module and

    message-summary from presence_mwi module.

-   The presence server works with database storage. It stores

-   published information and Subscribe -Notify dialog

-   characteristics.

-

-   It can also work only with the functionality of a library,

-   with no message processing and generation, but used only for

-   the exported functions. This mode of operation is enabled if

-   the db_url parameter is not set to any value.

+   The modules uses database storage. It has later been improved

+   with memory caching operations to improve performance. The

+   Subscribe dialog information are stored in memory and are

+   periodically updated in database, while for Publish only the

+   presence or absence of stored info for a certain resource is

+   maintained in memory to avoid unnecessary, costly db

+   operations. It is possible to configure a fallback to database

+   mode(by setting module parameter "fallback2db"). In this mode,

+   in case a searched record is not found in cache, the search is

+   continued in database. This is useful for an architecture in

+   which processing and memory load might be divided on more

+   machines using the same database.

+

+   The module can also work only with the functionality of a

+   library, with no message processing and generation, but used

+   only for the exported functions. This mode of operation is

+   enabled if the db_url parameter is not set to any value.

    The server follows the specifications in: RFC3265, RFC3856,

    RFC3857, RFC3858.

@@ -244,6 +255,20 @@ modparam("presence", "server_address", "sip:10.10.10.10:5060")

 ...

      _________________________________________________________

+1.3.11. fallback2db (int)

+

+   Setting this parameter enables a fallback to db mode of

+   operation. In this mode, in case a searched record is not

+   found in cache, the search is continued in database. Useful

+   for an architecture in which processing and memory load might

+   be divided on more machines using the same database.

+

+   Example 1-11. Set fallback2db parameter

+...

+modparam("presence", "fallback2db", 1)

+...

+     _________________________________________________________

+

 1.4. Exported Functions

 1.4.1. handle_publish(char* sender_uri)

@@ -262,7 +287,7 @@ modparam("presence", "server_address", "sip:10.10.10.10:5060")

    This function can be used from REQUEST_ROUTE.

-   Example 1-11. handle_publish usage

+   Example 1-12. handle_publish usage

 ...

         if(is_method("PUBLISH"))

         {

@@ -284,7 +309,7 @@ modparam("presence", "server_address", "sip:10.10.10.10:5060")

    This function can be used from REQUEST_ROUTE.

-   Example 1-12. handle_subscribe usage

+   Example 1-13. handle_subscribe usage

 ...

 if(method=="SUBSCRIBE")

     handle_subscribe();

@@ -38,7 +38,6 @@ int bind_presence(event_api_t* api)

 	api->add_event = add_event;

 	api->contains_event= contains_event;

-	api->get_sname_event= get_sname_event;

 	api->get_event_list= get_event_list;

 	return 0;

 }

@@ -34,7 +34,6 @@

 typedef struct event_api {

 	add_event_t add_event;

 	contains_event_t contains_event;

-	get_sname_event_t get_sname_event;

 	get_event_list_t get_event_list;

 } event_api_t;

@@ -20,11 +20,21 @@

 	module and message-summary from presence_mwi module.

 	</para>

 	<para>

-	The presence server works with database storage. It stores published information 

-	and Subscribe -Notify dialog characteristics.

+	The modules uses database storage. 

+	It has later been improved with memory caching operations to improve

+	performance. The Subscribe dialog information are stored in memory and 

+	are periodically updated in database, while for Publish only the presence

+	or absence of stored info for a certain resource is maintained in memory

+	to avoid unnecessary, costly db operations. 

+	It is possible to configure a fallback to database mode(by setting module

+	parameter "fallback2db"). In this mode, in case a searched record is not 

+	found in cache, the search is continued	in database. This is useful for

+	an architecture in which processing and memory load might be divided on 

+	more machines using the same database.

 	</para>

-	<para>It can also work only with the functionality of a library, with no message 

-	processing and generation, but used only for the exported functions.

+	<para>The module can also work only with the functionality of a library,

+	with no message processing and generation, but used only for the exported

+	functions.

 	This mode of operation is enabled if the db_url parameter is not set to any value.

 	</para>

 	<para>

@@ -264,6 +274,24 @@ modparam("presence", "server_address", "sip:10.10.10.10:5060")

 </programlisting>

 		</example>

 	</section>

+<section>

+		<title><varname>fallback2db</varname> (int)</title>

+		<para>

+		Setting this parameter enables a fallback to db mode of operation.

+		In this mode, in case a searched record is not found in cache, 

+		the search is continued	in database. Useful for an architecture in

+		which processing and memory load might be divided on more machines

+		using the same database.

+		</para>

+		<example>

+		<title>Set <varname>fallback2db</varname> parameter</title>

+		<programlisting format="linespecific">

+...

+modparam("presence", "fallback2db", 1)

+...

+</programlisting>

+		</example>

+	</section>

 </section>

@@ -31,19 +31,93 @@

 #include <string.h>

 #include "../../str.h"

 #include "../../dprint.h"

+#include "../../parser/parse_event.h" 

 #include "../../mem/shm_mem.h" 

+#include "../../mem/mem.h" 

 #include "event_list.h"

+#include "hash.h"

 #define MAX_EVNAME_SIZE 20

-int add_event(ev_t* event)

+event_t* shm_copy_event(event_t* e)

 {

-	ev_t* ev= NULL;

+	event_t* ev= NULL;

+	param_t* p1, *p2;

 	int size;

-	char* sep= NULL;

+

+	ev= (event_t*)shm_malloc(sizeof(event_t));

+	if(ev== NULL)

+	{

+		ERR_MEM("shm_copy_event");

+	}

+	memset(ev, 0, sizeof(event_t));

+

+	ev->text.s= (char*)shm_malloc(e->text.len* sizeof(char));

+	if(ev->text.s== NULL)

+	{

+		ERR_MEM("shm_copy_event");

+	}

+	memcpy(ev->text.s, e->text.s, e->text.len);

+	ev->text.len= e->text.len;

+

+	p1= e->params;

+	while(p1)

+	{

+		size= sizeof(param_t)+ (p1->name.len+ p1->body.len)* sizeof(char);

+		p2= (param_t*)shm_malloc(size);

+		if(p2== NULL)

+		{

+			ERR_MEM("shm_copy_event");

+		}

+		memset(p2, 0, size);

+

+		size= sizeof(param_t);

+		CONT_COPY(p2, p2->name, p1->name);

+		if(p1->body.s && p1->body.len)

+			CONT_COPY(p2, p2->body, p1->body);

+		p2->next= ev->params;

+		ev->params= p2;

+		p1= p1->next;

+	}

+	ev->parsed= e->parsed;

+

+	return ev;

+

+error:

+	shm_free_event(ev);

+	return NULL;

+}

+

+void shm_free_event(event_t* ev)

+{

+	param_t* p1, *p2;

+

+	if(ev== NULL)

+		return;

+	

+	if(ev->text.s)

+		shm_free(ev->text.s);

+	p1= ev->params;

+	while(p1)

+	{

+		p2= p1;

+		p1= p1->next;

+		shm_free(p2);

+	}

+	shm_free(ev);

+}

+

+

+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 ret_code= 1;

+	int not_in_list= 0;

+

+	memset(&parsed_event, 0, sizeof(event_t));

 	if(event->name.s== NULL || event->name.len== 0)

 	{

@@ -56,70 +130,56 @@ int add_event(ev_t* event)

 		LOG(L_ERR, "PRESENCE: add_event: NULL content_type param\n");

 		return -1;

 	}

-

-	if(contains_event(&event->name, event->param))

-	{

-		DBG("PRESENCE: add_event: Found prevoius record for event\n");

-		ret_code= -1;

-		goto done;

-	}	

-	size= sizeof(ev_t)+ (event->name.len+ event->content_type.len)*sizeof(char);

-

-	if(event->param)

-		size+= sizeof(str)+ ( 2*event->param->len + event->name.len+ 2)* sizeof(char);

-

-	ev= (ev_t*)shm_malloc(size);

+	

+	ev= contains_event(&event->name, &parsed_event);

 	if(ev== NULL)

 	{

-		LOG(L_ERR, "PRESENCE: add_event: ERROR while allocating memory\n");

-		ret_code= -1;

-		goto done;

-	}

-	memset(ev, 0, size);

-

-	size= sizeof(ev_t);

-	ev->name.s= (char*)ev+ size;

-	ev->name.len= event->name.len;

-	memcpy(ev->name.s, event->name.s, event->name.len);

-	size+= event->name.len;

+		not_in_list= 1;

+		ev= (pres_ev_t*)shm_malloc(sizeof(pres_ev_t));

+		if(ev== NULL)

+		{

+			ERR_MEM("add_event");

+		}

+		memset(ev, 0, sizeof(pres_ev_t));

+		ev->name.s= (char*)shm_malloc(event->name.len* sizeof(char));

+		if(ev->name.s== NULL)

+		{

+			ERR_MEM("add_events");

+		}

+		memcpy(ev->name.s, event->name.s, event->name.len);

+		ev->name.len= event->name.len;

-	if(event->param)

-	{	

-		ev->param= (str*)((char*)ev+ size);

-		size+= sizeof(str);

-		ev->param->s= (char*)ev+ size;

-		memcpy(ev->param->s, event->param->s, event->param->len);

-		ev->param->len= event->param->len;

-		size+= event->param->len;

-	

-		ev->stored_name.s= (char*)ev+ size;

-		memcpy(ev->stored_name.s, event->name.s, event->name.len);

-		ev->stored_name.len= event->name.len;

-		memcpy(ev->stored_name.s+ ev->stored_name.len, ";", 1);

-		ev->stored_name.len+= 1;

-		memcpy(ev->stored_name.s+ ev->stored_name.len, event->param->s, event->param->len);

-		ev->stored_name.len+= event->param->len;

-		size+= ev->stored_name.len;

+		ev->evp= shm_copy_event(&parsed_event);

+		if(ev->evp== NULL)

+		{

+			LOG(L_ERR, "PRESENCE:add_event:ERROR copying event_t structure\n");

+			goto error;

+		}

 	}

 	else

 	{

-		ev->stored_name.s= ev->name.s;

-		ev->stored_name.len= ev->name.len;

-	}	

+		if(ev->content_type.s)

+		{

+			DBG("PRESENCE: add_event: Event already registered\n");

+			return 0;

+		}

+	}

-	ev->content_type.s= (char*)ev+ size;

+	ev->content_type.s=(char*)shm_malloc(event->content_type.len* sizeof(char)) ;

+	if(ev->content_type.s== NULL)

+	{

+		ERR_MEM("add_event");

+	}	

 	ev->content_type.len= event->content_type.len;

 	memcpy(ev->content_type.s, event->content_type.s, event->content_type.len);

-	size+= ev->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, ev->param );

+		ev->wipeer= contains_event(&wipeer_name, NULL);

 	}

 	else

 	{	

@@ -129,7 +189,7 @@ int add_event(ev_t* event)

 		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, ev->param);

+		ev->wipeer= contains_event(&wipeer_name, NULL);

 	}

 	if(ev->wipeer)	

@@ -144,15 +204,36 @@ int add_event(ev_t* event)

 	ev->free_body= event->free_body;

 	ev->default_expires= event->default_expires;

-	ev->next= EvList->events;

-	EvList->events= ev;

+	if(not_in_list)

+	{

+		ev->next= EvList->events;

+		EvList->events= ev;

+	}

 	EvList->ev_count++;

-

-	DBG("PRESENCE: add_event: succesfully added event: %.*s - len= %d\n", 

-			ev->stored_name.len, ev->stored_name.s, ev->stored_name.len);

-done:

-	return ret_code; 

+	DBG("PRESENCE: add_event: 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;

+}

+

+void free_pres_event(pres_ev_t* ev)

+{

+	if(ev== NULL)

+		return;

+

+	if(ev->name.s)

+		shm_free(ev->name.s);

+	if(ev->content_type.s)

+		shm_free(ev->content_type.s);

+	shm_free_event(ev->evp);

+	shm_free(ev);

+

 }

 evlist_t* init_evlist()

@@ -171,52 +252,74 @@ evlist_t* init_evlist()

 	return list;

 }	

-ev_t* contains_event(str* name, str* param)

+pres_ev_t* contains_event(str* sname, event_t* parsed_event)

 {

-	ev_t* event;

-	event= EvList->events;

+	event_t event;

+	pres_ev_t* e;

-	while(event)

+	if(event_parser(sname->s, sname->len, &event)< 0)

 	{

-		if(event->name.len== name->len &&

-				strncmp(event->name.s, name->s, name->len)== 0)

-		{

-			// verify if there is a restrictive params and if it equals the given one

-			if(!event->param)

-				return event;

-			

-			if(!param)

-				return NULL;

-

-			if(event->param->len== param->len &&

-					strncmp(event->param->s, param->s, param->len)== 0)

-				return event;

+		LOG(L_ERR, "PRESENCE:contains_event: ERROR parsing event\n");

+		return NULL;

+	}

+	if(parsed_event)

+		*parsed_event= event;

-		}

-		

-		event= event->next;

-	}	

+	e= search_event(&event);

-	return NULL;	

+	return e;

 }

+	

-ev_t* get_sname_event(str* stored_name)

+pres_ev_t* search_event(event_t* event)

 {

-	ev_t* event;

-	event= EvList->events;

+	pres_ev_t* pres_ev;

+	pres_ev= EvList->events;

+	param_t* ps, *p;

+	int found;

-	while(event)

+	DBG("PRESENCE:search_event...\n");

+	while(pres_ev)

 	{

-		if(stored_name->len== event->stored_name.len && 

-			strncmp(stored_name->s,event->stored_name.s,stored_name->len)==0)

-			return event;

-		event= event->next;

+		if(pres_ev->evp->parsed== event->parsed)

+		{

+			if(event->params== NULL)

+				return pres_ev;

+	

+			/* search all parameters in event in ev */

+			ps= event->params;

+			while(ps)

+			{

+				p= pres_ev->evp->params;

+				found= 0;

+				while(p)

+				{

+					if(p->name.len== ps->name.len && 

+					strncmp(p->name.s,ps->name.s, ps->name.len)== 0)

+						if((p->body.s== 0 && ps->body.s== 0) ||

+						(p->body.len== ps->body.len && 

+						 strncmp(p->body.s,ps->body.s,ps->body.len)== 0))

+						{

+							found= 1;

+							break;

+						}

+					p= p->next;

+				}

+				if(found== 0)

+					return NULL;

+				ps= ps->next;

+			}

+			return pres_ev;

+		}

+		pres_ev= pres_ev->next;

 	}

 	return NULL;

+

 }

+

 int get_event_list(str** ev_list)

 {	

-	ev_t* ev= EvList->events;

+	pres_ev_t* ev= EvList->events;

 	int i;

 	str* list;

 	*ev_list= NULL;

@@ -247,8 +350,8 @@ int get_event_list(str** ev_list)

 			memcpy(list->s+ list->len, ", ", 2);

 			list->len+= 2;

 		}	

-		memcpy(list->s+ list->len, ev->stored_name.s, ev->stored_name.len );

-		list->len+= ev->stored_name.len ;

+		memcpy(list->s+ list->len, ev->name.s, ev->name.len );

+		list->len+= ev->name.len ;

 		ev= ev->next;

 	}

@@ -258,14 +361,14 @@ int get_event_list(str** ev_list)

 void destroy_evlist()

 {

-    ev_t* e1, *e2;

+    pres_ev_t* e1, *e2;

     if (EvList) 

 	{

 		e1= EvList->events;

 		while(e1)

 	    {

 			e2= e1->next;

-			shm_free(e1);

+			free_pres_event(e1);

 			e1= e2;

 	    }	

 		shm_free(EvList);

@@ -30,6 +30,7 @@

 #define  _PRES_EV_LST_H

 #include "../../parser/msg_parser.h"

+#include "../../parser/parse_event.h"

 #include "../../str.h"

 #include "subscribe.h"

@@ -61,12 +62,10 @@ typedef int (is_allowed_t)(struct subscription* subs);

 /* event specific body free function */

 typedef void(free_body_t)(char* body);

-struct ev

+struct pres_ev

 {

 	str name;

-	str* param;         // required param 

-	/* to do: transform it in a list ( for multimple param)*/

-	str stored_name;

+	event_t* evp;

 	str content_type;

 	int default_expires;

 	int type;

@@ -94,31 +93,27 @@ struct ev

 	publ_handling_t  * evs_publ_handl;

 	subs_handling_t  * evs_subs_handl;

 	free_body_t* free_body;

-	struct ev* wipeer;			

-	struct ev* next;

+	struct pres_ev* wipeer;			

+	struct pres_ev* next;

 };

-typedef struct ev ev_t;

+typedef struct pres_ev pres_ev_t;

 typedef struct evlist

 {

 	int ev_count;

-	ev_t* events;

+	pres_ev_t* events;

 }evlist_t;	

 evlist_t* init_evlist();

-int add_event(ev_t* event);

+int add_event(pres_ev_t* event);

-typedef int (*add_event_t)(ev_t* event);

+typedef int (*add_event_t)(pres_ev_t* event);

-ev_t* contains_event(str* name, str* param);

+pres_ev_t* contains_event(str* name, event_t* parsed_event);

-typedef ev_t* (*contains_event_t) (str* name, str* param);

-

-ev_t* get_sname_event(str* stored_name);

-

-typedef ev_t* (*get_sname_event_t)(str* stored_name);

+typedef pres_ev_t* (*contains_event_t)(str* name, event_t* parsed_event);

 int get_event_list(str** ev_list);

@@ -128,4 +123,13 @@ void destroy_evlist();

 extern evlist_t* EvList;

+pres_ev_t* search_event(event_t* event);

+

+event_t* shm_copy_event(event_t* e);

+

+void shm_free_event(event_t* ev);

+

+void free_pres_event(pres_ev_t* ev);

+

+

 #endif

@@ -38,8 +38,9 @@

 #include "../../str.h"

 #include "../../db/db.h"

 #include "../../db/db_val.h"

-#include "../tm/tm_load.h"

 #include "../../socket_info.h"

+#include "../tm/tm_load.h"

+#include "../pua/hash.h"

 #include "presentity.h"

 #include "presence.h"

 #include "notify.h"

@@ -49,38 +50,47 @@

 #define MAX_FORWARD 70

 extern struct tm_binds tmb;

-c_back_param* shm_dup_subs(subs_t* subs, str to_tag);

+c_back_param* shm_dup_cbparam(subs_t* , subs_t*);

+void free_cbparam(c_back_param* cb_param);

 void p_tm_callback( struct cell *t, int type, struct tmcb_params *ps);

+char* get_status_str(int status_flag)

+{

+	switch(status_flag)

+	{

+		case ACTIVE_STATUS: return "active";

+		case PENDING_STATUS: return "pending";

+		case TERMINATED_STATUS: return "terminated";

+	}

+	return NULL;

+}

+

 void printf_subs(subs_t* subs)

 {	

-	DBG("\n\tpres_user= %.*s - len: %d\tpres_domain= %.*s - len: %d", 

-			subs->pres_user.len,  subs->pres_user.s, subs->pres_user.len,

-			subs->pres_domain.len,  subs->pres_domain.s, subs->pres_domain.len);

-	DBG("\n\t[p_user]= %.*s  [p_domain]= %.*s\n\t[w_user]= %.*s "  

-			"[w_domain]= %.*s\n",

-			subs->to_user.len, subs->to_user.s, subs->to_domain.len,

-			subs->to_domain.s,

-			subs->from_user.len, subs->from_user.s, subs->from_domain.len,

-			subs->from_domain.s);

-	DBG("[event]= %.*s\n\t[status]= %.*s\n\t[expires]= %d\n",

-			subs->event->stored_name.len, subs->event->stored_name.s,	subs->status.len, subs->status.s,

-			subs->expires );

-	DBG("[to_tag]= %.*s\n\t[from_tag]= %.*s\n",

-			subs->to_tag.len, subs->to_tag.s,	subs->from_tag.len, subs->from_tag.s);

-	DBG("[contact]= %.*s\n",

-			subs->contact.len, subs->contact.s);

+	DBG("\t[pres_uri]= %.*s - len: %d", 

+		subs->pres_uri.len,  subs->pres_uri.s, subs->pres_uri.len);

+	DBG("\n\t[to_user]= %.*s\t[to_domain]= %.*s\n\t[w_user]= %.*s"

+		"\t[w_domain]= %.*s",subs->to_user.len,subs->to_user.s, 

+		subs->to_domain.len,subs->to_domain.s,subs->from_user.len,

+		subs->from_user.s, subs->from_domain.len,subs->from_domain.s);

+	DBG("\n\t[event]= %.*s\n\t[status]= %s\n\t[expires]= %u",

+		subs->event->name.len, subs->event->name.s,	

+		get_status_str(subs->status), subs->expires );

+	DBG("\n\t[to_tag]= %.*s\n\t[from_tag]= %.*s",subs->to_tag.len, 

+		subs->to_tag.s,	subs->from_tag.len, subs->from_tag.s);

+	DBG("\n\t[contact]= %.*s\n",subs->contact.len, subs->contact.s);

 }

-str* create_winfo_xml(watcher_t* watchers,int n, char* version,char* resource, int STATE_FLAG );

+str* create_winfo_xml(watcher_t* watchers, char* version,str resource, int STATE_FLAG );

 int build_str_hdr(subs_t* subs, int is_body, str** hdr)

 {

 	str* str_hdr = NULL;	

 	char* subs_expires = NULL;

 	int len = 0;

-	ev_t* event= subs->event;

+	pres_ev_t* event= subs->event;

 	int expires_t;

+	char* status= NULL;

 	str_hdr =(str*)pkg_malloc(sizeof(str));

 	if(str_hdr== NULL)

@@ -114,9 +124,9 @@ int build_str_hdr(subs_t* subs, int is_body, str** hdr)

 	strncpy(str_hdr->s+str_hdr->len  ,"Event: ", 7);

 	str_hdr->len+= 7;

-	strncpy(str_hdr->s+str_hdr->len, event->stored_name.s, event->stored_name.len);

-	str_hdr->len+= event->stored_name.len;

-	if (subs->event_id.len) 

+	strncpy(str_hdr->s+str_hdr->len, event->name.s, event->name.len);

+	str_hdr->len+= event->name.len;

+	if(subs->event_id.len && subs->event_id.s) 

 	{

  		strncpy(str_hdr->s+str_hdr->len, ";id=", 4);

  		str_hdr->len += 4;

@@ -126,7 +136,6 @@ int build_str_hdr(subs_t* subs, int is_body, str** hdr)

 	strncpy(str_hdr->s+str_hdr->len, CRLF, CRLF_LEN);

 	str_hdr->len += CRLF_LEN;

-

 	strncpy(str_hdr->s+str_hdr->len ,"Contact: <", 10);

 	str_hdr->len += 10;

 	strncpy(str_hdr->s+str_hdr->len, subs->local_contact.s, subs->local_contact.len);

@@ -135,15 +144,34 @@ int build_str_hdr(subs_t* subs, int is_body, str** hdr)

 	str_hdr->len += 1;

 	strncpy(str_hdr->s+str_hdr->len, CRLF, CRLF_LEN);

 	str_hdr->len += CRLF_LEN;

-

-	if(strncmp(subs->status.s, "terminated",10) == 0)

+	

+	strncpy(str_hdr->s+str_hdr->len,"Subscription-State: ", 20);

+	str_hdr->len+= 20;

+	status= get_status_str(subs->status);

+	if(status== NULL)

+	{

+		LOG(L_ERR,"PRESENCE: build_str_hdr: ERROR bad status flag= %d\n",

+				subs->status);

+		pkg_free(str_hdr->s);

+		pkg_free(str_hdr);

+		return -1;

+	}

+	strcpy(str_hdr->s+str_hdr->len, status);

+	str_hdr->len+= strlen(status);

+	

+	if(subs->expires <= 0)

+	{

+		expires_t = 0;

+		subs->status= TERMINATED_STATUS;

+		subs->reason.s= "timeout";

+		subs->reason.len= 7;

+	}

+	else

+		expires_t= subs->expires;

+	

+	if(subs->status== TERMINATED_STATUS)

 	{

 		DBG( "PRESENCE: build_str_hdr: state = terminated \n");

-

-		strncpy(str_hdr->s+str_hdr->len,"Subscription-State: ", 20);

-		str_hdr->len+= 20;

-		strncpy(str_hdr->s+str_hdr->len, subs->status.s ,subs->status.len );

-		str_hdr->len+= subs->status.len;

 		strncpy(str_hdr->s+str_hdr->len,";reason=", 8);

 		str_hdr->len+= 8;

@@ -151,22 +179,12 @@ int build_str_hdr(subs_t* subs, int is_body, str** hdr)

 		str_hdr->len+= subs->reason.len;

 		strncpy(str_hdr->s+str_hdr->len, CRLF, CRLF_LEN);

 		str_hdr->len+= CRLF_LEN;

-

 	}

 	else

 	{	

-		strncpy(str_hdr->s+str_hdr->len,"Subscription-State: ", 20);

-		str_hdr->len += 20;

-		strncpy(str_hdr->s+str_hdr->len, subs->status.s ,subs->status.len );

-		str_hdr->len += subs->status.len;

 		strncpy(str_hdr->s+str_hdr->len,";expires=", 9);

 		str_hdr->len+= 9;

-		if(subs->expires < 0)

-			expires_t = 0;

-		else

-			expires_t= subs->expires;

-

 		subs_expires= int2str(expires_t, &len); 

 		if(subs_expires == NULL || len == 0)

@@ -196,7 +214,14 @@ int build_str_hdr(subs_t* subs, int is_body, str** hdr)

 			str_hdr->len += CRLF_LEN;

 		}

 	}

+	if(str_hdr->len> ALLOC_SIZE)

+	{

+		LOG(L_ERR, "PRESENCE:build_str_hdr:ERROR buffer size overflown\n");

+		pkg_free(str_hdr->s);

+		pkg_free(str_hdr);

+		return -1;

+	}

 	str_hdr->s[str_hdr->len] = '\0';

 	*hdr= str_hdr;

@@ -204,8 +229,9 @@ int build_str_hdr(subs_t* subs, int is_body, str** hdr)

 }

-str* get_wi_notify_body(subs_t* subs, subs_t* watcher_subs)

-{

+int get_wi_subs_db(subs_t* subs, watcher_t** watchers)

+{	

+	watcher_t *w;

 	db_key_t query_cols[6];

 	db_op_t  query_ops[6];

 	db_val_t query_vals[6];

@@ -213,209 +239,293 @@ str* get_wi_notify_body(subs_t* subs, subs_t* watcher_subs)

 	db_res_t *result = NULL;

 	db_row_t *row = NULL ;	

 	db_val_t *row_vals = NULL;

-	str* notify_body = NULL;

-	str p_uri;

-	char* version_str;

-	watcher_t *watchers = NULL;

-	watcher_t swatchers;

 	int n_result_cols = 0;

 	int n_query_cols = 0;

-	int i , len = 0;

+	int i;

 	int status_col, expires_col, from_user_col, from_domain_col;

-	

-	uandd_to_uri(subs->to_user, subs->to_domain, &p_uri);

-	if(p_uri.s == NULL)

-	{

-		LOG(L_ERR,"PRESENCE:get_wi_notify_body: ERROR while creating uri\n");

-		return NULL;

-	}

-

-	memset(&swatchers, 0, sizeof(watcher_t));

-	version_str = int2str(subs->version, &len);

-

-	if(version_str ==NULL)

-	{

-		LOG(L_ERR,"PRESENCE:get_wi_notify_body: ERROR while converting int"

-				" to str\n ");

-		goto error;

-	}

-

-	if(watcher_subs != NULL) /*no need to query data base */

-	{

-		

-		swatchers.status= watcher_subs->status;

-		uandd_to_uri( watcher_subs->from_user,watcher_subs->from_domain,

-						&swatchers.uri);

-		if(swatchers.uri.s== NULL)

-			goto error;

-

-		swatchers.id.s = (char *)pkg_malloc(swatchers.uri.len *2 +1);

-		if(swatchers.id.s==0)

-		{

-			LOG(L_ERR,"PRESENCE:get_wi_notify_body: ERROR no more pkg mem\n");

-			pkg_free(swatchers.uri.s);

-			goto error;

-		}

-		to64frombits((unsigned char *)swatchers.id.s,

-				(const unsigned char*) swatchers.uri.s, swatchers.uri.len );

-			

-		swatchers.id.len = strlen(swatchers.id.s);

-		

-		swatchers.event= watcher_subs->event->stored_name;

-		

-		notify_body = create_winfo_xml(&swatchers, 1, version_str,p_uri.s,

-				PARTIAL_STATE_FLAG );

-

-		if(swatchers.uri.s !=NULL)