示例#1
0
文件: hep.c 项目: 4N7HR4X/kamailio
int hepv3_message_parse(char *buf, unsigned int len, sip_msg_t* msg) {

	union sockaddr_union from;
	union sockaddr_union to;
	char *tmp;
	struct ip_addr dst_ip, src_ip;
	struct socket_info* si = 0;
	int i;
	char *payload = NULL;
	unsigned int payload_len = 0;
        struct hep_chunk *chunk;	
        struct hep_generic_recv *hg;
        int totelem = 0;
        int chunk_vendor=0, chunk_type=0, chunk_length=0;
        int total_length = 0;
        int ret = 0;
        
	hg = (struct hep_generic_recv*)pkg_malloc(sizeof(struct hep_generic_recv));
	if(hg==NULL) {
	        LM_ERR("no more pkg memory left for hg\n");
	        return -1;
        }
	                                                 		
	memset(hg, 0, sizeof(struct hep_generic_recv));

	
        memset(heptime, 0, sizeof(struct hep_timehdr));	
	        

	/* HEADER */
	hg->header  = (hep_ctrl_t *) (buf);

	/*Packet size */
	total_length = ntohs(hg->header->length);

	dst_ip.af = 0;
        src_ip.af = 0;
                	        
	payload = NULL;
	correlation_id = NULL;
	authkey = NULL;

	i = sizeof(hep_ctrl_t);	        
	        
	while(i < total_length) {
                
	        /*OUR TMP DATA */                                  
                tmp = buf+i;

                chunk = (struct hep_chunk*) tmp;
                             
                chunk_vendor = ntohs(chunk->vendor_id);                             
                chunk_type = ntohs(chunk->type_id);
                chunk_length = ntohs(chunk->length);
                       
                /* if chunk_length */
                if(chunk_length == 0) {
                        /* BAD LEN we drop this packet */
                        goto error;
                }

                /* SKIP not general Chunks */
                if(chunk_vendor != 0) {
                        i+=chunk_length;
                }
                else {                                                                                                                               
                        switch(chunk_type) {
                                     
                                case 0:
                                        goto error;
                                        break;
                                     
                                case 1:                                                                          
                                        hg->ip_family  = (hep_chunk_uint8_t *) (tmp);
                                        i+=chunk_length;
                                        totelem++;
                                        break;
                                case 2:
                                        hg->ip_proto  = (hep_chunk_uint8_t *) (tmp);
                                        i+=chunk_length;
                                        totelem++;
                                        break;                                                     
                                case 3:
                                        hg->hep_src_ip4  = (hep_chunk_ip4_t *) (tmp);
                                        i+=chunk_length;
                                        src_ip.af=AF_INET;
				        src_ip.len=4;
				        src_ip.u.addr32[0] = hg->hep_src_ip4->data.s_addr;
				        totelem++;
				        break;
                                case 4:
                                        hg->hep_dst_ip4  = (hep_chunk_ip4_t *) (tmp);
                                        i+=chunk_length;                                                     
					dst_ip.af=AF_INET;
				        dst_ip.len=4;
				        dst_ip.u.addr32[0] = hg->hep_dst_ip4->data.s_addr;
                                        totelem++;

                                        break;
                                case 5:
                                        hg->hep_src_ip6  = (hep_chunk_ip6_t *) (tmp);
                                        i+=chunk_length;
                                        src_ip.af=AF_INET6;
				        src_ip.len=16;
				        memcpy(src_ip.u.addr, &hg->hep_src_ip6->data, 16);
				        totelem++;
                                        break;
                                case 6:
                                        hg->hep_dst_ip6  = (hep_chunk_ip6_t *) (tmp);
                                        i+=chunk_length;                                                     
                                        dst_ip.af=AF_INET6;
				        dst_ip.len=16;
				        memcpy(dst_ip.u.addr, &hg->hep_dst_ip6->data, 16);
				        totelem++;
                                        break;
        
                                case 7:
                                        hg->src_port  = (hep_chunk_uint16_t *) (tmp);
                                        msg->rcv.src_port = ntohs(hg->src_port->data);
                                        i+=chunk_length;                      
                                        totelem++;
                                        break;

                                case 8:
                                        hg->dst_port  = (hep_chunk_uint16_t *) (tmp);
                                        msg->rcv.dst_port = ntohs(hg->dst_port->data);
                                        i+=chunk_length;
                                        totelem++;
                                        break;
                                case 9:
                                        hg->time_sec  = (hep_chunk_uint32_t *) (tmp);
                                        hg->time_sec->data = ntohl(hg->time_sec->data);
                                        heptime->tv_sec = hg->time_sec->data;
                                        i+=chunk_length;
                                        totelem++;
                                        break;                                                     
                                                     
                                case 10:
                                        hg->time_usec  = (hep_chunk_uint32_t *) (tmp);
                                        hg->time_usec->data = ntohl(hg->time_usec->data);
                                        heptime->tv_usec = hg->time_usec->data;
                                        i+=chunk_length;
                                        totelem++;
                                        break;      

                                case 11:
                                        hg->proto_t  = (hep_chunk_uint8_t *) (tmp);
                                        i+=chunk_length;
                                        totelem++;
                                        break;                                                                                                                                                         

                                case 12:
                                        hg->capt_id  = (hep_chunk_uint32_t *) (tmp);
                                        i+=chunk_length;
                                        heptime->captid = ntohs(hg->capt_id->data);
                                        totelem++;
                                        break;

                                case 13:
                                        hg->keep_tm  = (hep_chunk_uint16_t *) (tmp);
                                        i+=chunk_length;
                                        break;                                                     

                                case 14:
                                        authkey = (char *) tmp + sizeof(hep_chunk_t);
                                        i+=chunk_length;                                                                             
                                        break;
                                                     
                                case 15:
                                        hg->payload_chunk  = (hep_chunk_t *) (tmp);
                                        payload = (char *) tmp+sizeof(hep_chunk_t);
                                        payload_len = chunk_length - sizeof(hep_chunk_t);
                                        i+=chunk_length;
                                        totelem++;
                                        break;
                                case 17:
                                
                                        correlation_id = (char *) tmp + sizeof(hep_chunk_t);
                                        i+=chunk_length;                                                                            
					break;

                                                     
                                default:
                                        i+=chunk_length;
                                        break;
                        }                                        
                }
        }	                                                                                                          
                        
        /* CHECK how much elements */
        if(totelem < 9) {                        
                LM_ERR("Not all elements [%d]\n", totelem);                        
                goto done;
        }                 

        if ( dst_ip.af == 0 || src_ip.af == 0)  {
                LM_ERR("NO IP's set\n");
                goto done;
        }

                        
        ip_addr2su(&to, &dst_ip, msg->rcv.dst_port);
        ip_addr2su(&from, &src_ip, msg->rcv.src_port);
                        
        msg->rcv.src_su=from;
        su2ip_addr(&msg->rcv.src_ip, &from);
        su2ip_addr(&msg->rcv.dst_ip, &to);

	if(hg->ip_proto->data == IPPROTO_TCP) msg->rcv.proto=PROTO_TCP;
	else if(hg->ip_proto->data == IPPROTO_UDP) msg->rcv.proto=PROTO_UDP;

        if(payload != NULL) ret = len - payload_len;

	/*TIME*/ 
        heptime->tv_sec = hg->time_sec->data;
        heptime->tv_usec = hg->time_usec->data;
        heptime->captid = ntohs(hg->capt_id->data);

done:
          
        //if(si) pkg_free(si);
        if(hg) pkg_free(hg);                     

        return ret;
        
error:

        if(si) pkg_free(si);
        if(hg) pkg_free(hg);
                
        return -1;           
        
}
示例#2
0
文件: hep.c 项目: 4N7HR4X/kamailio
int parsing_hepv3_message(char *buf, unsigned int len) {

	union sockaddr_union from;
	union sockaddr_union to;
        struct receive_info ri;
	char *tmp;
	struct ip_addr dst_ip, src_ip;
	struct socket_info* si = 0;
	int tmp_len, i;
	char *payload = NULL;
	unsigned int payload_len = 0;
        struct hep_chunk *chunk;	
        struct hep_generic_recv *hg;
        int totelem = 0;
        int chunk_vendor=0, chunk_type=0, chunk_length=0;
        int total_length = 0;


	hg = (struct hep_generic_recv*)pkg_malloc(sizeof(struct hep_generic_recv));
	if(hg==NULL) {
	        LM_ERR("no more pkg memory left for hg\n");
	        return -1;
        }
	                                                 		
	memset(hg, 0, sizeof(struct hep_generic_recv));

	
        memset(heptime, 0, sizeof(struct hep_timehdr));	
	        

	/* HEADER */
	hg->header  = (hep_ctrl_t *) (buf);

	/*Packet size */
	total_length = ntohs(hg->header->length);

	ri.src_port = 0;
	ri.dst_port = 0;
	dst_ip.af = 0;
        src_ip.af = 0;
                	        
	payload = NULL;
	correlation_id = NULL;
	authkey = NULL;

	i = sizeof(hep_ctrl_t);	        
	        
	while(i < total_length) {
                
	        /*OUR TMP DATA */                                  
                tmp = buf+i;

                chunk = (struct hep_chunk*) tmp;
                             
                chunk_vendor = ntohs(chunk->vendor_id);                             
                chunk_type = ntohs(chunk->type_id);
                chunk_length = ntohs(chunk->length);
                       


                /* if chunk_length */
                if(chunk_length == 0) {
                        /* BAD LEN we drop this packet */
                        goto error;
                }

                /* SKIP not general Chunks */
                if(chunk_vendor != 0) {
                        i+=chunk_length;
                }
                else {                                                                                                                               
                        switch(chunk_type) {
                                     
                                case 0:
                                        goto error;
                                        break;
                                     
                                case 1:                                                                          
                                        hg->ip_family  = (hep_chunk_uint8_t *) (tmp);
                                        i+=chunk_length;
                                        totelem++;
                                        break;
                                case 2:
                                        hg->ip_proto  = (hep_chunk_uint8_t *) (tmp);
                                        i+=chunk_length;
                                        totelem++;
                                        break;                                                     
                                case 3:
                                        hg->hep_src_ip4  = (hep_chunk_ip4_t *) (tmp);
                                        i+=chunk_length;
                                        src_ip.af=AF_INET;
				        src_ip.len=4;
				        src_ip.u.addr32[0] = hg->hep_src_ip4->data.s_addr;
				        totelem++;
				        break;
                                case 4:
                                        hg->hep_dst_ip4  = (hep_chunk_ip4_t *) (tmp);
                                        i+=chunk_length;                                                     
					dst_ip.af=AF_INET;
				        dst_ip.len=4;
				        dst_ip.u.addr32[0] = hg->hep_dst_ip4->data.s_addr;
                                        totelem++;

                                        break;
                                case 5:
                                        hg->hep_src_ip6  = (hep_chunk_ip6_t *) (tmp);
                                        i+=chunk_length;
                                        src_ip.af=AF_INET6;
				        src_ip.len=16;
				        memcpy(src_ip.u.addr, &hg->hep_src_ip6->data, 16);
				        totelem++;
                                        break;
                                case 6:
                                        hg->hep_dst_ip6  = (hep_chunk_ip6_t *) (tmp);
                                        i+=chunk_length;                                                     
                                        dst_ip.af=AF_INET6;
				        dst_ip.len=16;
				        memcpy(dst_ip.u.addr, &hg->hep_dst_ip6->data, 16);
				        totelem++;
                                        break;
        
                                case 7:
                                        hg->src_port  = (hep_chunk_uint16_t *) (tmp);
                                        ri.src_port = ntohs(hg->src_port->data);
                                        i+=chunk_length;                      
                                        totelem++;
                                        break;

                                case 8:
                                        hg->dst_port  = (hep_chunk_uint16_t *) (tmp);
                                        ri.dst_port = ntohs(hg->dst_port->data);
                                        i+=chunk_length;
                                        totelem++;
                                        break;
                                case 9:
                                        hg->time_sec  = (hep_chunk_uint32_t *) (tmp);
                                        hg->time_sec->data = ntohl(hg->time_sec->data);
                                        heptime->tv_sec = hg->time_sec->data;
                                        i+=chunk_length;
                                        totelem++;
                                        break;                                                     
                                                     
                                case 10:
                                        hg->time_usec  = (hep_chunk_uint32_t *) (tmp);
                                        hg->time_usec->data = ntohl(hg->time_usec->data);
                                        heptime->tv_usec = hg->time_usec->data;
                                        i+=chunk_length;
                                        totelem++;
                                        break;      

                                case 11:
                                        hg->proto_t  = (hep_chunk_uint8_t *) (tmp);
                                        i+=chunk_length;
                                        totelem++;
                                        break;                                                                                                                                                         

                                case 12:
                                        hg->capt_id  = (hep_chunk_uint32_t *) (tmp);
                                        i+=chunk_length;
                                        heptime->captid = ntohs(hg->capt_id->data);
                                        totelem++;
                                        break;

                                case 13:
                                        hg->keep_tm  = (hep_chunk_uint16_t *) (tmp);
                                        i+=chunk_length;
                                        break;                                                     

                                case 14:
                                        authkey = (char *) tmp + sizeof(hep_chunk_t);
                                        i+=chunk_length;                                                                             
                                        break;
                                                     
                                case 15:
                                        hg->payload_chunk  = (hep_chunk_t *) (tmp);
                                        payload = (char *) tmp+sizeof(hep_chunk_t);
                                        payload_len = chunk_length - sizeof(hep_chunk_t);
                                        i+=chunk_length;
                                        totelem++;
                                        break;
                                case 17:
                                
                                        correlation_id = (char *) tmp + sizeof(hep_chunk_t);
                                        i+=chunk_length;                                                                            
					break;

                                                     
                                default:
                                        i+=chunk_length;
                                        break;
                        }                                        
                }
        }	                                                                                                          
                        
        /* CHECK how much elements */
        if(totelem < 9) {                        
                LM_ERR("Not all elements [%d]\n", totelem);                        
                goto done;
        }                 

        if ( dst_ip.af == 0 || src_ip.af == 0)  {
                LM_ERR("NO IP's set\n");
                goto done;
        }

                        
        ip_addr2su(&to, &dst_ip, ri.dst_port);
        ip_addr2su(&from, &src_ip, ri.src_port);
                        
        ri.src_su=from;
        su2ip_addr(&ri.src_ip, &from);
        su2ip_addr(&ri.dst_ip, &to);

	if(hg->ip_proto->data == IPPROTO_TCP) ri.proto=PROTO_TCP;
	else if(hg->ip_proto->data == IPPROTO_UDP) ri.proto=PROTO_UDP;

	/* a little bit memory */
        si=(struct socket_info*) pkg_malloc(sizeof(struct socket_info));
        if (si==0) {
                LOG(L_ERR, "ERROR: new_sock_info: memory allocation error\n");
                goto error;
        }

	memset(si, 0, sizeof(struct socket_info));
        si->address = ri.dst_ip;
        si->socket=-1;

        /* set port & proto */
        si->port_no = ri.dst_port;

        if(hg->ip_proto->data == IPPROTO_TCP) si->proto=PROTO_TCP;
        else if(hg->ip_proto->data == IPPROTO_UDP) si->proto=PROTO_UDP;

        si->flags=0;
        si->addr_info_lst=0;

        si->address_str.s = ip_addr2a(&si->address);;
        si->address_str.len = strlen(si->address_str.s);                                                

        si->port_no_str.s = int2str(si->port_no, &tmp_len);
        si->port_no_str.len = tmp_len;
	si->address_str.len = strlen(si->address_str.s);

        si->name.len = si->address_str.len;
        si->name.s = si->address_str.s;
        ri.bind_address=si;


	/*TIME*/ 
        heptime->tv_sec = hg->time_sec->data;
        heptime->tv_usec = hg->time_usec->data;
        heptime->captid = ntohs(hg->capt_id->data);
          

        if(payload != NULL ) {
                /* and now recieve message */
                if (hg->proto_t->data == 5) receive_logging_json_msg(payload, payload_len, hg, "rtcp_capture");
                else if (hg->proto_t->data == 32) receive_logging_json_msg(payload, payload_len, hg, "report_capture");
                else if (hg->proto_t->data == 99) receive_logging_json_msg(payload, payload_len, hg, "report_capture");
                else if (hg->proto_t->data == 100) receive_logging_json_msg(payload, payload_len, hg, "logs_capture");
                else receive_msg(payload, payload_len, &ri);
        }

done:
        if(si) pkg_free(si);
        if(hg) pkg_free(hg);                     

        return 1;
        
error:

        if(si) pkg_free(si);
        if(hg) pkg_free(hg);
                
        return -1;           
        
}
示例#3
0
/* receive an ipv4 udp packet over a raw socket.
 * The packet is copied in *buf and *buf is advanced to point to the
 * payload.  Fills from and to.
 * @param rsock - raw socket
 * @param buf - the packet will be written to where *buf points intially and
 *              then *buf will be advanced to point to the udp payload.
 * @param len - buffer length (should be enough to hold at least the
 *               ip and udp headers + 1 byte).
 * @param from - result parameter, filled with source address and port of the
 *               packet.
 * @param from - result parameter, filled with destination (local) address and
 *               port of the packet.
 * @param rf   - filter used to decide whether or not the packet is
 *                accepted/processed. If null, all the packets are accepted.
 * @return packet len or  <0 on error (-1 and -2 on recv error @see recvpkt4,
 *         -3 if the headers are invalid and -4 if the packet doesn't
 *         match the  filter).
 */
int raw_udp4_recv(int rsock, char** buf, int len, union sockaddr_union* from,
					union sockaddr_union* to, struct raw_filter* rf)
{
	int n;
	unsigned short dst_port;
	unsigned short src_port;
	struct ip_addr dst_ip;
	char* end;
	char* udph_start;
	char* udp_payload;
	struct ip iph;
	struct udphdr udph;
	unsigned short udp_len;

	n=recvpkt4(rsock, *buf, len, from, to);
	if (unlikely(n<0)) goto error;
	
	end=*buf+n;
	if (unlikely(n<((sizeof(struct ip) * raw_ipip ? 2 : 1)+sizeof(struct udphdr)))) {
		n=-3;
		goto error;
	}
	
	if(raw_ipip) 
        	*buf = *buf + sizeof(struct ip);
	
	/* FIXME: if initial buffer is aligned, one could skip the memcpy
	   and directly cast ip and udphdr pointer to the memory */
	memcpy(&iph, *buf, sizeof(struct ip));
	udph_start=*buf+iph.ip_hl*4;
	udp_payload=udph_start+sizeof(struct udphdr);
	if (unlikely(udp_payload>end)){
		n=-3;
		goto error;
	}
	memcpy(&udph, udph_start, sizeof(struct udphdr));
	udp_len=ntohs(udph.uh_ulen);
	if (unlikely((udph_start+udp_len)!=end)){
		if ((udph_start+udp_len)>end){
			n=-3;
			goto error;
		}else{
			ERR("udp length too small: %d/%d\n",
					(int)udp_len, (int)(end-udph_start));
			n=-3;
			goto error;
		}
	}
	/* advance buf */
	*buf=udp_payload;
	n=(int)(end-*buf);
	/* fill ip from the packet (needed if no PKT_INFO is used) */
	dst_ip.af=AF_INET;
	dst_ip.len=4;
	dst_ip.u.addr32[0]=iph.ip_dst.s_addr;
	/* fill dst_port */
	dst_port=ntohs(udph.uh_dport);
	ip_addr2su(to, &dst_ip, dst_port);
	/* fill src_port */
	src_port=ntohs(udph.uh_sport);
	su_setport(from, src_port);
	if (likely(rf)) {
		su2ip_addr(&dst_ip, to);
		if ( (dst_port && rf->port1 && ((dst_port<rf->port1) ||
										(dst_port>rf->port2)) ) ||
			(matchnet(&dst_ip, &rf->dst)!=1) ){
			/* no match */
			n=-4;
			goto error;
		}
	}
	
error:
	return n;
}
示例#4
0
/*!
 * \brief Convert a STR [proto:]ip[:port] into socket address.
 * [proto:]ip[:port]
 * \param pipport (udp:127.0.0.1:5060 or tcp:2001:0DB8:AC10:FE01:5060)
 * \param tmp_su target structure
 * \param proto uint protocol type
 * \return success / unsuccess
 */
static int pipport2su (str *sproto, str *ip, unsigned short port,
			union sockaddr_union *tmp_su, unsigned int *proto)
{
	struct ip_addr *ip_a;
	str host_uri;

	/*parse protocol */
	if(strncmp(sproto->s, "udp",3) == 0) *proto = IPPROTO_UDP;
	else if(strncmp(sproto->s, "tcp",3) == 0) *proto = IPPROTO_TCP;
	else if(strncmp(sproto->s, "tls",3) == 0) *proto = IPPROTO_IDP;
												/* fake proto type */
	else if(strncmp(sproto->s, "sctp",4) == 0) *proto = IPPROTO_SCTP;
	else if(strncmp(sproto->s, "any",3) == 0) *proto = IPPROTO_UDP;
	else if(strncmp(sproto->s, "ws",2) == 0) *proto = IPPROTO_ESP;
												/* fake proto type */
	else {
		LM_ERR("bad protocol %.*s\n", sproto->len, sproto->s);
		return -1;
	}

	/*check if ip is not null*/
	if (ip->len == 0) {
		LM_ERR("malformed ip address\n");
		return -1;
	}

	if (port == 0) {
		port = SIP_PORT;
	}
	else{
	/*the address contains a port number*/
		if (port<1024  || port>65536)
		{
			LM_ERR("invalid port number; must be in [1024,65536]\n");
			return -1;
		}
	}
	LM_DBG("proto %d, host %.*s , port %d \n",*proto, ip->len, ip->s, port);

	/* now IPv6 address has no brakets. It should be fixed! */
	host_uri = *ip;
	if (host_uri.s[0] == '[') {
		if(host_uri.s[host_uri.len-1] != ']') {
			LM_ERR("bracket not closed\n");
			return -1;
		}
		host_uri.s++;
		host_uri.len -= 2;
	}

	/* check if it's an ip address */
	if (((ip_a = str2ip(&host_uri)) != 0)
			|| ((ip_a = str2ip6 (&host_uri)) != 0)
	) {
		ip_addr2su(tmp_su, ip_a, ntohs(port));
		return 0;
	}

	LM_ERR("host <%.*s> is not an IP\n",host_uri.len,host_uri.s);
	return -1;
}
示例#5
0
/*!
 * \brief Convert a STR [proto:]ip[:port] into socket address.
 * [proto:]ip[:port]
 * \param pipport (udp:127.0.0.1:5060 or tcp:2001:0DB8:AC10:FE01:5060)
 * \param tmp_su target structure
 * \param proto uint protocol type
 * \return success / unsuccess
 */
static int pipport2su (char *pipport, union sockaddr_union *tmp_su, unsigned int *proto)
{
	unsigned int port_no, cutlen = 4;
	struct ip_addr *ip;
	char *p, *host_s;
	str port_str, host_uri;
	unsigned len = 0;
	char tmp_piport[256];

	/*parse protocol */
	if(strncmp(pipport, "udp:",4) == 0) *proto = IPPROTO_UDP;
	else if(strncmp(pipport, "tcp:",4) == 0) *proto = IPPROTO_TCP;
	else if(strncmp(pipport, "tls:",4) == 0) *proto = IPPROTO_IDP; /* fake proto type */
	else if(strncmp(pipport, "ws:",3) == 0) *proto = IPPROTO_IDP; /* fake proto type */
	else if(strncmp(pipport, "wss:",4) == 0) *proto = IPPROTO_IDP; /* fake proto type */
#ifdef USE_SCTP
	else if(strncmp(pipport, "sctp:",5) == 0) cutlen = 5, *proto = IPPROTO_SCTP;
#endif
	else if(strncmp(pipport, "any:",4) == 0) *proto = IPPROTO_UDP;
	else {
		LM_ERR("bad protocol %s\n", pipport);
		return -1;
	}

	if((len = strlen(pipport)) >= 256) {
		LM_ERR("too big pipport\n");
		goto error;
	}

	/* our tmp string */
	strncpy(tmp_piport, pipport, len+1);

	len = 0;

	/*separate proto and host */
	p = tmp_piport+cutlen;
	if( (*(p)) == '\0') {
		LM_ERR("malformed ip address\n");
		goto error;
	}
	host_s=p;

	if( (p = strrchr(p+1, ':')) == 0 ) {
		LM_DBG("no port specified\n");
		port_no = 0;
	}
	else {
		/*the address contains a port number*/
		*p = '\0';
		p++;
		port_str.s = p;
		port_str.len = strlen(p);
		LM_DBG("the port string is %s\n", p);
		if(str2int(&port_str, &port_no) != 0 ) {
			LM_ERR("there is not a valid number port\n");
			goto error;
		}
		*p = '\0';
	}

	/* now IPv6 address has no brakets. It should be fixed! */
	if (host_s[0] == '[') {
		len = strlen(host_s + 1) - 1;
		if(host_s[len+1] != ']') {
			LM_ERR("bracket not closed\n");
			goto error;
		}
		memmove(host_s, host_s + 1, len);
		host_s[len] = '\0';
	}

	host_uri.s = host_s;
	host_uri.len = strlen(host_s);

	/* check if it's an ip address */
	if (((ip=str2ip(&host_uri))!=0)
			|| ((ip=str2ip6(&host_uri))!=0)
	   ) {
		ip_addr2su(tmp_su, ip, ntohs(port_no));
		return 0;	

	}

error:
	return -1;
}