Contributed Logic / file revision

 /*

  * $Id: enum.c 5901 2009-07-21 07:45:05Z bogdan_iancu $

  *

  * Enum and E164 related functions

  *

  * Copyright (C) 2002-2008 Juha Heinanen

  *

  * This file is part of opensips, a free SIP server.

  *

  * opensips is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version

  *

  * opensips is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License 

  * along with this program; if not, write to the Free Software 

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  */

 #include <stdlib.h>

 #include "enum.h"

 #include "../../parser/parse_uri.h"

 #include "../../parser/parse_from.h"

 #include "../../ut.h"

 #include "../../resolve.h"

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

 #include "../../dset.h"

 #include "../../qvalue.h"

 #include "enum_mod.h"

 #include "../../regexp.h"

 #include "../../pvar.h"

 /*

  * Input: E.164 number w/o leading +

  *

  * Output: number of digits in the country code

  * 	   0 on invalid number

  *

  * convention:

  *   3 digits is the default length of a country code.

  *   country codes 1 and 7 are a single digit.

  *   the following country codes are two digits: 20, 27, 30-34, 36, 39,

  *     40, 41, 43-49, 51-58, 60-66, 81, 82, 84, 86, 90-95, 98.

  */

 static int cclen(const char *number)

 {

 	char d1,d2;

 	if (!number || (strlen(number) < 3))

 		return(0);

 	d1 = number[0];

 	d2 = number[1];

 	if (!isdigit((int)d2)) 

 		return(0);

 	switch(d1) {

 		case '1':

 		case '7':

 			return(1);

 		case '2':

 			if ((d2 == '0') || (d1 == '7'))

 				return(2);

 			break;

 		case '3':

 			if ((d2 >= '0') && (d1 <= '4'))

 				return(2);

 			if ((d2 == '6') || (d1 == '9'))

 				return(2);

 			break;

 		case '4':

 			if (d2 != '2')

 				return(2);

 			break;

 		case '5':

 			if ((d2 >= '1') && (d1 <= '8'))

 				return(2);

 			break;

 		case '6':

 			if (d1 <= '6')

 				return(2);

 			break;

 		case '8':

 			if ((d2 == '1') || (d1 == '2') || (d1 == '4') || (d1 == '6')) 

 				return(2);

 			break;

 		case '9':

 			if (d1 <= '5')

 				return(2);

 			if (d2 == '8')

 				return(2);

 			break;

 		default:

 			return(0);

 	}

 	return(3);

 }

 /* return the length of the string until c, if not found returns n */

 static inline int findchr(char* p, int c, unsigned int size)

 {

 	int len=0;

 	for(;len<size;p++){

 		if (*p==(unsigned char)c) {

 			return len;

 		}

 		len++;   

 	}

 	return len;

 }

 /* Parse NAPTR regexp field of the form !pattern!replacement! and return its

  * components in pattern and replacement parameters.  Regexp field starts at

  * address first and is len characters long.

  */

 static inline int parse_naptr_regexp(char* first, int len, str* pattern,

 										str* replacement)

 {

 	char *second, *third;

 	if (len > 0) {

 		if (*first == '!') {

 			second = (char *)memchr((void *)(first + 1), '!', len - 1);

 			if (second) {

 				len = len - (second - first + 1);

 				if (len > 0) {

 					third = memchr(second + 1, '!', len);

 					if (third) {

 						pattern->len = second - first - 1;

 						pattern->s = first + 1;

 						replacement->len = third - second - 1;

 						replacement->s = second + 1;

 						return 1;

 					} else {

 						LM_ERR("Third ! missing from regexp\n");

 						return -1;

 					}

 				} else {

 					LM_ERR("Third ! missing from regexp\n");

 					return -2;

 				}

 			} else {

 				LM_ERR("Second ! missing from regexp\n");

 				return -3;

 			}

 		} else {

 			LM_ERR("First ! missing from regexp\n");

 			return -4;

 		}

 	} else {

 		LM_ERR("Regexp missing\n");

 		return -5;

 	}

 }

 /* Checks if NAPTR record has flag u and its services field

  * e2u+[service:]sip or

  * e2u+service[+service[+service[+...]]]

  */

 static inline int sip_match( struct naptr_rdata* naptr, str* service)

 {

   if (service->len == 0) {

     return (naptr->flags_len == 1) &&

       ((naptr->flags[0] == 'u') || (naptr->flags[0] == 'U')) &&

       (naptr->services_len == 7) &&

       ((strncasecmp(naptr->services, "e2u+sip", 7) == 0) ||

        (strncasecmp(naptr->services, "sip+e2u", 7) == 0));

   } else if (service->s[0] != '+') {

     return (naptr->flags_len == 1) &&

       ((naptr->flags[0] == 'u') || (naptr->flags[0] == 'U')) &&

       (naptr->services_len == service->len + 8) &&

       (strncasecmp(naptr->services, "e2u+", 4) == 0) &&

       (strncasecmp(naptr->services + 4, service->s, service->len) == 0) &&

       (strncasecmp(naptr->services + 4 + service->len, ":sip", 4) == 0);

   } else { /* handle compound NAPTRs and multiple services */

     str bakservice, baknaptr; /* we bakup the str */

     int naptrlen, len;        /* length of the extracted service */

     /* RFC 3761, NAPTR service field must start with E2U+ */

     if (strncasecmp(naptr->services, "e2u+", 4) != 0) {

       return 0;

     }

     baknaptr.s   = naptr->services + 4; /* leading 'e2u+' */

     baknaptr.len = naptr->services_len - 4;

     for (;;) { /* iterate over services in NAPTR */

       bakservice.s   = service->s + 1; /* leading '+' */

       bakservice.len = service->len - 1;

       naptrlen = findchr(baknaptr.s,'+',baknaptr.len);

       for (;;) { /* iterate over services in enum_query */

         len = findchr(bakservice.s,'+',bakservice.len);

         if ((naptrlen == len ) && !strncasecmp(baknaptr.s, bakservice.s, len)){

           return 1;

         }

         if ( (bakservice.len -= len+1) > 0) {

           bakservice.s += len+1;

           continue;

         }

         break;

       }

       if ( (baknaptr.len -= naptrlen+1) > 0) {

         baknaptr.s += naptrlen+1;

         continue;

       }

       break;

     }

     /* no matching service found */

     return 0;

   }

 }

 /*

  * Checks if argument is an e164 number starting with +

  */

 static inline int is_e164(str* _user)

 {

 	int i;

 	char c;

 	if ((_user->len > 2) && (_user->len < 17) && ((_user->s)[0] == '+')) {

 		for (i = 1; i < _user->len; i++) {

 			c = (_user->s)[i];

 			if ((c < '0') || (c > '9')) return -1;

 		}

 		return 1;

 	} else {

 	    return -1;

 	}

 }

 /*

  * Call is_from_user_enum_2 with module parameter suffix and default service.

  */

 int is_from_user_enum_0(struct sip_msg* _msg, char* _str1, char* _str2)

 {

 	return is_from_user_enum_2(_msg, (char *)(&suffix), (char *)(&service));

 }

 /*

  * Call is_from_user_enum_2 with given suffix and default service.

  */

 int is_from_user_enum_1(struct sip_msg* _msg, char* _suffix, char* _str2)

 {

 	return is_from_user_enum_2(_msg, _suffix, (char *)(&service));

 }

 /*

  * Check if from user is a valid enum based user, and check to make sure

  * that the src_ip == an srv record that maps to the enum from user.

  */

 int is_from_user_enum_2(struct sip_msg* _msg, char* _suffix, char* _service)

 {

 	struct ip_addr addr;

 	struct hostent* he;

 	unsigned short zp;

 	unsigned short proto;

 	char *user_s;

 	int user_len, i, j;

 	char name[MAX_DOMAIN_SIZE];

 	char uri[MAX_URI_SIZE];

 	struct sip_uri *furi;

 	struct sip_uri luri;

 	struct rdata* head;

 	str* suffix;

 	str* service;

 	struct rdata* l;

 	struct naptr_rdata* naptr;

 	str pattern, replacement, result;

 	char string[17];

 	if (parse_from_header(_msg) < 0) {

 	    LM_ERR("Failed to parse From header\n");

 	    return -1;

 	}

 	if(_msg->from==NULL || get_from(_msg)==NULL) {

 	    LM_DBG("No From header\n");

 	    return -1;

 	}

 	if ((furi = parse_from_uri(_msg)) == NULL) {

 	    LM_ERR("Failed to parse From URI\n");

 	    return -1;

 	}

 	suffix = (str*)_suffix;

 	service = (str*)_service;

 	if (is_e164(&(furi->user)) == -1) {

 	    LM_ERR("From URI user is not an E164 number\n");

 	    return -1;

 	}

 	/* assert: the from user is a valid formatted e164 string */

 	user_s = furi->user.s;

 	user_len = furi->user.len;

 	j = 0;

 	for (i = user_len - 1; i > 0; i--) {

 		name[j] = user_s[i];

 		name[j + 1] = '.';

 		j = j + 2;

 	}

 	memcpy(name + j, suffix->s, suffix->len + 1);

 	head = get_record(name, T_NAPTR);

 	if (head == 0) {

 		LM_DBG("No NAPTR record found for %s.\n", name);

 		return -3;

 	}

 	/* we have the naptr records, loop and find an srv record with */

 	/* same ip address as source ip address, if we do then true is returned */

 	for (l = head; l; l = l->next) {

 		if (l->type != T_NAPTR) continue; /*should never happen*/

 		naptr = (struct naptr_rdata*)l->rdata;

 		if (naptr == 0) {

 			LM_ERR("Null rdata in DNS response\n");

 			free_rdata_list(head);

 			return -4;

 		}

 		LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags "

 		       "'%.*s', slen %u, services '%.*s', rlen %u, "

 		       "regexp '%.*s'\n",

 		       name, naptr->order, naptr->pref,

 		    naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags), naptr->services_len,

 		    (int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,

 		    (int)(naptr->regexp_len), ZSW(naptr->regexp));

 		if (sip_match(naptr, service) != 0) {

 			if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,

 					 &pattern, &replacement) < 0) {

 				free_rdata_list(head); /*clean up*/

 				LM_ERR("Parsing of NAPTR regexp failed\n");

 				return -5;

 			}

 #ifdef LATER

 			if ((pattern.len == 4) && (strncmp(pattern.s, "^.*$", 4) == 0)) {

 				LM_DBG("Resulted in replacement: '%.*s'\n",

 				       replacement.len, ZSW(replacement.s));				

 				retval = set_uri(_msg, replacement.s, replacement.len);

 				free_rdata_list(head); /*clean up*/

 				return retval;

 			}

 #endif

 			result.s = &(uri[0]);

 			result.len = MAX_URI_SIZE;

 			/* Avoid making copies of pattern and replacement */

 			pattern.s[pattern.len] = (char)0;

 			replacement.s[replacement.len] = (char)0;

 			/* We have already checked the size of

 			   _msg->parsed_uri.user.s */ 

 			memcpy(&(string[0]), user_s, user_len);

 			string[user_len] = (char)0;

 			if (reg_replace(pattern.s, replacement.s, &(string[0]),

 					&result) < 0) {

 				pattern.s[pattern.len] = '!';

 				replacement.s[replacement.len] = '!';

 				LM_ERR("Regexp replace failed\n");

 				free_rdata_list(head); /*clean up*/

 				return -6;

 			}

 			LM_DBG("Resulted in replacement: '%.*s'\n",

 			    result.len, ZSW(result.s));

 			if(parse_uri(result.s, result.len, &luri) < 0)

 			{

 				LM_ERR("Parsing of URI <%.*s> failed\n",

 				       result.len, result.s);

 				free_rdata_list(head); /*clean up*/

 				return -7;

 			}

 			pattern.s[pattern.len] = '!';

 			replacement.s[replacement.len] = '!';

 			zp = 0;

 			proto = PROTO_NONE;

 			he = sip_resolvehost(&luri.host, &zp, &proto,

 				(luri.type==SIPS_URI_T)?1:0 , 0);

 			hostent2ip_addr(&addr, he, 0);

 			if(ip_addr_cmp(&addr, &_msg->rcv.src_ip))

 			{

 				free_rdata_list(head);

 				return(1);

 			}

 		}

 	}

 	free_rdata_list(head); /*clean up*/

 	LM_DBG("FAIL\n");

     /* must not have found the record */

     return(-8);

 }

 /* 

  * Add parameter to URI.

  */

 int add_uri_param(str *uri, str *param, str *new_uri)

 {

 	struct sip_uri puri;

 	char *at;

 	if (parse_uri(uri->s, uri->len, &puri) < 0) {

 		return 0;

 	}

 	/* if current uri has no headers, pad param to the end of uri */

 	if (puri.headers.len == 0) {

 		memcpy(uri->s + uri->len, param->s, param->len);

 		uri->len = uri->len + param->len;

 		new_uri->len = 0;

 		return 1;

 	}

 	/* otherwise take the long path and create new_uri */

 	at = new_uri->s;

 	switch (puri.type) {

 	case SIP_URI_T:

 	    memcpy(at, "sip:", 4);

 	    at = at + 4;

 	    break;

 	case SIPS_URI_T:

 	    memcpy(at, "sips:", 5);

 	    at = at + 5;

 	    break;

 	case TEL_URI_T:

 	    memcpy(at, "tel:", 4);

 	    at = at + 4;

 	    break;

 	case TELS_URI_T:

 	    memcpy(at, "tels:", 5);

 	    at = at + 5;

 	    break;

 	default:

 	    LM_ERR("Unknown URI scheme <%d>\n", puri.type);

 	    return 0;

 	}

 	if (puri.user.len) {

 		memcpy(at, puri.user.s, puri.user.len);

 		at = at + puri.user.len;

 		if (puri.passwd.len) {

 			*at = ':';

 			at = at + 1;

 			memcpy(at, puri.passwd.s, puri.passwd.len);

 			at = at + puri.passwd.len;

 		};

 		*at = '@';

 		at = at + 1;

 	}

 	memcpy(at, puri.host.s, puri.host.len);

 	at = at + puri.host.len;

 	if (puri.port.len) {

 		*at = ':';

 		at = at + 1;

 		memcpy(at, puri.port.s, puri.port.len);

 		at = at + puri.port.len;

 	}

 	if (puri.params.len) {

 		*at = ';';

 		at = at + 1;

 		memcpy(at, puri.params.s, puri.params.len);

 		at = at + puri.params.len;

 	}

 	memcpy(at, param->s, param->len);

 	at = at + param->len;

 	*at = '?';

 	at = at + 1;

 	memcpy(at, puri.headers.s, puri.headers.len);

 	at = at + puri.headers.len;

 	new_uri->len = at - new_uri->s;

 	return 1;

 }

 /*

  * Tests if one result record is "greater" that the other.  Non-NAPTR records

  * greater that NAPTR record.  An invalid NAPTR record is greater than a 

  * valid one.  Valid NAPTR records are compared based on their

  * (order,preference).

  */

 static inline int naptr_greater(struct rdata* a, struct rdata* b)

 {

 	struct naptr_rdata *na, *nb;

 	if (a->type != T_NAPTR) return 1;

 	if (b->type != T_NAPTR) return 0;

 	na = (struct naptr_rdata*)a->rdata;

 	if (na == 0) return 1;

 	nb = (struct naptr_rdata*)b->rdata;

 	if (nb == 0) return 0;

 	return (((na->order) << 16) + na->pref) >

 		(((nb->order) << 16) + nb->pref);

 }

 /*

  * Bubble sorts result record list according to naptr (order,preference).

  */

 static inline void naptr_sort(struct rdata** head)

 {

 	struct rdata *p, *q, *r, *s, *temp, *start;

         /* r precedes p and s points to the node up to which comparisons

          are to be made */ 

 	s = NULL;

 	start = *head;

 	while ( s != start -> next ) { 

 		r = p = start ; 

 		q = p -> next ;

 		while ( p != s ) { 

 			if ( naptr_greater(p, q) ) { 

 				if ( p == start ) { 

 					temp = q -> next ; 

 					q -> next = p ; 

 					p -> next = temp ;

 					start = q ; 

 					r = q ; 

 				} else {

 					temp = q -> next ; 

 					q -> next = p ; 

 					p -> next = temp ;

 					r -> next = q ; 

 					r = q ; 

 				} 

 			} else {

 				r = p ; 

 				p = p -> next ; 

 			} 

 			q = p -> next ; 

 			if ( q == s ) s = p ; 

 		}

 	}

 	*head = start;

 }	

 /*

  * Makes enum query on name.  On success, rewrites user part and 

  * replaces Request-URI.

  */

 int do_query(struct sip_msg* _msg, char *user, char *name, str *service) {

     char uri[MAX_URI_SIZE];

     char new_uri[MAX_URI_SIZE];

     unsigned int priority, curr_prio, first;

     qvalue_t q;

     struct rdata* head;

     struct rdata* l;

     struct naptr_rdata* naptr;

     str pattern, replacement, result, new_result;

     head = get_record(name, T_NAPTR);

     if (head == 0) {

 	LM_DBG("No NAPTR record found for %s.\n", name);

 	return -1;

     }

     naptr_sort(&head);

     q = MAX_Q - 10;

     curr_prio = 0;

     first = 1;

     for (l = head; l; l = l->next) {

 	if (l->type != T_NAPTR) continue; /*should never happen*/

 	naptr = (struct naptr_rdata*)l->rdata;

 	if (naptr == 0) {

 	    LM_ERR("Null rdata in DNS response\n");

 	    continue;

 	}

 	LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags '%.*s', "

 	       "slen %u, services '%.*s', rlen %u, regexp '%.*s'\n",

 	       name, naptr->order, naptr->pref,

 	    naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),

 	    naptr->services_len,

 	    (int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,

 	    (int)(naptr->regexp_len), ZSW(naptr->regexp));

 	if (sip_match(naptr, service) == 0) continue;

 	if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,

 			       &pattern, &replacement) < 0) {

 	    LM_ERR("Parsing of NAPTR regexp failed\n");

 	    continue;

 	}

 	result.s = &(uri[0]);

 	result.len = MAX_URI_SIZE;

 	/* Avoid making copies of pattern and replacement */

 	pattern.s[pattern.len] = (char)0;

 	replacement.s[replacement.len] = (char)0;

 	if (reg_replace(pattern.s, replacement.s, user, &result) < 0) {

 	    pattern.s[pattern.len] = '!';

 	    replacement.s[replacement.len] = '!';

 	    LM_ERR("Regexp replace failed\n");

 	    continue;

 	}

 	LM_DBG("Resulted in replacement: '%.*s'\n", result.len, ZSW(result.s));

 	pattern.s[pattern.len] = '!';

 	replacement.s[replacement.len] = '!';

 	if (param.len > 0) {

 	    if (result.len + param.len > MAX_URI_SIZE - 1) {

 		LM_ERR("URI is too long\n");

 		continue;

 	    }

 	    new_result.s = &(new_uri[0]);

 	    new_result.len = MAX_URI_SIZE;

 	    if (add_uri_param(&result, &param, &new_result) == 0) {

 		LM_ERR("Parsing of URI <%.*s> failed\n",

 		       result.len, result.s);

 		continue;

 	    }

 	    if (new_result.len > 0) {

 		result = new_result;

 	    }

 	}

 	if (first) {

 	    if (set_ruri(_msg, &result) == -1) {

 		goto done;

 	    }

 	    set_ruri_q(q);

 	    first = 0;

 	    curr_prio = ((naptr->order) << 16) + naptr->pref;

 	} else {

 	    priority = ((naptr->order) << 16) + naptr->pref;

 	    if (priority > curr_prio) {

 		q = q - 10;

 		curr_prio = priority;

 	    }

 	    if (append_branch(_msg, &result, 0, 0, q, 0, 0) == -1) {

 		goto done;

 	    }

 	}

     }

 done:

     free_rdata_list(head);

     return first ? -1 : 1;

 }

 /*

  * Call enum_query_2 with module parameter suffix and default service.

  */

 int enum_query_0(struct sip_msg* _msg, char* _str1, char* _str2)

 {

 	return enum_query_2(_msg, (char *)(&suffix), (char *)(&service));

 }

 /*

  * Call enum_query_2 with given suffix and default service.

  */

 int enum_query_1(struct sip_msg* _msg, char* _suffix, char* _str2)

 {

 	return enum_query_2(_msg, _suffix, (char *)(&service));

 }

 /*

  * See documentation in README file.

  */

 int enum_query_2(struct sip_msg* _msg, char* _suffix, char* _service)

 {

 	char *user_s;

 	int user_len, i, j;

 	char name[MAX_DOMAIN_SIZE];

 	char string[17];

 	str *suffix, *service;

 	suffix = (str*)_suffix;

 	service = (str*)_service;

 	if (parse_sip_msg_uri(_msg) < 0) {

 		LM_ERR("Parsing of R-URI failed\n");

 		return -1;

 	}

 	if (is_e164(&(_msg->parsed_uri.user)) == -1) {

 		LM_ERR("R-URI user is not an E164 number\n");

 		return -1;

 	}

 	user_s = _msg->parsed_uri.user.s;

 	user_len = _msg->parsed_uri.user.len;

 	memcpy(&(string[0]), user_s, user_len);

 	string[user_len] = (char)0;

 	j = 0;

 	for (i = user_len - 1; i > 0; i--) {

 		name[j] = user_s[i];

 		name[j + 1] = '.';

 		j = j + 2;

 	}

 	memcpy(name + j, suffix->s, suffix->len + 1);

 	return do_query(_msg, string, name, service);

 }

 /*

  * Call isn_query_2 with module parameter suffix and default service.

  */

 int isn_query_0(struct sip_msg* _msg, char* _str1, char* _str2)

 {

 	return isn_query_2(_msg, (char *)(&isnsuffix), (char *)(&service));

 }

 /*

  * Call isn_query_2 with given suffix and default service.

  */

 int isn_query_1(struct sip_msg* _msg, char* _suffix, char* _str2)

 {

 	return isn_query_2(_msg, _suffix, (char *)(&service));

 }

 /*

  * See documentation in README file.

  */

 int isn_query_2(struct sip_msg* _msg, char* _suffix, char* _service)

 {

 	char *user_s = NULL;

 	int user_len, i, j;

 	char name[MAX_DOMAIN_SIZE] = {0};

 	char string[17] = {0};

 	char szItad[17] = {0};

 	size_t nItlen = 0;

 	str *suffix, *service;

 	suffix = (str*)_suffix;

 	service = (str*)_service;

 	if (parse_sip_msg_uri(_msg) < 0) {

 		LM_ERR("Parsing of R-URI failed\n");

 		return -1;

 	}

 	user_s = _msg->parsed_uri.user.s;

 	user_len = _msg->parsed_uri.user.len;

 	memcpy(&(string[0]), user_s, user_len);

 	string[user_len] = (char)0;

 	/* Do primitive test for correct ISN format, */

 	/* and set szItad to the ISN ITAD (RFC 3872/2871). */

 	/* Correct ISN format guessed from freenum.org and IANA */

 	/* doc http://www.iana.org/assignments/trip-parameters/ */

 	{

 		char *pAster = strchr(string, '*');

 		if (pAster && (nItlen = strspn(pAster + sizeof(char), "0123456789")))

 			strncpy(szItad, pAster + sizeof(char), nItlen);

 		else {

 			LM_ERR("R-URI user does not contain a valid ISN\n");

 			return -1;

 		}

 	}

 	/* Ammend the original ENUM E.164 string logic to process */

 	/* ISN numbers instead, which include a nonreversed ITAD. */

 	i = user_len - nItlen - sizeof(char); /* Ex: *1212 */

 	j = 0;

 	while (i--) {

 		name[j] = user_s[i];

 		name[j + 1] = '.';

 		j = j + 2;

 	}

 	strcat(name + j, szItad);  /* Copy the unreversed ITAD, */

 	name[j + nItlen] = '.';    /* and append a trailing dot. */

 	memcpy(name + j + nItlen + sizeof(char), suffix->s, suffix->len + 1);

 	return do_query(_msg, string, name, service);

 }

 /*********** INFRASTRUCTURE ENUM ***************/

 /*

  * Call enum_query_2 with default suffix and service.

  */

 int i_enum_query_0(struct sip_msg* _msg, char* _suffix, char* _service)

 {

 	return i_enum_query_2(_msg, (char *)(&i_suffix), (char *)(&service));

 }

 /*

  * Call enum_query_2 with given suffix and default service.

  */

 int i_enum_query_1(struct sip_msg* _msg, char* _suffix, char* _service)

 {

 	return i_enum_query_2(_msg, _suffix, (char *)(&service));

 }

 int i_enum_query_2(struct sip_msg* _msg, char* _suffix, char* _service)

 {

 	char *user_s;

 	int user_len, i, j;

 	char name[MAX_DOMAIN_SIZE];

 	char apex[MAX_COMPONENT_SIZE + 1];

 	char separator[MAX_COMPONENT_SIZE + 1];

 	int sdl = 0;    /* subdomain location: infrastructure enum offset */

 	int cc_len;

 	struct rdata* head;

 	char string[17];

 	str *suffix, *service;

 	suffix = (str*)_suffix;

 	service = (str*)_service;

 	if (parse_sip_msg_uri(_msg) < 0) {

 		LM_ERR("Parsing of R-URI failed\n");

 		return -1;

 	}

 	if (is_e164(&(_msg->parsed_uri.user)) == -1) {

 		LM_ERR("R-URI user is not an E164 number\n");

 		return -1;

 	}

 	user_s = _msg->parsed_uri.user.s;

 	user_len = _msg->parsed_uri.user.len;

 	/* make sure we don't run out of space in strings */

 	if (( 2*user_len + MAX_COMPONENT_SIZE + MAX_COMPONENT_SIZE + 4) > MAX_DOMAIN_SIZE) {

 		LM_ERR("Strings too long\n");

 		return -1;

 	}

 	if ( i_branchlabel.len > MAX_COMPONENT_SIZE ) {

 		LM_ERR("i_branchlabel too long\n");

 		return -1;

 	}

 	if ( suffix->len > MAX_COMPONENT_SIZE ) {

 		LM_ERR("Suffix too long\n");

 		return -1;

 	}

 	memcpy(&(string[0]), user_s, user_len);

 	string[user_len] = (char)0;

 	/* Set up parameters as for user-enum */

 	memcpy(apex,  suffix->s , suffix->len);

 	apex[suffix->len] = (char)0;

 	sdl = 0;		/* where to insert i-enum separator */

 	separator[0] = 0;	/* don't insert anything */

 	cc_len = cclen(string + 1);

 	if (!strncasecmp(i_bl_alg.s,"ebl",i_bl_alg.len)) {

 		sdl = cc_len; /* default */

 		j = 0;

 		memcpy(name, i_branchlabel.s, i_branchlabel.len);

 		j += i_branchlabel.len;

 		name[j++] = '.';

 		for (i = cc_len ; i > 0; i--) {

 			name[j++] = user_s[i];

 			name[j++] = '.';

 		}

 		memcpy(name + j, suffix->s, suffix->len + 1);

 		LM_DBG("Looking for EBL record for %s.\n", name); 

 		head = get_record(name, T_EBL);

 		if (head == 0) {

 			LM_DBG("No EBL found for %s. Defaulting to user ENUM.\n",name);

 		} else {

 		    	struct ebl_rdata* ebl;

 			ebl = (struct ebl_rdata *) head->rdata;

 			LM_DBG("EBL record for %s is %d / %.*s / %.*s.\n",

 			       name, ebl->position, (int)ebl->separator_len,

 			       ebl->separator,(int)ebl->apex_len, ebl->apex);

 			if ((ebl->apex_len > MAX_COMPONENT_SIZE) || (ebl->separator_len > MAX_COMPONENT_SIZE)) {

 				LM_ERR("EBL strings too long\n"); 

 				return -1;

 			}

 			if (ebl->position > 15)  {

 				LM_ERR("EBL position too large (%d)\n",

 				       ebl->position); 

 				return -1;

 			}

 			sdl = ebl->position;

 			memcpy(separator, ebl->separator, ebl->separator_len);

 			separator[ebl->separator_len] = 0;

 			memcpy(apex, ebl->apex, ebl->apex_len);

 			apex[ebl->apex_len] = 0;

 			free_rdata_list(head);

 		}

 	} else if (!strncasecmp(i_bl_alg.s,"txt",i_bl_alg.len)) {

 		sdl = cc_len; /* default */

 		memcpy(separator, i_branchlabel.s, i_branchlabel.len);

 		separator[i_branchlabel.len] = 0;

 		/* no change to apex */

 		j = 0;

 		memcpy(name, i_branchlabel.s, i_branchlabel.len);

 		j += i_branchlabel.len;

 		name[j++] = '.';

 		for (i = cc_len ; i > 0; i--) {

 			name[j++] = user_s[i];

 			name[j++] = '.';

 		}

 		memcpy(name + j, suffix->s, suffix->len + 1);

 		head = get_record(name, T_TXT);

 		if (head == 0) {

 			LM_DBG("TXT found for %s. Defaulting to %d\n",

 			       name, cc_len);

 		} else {

 			sdl = atoi(((struct txt_rdata*)head->rdata)->txt);

 			LM_DBG("TXT record for %s is %d.\n", name, sdl);

 			if ((sdl < 0) || (sdl > 10)) {

 				LM_ERR("Sdl %d out of bounds. Set back to cc_len.\n", sdl);

 				sdl = cc_len;

 			}

 			free_rdata_list(head);

 		}

 	} else {	/* defaults to CC */

 		sdl = cc_len;

 		memcpy(separator, i_branchlabel.s, i_branchlabel.len);

 		separator[i_branchlabel.len] = 0;

 		/* no change to apex */

 	}

 	j = 0;

 	sdl++; /* to avoid comparing i to (sdl+1) */

 	for (i = user_len - 1; i > 0; i--) {

 		name[j] = user_s[i];

 		name[j + 1] = '.';

 		j = j + 2;

 		if (separator[0] && (i == sdl)) { /* insert the I-ENUM separator here? */

 			strcpy(name + j, separator);  /* we've checked string sizes. */

 			j += strlen(separator);

 			name[j++] = '.';

 		}

 	}

 	memcpy(name + j, apex, strlen(apex)+1);

 	return do_query(_msg, string, name, service);

 }

 /******************* FQUERY *******************/

 /*

  * Call enum_pv_query_3 with pv arg, module parameter suffix,

  * and default service.

  */

 int enum_pv_query_1(struct sip_msg* _msg, char* _sp)

 {

     return enum_pv_query_3(_msg, _sp, (char *)(&suffix), (char *)(&service));

 }

 /*

  * Call enum_pv_query_3 with pv and suffix args and default service.

  */

 int enum_pv_query_2(struct sip_msg* _msg, char* _sp, char* _suffix)

 {

     return enum_pv_query_3(_msg, _sp, _suffix, (char *)(&service));

 }

 /*

  * See documentation in README file.

  */

 int enum_pv_query_3(struct sip_msg* _msg, char* _sp, char* _suffix,

 		    char* _service)

 {

 	char *user_s;

 	int user_len, i, j, first;

 	char name[MAX_DOMAIN_SIZE];

 	char uri[MAX_URI_SIZE];

 	char new_uri[MAX_URI_SIZE];

 	unsigned int priority, curr_prio;

 	qvalue_t q;

 	char tostring[17];

 	struct rdata* head;

 	struct rdata* l;

 	struct naptr_rdata* naptr;

 	str pattern, replacement, result, new_result;

 	str *suffix, *service;

 	char string[17];

 	pv_spec_t *sp;

 	pv_value_t pv_val;

 	sp = (pv_spec_t *)_sp;

 	suffix = (str*)_suffix;

 	service = (str*)_service;

 	/*

 	 *  Get R-URI user to tostring

 	 */

 	if (parse_sip_msg_uri(_msg) < 0) {

 		LM_ERR("R-URI parsing failed\n");

 		return -1;

 	}

 	if (is_e164(&(_msg->parsed_uri.user)) == -1) {

 		LM_ERR("R-URI user is not an E164 number\n");

 		return -1;

 	}

 	user_s = _msg->parsed_uri.user.s;

 	user_len = _msg->parsed_uri.user.len;

 	memcpy(&(tostring[0]), user_s, user_len);

 	tostring[user_len] = (char)0;

 	/*

 	 * Get E.164 number from pseudo variable

          */

 	if (sp && (pv_get_spec_value(_msg, sp, &pv_val) == 0)) {

 	    if (pv_val.flags & PV_VAL_STR) {

 		if (pv_val.rs.len == 0 || pv_val.rs.s == NULL) {

 		    LM_DBG("Missing E.164 number\n");

 		    return -1;

 		}

 	    } else {

 		LM_DBG("Pseudo variable value is not string\n");

 		return -1;

 	}

 	} else {

 	    LM_DBG("Cannot get pseudo variable value\n");

 	    return -1;

 	}

 	if (is_e164(&(pv_val.rs)) == -1) {

 	    LM_ERR("pseudo variable does not contain an E164 number\n");

 	    return -1;

 	}

 	user_s = pv_val.rs.s;

 	user_len = pv_val.rs.len;

 	memcpy(&(string[0]), user_s, user_len);

 	string[user_len] = (char)0;

 	j = 0;

 	for (i = user_len - 1; i > 0; i--) {

 		name[j] = user_s[i];

 		name[j + 1] = '.';

 		j = j + 2;

 	}

 	memcpy(name + j, suffix->s, suffix->len + 1);

 	head = get_record(name, T_NAPTR);

 	if (head == 0) {

 		LM_DBG("No NAPTR record found for %s.\n", name);

 		return -1;

 	}

 	naptr_sort(&head);

 	q = MAX_Q - 10;

 	curr_prio = 0;

 	first = 1;

 	for (l = head; l; l = l->next) {

 		if (l->type != T_NAPTR) continue; /*should never happen*/

 		naptr = (struct naptr_rdata*)l->rdata;

 		if (naptr == 0) {

 			LM_ERR("Null rdata in DNS response\n");

 			continue;

 		}

 		LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags "

 		       "'%.*s', slen %u, services '%.*s', rlen %u, "

 		       "regexp '%.*s'\n",

 		       name, naptr->order, naptr->pref,

 		    naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),

 		    naptr->services_len,

 		    (int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,

 		    (int)(naptr->regexp_len), ZSW(naptr->regexp));

 		if (sip_match(naptr, service) == 0) continue;

 		if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,

 				       &pattern, &replacement) < 0) {

 			LM_ERR("Parsing of NAPTR regexp failed\n");

 			continue;

 		}

 		result.s = &(uri[0]);

 		result.len = MAX_URI_SIZE;

 		/* Avoid making copies of pattern and replacement */

 		pattern.s[pattern.len] = (char)0;

 		replacement.s[replacement.len] = (char)0;

 		if (reg_replace(pattern.s, replacement.s, &(tostring[0]),

 				&result) < 0) {

 			pattern.s[pattern.len] = '!';

 			replacement.s[replacement.len] = '!';

 			LM_ERR("Regexp replace failed\n");

 			continue;

 		}

 		LM_DBG("Resulted in replacement: '%.*s'\n",

 		       result.len, ZSW(result.s));

 		pattern.s[pattern.len] = '!';

 		replacement.s[replacement.len] = '!';

 		if (param.len > 0) {

 			if (result.len + param.len > MAX_URI_SIZE - 1) {

 				LM_ERR("URI is too long\n");

 				continue;

 			}

 			new_result.s = &(new_uri[0]);

 			new_result.len = MAX_URI_SIZE;

 			if (add_uri_param(&result, &param, &new_result) == 0) {

 				LM_ERR("Parsing of URI <%.*s> failed\n",

 				       result.len, result.s);

 				continue;

 			}

 			if (new_result.len > 0) {

 				result = new_result;

 			}

 		}

 		if (first) {

 			if (set_ruri(_msg, &result) == -1) {

 				goto done;

 			}

 			set_ruri_q(q);

 			first = 0;

 			curr_prio = ((naptr->order) << 16) + naptr->pref;

 		} else {

 			priority = ((naptr->order) << 16) + naptr->pref;

 			if (priority > curr_prio) {

 				q = q - 10;

 				curr_prio = priority;

 			}

 			if (append_branch(_msg, &result, 0, 0, q, 0, 0) == -1) {

 				goto done;

 			}

 		}

 	}

 done:

 	free_rdata_list(head);

 	return first ? -1 : 1;

 }