use double-quotes instead of angle-brackets for non-system include files (bug #4058)
[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
272         /* skip over first byte, as for some reason it's a vertical tab character */
273         answer += 1;
274         len -= 1;
275
276         /* answer is not null-terminated, but should be */
277         /* this is safe to do, as answer has extra bytes on the end we can 
278            safely overwrite with a null */
279         answer[len] = '\0';
280         /* now increment len so that len includes the null, so that we can
281            compare apples to apples */
282         len +=1;
283
284         /* finally, copy the answer into c->txt */
285         strncpy(c->txt, answer, len < c->txtlen ? len-1 : (c->txtlen)-1);
286         
287         /* just to be safe, let's make sure c->txt is null terminated */
288         c->txt[(c->txtlen)-1] = '\0';
289
290         return 1;
291 }
292
293 /*--- enum_callback: Callback from ENUM lookup function */
294 static int enum_callback(void *context, u_char *answer, int len, u_char *fullanswer)
295 {
296         struct enum_context *c = (struct enum_context *)context;
297
298         if (parse_naptr(c->dst, c->dstlen, c->tech, c->techlen, answer, len, c->naptrinput)) {
299                 ast_log(LOG_WARNING, "Failed to parse naptr :(\n");
300                 return -1;
301         }
302
303         if (!ast_strlen_zero(c->dst))
304                 return 1;
305
306         return 0;
307 }
308
309 /*--- ast_get_enum: ENUM lookup */
310 int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen)
311 {
312         struct enum_context context;
313         char tmp[259 + 80];
314         char naptrinput[80] = "+";
315         int pos = strlen(number) - 1;
316         int newpos = 0;
317         int ret = -1;
318         struct enum_search *s = NULL;
319         int version = -1;
320
321         strncat(naptrinput, number, sizeof(naptrinput) - 2);
322
323         context.naptrinput = naptrinput;        /* The number */
324         context.dst = dst;                      /* Return string */
325         context.dstlen = dstlen;
326         context.tech = tech;                    /* Return string */
327         context.techlen = techlen;
328
329         if (pos > 128)
330                 pos = 128;
331         while(pos >= 0) {
332                 tmp[newpos++] = number[pos--];
333                 tmp[newpos++] = '.';
334         }
335         
336         if (chan && ast_autoservice_start(chan) < 0)
337                 return -1;
338
339         for(;;) {
340                 ast_mutex_lock(&enumlock);
341                 if (version != enumver) {
342                         /* Ooh, a reload... */
343                         s = toplevs;
344                         version = enumver;
345                 } else {
346                         s = s->next;
347                 }
348                 if (s) {
349                         strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
350                 }
351                 ast_mutex_unlock(&enumlock);
352                 if (!s)
353                         break;
354                 ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
355                 if (ret > 0)
356                         break;
357         }
358         if (ret < 0) {
359                 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
360                 ret = 0;
361         }
362         if (chan)
363                 ret |= ast_autoservice_stop(chan);
364         return ret;
365 }
366
367 /*--- ast_get_txt: Get TXT record from DNS. 
368         Really has nothing to do with enum, but anyway...
369  */
370 int ast_get_txt(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen, char *txt, int txtlen)
371 {
372         struct enum_context context;
373         char tmp[259 + 80];
374         char naptrinput[80] = "+";
375         int pos = strlen(number) - 1;
376         int newpos = 0;
377         int ret = -1;
378         struct enum_search *s = NULL;
379         int version = -1;
380
381         strncat(naptrinput, number, sizeof(naptrinput) - 2);
382
383         context.naptrinput = naptrinput;
384         context.dst = dst;
385         context.dstlen = dstlen;
386         context.tech = tech;
387         context.techlen = techlen;
388         context.txt = txt;
389         context.txtlen = txtlen;
390
391         if (pos > 128)
392                 pos = 128;
393         while(pos >= 0) {
394                 tmp[newpos++] = number[pos--];
395                 tmp[newpos++] = '.';
396         }
397         
398         if (chan && ast_autoservice_start(chan) < 0)
399                 return -1;
400
401         for(;;) {
402                 ast_mutex_lock(&enumlock);
403                 if (version != enumver) {
404                         /* Ooh, a reload... */
405                         s = toplevs;
406                         version = enumver;
407                 } else {
408                         s = s->next;
409                 }
410                 if (s) {
411                         strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
412                 }
413                 ast_mutex_unlock(&enumlock);
414                 if (!s)
415                         break;
416
417                 ret = ast_search_dns(&context, tmp, C_IN, T_TXT, txt_callback);
418                 if (ret > 0)
419                         break;
420         }
421         if (ret < 0) {
422                 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
423                 ret = 0;
424         }
425         if (chan)
426                 ret |= ast_autoservice_stop(chan);
427         return ret;
428 }
429
430 /*--- enum_newtoplev: Add enum tree to linked list ---*/
431 static struct enum_search *enum_newtoplev(char *s)
432 {
433         struct enum_search *tmp;
434
435         tmp = malloc(sizeof(struct enum_search));
436         if (tmp) {
437                 memset(tmp, 0, sizeof(struct enum_search));
438                 strncpy(tmp->toplev, s, sizeof(tmp->toplev) - 1);
439         }
440         return tmp;
441 }
442
443 /*--- ast_enum_init: Initialize the ENUM support subsystem */
444 int ast_enum_init(void)
445 {
446         struct ast_config *cfg;
447         struct enum_search *s, *sl;
448         struct ast_variable *v;
449
450         /* Destroy existing list */
451         ast_mutex_lock(&enumlock);
452         s = toplevs;
453         while(s) {
454                 sl = s;
455                 s = s->next;
456                 free(sl);
457         }
458         toplevs = NULL;
459         cfg = ast_config_load("enum.conf");
460         if (cfg) {
461                 sl = NULL;
462                 v = ast_variable_browse(cfg, "general");
463                 while(v) {
464                         if (!strcasecmp(v->name, "search")) {
465                                 s = enum_newtoplev(v->value);
466                                 if (s) {
467                                         if (sl)
468                                                 sl->next = s;
469                                         else
470                                                 toplevs = s;
471                                         sl = s;
472                                 }
473                         }
474                         v = v->next;
475                 }
476                 ast_config_destroy(cfg);
477         } else {
478                 toplevs = enum_newtoplev(TOPLEV);
479         }
480         enumver++;
481         ast_mutex_unlock(&enumlock);
482         return 0;
483 }
484
485 int ast_enum_reload(void)
486 {
487         return ast_enum_init();
488 }