Contributed Logic: opensips/modules/enum/enum.c@733187d496d0 (annotated)

opensips/modules/enum/enum.c@733187d496d0 (annotated)

opensips/modules/enum/enum.c

Wed, 10 Feb 2010 21:21:24 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 10 Feb 2010 21:21:24 +0100
changeset 17: 733187d496d0
parent 12: a3ac912f2857
permissions: -rw-r--r--

Introduce authentication credential logic into the LCR module.
This logic is meant to complement that of changeset 18, adding
additional authentication flexibility to the UAC module.

 /*
  * $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;
 }

Contributed Logic / annotate

opensips/modules/enum/enum.c@733187d496d0 (annotated)

opensips/modules/enum/enum.c