@@ -107,7 +107,7 @@ int pua_add_events()

 }	

-int pres_process_body(publ_info_t* publ, str** fin_body, int ver, str* tuple)

+int pres_process_body(publ_info_t* publ, str** fin_body, int ver, str** tuple_param)

 {

 	xmlDocPtr doc= NULL;

@@ -117,8 +117,8 @@ int pres_process_body(publ_info_t* publ, str** fin_body, int ver, str* tuple)

 	char buf[50];

 	str* body= NULL;

 	int alloc_tuple= 0;

+	str* tuple= NULL;

-	tuple= NULL;

 	doc= xmlParseMemory(publ->body->s, publ->body->len );

 	if(doc== NULL)

 	{

@@ -135,6 +135,8 @@ int pres_process_body(publ_info_t* publ, str** fin_body, int ver, str* tuple)

 	tuple_id= xmlNodeGetAttrContentByName(node, "id");

 	if(tuple_id== NULL)

 	{

+		tuple= *(tuple_param);

+

 		if(tuple== NULL)	// generate a tuple_id

 		{

 			tuple_id= buf;

@@ -155,7 +157,12 @@ int pres_process_body(publ_info_t* publ, str** fin_body, int ver, str* tuple)

 			}

 			memcpy(tuple->s, tuple_id, tuple_id_len);

 			tuple->len= tuple_id_len;

+

+			*tuple_param= tuple;

 			alloc_tuple= 1;

+

+			DBG("PUA: pres_process_body: allocated tuple_id\n\n");

+

 		}

 		else

 		{

@@ -256,7 +263,7 @@ error:

 }	

-int bla_process_body(publ_info_t* publ, str** fin_body, int ver, str* tuple)

+int bla_process_body(publ_info_t* publ, str** fin_body, int ver, str** tuple)

 {

 	xmlNodePtr node= NULL;

 	xmlDocPtr doc= NULL;

@@ -320,7 +327,7 @@ error:

 	return -1;

 }

-int mwi_process_body(publ_info_t* publ, str** fin_body, int ver, str* tuple)

+int mwi_process_body(publ_info_t* publ, str** fin_body, int ver, str** tuple)

 {

 	*fin_body= publ->body;

 	return 0;

@@ -35,8 +35,8 @@

  * */

 int pua_add_events();

-int pres_process_body(struct publ_info* publ, str** fin_body, int ver, str* tuple);

-int bla_process_body (struct publ_info* publ, str** fin_body, int ver, str* tuple);

-int mwi_process_body (struct publ_info* publ, str** fin_body, int ver, str* tuple);

+int pres_process_body(struct publ_info* publ, str** fin_body, int ver, str** tuple);

+int bla_process_body (struct publ_info* publ, str** fin_body, int ver, str** tuple);

+int mwi_process_body (struct publ_info* publ, str** fin_body, int ver, str** tuple);

 #endif

@@ -33,7 +33,7 @@

 struct publ_info;

 typedef int (evs_process_body_t)(struct publ_info* , str** final_body, 

-		 int ver, str* tuple);

+		 int ver, str** tuple);

 typedef struct pua_event

 {

@@ -35,7 +35,19 @@

 #include "pua.h"

 #include "send_publish.h"

-

+void print_ua_pres(ua_pres_t* p)

+{

+	DBG("PUA:print_ua_pres: \n");

+	DBG("\tpres_uri= %.*s   len= %d\n", p->pres_uri->len, p->pres_uri->s, p->pres_uri->len);

+	if(p->watcher_uri)

+	{	

+		DBG("\twatcher_uri= %.*s  len= %d\n", p->watcher_uri->len, p->watcher_uri->s, p->watcher_uri->len);

+		DBG("\tcall_id= %.*s   len= %d\n", p->call_id.len, p->call_id.s, p->call_id.len);

+	}	

+	else

+		DBG("\tetag= %.*s - len= %d\n", p->etag.len, p->etag.s, p->etag.len);

+	DBG("\texpires= %ld\n", p->expires- (int)time(NULL));

+}	

 htable_t* new_htable()

 {

 	htable_t* H= NULL;

@@ -182,8 +194,8 @@ void update_htable(ua_pres_t* presentity,time_t desired_expires,

 	p->expires= expires+ (int)time(NULL);

 	p->desired_expires= desired_expires;

-	if(p->db_flag& NO_UPDATEDB_FLAG)

-		p->db_flag= UPDATEDB_FLAG;

+		

+	p->db_flag= UPDATEDB_FLAG;

 	if(p->watcher_uri)

 		p->cseq ++;

@@ -107,6 +107,9 @@ void destroy_htable();

 int is_dialog(ua_pres_t* dialog);

 ua_pres_t* get_dialog(ua_pres_t* dialog, unsigned int hash_code);

+/* for degug */

+void print_ua_pres(ua_pres_t* p);

+

 typedef int  (*query_dialog_t)(ua_pres_t* presentity);

 static inline int get_event_flag(str* event)

@@ -365,11 +365,10 @@ int db_restore()

 		row = &res->rows[i];

 		row_vals = ROW_VALUES(row);

-		pres_uri.s= row_vals[0].val.str_val.s;

+		pres_uri.s= (char*)row_vals[puri_col].val.string_val;

 		pres_uri.len = strlen(pres_uri.s);

-

-		pres_id.s= row_vals[1].val.str_val.s;

-		pres_id.len = strlen(pres_id.s);

+		

+		DBG("PUA: db_restore: pres_uri= %.*s\n", pres_uri.len, pres_uri.s);

 		memset(&etag,			 0, sizeof(str));

 		memset(&tuple_id,		 0, sizeof(str));

@@ -378,43 +377,49 @@ int db_restore()

 		memset(&to_tag,			 0, sizeof(str));

 		memset(&from_tag,		 0, sizeof(str));

 		memset(&record_route,	 0, sizeof(str));

+		memset(&pres_id,         0, sizeof(str));

-		if(row_vals[etag_col].val.str_val.s)

+		pres_id.s= (char*)row_vals[pid_col].val.string_val;

+		if(pres_id.s)

+			pres_id.len = strlen(pres_id.s);

+

+		if(row_vals[etag_col].val.string_val)

 		{

-			etag.s= row_vals[etag_col].val.str_val.s;

+			etag.s= (char*)row_vals[etag_col].val.string_val;

 			etag.len = strlen(etag.s);

-			tuple_id.s= row_vals[tuple_col].val.str_val.s;

+			tuple_id.s= (char*)row_vals[tuple_col].val.string_val;

 			tuple_id.len = strlen(tuple_id.s);

 		}

-		if(row_vals[watcher_col].val.str_val.s)

+		if(row_vals[watcher_col].val.string_val)

 		{	

-			watcher_uri.s= row_vals[watcher_col].val.str_val.s;

+			watcher_uri.s= (char*)row_vals[watcher_col].val.string_val;

 			watcher_uri.len = strlen(watcher_uri.s);

-			call_id.s= row_vals[callid_col].val.str_val.s;

+			call_id.s= (char*)row_vals[callid_col].val.string_val;

 			call_id.len = strlen(call_id.s);

-			to_tag.s= row_vals[totag_col].val.str_val.s;

+			to_tag.s= (char*)row_vals[totag_col].val.string_val;

 			to_tag.len = strlen(to_tag.s);

-			from_tag.s= row_vals[fromtag_col].val.str_val.s;

+			from_tag.s= (char*)row_vals[fromtag_col].val.string_val;

 			from_tag.len = strlen(from_tag.s);

-			if(row_vals[record_route_col].val.str_val.s)

+			if(row_vals[record_route_col].val.string_val)

 			{

-				record_route.s= row_vals[record_route_col].val.str_val.s;

+				record_route.s= (char*)row_vals[record_route_col].val.string_val;

 				record_route.len= strlen(record_route.s);

 			}	

 		}

-		size= sizeof(ua_pres_t)+ sizeof(str)+ pres_uri.len+ pres_id.len;

-		if(etag.len)

-			size+= etag.len+ tuple_id.len;

-		else

+		size= sizeof(ua_pres_t)+ sizeof(str)+ pres_uri.len+ pres_id.len+

+					tuple_id.len;

+		

+		if(watcher_uri.s)

 			size+= sizeof(str)+ watcher_uri.len+ call_id.len+ to_tag.len+

 				from_tag.len+ record_route.len;

+		

 		p= (ua_pres_t*)shm_malloc(size);

 		if(p== NULL)

 		{

@@ -430,30 +435,24 @@ int db_restore()

 		memcpy(p->pres_uri->s, pres_uri.s, pres_uri.len);

 		p->pres_uri->len= pres_uri.len;

 		size+= pres_uri.len;

-

-		p->id.s= (char*)p + size;

-		memcpy(p->id.s, pres_id.s, pres_id.len);

-		p->id.len= pres_id.len;

-		size+= pres_id.len;

-

-		p->expires= row_vals[expires_col].val.int_val;

-		p->flag|=	row_vals[flag_col].val.int_val;

-		p->db_flag|= INSERTDB_FLAG;

-

-		if(etag.len)

+		

+		if(pres_id.s)

+		{	

+			p->id.s= (char*)p + size;

+			memcpy(p->id.s, pres_id.s, pres_id.len);

+			p->id.len= pres_id.len;

+			size+= pres_id.len;

+		}

+		if(tuple_id.s && tuple_id.len)

 		{

-			p->etag.s= (char*)p+ size;

-			memcpy(p->etag.s, etag.s, etag.len);

-			p->etag.len= etag.len;

-			size+= etag.len;

-			

 			p->tuple_id.s= (char*)p + size;

 			memcpy(p->tuple_id.s, tuple_id.s, tuple_id.len);

 			p->tuple_id.len= tuple_id.len;

 			size+= tuple_id.len;

-		}

-		else

-		{

+		}	

+

+		if(watcher_uri.s && watcher_uri.len)

+		{	

 			p->watcher_uri= (str*)((char*)p+ size);

 			size+= sizeof(str);

@@ -486,10 +485,30 @@ int db_restore()

 			}	

 			p->cseq= row_vals[cseq_col].val.int_val;

 		}

+		

 		p->event= row_vals[event_col].val.int_val;

+		p->expires= row_vals[expires_col].val.int_val;

+		p->flag|=	row_vals[flag_col].val.int_val;

+		p->db_flag|= INSERTDB_FLAG;

+		memset(&p->etag, 0, sizeof(str));

+		if(etag.s && etag.len)

+		{

+			/* alloc separately */

+			p->etag.s= (char*)shm_malloc(etag.len* sizeof(char));

+			if(p->etag.s==  NULL)

+			{

+				LOG(L_ERR, "pua:db_restore:ERROR while aloocating memory\n");

+				goto error;

+			}	

+			memcpy(p->etag.s, etag.s, etag.len);

+			p->etag.len= etag.len;

+		}

+

+		print_ua_pres(p);

 		insert_htable(p);

 	}

+

 	if(res)

 	{

 		pua_dbf.free_result(pua_db, res);

@@ -527,6 +546,7 @@ void hashT_clean(unsigned int ticks,void *param)

 		p= HashT->p_records[i].entity->next;

 		while(p)

 		{	

+			print_ua_pres(p);

 			if(p->expires- update_period < now )

 			{

 				if((p->desired_expires> p->expires + min_expires) || 

@@ -589,7 +609,7 @@ int update_pua(ua_pres_t* p, unsigned int hash_code)

 			LOG(L_ERR, "PUA: update_pua: ERROR while constructing publ callback param\n");

 			goto error;

 		}	

-		result= tmb.t_request(&met,						/* Type of the message */

+		result= tmb.t_request(&met,				/* Type of the message */

 				p->pres_uri,					/* Request-URI */

 				p->pres_uri,					/* To */

 				p->pres_uri,					/* From */

@@ -843,7 +863,7 @@ void db_update(unsigned int ticks,void *param)

 						}

 						pua_dbf.free_result(pua_db, res);

 						res= NULL;

-

+						break;		

 					}

 					else

 					{

@@ -854,8 +874,8 @@ void db_update(unsigned int ticks,void *param)

 						}

 						DBG("PUA:db_update: UPDATEDB_FLAG and no record"

 								" found\n");

+						p->db_flag= INSERTDB_FLAG;

 					}	

-					break;		

 				}

 				case INSERTDB_FLAG:

@@ -902,7 +922,7 @@ void db_update(unsigned int ticks,void *param)

 			lock_release(&HashT->p_records[i].lock);	

 	}

-	db_vals[0].val.int_val= (int)time(NULL);

+	db_vals[0].val.int_val= (int)time(NULL)- 10;

 	db_ops[0]= OP_LT;

 	if(pua_dbf.delete(pua_db, db_cols, db_ops, db_vals, 1) < 0)

 	{

@@ -920,21 +940,20 @@ treq_cbparam_t* build_uppubl_cbparam(ua_pres_t* pres)

 	treq_cbparam_t* cb_param= NULL;

 	size= sizeof(treq_cbparam_t)+ sizeof(str)*2+ (pres->pres_uri->len+ 

-		+ pres->content_type.len+ pres->id.len+ pres->etag.len+

-		pres->tuple_id.len+ 1)*sizeof(char); 

+		+ pres->id.len+ pres->etag.len+ pres->tuple_id.len)*sizeof(char); 

-	DBG("PUA: send_publish: before allocating size= %d\n", size);

+	DBG("PUA: build_uppubl_cbparam: before allocating size= %d\n", size);

 	cb_param= (treq_cbparam_t*)shm_malloc(size);

 	if(cb_param== NULL)

 	{

-		LOG(L_ERR, "PUA: send_publish: ERROR no more share memory while"

+		LOG(L_ERR, "PUA: build_uppubl_cbparam: ERROR no more share memory while"

 				" allocating cb_param - size= %d\n", size);

 		return NULL;

 	}

 	memset(cb_param, 0, size);

 	memset(&cb_param->publ, 0, sizeof(publ_info_t));

 	size =  sizeof(treq_cbparam_t);

-	DBG("PUA: send_publish: size= %d\n", size);

+	DBG("PUA: build_uppubl_cbparam: size= %d\n", size);

 	cb_param->publ.pres_uri = (str*)((char*)cb_param + size);

 	size+= sizeof(str);

@@ -966,7 +985,7 @@ treq_cbparam_t* build_uppubl_cbparam(ua_pres_t* pres)

 	cb_param->tuple_id.len= pres->tuple_id.len;

 	size+= pres->tuple_id.len;

-	DBG("PUA:send_publish: after allocating: size= %d\n", size);

+	DBG("PUA:build_uppubl_cbparam: after allocating: size= %d\n", size);

 	cb_param->publ.event= pres->event;

 	cb_param->publ.source_flag|= pres->flag;

 	cb_param->publ.expires= pres->expires;

@@ -979,14 +998,8 @@ ua_pres_t* build_upsubs_cbparam(ua_pres_t* p)

 	ua_pres_t* hentity;

 	int size;

-	size= sizeof(ua_pres_t)+ sizeof(str)+ (p->pres_uri->len+ 1)*sizeof(char);

+	size= sizeof(ua_pres_t)+ sizeof(str)*2+ (p->pres_uri->len+ p->watcher_uri->len)*sizeof(char);

-	if(p->watcher_uri)

-		size+= sizeof(str)+ p->watcher_uri->len*sizeof(char);

-	else

-	if(p->id.s && p->id.len)

-		size+=  p->id.len*sizeof(char);

-

 	hentity= (ua_pres_t*)shm_malloc(size);

 	if(hentity== NULL)

 	{

@@ -1006,23 +1019,13 @@ ua_pres_t* build_upsubs_cbparam(ua_pres_t* p)

 	hentity->pres_uri->len= p->pres_uri->len;

 	size+= p->pres_uri->len;

-	if(p->watcher_uri)

-	{

-		hentity->watcher_uri=(str*)((char*)hentity+ size);

-		size+= sizeof(str);

-		hentity->watcher_uri->s= (char*)hentity+ size;

-		memcpy(hentity->watcher_uri->s, p->watcher_uri->s,p->watcher_uri->len);

-		hentity->watcher_uri->len= p->watcher_uri->len;

-		size+= p->watcher_uri->len;

-	}	

-	else

-	if(p->id.s && p->id.len)

-	{	

-		hentity->id.s = ((char*)hentity+ size);

-		memcpy(hentity->id.s, p->id.s, p->id.len);

-		hentity->id.len= p->id.len;

-		size+= p->id.len;

-	}

+	hentity->watcher_uri=(str*)((char*)hentity+ size);

+	size+= sizeof(str);

+	hentity->watcher_uri->s= (char*)hentity+ size;

+	memcpy(hentity->watcher_uri->s, p->watcher_uri->s,p->watcher_uri->len);

+	hentity->watcher_uri->len= p->watcher_uri->len;

+	size+= p->watcher_uri->len;

+	

 	hentity->flag|= p->flag;

 	return hentity;

@@ -317,6 +317,8 @@ void publ_cback_func(struct cell *t, int type, struct tmcb_params *ps)

 		goto error;

 	}	

 	memset(presentity, 0, size);

+	memset(&presentity->etag, 0, sizeof(str));

+

 	size= sizeof(ua_pres_t);

 	presentity->pres_uri= (str*)((char*)presentity+ size);

 	size+= sizeof(str);

@@ -507,7 +509,7 @@ insert:

 	if(publ->body && publ->body->s)

 	{

-		ret_code= ev->process_body(publ, &body, ver, tuple_id);

+		ret_code= ev->process_body(publ, &body, ver, &tuple_id );

 		if( ret_code< 0 || body== NULL)

 		{

 			LOG(L_ERR, "PUA:send_publish: ERROR while processing body\n");

@@ -516,6 +518,9 @@ insert:

 			goto error;

 		}

 	}

+	if(tuple_id)

+		DBG("\n\nPUA:send_publish: tuple_id= %.*s\n\n", tuple_id->len, tuple_id->s  );

+	

 	/* construct the callback parameter */

 	size= sizeof(treq_cbparam_t)+ sizeof(str)+ (publ->pres_uri->len+ 

@@ -58,7 +58,7 @@ typedef struct treq_cbparam

 typedef int (*send_publish_t)(publ_info_t* publ);

 int send_publish( publ_info_t* publ );

-void print_ua_pres(ua_pres_t* p);

+

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

 str* publ_build_hdr(int expires, pua_event_t* event, str* content_type, str* etag,

 		str* extra_headers, int is_body);