Fix ENUM documentation (bug #3698)
[asterisk/asterisk.git] / enum.c
1 /*
2  * ENUM Support for Asterisk
3  *
4  * Copyright (C) 2003-2005, Digium, inc
5  *
6  * Written by Mark Spencer <markster@digium.com>
7  *
8  * Funding provided by nic.at
9  *
10  * Distributed under the terms of the GNU GPL
11  *
12  */
13
14 #include <sys/types.h>
15 #include <sys/socket.h>
16 #include <netinet/in.h>
17 #include <arpa/nameser.h>
18 #if __APPLE_CC__ >= 1495
19 #include <arpa/nameser_compat.h>
20 #endif
21 #include <resolv.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <ctype.h>
25 #include <regex.h>
26 #include <unistd.h>
27 #include <errno.h>
28
29 #include <asterisk/logger.h>
30 #include <asterisk/options.h>
31 #include <asterisk/enum.h>
32 #include <asterisk/dns.h>
33 #include <asterisk/channel.h>
34 #include <asterisk/config.h>
35 #include <asterisk/utils.h>
36
37 #ifdef __APPLE__
38 #undef T_NAPTR
39 #define T_NAPTR 35
40 #endif
41
42 #ifdef __APPLE__
43 #undef T_TXT
44 #define T_TXT 16
45 #endif
46
47 /* The IETF Enum standard root, managed by the ITU */
48 #define TOPLEV "e164.arpa."
49
50 /* Linked list from config file */
51 static struct enum_search {
52         char toplev[80];
53         struct enum_search *next;
54 } *toplevs;
55
56 static int enumver = 0;
57
58 AST_MUTEX_DEFINE_STATIC(enumlock);
59
60 struct naptr {
61         unsigned short order;
62         unsigned short pref;
63 } __attribute__ ((__packed__));
64
65 /*--- parse_ie: Parse NAPTR record information elements */
66 static int parse_ie(unsigned char *data, int maxdatalen, unsigned char *src, int srclen)
67 {
68         int len, olen;
69
70         len = olen = (int)src[0];
71         src++;
72         srclen--;
73         if (len > srclen) {
74                 ast_log(LOG_WARNING, "Want %d, got %d\n", len, srclen);
75                 return -1;
76         }
77         if (len > maxdatalen)
78                 len = maxdatalen;
79         memcpy(data, src, len);
80         return olen + 1;
81 }
82
83 /*--- parse_naptr: Parse DNS NAPTR record used in ENUM ---*/
84 static int parse_naptr(unsigned char *dst, int dstsize, char *tech, int techsize, unsigned char *answer, int len, char *naptrinput)
85 {
86         unsigned char *oanswer = answer;
87         unsigned char flags[80] = "";
88         unsigned char services[80] = "";
89         unsigned char regexp[80] = "";
90         unsigned char repl[80] = "";
91         unsigned char temp[80] = "";
92         unsigned char delim;
93         unsigned char *delim2;
94         unsigned char *pattern, *subst, *d;
95         int res;
96         int regexp_len, size, backref;
97         int d_len = sizeof(temp) - 1;
98         regex_t preg;
99         regmatch_t pmatch[9];
100
101
102         dst[0] = '\0';
103         
104         if (len < sizeof(struct naptr)) {
105                 ast_log(LOG_WARNING, "NAPTR record length too short\n");
106                 return -1;
107         }
108         answer += sizeof(struct naptr);
109         len -= sizeof(struct naptr);
110         if ((res = parse_ie(flags, sizeof(flags) - 1, answer, len)) < 0) {
111                 ast_log(LOG_WARNING, "Failed to get flags from NAPTR record\n");
112                 return -1; 
113         } else { 
114                 answer += res; 
115                 len -= res; 
116         }
117         if ((res = parse_ie(services, sizeof(services) - 1, answer, len)) < 0) {
118                 ast_log(LOG_WARNING, "Failed to get services from NAPTR record\n");
119                 return -1; 
120         } else { 
121                 answer += res; 
122                 len -= res; 
123         }
124         if ((res = parse_ie(regexp, sizeof(regexp) - 1, answer, len)) < 0) {
125                 ast_log(LOG_WARNING, "Failed to get regexp from NAPTR record\n");
126                 return -1; 
127         } else { 
128                 answer += res; 
129                 len -= res; 
130         }
131         if ((res = dn_expand(oanswer,answer + len,answer, repl, sizeof(repl) - 1)) < 0) {
132                 ast_log(LOG_WARNING, "Failed to expand hostname\n");
133                 return -1;
134         } 
135
136         if (option_debug > 2)   /* Advanced NAPTR debugging */
137                 ast_log(LOG_DEBUG, "NAPTR input='%s', flags='%s', services='%s', regexp='%s', repl='%s'\n",
138                         naptrinput, flags, services, regexp, repl);
139
140         if (tolower(flags[0]) != 'u') {
141                 ast_log(LOG_WARNING, "NAPTR Flag must be 'U' or 'u'.\n");
142                 return -1;
143         }
144
145         if ((!strncasecmp(services, "e2u+sip", 7)) || 
146             (!strncasecmp(services, "sip+e2u", 7))) {
147                 strncpy(tech, "sip", techsize -1); 
148         } else if ((!strncasecmp(services, "e2u+h323", 8)) || 
149             (!strncasecmp(services, "h323+e2u", 8))) {
150                 strncpy(tech, "h323", techsize -1); 
151         } else if ((!strncasecmp(services, "e2u+x-iax2", 10)) || 
152             (!strncasecmp(services, "e2u+iax2", 8)) ||
153             (!strncasecmp(services, "iax2+e2u", 8))) {
154                 strncpy(tech, "iax2", techsize -1); 
155         } else if ((!strncasecmp(services, "e2u+x-iax", 9)) ||
156             (!strncasecmp(services, "e2u+iax", 7)) ||
157             (!strncasecmp(services, "iax+e2u", 7))) {
158                 strncpy(tech, "iax", techsize -1); 
159         } else if ((!strncasecmp(services, "e2u+tel", 7)) || 
160             (!strncasecmp(services, "tel+e2u", 7))) {
161                 strncpy(tech, "tel", techsize -1); 
162         } else if (!strncasecmp(services, "e2u+voice:", 10)) {
163                 strncpy(tech, services+10, techsize -1); 
164         } else {
165                 ast_log(LOG_DEBUG, 
166                 "Services must be e2u+${tech}, ${tech}+e2u, or e2u+voice: where $tech is from (sip, h323, tel, iax, iax2). \n");
167                 return 0;
168         }
169
170         /* DEDBUGGING STUB
171         strncpy(regexp, "!^\\+43(.*)$!\\1@bla.fasel!", sizeof(regexp) - 1);
172         */
173
174         regexp_len = strlen(regexp);
175         if (regexp_len < 7) {
176                 ast_log(LOG_WARNING, "Regex too short to be meaningful.\n");
177                 return -1;
178         } 
179
180
181         delim = regexp[0];
182         delim2 = strchr(regexp + 1, delim);
183         if ((delim2 == NULL) || (regexp[regexp_len-1] != delim)) {
184                 ast_log(LOG_WARNING, "Regex delimiter error (on \"%s\").\n",regexp);
185                 return -1;
186         }
187
188         pattern = regexp + 1;
189         *delim2 = 0;
190         subst   = delim2 + 1;
191         regexp[regexp_len-1] = 0;
192
193 #if 0
194         printf("Pattern: %s\n", pattern);
195         printf("Subst: %s\n", subst);
196 #endif
197
198 /*
199  * now do the regex wizardry.
200  */
201
202         if (regcomp(&preg, pattern, REG_EXTENDED | REG_NEWLINE)) {
203                 ast_log(LOG_WARNING, "NAPTR Regex compilation error (regex = \"%s\").\n",regexp);
204                 return -1;
205         }
206
207         if (preg.re_nsub > 9) {
208                 ast_log(LOG_WARNING, "NAPTR Regex compilation error: too many subs.\n");
209                 regfree(&preg);
210                 return -1;
211         }
212
213         if (regexec(&preg, naptrinput, 9, pmatch, 0)) {
214                 ast_log(LOG_WARNING, "NAPTR Regex match failed.\n");
215                 regfree(&preg);
216                 return -1;
217         }
218         regfree(&preg);
219
220         d = temp; 
221         d_len--; 
222         while( *subst && (d_len > 0) ) {
223                 if ((subst[0] == '\\') && isdigit(subst[1]) && (pmatch[subst[1]-'0'].rm_so != -1)) {
224                         backref = subst[1]-'0';
225                         size = pmatch[backref].rm_eo - pmatch[backref].rm_so;
226                         if (size > d_len) {
227                                 ast_log(LOG_WARNING, "Not enough space during NAPTR regex substitution.\n");
228                                 return -1;
229                                 }
230                         memcpy(d, naptrinput + pmatch[backref].rm_so, size);
231                         d += size;
232                         d_len -= size;
233                         subst += 2;
234                 } else if (isprint(*subst)) {
235                         *d++ = *subst++;
236                         d_len--;
237                 } else {
238                         ast_log(LOG_WARNING, "Error during regex substitution.\n");
239                         return -1;
240                 }
241         }
242         *d = 0;
243         strncpy(dst, temp, dstsize - 1);
244         dst[dstsize - 1] = '\0';
245         return 0;
246 }
247
248 struct enum_context {
249         char *dst;      /* Destination part of URL from ENUM */
250         int dstlen;     /* Length */
251         char *tech;     /* Technology (from URL scheme) */
252         int techlen;    /* Length */
253         char *txt;      /* TXT record in TXT lookup */
254         int txtlen;     /* Length */
255         char *naptrinput;       /* The number to lookup */
256 };
257
258 /*--- txt_callback: Callback for TXT record lookup */
259 static int txt_callback(void *context, u_char *answer, int len, u_char *fullanswer)
260 {
261         struct enum_context *c = (struct enum_context *)context;
262 #if 0
263         printf("ENUMTXT Called\n");
264 #endif
265
266         if (answer == NULL) {
267                 c->txt = NULL;
268                 c->txtlen = 0;
269                 return 0;
270         }
271         strncpy(c->txt, answer, sizeof(c->txt) - 1);
272         c->txt[sizeof(c->txt) - 1] = 0; /* Make sure the string is terminated */
273         c->txtlen = strlen(c->txt);
274         return 1;
275 }
276
277 /*--- enum_callback: Callback from ENUM lookup function */
278 static int enum_callback(void *context, u_char *answer, int len, u_char *fullanswer)
279 {
280         struct enum_context *c = (struct enum_context *)context;
281
282         if (parse_naptr(c->dst, c->dstlen, c->tech, c->techlen, answer, len, c->naptrinput)) {
283                 ast_log(LOG_WARNING, "Failed to parse naptr :(\n");
284                 return -1;
285         }
286
287         if (!ast_strlen_zero(c->dst))
288                 return 1;
289
290         return 0;
291 }
292
293 /*--- ast_get_enum: ENUM lookup */
294 int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen)
295 {
296         struct enum_context context;
297         char tmp[259 + 80];
298         char naptrinput[80] = "+";
299         int pos = strlen(number) - 1;
300         int newpos = 0;
301         int ret = -1;
302         struct enum_search *s = NULL;
303         int version = -1;
304
305         strncat(naptrinput, number, sizeof(naptrinput) - 2);
306
307         context.naptrinput = naptrinput;        /* The number */
308         context.dst = dst;                      /* Return string */
309         context.dstlen = dstlen;
310         context.tech = tech;                    /* Return string */
311         context.techlen = techlen;
312
313         if (pos > 128)
314                 pos = 128;
315         while(pos >= 0) {
316                 tmp[newpos++] = number[pos--];
317                 tmp[newpos++] = '.';
318         }
319         
320         if (chan && ast_autoservice_start(chan) < 0)
321                 return -1;
322
323         for(;;) {
324                 ast_mutex_lock(&enumlock);
325                 if (version != enumver) {
326                         /* Ooh, a reload... */
327                         s = toplevs;
328                         version = enumver;
329                 } else {
330                         s = s->next;
331                 }
332                 if (s) {
333                         strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
334                 }
335                 ast_mutex_unlock(&enumlock);
336                 if (!s)
337                         break;
338                 ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
339                 if (ret > 0)
340                         break;
341         }
342         if (ret < 0) {
343                 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
344                 ret = 0;
345         }
346         if (chan)
347                 ret |= ast_autoservice_stop(chan);
348         return ret;
349 }
350
351 /*--- ast_get_txt: Get TXT record from DNS. 
352         Really has nothing to do with enum, but anyway...
353  */
354 int ast_get_txt(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen, char *txt, int txtlen)
355 {
356         struct enum_context context;
357         char tmp[259 + 80];
358         char naptrinput[80] = "+";
359         int pos = strlen(number) - 1;
360         int newpos = 0;
361         int ret = -1;
362         struct enum_search *s = NULL;
363         int version = -1;
364
365         strncat(naptrinput, number, sizeof(naptrinput) - 2);
366
367         context.naptrinput = naptrinput;
368         context.dst = dst;
369         context.dstlen = dstlen;
370         context.tech = tech;
371         context.techlen = techlen;
372         context.txt = txt;
373         context.txtlen = txtlen;
374
375         if (pos > 128)
376                 pos = 128;
377         while(pos >= 0) {
378                 tmp[newpos++] = number[pos--];
379                 tmp[newpos++] = '.';
380         }
381         
382         if (chan && ast_autoservice_start(chan) < 0)
383                 return -1;
384
385         for(;;) {
386                 ast_mutex_lock(&enumlock);
387                 if (version != enumver) {
388                         /* Ooh, a reload... */
389                         s = toplevs;
390                         version = enumver;
391                 } else {
392                         s = s->next;
393                 }
394                 if (s) {
395                         strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
396                 }
397                 ast_mutex_unlock(&enumlock);
398                 if (!s)
399                         break;
400
401                 ret = ast_search_dns(&context, tmp, C_IN, T_TXT, txt_callback);
402                 if (ret > 0)
403                         break;
404         }
405         if (ret < 0) {
406                 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
407                 ret = 0;
408         }
409         if (chan)
410                 ret |= ast_autoservice_stop(chan);
411         return ret;
412 }
413
414 /*--- enum_newtoplev: Add enum tree to linked list ---*/
415 static struct enum_search *enum_newtoplev(char *s)
416 {
417         struct enum_search *tmp;
418
419         tmp = malloc(sizeof(struct enum_search));
420         if (tmp) {
421                 memset(tmp, 0, sizeof(struct enum_search));
422                 strncpy(tmp->toplev, s, sizeof(tmp->toplev) - 1);
423         }
424         return tmp;
425 }
426
427 /*--- ast_enum_init: Initialize the ENUM support subsystem */
428 int ast_enum_init(void)
429 {
430         struct ast_config *cfg;
431         struct enum_search *s, *sl;
432         struct ast_variable *v;
433
434         /* Destroy existing list */
435         ast_mutex_lock(&enumlock);
436         s = toplevs;
437         while(s) {
438                 sl = s;
439                 s = s->next;
440                 free(sl);
441         }
442         toplevs = NULL;
443         cfg = ast_config_load("enum.conf");
444         if (cfg) {
445                 sl = NULL;
446                 v = ast_variable_browse(cfg, "general");
447                 while(v) {
448                         if (!strcasecmp(v->name, "search")) {
449                                 s = enum_newtoplev(v->value);
450                                 if (s) {
451                                         if (sl)
452                                                 sl->next = s;
453                                         else
454                                                 toplevs = s;
455                                         sl = s;
456                                 }
457                         }
458                         v = v->next;
459                 }
460                 ast_config_destroy(cfg);
461         } else {
462                 toplevs = enum_newtoplev(TOPLEV);
463         }
464         enumver++;
465         ast_mutex_unlock(&enumlock);
466         return 0;
467 }
468
469 int ast_enum_reload(void)
470 {
471         return ast_enum_init();
472 }