自学教程：C++ ERR_MEM函数代码示例

event_t *shm_copy_event(event_t *e){	event_t *ev = NULL;	param_t *p1, *p2;	int size;	ev = (event_t *)shm_malloc(sizeof(event_t));	if(ev == NULL) {		ERR_MEM(SHARE_MEM);	}	memset(ev, 0, sizeof(event_t));	ev->name.s = (char *)shm_malloc(e->name.len * sizeof(char));	if(ev->name.s == NULL) {		ERR_MEM(SHARE_MEM);	}	memcpy(ev->name.s, e->name.s, e->name.len);	ev->name.len = e->name.len;	p1 = e->params.list;	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(SHARE_MEM);		}		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.list;		ev->params.list = p2;		/* Update parameter hooks in the shmmem copy, this is needed so that		 * we can test for the presence of the sla parameter even in the		 * shared copy of the event */		if(e->params.hooks.event_dialog.call_id == p1)			ev->params.hooks.event_dialog.call_id = p2;		if(e->params.hooks.event_dialog.from_tag == p1)			ev->params.hooks.event_dialog.from_tag = p2;		if(e->params.hooks.event_dialog.to_tag == p1)			ev->params.hooks.event_dialog.to_tag = p2;		if(e->params.hooks.event_dialog.include_session_description == p1)			ev->params.hooks.event_dialog.include_session_description = p2;		if(e->params.hooks.event_dialog.sla == p1)			ev->params.hooks.event_dialog.sla = p2;		p1 = p1->next;	}	ev->type = e->type;	return ev;error:	shm_free_event(ev);	return NULL;}

subs_t* mem_copy_subs_noc(subs_t* s){	int size;	subs_t* dest;	size= sizeof(subs_t)+ s->pres_uri.len+ s->to_user.len		+ s->to_domain.len+ s->from_user.len+ s->from_domain.len+ s->callid.len		+ s->to_tag.len+ s->from_tag.len+s->event_id.len		+ s->local_contact.len + s->record_route.len+		+ s->reason.len+ 1;	dest= (subs_t*)shm_malloc(size);	if(dest== NULL)	{		ERR_MEM(SHARE_MEM);	}	memset(dest, 0, size);	size= sizeof(subs_t);	CONT_COPY(dest, dest->pres_uri, s->pres_uri);	CONT_COPY(dest, dest->to_user, s->to_user);	CONT_COPY(dest, dest->to_domain, s->to_domain);	CONT_COPY(dest, dest->from_user, s->from_user);	CONT_COPY(dest, dest->from_domain, s->from_domain);	CONT_COPY(dest, dest->to_tag, s->to_tag);	CONT_COPY(dest, dest->from_tag, s->from_tag);	CONT_COPY(dest, dest->callid, s->callid);	CONT_COPY(dest, dest->local_contact, s->local_contact);	CONT_COPY(dest, dest->record_route, s->record_route);	if(s->event_id.s)		CONT_COPY(dest, dest->event_id, s->event_id);	if(s->reason.s)		CONT_COPY(dest, dest->reason, s->reason);	dest->event= s->event;	dest->local_cseq= s->local_cseq;	dest->remote_cseq= s->remote_cseq;	dest->status= s->status;	dest->version= s->version;	dest->expires= s->expires;	dest->db_flag= s->db_flag;	dest->sockinfo = s->sockinfo;	dest->contact.s= (char*)shm_malloc(s->contact.len);	if(dest->contact.s== NULL)	{		ERR_MEM(SHARE_MEM);	}	memcpy(dest->contact.s, s->contact.s, s->contact.len);	dest->contact.len= s->contact.len;	return dest;error:	if(dest)			shm_free(dest);	return NULL;}

int insert_phtable(str* pres_uri, int event, char* sphere){	unsigned int hash_code;	pres_entry_t* p= NULL;	int size;	hash_code= core_case_hash(pres_uri, NULL, phtable_size);	lock_get(&pres_htable[hash_code].lock);		p= search_phtable(pres_uri, event, hash_code);	if(p)	{		p->publ_count++;		lock_release(&pres_htable[hash_code].lock);		return 0;	}	size= sizeof(pres_entry_t)+ pres_uri->len* sizeof(char);	p= (pres_entry_t*)shm_malloc(size);	if(p== NULL)	{		lock_release(&pres_htable[hash_code].lock);		ERR_MEM(SHARE_MEM);	}	memset(p, 0, size);	size= sizeof(pres_entry_t);	p->pres_uri.s= (char*)p+ size;	memcpy(p->pres_uri.s, pres_uri->s, pres_uri->len);	p->pres_uri.len= pres_uri->len;		if(sphere)	{		p->sphere= (char*)shm_malloc((strlen(sphere)+ 1)*sizeof(char));		if(p->sphere== NULL)		{			lock_release(&pres_htable[hash_code].lock);			shm_free(p);			ERR_MEM(SHARE_MEM);		}		strcpy(p->sphere, sphere);	}	p->event= event;	p->publ_count=1;	/* link the item in the hash table */	p->next= pres_htable[hash_code].entries->next;	pres_htable[hash_code].entries->next= p;	lock_release(&pres_htable[hash_code].lock);		return 0;error:	return -1;}

event_t* shm_copy_event(event_t* e){	event_t* ev= NULL;	param_t* p1, *p2;	int size;	ev= (event_t*)shm_malloc(sizeof(event_t));	if(ev== NULL)	{		ERR_MEM(SHARE_MEM);	}	memset(ev, 0, sizeof(event_t));	ev->text.s= (char*)shm_malloc(e->text.len);	if(ev->text.s== NULL)	{		ERR_MEM(SHARE_MEM);	}	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;		p2= (param_t*)shm_malloc(size);		if(p2== NULL)		{			ERR_MEM(SHARE_MEM);		}		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;}

pres_entry_t* insert_phtable(str* pres_uri, int event, str* etag, char* sphere, int init_turn){	unsigned int hash_code;	pres_entry_t* p= NULL;	int size;	size= sizeof(pres_entry_t)+ pres_uri->len;	p= (pres_entry_t*)shm_malloc(size);	if(p== NULL)	{		ERR_MEM(SHARE_MEM);	}	memset(p, 0, size);	size= sizeof(pres_entry_t);	p->pres_uri.s= (char*)p+ size;	memcpy(p->pres_uri.s, pres_uri->s, pres_uri->len);	p->pres_uri.len= pres_uri->len;	if(sphere)	{		p->sphere= (char*)shm_malloc(strlen(sphere)+ 1);		if(p->sphere== NULL)		{			ERR_MEM(SHARE_MEM);		}		strcpy(p->sphere, sphere);	}	p->event= event;	update_pres_etag(p, etag);	hash_code= core_hash(pres_uri, NULL, phtable_size);	lock_get(&pres_htable[hash_code].lock);	p->next= pres_htable[hash_code].entries->next;	pres_htable[hash_code].entries->next= p;	p->last_turn = init_turn;	lock_release(&pres_htable[hash_code].lock);	return p;error:	if(p)		shm_free(p);	return NULL;}

subs_t* mem_copy_subs(subs_t* s, int mem_type){	int size;	subs_t* dest;	size= sizeof(subs_t)+ s->pres_uri.len+ s->to_user.len		+ s->to_domain.len+ s->from_user.len+ s->from_domain.len+ s->callid.len		+ s->to_tag.len+ s->from_tag.len+s->event_id.len		+ s->local_contact.len+ s->contact.len+ s->record_route.len+		+ s->reason.len+ 1;	if(mem_type == PKG_MEM_TYPE)		dest= (subs_t*)pkg_malloc(size);	else		dest= (subs_t*)shm_malloc(size);	if(dest== NULL)	{		ERR_MEM((mem_type==PKG_MEM_TYPE)?PKG_MEM_STR:SHARE_MEM);	}	memset(dest, 0, size);	size= sizeof(subs_t);	CONT_COPY(dest, dest->pres_uri, s->pres_uri);	CONT_COPY(dest, dest->to_user, s->to_user);	CONT_COPY(dest, dest->to_domain, s->to_domain);	CONT_COPY(dest, dest->from_user, s->from_user);	CONT_COPY(dest, dest->from_domain, s->from_domain);	CONT_COPY(dest, dest->to_tag, s->to_tag);	CONT_COPY(dest, dest->from_tag, s->from_tag);	CONT_COPY(dest, dest->callid, s->callid);	CONT_COPY(dest, dest->local_contact, s->local_contact);	CONT_COPY(dest, dest->contact, s->contact);	CONT_COPY(dest, dest->record_route, s->record_route);	if(s->event_id.s)		CONT_COPY(dest, dest->event_id, s->event_id);	if(s->reason.s)		CONT_COPY(dest, dest->reason, s->reason);	dest->event= s->event;	dest->local_cseq= s->local_cseq;	dest->remote_cseq= s->remote_cseq;	dest->status= s->status;	dest->version= s->version;	dest->expires= s->expires;	dest->db_flag= s->db_flag;	dest->sockinfo= s->sockinfo;	return dest;error:	if(dest)	{		if(mem_type == PKG_MEM_TYPE)			pkg_free(dest);		else			shm_free(dest);	}	return NULL;}

phtable_t* new_phtable(void){	phtable_t* htable= NULL;	int i, j;	i = 0;	htable= (phtable_t*)shm_malloc(phtable_size* sizeof(phtable_t));	if(htable== NULL)	{		ERR_MEM(SHARE_MEM);	}	memset(htable, 0, phtable_size* sizeof(phtable_t));	for(i= 0; i< phtable_size; i++)	{		if(lock_init(&htable[i].lock)== 0)		{			LM_ERR("initializing lock [%d]/n", i);			goto error;		}		htable[i].entries= (pres_entry_t*)shm_malloc(sizeof(pres_entry_t));		if(htable[i].entries== NULL)		{			ERR_MEM(SHARE_MEM);		}		memset(htable[i].entries, 0, sizeof(pres_entry_t));		htable[i].entries->next= NULL;	}	return htable;error:	if(htable)	{		for(j=0; j< i; j++)		{			if(htable[i].entries)				shm_free(htable[i].entries);			else 				break;			lock_destroy(&htable[i].lock);		}		shm_free(htable);	}	return NULL;}

shtable_t new_shtable(int hash_size){	shtable_t htable= NULL;	int i, j;	i = 0;	htable= (subs_entry_t*)shm_malloc(hash_size* sizeof(subs_entry_t));	if(htable== NULL)	{		ERR_MEM(SHARE_MEM);	}	memset(htable, 0, hash_size* sizeof(subs_entry_t));	for(i= 0; i< hash_size; i++)	{		if(lock_init(&htable[i].lock)== 0)		{			LM_ERR("initializing lock [%d]/n", i);			goto error;		}		htable[i].entries= (subs_t*)shm_malloc(sizeof(subs_t));		if(htable[i].entries== NULL)		{			lock_destroy(&htable[i].lock);			ERR_MEM(SHARE_MEM);		}		memset(htable[i].entries, 0, sizeof(subs_t));		htable[i].entries->next= NULL;	}	return htable;error:	if(htable)	{		for(j=0; j< i; j++)		{			lock_destroy(&htable[j].lock);			shm_free(htable[j].entries);		}		shm_free(htable);	}	return NULL;}

dlg_t* b2b_client_build_dlg(b2b_dlg_t* dlg, dlg_leg_t* leg){	dlg_t* td =NULL;	td = (dlg_t*)pkg_malloc(sizeof(dlg_t));	if(td == NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memset(td, 0, sizeof(dlg_t));	td->loc_seq.value   = dlg->cseq[CALLER_LEG];	dlg->cseq[CALLER_LEG]++;	td->loc_seq.is_set  = 1;	td->id.call_id = dlg->callid;	td->id.loc_tag = dlg->tag[CALLER_LEG];	td->loc_uri = dlg->from_uri;	td->rem_uri = dlg->to_uri;	td->loc_dname = dlg->from_dname;	td->rem_dname = dlg->to_dname;	if(leg)	{		if(leg->route_set.s && leg->route_set.len)		{			if(parse_rr_body(leg->route_set.s, leg->route_set.len,				&td->route_set)< 0)			{				LM_ERR("failed to parse record route body/n");				goto error;			}		}		td->id.rem_tag = leg->tag;		LM_DBG("Rem_target = %.*s/n", leg->contact.len, leg->contact.s);		td->rem_target = leg->contact;	}	td->state= DLG_CONFIRMED ;	td->send_sock = dlg->send_sock;	if(dlg->send_sock)		LM_DBG("send sock= %.*s/n", dlg->send_sock->address_str.len,			dlg->send_sock->address_str.s);	return td;error:	if(td)		pkg_free(td);	return 0;}

xcap_node_sel_t* xcapInitNodeSel(void){	xcap_node_sel_t* nsel= NULL;	nsel= (xcap_node_sel_t*)pkg_malloc(sizeof(xcap_node_sel_t));	if(nsel== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memset(nsel, 0, sizeof(xcap_node_sel_t));	nsel->steps= (step_t*)pkg_malloc(sizeof(step_t));	if(nsel->steps== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memset(nsel->steps, 0, sizeof(step_t));	nsel->last_step= nsel->steps;	nsel->ns_list= (ns_list_t*)pkg_malloc(sizeof(ns_list_t));	if(nsel->ns_list== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memset(nsel->ns_list, 0, sizeof(ns_list_t));	nsel->last_ns= nsel->ns_list;	return nsel;error:	if(nsel)	{		if(nsel->steps)			pkg_free(nsel->steps);		if(nsel->ns_list)			pkg_free(nsel->ns_list);		pkg_free(nsel);	}	return NULL;}

char* extract_sphere(str body){	/* check for a rpid sphere element */	xmlDocPtr doc= NULL;	xmlNodePtr node;	char* cont, *sphere= NULL;	doc= xmlParseMemory(body.s, body.len);	if(doc== NULL)	{		LM_ERR("failed to parse xml body/n");		return NULL;	}	node= xmlNodeGetNodeByName(doc->children, "sphere", "rpid");	if(node== NULL)		node= xmlNodeGetNodeByName(doc->children, "sphere", "r");	if(node)	{		LM_DBG("found sphere definition/n");		cont= (char*)xmlNodeGetContent(node);		if(cont== NULL)		{			LM_ERR("failed to extract sphere node content/n");			goto error;		}		sphere= (char*)pkg_malloc(strlen(cont)+ 1);		if(sphere== NULL)		{			xmlFree(cont);			ERR_MEM(PKG_MEM_STR);		}		strcpy(sphere, cont);		xmlFree(cont);	}	else		LM_DBG("didn't find sphere definition/n");error:	xmlFreeDoc(doc);	return sphere;}

static int shm_copy_xcap_list(void){	xcap_serv_t* xs, *shm_xs, *prev_xs;	int size;	xs= xs_list;	if(xs== NULL)	{		if(force_active== 0 && !integrated_xcap_server)		{			LM_ERR("no xcap_server parameter set/n");			return -1;		}		return 0;	}	xs_list= NULL;	size= sizeof(xcap_serv_t);		while(xs)	{		size+= (strlen(xs->addr)+ 1)* sizeof(char);		shm_xs= (xcap_serv_t*)shm_malloc(size);		if(shm_xs== NULL)		{			ERR_MEM(SHARE_MEM);		}		memset(shm_xs, 0, size);		size= sizeof(xcap_serv_t);		shm_xs->addr= (char*)shm_xs+ size;		strcpy(shm_xs->addr, xs->addr);		shm_xs->port= xs->port;		shm_xs->next= xs_list; 		xs_list= shm_xs;		prev_xs= xs;		xs= xs->next;		pkg_free(prev_xs);	}	return 0;error:	free_xs_list(xs_list, SHM_MEM_TYPE);	return -1;}

dlg_t* b2b_server_build_dlg(b2b_dlg_t* dlg){	dlg_t* td =NULL;	td = (dlg_t*)pkg_malloc(sizeof(dlg_t));	if(td == NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memset(td, 0, sizeof(dlg_t));	td->loc_seq.value = dlg->cseq[CALLEE_LEG];	td->loc_seq.is_set = 1;	dlg->cseq[CALLEE_LEG]++;	td->id.call_id = dlg->callid;	td->id.rem_tag = dlg->tag[CALLER_LEG];	td->id.loc_tag = dlg->tag[CALLEE_LEG];	td->rem_target = dlg->contact[CALLER_LEG];	td->loc_uri = dlg->to_uri;	td->rem_uri = dlg->from_uri;	td->loc_dname = dlg->to_dname;	td->rem_dname = dlg->from_dname;	if(dlg->route_set[CALLER_LEG].s && dlg->route_set[CALLER_LEG].len)	{		if(parse_rr_body(dlg->route_set[CALLER_LEG].s, dlg->route_set[CALLER_LEG].len,			&td->route_set)< 0)		{			LM_ERR("failed to parse record route body/n");			goto error;		}	}	td->state= DLG_CONFIRMED ;	td->send_sock = dlg->send_sock;	return td;error:	if(td)		pkg_free(td);	return NULL;}

int init_b2bl_htable(void){	int i;	b2bl_htable = (b2bl_table_t)shm_malloc(b2bl_hsize* sizeof(b2bl_entry_t));	if(!b2bl_htable)		ERR_MEM(SHARE_MEM);		memset(b2bl_htable, 0, b2bl_hsize* sizeof(b2bl_entry_t));	for(i= 0; i< b2bl_hsize; i++)	{		lock_init(&b2bl_htable[i].lock);		b2bl_htable[i].first = NULL;	}	return 0;error:	return -1;}

int register_xcapcb( int types, xcap_cb f){	xcap_callback_t* xcb;	xcb= (xcap_callback_t*)shm_malloc(sizeof(xcap_callback_t));	if(xcb== NULL)	{		ERR_MEM(SHARE_MEM);	}	memset(xcb, 0, sizeof(xcap_callback_t));	xcb->callback= f;	xcb->types= types;	xcb->next= xcapcb_list;	xcapcb_list= xcb;	return 0;error:	return -1;}

/* * function that updates a subscription in hash table *	sets reply_code and reply_str in case of error and *	if different that server error * */int update_rlsubs( subs_t* subs, unsigned int hash_code,		int* reply_code, str* reply_str){	subs_t* s, *ps;	/* search the record in hash table */	lock_get(&rls_table[hash_code].lock);	s= pres_search_shtable(rls_table, subs->callid,			subs->to_tag, subs->from_tag, hash_code);	if(s== NULL)	{		LM_DBG("record not found in hash table/n");		lock_release(&rls_table[hash_code].lock);		return -1;	}	s->expires= subs->expires+ (int)time(NULL);		if(s->db_flag == NO_UPDATEDB_FLAG)		s->db_flag= UPDATEDB_FLAG;		if(	s->remote_cseq>= subs->remote_cseq)	{		lock_release(&rls_table[hash_code].lock);		LM_DBG("stale cseq stored cseq= %d - received cseq= %d/n", s->remote_cseq, subs->remote_cseq);		*reply_code =  Stale_cseq_code;		*reply_str = stale_cseq_rpl;		return -1;	}	s->remote_cseq= subs->remote_cseq;	subs->pres_uri.s= (char*)pkg_malloc(s->pres_uri.len* sizeof(char));	if(subs->pres_uri.s== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memcpy(subs->pres_uri.s, s->pres_uri.s, s->pres_uri.len);	subs->pres_uri.len= s->pres_uri.len;	subs->local_cseq= s->local_cseq;	subs->version= s->version;	if(s->record_route.s && s->record_route.len)	{		subs->record_route.s= (char*)pkg_malloc(s->record_route.len);		if(subs->record_route.s== NULL)		{			ERR_MEM(PKG_MEM_STR);		}		memcpy(subs->record_route.s, s->record_route.s, s->record_route.len);		subs->record_route.len= s->record_route.len;	}	if(subs->expires== 0)	{		/* delete record from hash table */		ps= rls_table[hash_code].entries;		int found= 0;		while(ps->next)		{			if(ps->next== s)			{				found= 1;				break;			}			ps= ps->next;		}		if(found== 0)		{			LM_ERR("record not found/n");			goto error;		}		ps->next= s->next;		shm_free(s);		/* delete from rls_presentity table also */	}		lock_release(&rls_table[hash_code].lock);	return 0;error:	lock_release(&rls_table[hash_code].lock);	return -1;}

static int pxml_add_xcap_server( modparam_t type, void* val){	xcap_serv_t* xs;	int size;	char* serv_addr= (char*)val;	char* sep= NULL;	unsigned int port= 80;	str serv_addr_str;			serv_addr_str.s= serv_addr;	serv_addr_str.len= strlen(serv_addr);	sep= strchr(serv_addr, ':');	if(sep)	{			char* sep2= NULL;		str port_str;				sep2= strchr(sep+ 1, ':');		if(sep2)			sep= sep2;				port_str.s= sep+ 1;		port_str.len= serv_addr_str.len- (port_str.s- serv_addr);		if(str2int(&port_str, &port)< 0)		{			LM_ERR("while converting string to int/n");			goto error;		}		if(port< 0 || port> 65535)		{			LM_ERR("wrong port number/n");			goto error;		}		*sep = '/0';		serv_addr_str.len= sep- serv_addr;	}	size= sizeof(xcap_serv_t)+ (serv_addr_str.len+ 1)* sizeof(char);	xs= (xcap_serv_t*)pkg_malloc(size);	if(xs== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memset(xs, 0, size);	size= sizeof(xcap_serv_t);	xs->addr= (char*)xs+ size;	strcpy(xs->addr, serv_addr);	xs->port= port;	/* check for duplicates */	xs->next= xs_list;	xs_list= xs;	return 0;error:	free_xs_list(xs_list, PKG_MEM_TYPE);	return -1;}

int parse_subs_state(str auth_state, str *reason, int *expires){	str str_exp;	char* smc= NULL;	int len, flag= -1;	if (strncmp(auth_state.s, "active", 6)== 0)		flag= ACTIVE_STATE;	if (strncmp(auth_state.s, "pending", 7)== 0)		flag= PENDING_STATE; 	if (strncmp(auth_state.s, "terminated", 10)== 0)	{		smc= strchr(auth_state.s, ';');		if (smc== NULL)		{			LM_ERR("terminated state and no reason found");			return -1;		}		if (strncmp(smc+1, "reason=", 7))		{			LM_ERR("terminated state and no reason found");			return -1;        	}		len=  auth_state.len- 10- 1- 7;		reason->s = (char*) pkg_malloc(len* sizeof(char));		if (reason->s== NULL)		{			ERR_MEM(PKG_MEM_STR);		}		memcpy(reason->s, smc+ 8, len);		reason->len= len;		return TERMINATED_STATE;	}		if(flag> 0)	{		smc= strchr(auth_state.s, ';');		if(smc== NULL)		{			LM_ERR("active or pending state and no expires parameter found");			return -1;		}			if(strncmp(smc+1, "expires=", 8))		{			LM_ERR("active or pending state and no expires parameter found");			return -1;		}		str_exp.s= smc+ 9;		str_exp.len= auth_state.s+ auth_state.len- smc- 9;		if( str2int(&str_exp, (unsigned int*)expires)< 0)		{			LM_ERR("while getting int from str/n");			return -1;		}		return flag;		}error:	if (reason->s) pkg_free(reason->s);	return -1;}

//.........这里部分代码省略.........	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 update_rlsubs( subs_t* subs, unsigned int hash_code){	subs_t* s;	if (dbmode == RLS_DB_ONLY)	{		LM_ERR( "update_rlsubs called in RLS_DB_ONLY mode/n" );	} 	/* search the record in hash table */	lock_get(&rls_table[hash_code].lock);	s= pres_search_shtable(rls_table, subs->callid,			subs->to_tag, subs->from_tag, hash_code);	if(s== NULL)	{		LM_DBG("record not found in hash table/n");		lock_release(&rls_table[hash_code].lock);		return -1;	}	s->expires= subs->expires+ (int)time(NULL);		if(s->db_flag & NO_UPDATEDB_FLAG)		s->db_flag= UPDATEDB_FLAG;		if(	s->remote_cseq>= subs->remote_cseq)	{		lock_release(&rls_table[hash_code].lock);		LM_DBG("stored cseq= %d/n", s->remote_cseq);		return Stale_cseq_code;	}	s->remote_cseq= subs->remote_cseq;	subs->pres_uri.s= (char*)pkg_malloc(s->pres_uri.len* sizeof(char));	if(subs->pres_uri.s== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memcpy(subs->pres_uri.s, s->pres_uri.s, s->pres_uri.len);	subs->pres_uri.len= s->pres_uri.len;	if(s->record_route.s!=NULL && s->record_route.len>0)	{		subs->record_route.s =				(char*)pkg_malloc(s->record_route.len* sizeof(char));		if(subs->record_route.s==NULL)		{			ERR_MEM(PKG_MEM_STR);		}		memcpy(subs->record_route.s, s->record_route.s, s->record_route.len);		subs->record_route.len= s->record_route.len;	}	subs->local_cseq= s->local_cseq;	subs->version= s->version;	lock_release(&rls_table[hash_code].lock);	return 0;error:	lock_release(&rls_table[hash_code].lock);	return -1;}

static void send_notifies(db1_res_t *result, int did_col, int resource_uri_col, int auth_state_col, int reason_col,                   int pres_state_col, int content_type_col){	int i;	char* prev_did= NULL, * curr_did= NULL;	db_row_t *row;		db_val_t *row_vals;	char* resource_uri;	str pres_state = {0, 0};	xmlDocPtr rlmi_doc= NULL;	xmlNodePtr list_node= NULL, instance_node= NULL, resource_node;	unsigned int hash_code= 0;	int size= BUF_REALLOC_SIZE, buf_len= 0;		char* buf= NULL, *auth_state= NULL, *boundary_string= NULL;	str cid = {0,0};	str content_type= {0, 0};	int auth_state_flag;	int chunk_len=0;	str bstr= {0, 0};	subs_t* dialog= NULL;	int len_est = 0;	int resource_added = 0; /* Flag to indicate that we have added at least one resource */	/* generate the boundary string */	boundary_string= generate_string(BOUNDARY_STRING_LEN);	bstr.len= strlen(boundary_string);	bstr.s= (char*)pkg_malloc((bstr.len+ 1)* sizeof(char));	if(bstr.s== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memcpy(bstr.s, boundary_string, bstr.len);	bstr.s[bstr.len]= '/0';	/* Allocate an initial buffer for the multipart body.	 * This buffer will be reallocated if neccessary */	buf= pkg_malloc(size* sizeof(char));	if(buf== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	LM_DBG("found %d records with updated state/n", result->n);	for(i= 0; i< result->n; i++)	{		row = &result->rows[i];		row_vals = ROW_VALUES(row);				curr_did=     (char*)row_vals[did_col].val.string_val;		resource_uri= (char*)row_vals[resource_uri_col].val.string_val;		auth_state_flag=     row_vals[auth_state_col].val.int_val;		pres_state.s=   (char*)row_vals[pres_state_col].val.string_val;		pres_state.len = strlen(pres_state.s);		trim(&pres_state);				/* If we have moved onto a new resource list Subscribe dialog indentifier, 		   send a NOTIFY for the previous ID and then drop the existing documents. */		if(prev_did!= NULL && strcmp(prev_did, curr_did)) 		{			if (send_notify(&rlmi_doc, buf, buf_len, bstr, dialog, hash_code))			{  				LM_ERR("in send_notify/n");				goto error;			}			len_est = 0;			pkg_free(dialog);			dialog= NULL;		}		/*if first or different*/		if(prev_did==NULL || strcmp(prev_did, curr_did)!=0)		{			/* Work out a subscription from the did. */			get_dialog_from_did(curr_did, &dialog, &hash_code);			if(dialog== NULL)			{				prev_did = NULL;				LM_INFO("Dialog is NULL/n");				continue;			}					len_est = create_empty_rlmi_doc(&rlmi_doc, &list_node, &dialog->pres_uri, dialog->version, 0);			len_est += 2*strlen(boundary_string)+4+102+2+50+strlen(resource_uri)+20;			buf_len= 0;			resource_added = 0;			/* !!!! for now I will include the auth state without checking if 			 * it has changed - > in future chech if it works */				}		/* add a node in rlmi_doc and if any presence state registered add 		 * it in the buffer */				resource_node= xmlNewChild(list_node,NULL,BAD_CAST "resource", NULL);		if(resource_node== NULL)		{			LM_ERR("when adding resource child/n");			goto done;		}		xmlNewProp(resource_node, BAD_CAST "uri", BAD_CAST resource_uri);//.........这里部分代码省略.........

//.........这里部分代码省略.........		return -1;	}	if( pxml_dbf.query(pxml_db, query_cols, 0 , query_vals, result_cols, 				n_query_cols, 1, 0, &result)<0)	{		LM_ERR("while querying table xcap for [user]=%.*s/t[domain]= %.*s/n",				user->len, user->s,	domain->len, domain->s);		if(result)			pxml_dbf.free_result(pxml_db, result);		return -1;	}	if(result== NULL)		return -1;	if(result->n<= 0)	{		LM_DBG("No document found in db table for [user]=%.*s"			"/t[domain]= %.*s/t[doc_type]= %d/n",user->len, user->s,			domain->len, domain->s, type);				if(!integrated_xcap_server)		{			if(http_get_rules_doc(*user, *domain, &body)< 0)			{				LM_ERR("fetching document with HTTP request from xcap server/n");				goto error;			}			if(body.s && body.len)  /* if the document was found */				goto done;		}		pxml_dbf.free_result(pxml_db, result);		return 0;	}		row = &result->rows[xcap_doc_col];	row_vals = ROW_VALUES(row);	switch (row_vals[0].type) {		case DB_STRING:			LM_DBG("extracted db_string/n");			body.s = (char*)row_vals[0].val.string_val;			if (body.s)				body.len = strlen(body.s);			break;		case DB_STR:			LM_DBG("extracted db_str/n");			body = row_vals[0].val.str_val;			break;		case DB_BLOB:			LM_DBG("extracted db_blob/n");			body = row_vals[0].val.blob_val;			break;		default:			LM_ERR("unexpected column type %d/n",row_vals[0].type);			goto error;	}	if(body.s== NULL)	{		LM_ERR("Xcap doc NULL/n");		goto error;	}		if(body.len== 0)	{		LM_ERR("Xcap doc empty/n");		goto error;	}				LM_DBG("xcap document:/n%.*s", body.len,body.s);done:	doc= (str*)pkg_malloc(sizeof(str));	if(doc== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	doc->s= (char*)pkg_malloc(body.len* sizeof(char));	if(doc->s== NULL)	{		pkg_free(doc);		ERR_MEM(PKG_MEM_STR);	}	memcpy(doc->s, body.s, body.len);	doc->len= body.len;	*rules_doc= doc;	if(result)		pxml_dbf.free_result(pxml_db, result);	return 0;error:	if(result)		pxml_dbf.free_result(pxml_db, result);	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;	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)//.........这里部分代码省略.........

str* offline_nbody(str* body){	xmlDocPtr doc= NULL;	xmlDocPtr new_doc= NULL;	xmlNodePtr node, tuple_node= NULL, status_node;	xmlNodePtr root_node, add_node, pres_node;	str* new_body;	doc= xmlParseMemory(body->s, body->len);	if(doc==  NULL)	{		LM_ERR("while parsing xml memory/n");		return NULL;	}	node= xmlDocGetNodeByName(doc, "basic", NULL);	if(node== NULL)	{		LM_ERR("while extracting basic node/n");		goto error;	}	xmlNodeSetContent(node, (const unsigned char*)"closed");	tuple_node= xmlDocGetNodeByName(doc, "tuple", NULL);	if(tuple_node== NULL)	{		LM_ERR("while extracting tuple node/n");		goto error;	}	status_node= xmlDocGetNodeByName(doc, "status", NULL);	if(status_node== NULL)	{		LM_ERR("while extracting tuple node/n");		goto error;	}	pres_node= xmlDocGetNodeByName(doc, "presence", NULL);	if(node== NULL)	{		LM_ERR("while extracting presence node/n");		goto error;	}    new_doc = xmlNewDoc(BAD_CAST "1.0");    if(new_doc==0)		goto error;	root_node= xmlCopyNode(pres_node, 2);	if(root_node== NULL)	{		LM_ERR("while copying node/n");		goto error;	}    xmlDocSetRootElement(new_doc, root_node);	tuple_node= xmlCopyNode(tuple_node, 2);	if(tuple_node== NULL)	{		LM_ERR("while copying node/n");		goto error;	}	xmlAddChild(root_node, tuple_node);	add_node= xmlCopyNode(status_node, 1);	if(add_node== NULL)	{		LM_ERR("while copying node/n");		goto error;	}	xmlAddChild(tuple_node, add_node);	new_body = (str*)pkg_malloc(sizeof(str));	if(new_body == NULL)	{		ERR_MEM(PKG_MEM_STR);	}	memset(new_body, 0, sizeof(str));	xmlDocDumpFormatMemory(new_doc,(xmlChar**)(void*)&new_body->s,		&new_body->len, 1);	xmlFreeDoc(doc);	xmlFreeDoc(new_doc);	xmlCleanupParser();	xmlMemoryDump();	return new_body;error:	if(doc)		xmlFreeDoc(doc);	if(new_doc)		xmlFreeDoc(new_doc);	return NULL;}		

//.........这里部分代码省略.........			goto error;		}		append= 1;		node= xmlNodeGetChildByName(new_p_root, "tuple");		if(node != NULL)		{			tuple_id= xmlNodeGetAttrContentByName(node, "id");			if(tuple_id== NULL)			{				LM_ERR("while extracting tuple id/n");				goto error;			}			for (node = p_root->children; node!=NULL; node = node->next)			{						if( xmlStrcasecmp(node->name,(unsigned char*)"text")==0)					continue;							if( xmlStrcasecmp(node->name,(unsigned char*)"tuple")==0)				{					id = xmlNodeGetAttrContentByName(node, "id");					if(id== NULL)					{						LM_ERR("while extracting tuple id/n");						goto error;					}									if(xmlStrcasecmp((unsigned char*)tuple_id,								(unsigned char*)id )== 0)					{						append = 0;						xmlFree(id);						break;					}					xmlFree(id);				}			}			xmlFree(tuple_id);			tuple_id= NULL;		}		if(append) 		{				for(node= new_p_root->children; node; node= node->next)			{					add_node= xmlCopyNode(node, 1);				if(add_node== NULL)				{					LM_ERR("while copying node/n");					goto error;				}				if(xmlAddChild(p_root, add_node)== NULL)				{					LM_ERR("while adding child/n");					goto error;				}											}		}	}	body = (str*)pkg_malloc(sizeof(str));	if(body == NULL)	{		ERR_MEM(PKG_MEM_STR);	}	xmlDocDumpFormatMemory(xml_array[j],(xmlChar**)(void*)&body->s, 			&body->len, 1);	  	for(i=0; i<=j; i++)	{		if(xml_array[i]!=NULL)			xmlFreeDoc( xml_array[i]);	}	if(xml_array!=NULL)		pkg_free(xml_array);    	xmlCleanupParser();    xmlMemoryDump();	return body;error:	if(xml_array!=NULL)	{		for(i=0; i<=j; i++)		{			if(xml_array[i]!=NULL)				xmlFreeDoc( xml_array[i]);		}		pkg_free(xml_array);	}	if(tuple_id)		xmlFree(tuple_id);	if(body)		pkg_free(body);	return NULL;}

//.........这里部分代码省略.........		query_vals[n_query_cols].val.str_val = *domain;		n_query_cols++;	}	else	{		LM_ERR("Need to specify file uri _OR_ username and domain/n");		return -1;	}		result_cols[xcap_doc_col= n_result_cols++] = &tmp5;		if (pxml_dbf.use_table(pxml_db, &xcap_table) < 0) 	{		LM_ERR("in use_table-[table]= %.*s/n", xcap_table.len, xcap_table.s);		return -1;	}	if( pxml_dbf.query(pxml_db, query_cols, 0 , query_vals, result_cols, 				n_query_cols, 1, 0, &result)<0)	{		LM_ERR("while querying table xcap for [user]=%.*s/t[domain]= %.*s/n",				user->len, user->s,	domain->len, domain->s);		if(result)			pxml_dbf.free_result(pxml_db, result);		return -1;	}	if(result== NULL)		return -1;	if(result->n<= 0)	{		LM_DBG("No document found in db table for [user]=%.*s"			"/t[domain]= %.*s/t[doc_type]= %d/n",user->len, user->s,			domain->len, domain->s, type);				if (!integrated_xcap_server && type != PRES_RULES)		{			LM_WARN("Cannot retrieve non pres-rules documents from"				"external XCAP server/n");		}		else if(!integrated_xcap_server)		{			if(http_get_rules_doc(*user, *domain, &body)< 0)			{				LM_ERR("sending http GET request to xcap server/n");						goto error;			}			if(body.s && body.len)				goto done; 		}		pxml_dbf.free_result(pxml_db, result);		return 0;	}			row = &result->rows[xcap_doc_col];	row_vals = ROW_VALUES(row);	body.s = (char*)row_vals[0].val.string_val;	if(body.s== NULL)	{		LM_ERR("Xcap doc NULL/n");		goto error;	}		body.len = strlen(body.s);	if(body.len== 0)	{		LM_ERR("Xcap doc empty/n");		goto error;	}				LM_DBG("xcap document:/n%.*s", body.len,body.s);done:	doc= (str*)pkg_malloc(sizeof(str));	if(doc== NULL)	{		ERR_MEM(PKG_MEM_STR);	}	doc->s= (char*)pkg_malloc(body.len* sizeof(char));	if(doc->s== NULL)	{		pkg_free(doc);		ERR_MEM(PKG_MEM_STR);	}	memcpy(doc->s, body.s, body.len);	doc->len= body.len;	*rules_doc= doc;	if(result)		pxml_dbf.free_result(pxml_db, result);	return 1;error:	if(result)		pxml_dbf.free_result(pxml_db, result);	return -1;}

//.........这里部分代码省略.........		pkg_free(record_route.s);		record_route.s = NULL;	}	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)	{		presentity->extra_headers= (str*)((char*)presentity+ size);		size+= sizeof(str);		presentity->extra_headers->s=(char*)presentity+ size;		memcpy(presentity->extra_headers->s, hentity->extra_headers->s, 			hentity->extra_headers->len);		presentity->extra_headers->len= hentity->extra_headers->len; 		size+= 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);	if (dbmode==PUA_DB_ONLY)	{		if (pua_dbf.end_transaction)		{			if (pua_dbf.end_transaction(pua_db) < 0)			{				LM_ERR("in end_transaction/n");				goto error;			}		}		if (pua_dbf.start_transaction)		{			if (pua_dbf.start_transaction(pua_db, db_table_lock) < 0)

int reply_200(struct sip_msg* msg, str* local_contact, int expires, str* rtag){	char* hdr_append;	int len;	int lexpire_len;	char *lexpire_s;	char* p;	lexpire_s = int2str((unsigned long)expires, &lexpire_len);	len = 9 /*"Expires: "*/ + lexpire_len + CRLF_LEN		+ 10 /*"Contact: <"*/ + local_contact->len + 1 /*">"*/		+ ((msg->rcv.proto!=PROTO_UDP)?15/*";transport=xxxx"*/:0)		+ CRLF_LEN + 18 /*Require: eventlist*/ + CRLF_LEN;	hdr_append = (char *)pkg_malloc( len );	if(hdr_append == NULL)	{		ERR_MEM(PKG_MEM_STR);	}	p = hdr_append;	/* expires header */	memcpy(p, "Expires: ", 9);	p += 9;	memcpy(p,lexpire_s,lexpire_len);	p += lexpire_len;	memcpy(p,CRLF,CRLF_LEN);	p += CRLF_LEN;	/* contact header */	memcpy(p,"Contact: <", 10);	p += 10;	memcpy(p,local_contact->s,local_contact->len);	p += local_contact->len;	if (msg->rcv.proto!=PROTO_UDP) {		memcpy(p,";transport=",11);		p += 11;		p = proto2str(msg->rcv.proto, p);		if (p==NULL) {			LM_ERR("invalid proto/n");			goto error;		}	}	*(p++) = '>';	memcpy(p, CRLF, CRLF_LEN);	p += CRLF_LEN;	memcpy(p, "Require: eventlist", 18);	p += 18;	memcpy(p, CRLF, CRLF_LEN);	p += CRLF_LEN;	if (add_lump_rpl( msg, hdr_append, p-hdr_append, LUMP_RPL_HDR)==0 )	{		LM_ERR("unable to add lump_rl/n");		goto error;	}	if( rls_sigb.reply( msg, 200, &su_200_rpl, rtag)< 0)	{		LM_ERR("failed to send reply/n");		goto error;	}		pkg_free(hdr_append);	return 0;error:	pkg_free(hdr_append);	return -1;}	

int get_rules_doc(str* user, str* domain, int type, str** rules_doc){    db_key_t query_cols[5];    db_val_t query_vals[5];    db_key_t result_cols[3];    int n_query_cols = 0;    db1_res_t *result = 0;    db_row_t *row;    db_val_t *row_vals;    str body;    str* doc= NULL;    int n_result_cols= 0, xcap_doc_col;    static str tmp1 = str_init("username");    static str tmp2 = str_init("domain");    static str tmp3 = str_init("doc_type");    static str tmp4 = str_init("doc");    LM_DBG("[user]= %.*s/t[domain]= %.*s", 	   user->len, user->s, domain->len, domain->s);    query_cols[n_query_cols] = &tmp1;    query_vals[n_query_cols].type = DB1_STR;    query_vals[n_query_cols].nul = 0;    query_vals[n_query_cols].val.str_val = *user;    n_query_cols++;        query_cols[n_query_cols] = &tmp2;    query_vals[n_query_cols].type = DB1_STR;    query_vals[n_query_cols].nul = 0;    query_vals[n_query_cols].val.str_val = *domain;    n_query_cols++;        query_cols[n_query_cols] = &tmp3;    query_vals[n_query_cols].type = DB1_INT;    query_vals[n_query_cols].nul = 0;    query_vals[n_query_cols].val.int_val= type;    n_query_cols++;    result_cols[xcap_doc_col= n_result_cols++] = &tmp4;    if (pres_dbf.query(pres_dbh, query_cols, 0 , query_vals, result_cols, 		       n_query_cols, 1, 0, &result) < 0) {	LM_ERR("while querying table xcap for [user]=%.*s/t[domain]= %.*s/n",	       user->len, user->s, domain->len, domain->s);	if (result)	    pres_dbf.free_result(pres_dbh, result);	return -1;    }    if(result == NULL)	return -1;    if (result->n <= 0) {	LM_DBG("No document found in db table for [user]=%.*s"	       "/t[domain]= %.*s/t[doc_type]= %d/n",user->len, user->s,	       domain->len, domain->s, type);	pres_dbf.free_result(pres_dbh, result);	return 0;    }		    row = &result->rows[xcap_doc_col];    row_vals = ROW_VALUES(row);    body.s = (char*)row_vals[0].val.string_val;    if (body.s== NULL) {	LM_ERR("Xcap doc NULL/n");	goto error;    }	    body.len = strlen(body.s);    if (body.len== 0) {	LM_ERR("Xcap doc empty/n");	goto error;    }			    LM_DBG("xcap document:/n%.*s", body.len,body.s);        doc= (str*)pkg_malloc(sizeof(str));    if (doc== NULL) {	ERR_MEM(PKG_MEM_STR);    }    doc->s= (char*)pkg_malloc(body.len* sizeof(char));    if (doc->s== NULL) {	pkg_free(doc);	ERR_MEM(PKG_MEM_STR);    }    memcpy(doc->s, body.s, body.len);    doc->len= body.len;    *rules_doc= doc;    if (result)	pres_dbf.free_result(pres_dbh, result);    return 0;error:    if (result)	pres_dbf.free_result(pres_dbh, result);    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;//.........这里部分代码省略.........