add missing ~ to ast_parse_allow_deny that was breaking disallow
[asterisk/asterisk.git] / enum.c
1 /*
2  * ENUM Support for Asterisk
3  *
4  * Copyright (C) 2003 Digium
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 #define TOPLEV "e164.arpa."
48
49 static struct enum_search {
50         char toplev[80];
51         struct enum_search *next;
52 } *toplevs;
53
54 static int enumver = 0;
55
56 AST_MUTEX_DEFINE_STATIC(enumlock);
57
58 struct naptr {
59         unsigned short order;
60         unsigned short pref;
61 } __attribute__ ((__packed__));
62
63 static int parse_ie(unsigned char *data, int maxdatalen, unsigned char *src, int srclen)
64 {
65         int len, olen;
66         len = olen = (int)src[0];
67         src++;
68         srclen--;
69         if (len > srclen) {
70                 ast_log(LOG_WARNING, "Want %d, got %d\n", len, srclen);
71                 return -1;
72         }
73         if (len > maxdatalen)
74                 len = maxdatalen;
75         memcpy(data, src, len);
76         return olen + 1;
77 }
78
79 static int parse_naptr(unsigned char *dst, int dstsize, char *tech, int techsize, unsigned char *answer, int len, char *naptrinput)
80 {
81         unsigned char *oanswer = answer;
82         unsigned char flags[80] = "";
83         unsigned char services[80] = "";
84         unsigned char regexp[80] = "";
85         unsigned char repl[80] = "";
86         unsigned char temp[80] = "";
87         unsigned char delim;
88         unsigned char *delim2;
89         unsigned char *pattern, *subst, *d;
90         int res;
91         int regexp_len, size, backref;
92         int d_len = sizeof(temp) - 1;
93         regex_t preg;
94         regmatch_t pmatch[9];
95
96
97         dst[0] = '\0';
98         
99         if (len < sizeof(struct naptr)) {
100                 ast_log(LOG_WARNING, "Length too short\n");
101                 return -1;
102         }
103         answer += sizeof(struct naptr);
104         len -= sizeof(struct naptr);
105         if ((res = parse_ie(flags, sizeof(flags) - 1, answer, len)) < 0) {
106                 ast_log(LOG_WARNING, "Failed to get flags\n");
107                 return -1; 
108         } else { answer += res; len -= res; }
109         if ((res = parse_ie(services, sizeof(services) - 1, answer, len)) < 0) {
110                 ast_log(LOG_WARNING, "Failed to get services\n");
111                 return -1; 
112         } else { answer += res; len -= res; }
113         if ((res = parse_ie(regexp, sizeof(regexp) - 1, answer, len)) < 0)
114                 return -1; else { answer += res; len -= res; }
115         if ((res = dn_expand(oanswer,answer + len,answer, repl, sizeof(repl) - 1)) < 0) {
116                 ast_log(LOG_WARNING, "Failed to expand hostname\n");
117                 return -1;
118         } 
119
120         ast_log(LOG_DEBUG, "input='%s', flags='%s', services='%s', regexp='%s', repl='%s'\n",
121                     naptrinput, flags, services, regexp, repl);
122
123         if (tolower(flags[0]) != 'u') {
124                 ast_log(LOG_WARNING, "Flag must be 'U' or 'u'.\n");
125                 return -1;
126         }
127
128         if ((!strncasecmp(services, "e2u+sip", 7)) || 
129             (!strncasecmp(services, "sip+e2u", 7))) {
130                 strncpy(tech, "sip", techsize -1); 
131         } else if ((!strncasecmp(services, "e2u+h323", 8)) || 
132             (!strncasecmp(services, "h323+e2u", 8))) {
133                 strncpy(tech, "h323", techsize -1); 
134         } else if ((!strncasecmp(services, "e2u+x-iax2", 10)) || 
135             (!strncasecmp(services, "e2u+iax2", 8)) ||
136             (!strncasecmp(services, "iax2+e2u", 8))) {
137                 strncpy(tech, "iax2", techsize -1); 
138         } else if ((!strncasecmp(services, "e2u+x-iax", 9)) ||
139             (!strncasecmp(services, "e2u+iax", 7)) ||
140             (!strncasecmp(services, "iax+e2u", 7))) {
141                 strncpy(tech, "iax", techsize -1); 
142         } else if ((!strncasecmp(services, "e2u+tel", 7)) || 
143             (!strncasecmp(services, "tel+e2u", 7))) {
144                 strncpy(tech, "tel", techsize -1); 
145         } else if (!strncasecmp(services, "e2u+voice:", 10)) {
146                 strncpy(tech, services+10, techsize -1); 
147         } else {
148                 ast_log(LOG_DEBUG, 
149                 "Services must be e2u+${tech}, ${tech}+e2u, or e2u+voice: where $tech is from (sip, h323, tel, iax, iax2). \n");
150                 return 0;
151         }
152
153         /* DEDBUGGING STUB
154         strncpy(regexp, "!^\\+43(.*)$!\\1@bla.fasel!", sizeof(regexp) - 1);
155         */
156
157         regexp_len = strlen(regexp);
158         if (regexp_len < 7) {
159                 ast_log(LOG_WARNING, "Regex too short to be meaningful.\n");
160                 return -1;
161         } 
162
163
164         delim = regexp[0];
165         delim2 = strchr(regexp + 1, delim);
166         if ((delim2 == NULL) || (regexp[regexp_len-1] != delim)) {
167                 ast_log(LOG_WARNING, "Regex delimiter error (on \"%s\").\n",regexp);
168                 return -1;
169         }
170
171         pattern = regexp + 1;
172         *delim2 = 0;
173         subst   = delim2 + 1;
174         regexp[regexp_len-1] = 0;
175
176 #if 0
177         printf("Pattern: %s\n", pattern);
178         printf("Subst: %s\n", subst);
179 #endif
180
181 /*
182  * now do the regex wizardry.
183  */
184
185         if (regcomp(&preg, pattern, REG_EXTENDED | REG_NEWLINE)) {
186                 ast_log(LOG_WARNING, "Regex compilation error (regex = \"%s\").\n",regexp);
187                 return -1;
188         }
189
190         if (preg.re_nsub > 9) {
191                 ast_log(LOG_WARNING, "Regex compilation error: too many subs.\n");
192                 regfree(&preg);
193                 return -1;
194         }
195
196         if (regexec(&preg, naptrinput, 9, pmatch, 0)) {
197                 ast_log(LOG_WARNING, "Regex match failed.\n");
198                 regfree(&preg);
199                 return -1;
200         }
201         regfree(&preg);
202
203         d = temp; d_len--; 
204         while( *subst && (d_len > 0) ) {
205                 if ((subst[0] == '\\') && isdigit(subst[1]) && (pmatch[subst[1]-'0'].rm_so != -1)) {
206                         backref = subst[1]-'0';
207                         size = pmatch[backref].rm_eo - pmatch[backref].rm_so;
208                         if (size > d_len) {
209                                 ast_log(LOG_WARNING, "Not enough space during regex substitution.\n");
210                                 return -1;
211                                 }
212                         memcpy(d, naptrinput + pmatch[backref].rm_so, size);
213                         d += size;
214                         d_len -= size;
215                         subst += 2;
216                 } else if (isprint(*subst)) {
217                         *d++ = *subst++;
218                         d_len--;
219                 } else {
220                         ast_log(LOG_WARNING, "Error during regex substitution.\n");
221                         return -1;
222                 }
223         }
224         *d = 0;
225         strncpy(dst, temp, dstsize - 1);
226         dst[dstsize - 1] = '\0';
227         return 0;
228 }
229
230 struct enum_context {
231         char *dst;
232         int dstlen;
233         char *tech;
234         int techlen;
235         char *txt;
236         int txtlen;
237         char *naptrinput;
238 };
239
240 static int txt_callback(void *context, u_char *answer, int len, u_char *fullanswer)
241 {
242         struct enum_context *c = (struct enum_context *)context;
243 #if 0
244         printf("ENUMTXT Called\n");
245 #endif
246
247         if (answer != NULL) {
248                 c->txtlen = strlen(answer);
249                 strncpy(c->txt, answer, sizeof(c->txt) - 1);
250                 c->txt[sizeof(c->txt) - 1] = 0;
251                 return 1;
252         } else {
253                 c->txt = NULL;
254                 c->txtlen = 0;
255                 return 0;
256         }
257 }
258
259 static int enum_callback(void *context, u_char *answer, int len, u_char *fullanswer)
260 {
261         struct enum_context *c = (struct enum_context *)context;
262
263         if (parse_naptr(c->dst, c->dstlen, c->tech, c->techlen, answer, len, c->naptrinput)) {
264                 ast_log(LOG_WARNING, "Failed to parse naptr :(\n");
265                 return -1;
266         }
267
268         if (!ast_strlen_zero(c->dst))
269                 return 1;
270
271         return 0;
272 }
273
274 int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen)
275 {
276         struct enum_context context;
277         char tmp[259 + 80];
278         char naptrinput[80] = "+";
279         int pos = strlen(number) - 1;
280         int newpos = 0;
281         int ret = -1;
282         struct enum_search *s = NULL;
283         int version = -1;
284
285         strncat(naptrinput, number, sizeof(naptrinput) - 2);
286
287         context.naptrinput = naptrinput;
288         context.dst = dst;
289         context.dstlen = dstlen;
290         context.tech = tech;
291         context.techlen = techlen;
292
293         if (pos > 128)
294                 pos = 128;
295         while(pos >= 0) {
296                 tmp[newpos++] = number[pos--];
297                 tmp[newpos++] = '.';
298         }
299         
300         if (chan && ast_autoservice_start(chan) < 0)
301                 return -1;
302
303         for(;;) {
304                 ast_mutex_lock(&enumlock);
305                 if (version != enumver) {
306                         /* Ooh, a reload... */
307                         s = toplevs;
308                         version = enumver;
309                 } else {
310                         s = s->next;
311                 }
312                 if (s) {
313                         strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
314                 }
315                 ast_mutex_unlock(&enumlock);
316                 if (!s)
317                         break;
318                 ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
319                 if (ret > 0)
320                         break;
321         }
322         if (ret < 0) {
323                 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
324                 ret = 0;
325         }
326         if (chan)
327                 ret |= ast_autoservice_stop(chan);
328         return ret;
329 }
330
331 int ast_get_txt(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen, char *txt, int txtlen)
332 {
333         struct enum_context context;
334         char tmp[259 + 80];
335         char naptrinput[80] = "+";
336         int pos = strlen(number) - 1;
337         int newpos = 0;
338         int ret = -1;
339         struct enum_search *s = NULL;
340         int version = -1;
341
342         strncat(naptrinput, number, sizeof(naptrinput) - 2);
343
344         context.naptrinput = naptrinput;
345         context.dst = dst;
346         context.dstlen = dstlen;
347         context.tech = tech;
348         context.techlen = techlen;
349         context.txt = txt;
350         context.txtlen = txtlen;
351
352         if (pos > 128)
353                 pos = 128;
354         while(pos >= 0) {
355                 tmp[newpos++] = number[pos--];
356                 tmp[newpos++] = '.';
357         }
358         
359         if (chan && ast_autoservice_start(chan) < 0)
360                 return -1;
361
362         for(;;) {
363                 ast_mutex_lock(&enumlock);
364                 if (version != enumver) {
365                         /* Ooh, a reload... */
366                         s = toplevs;
367                         version = enumver;
368                 } else {
369                         s = s->next;
370                 }
371                 if (s) {
372                         strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
373                 }
374                 ast_mutex_unlock(&enumlock);
375                 if (!s)
376                         break;
377                 ret = ast_search_dns(&context, tmp, C_IN, T_TXT, txt_callback);
378                 if (ret > 0)
379                         break;
380         }
381         if (ret < 0) {
382                 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
383                 ret = 0;
384         }
385         if (chan)
386                 ret |= ast_autoservice_stop(chan);
387         return ret;
388 }
389
390 static struct enum_search *enum_newtoplev(char *s)
391 {
392         struct enum_search *tmp;
393         tmp = malloc(sizeof(struct enum_search));
394         if (tmp) {
395                 memset(tmp, 0, sizeof(struct enum_search));
396                 strncpy(tmp->toplev, s, sizeof(tmp->toplev) - 1);
397         }
398         return tmp;
399 }
400
401 int ast_enum_init(void)
402 {
403         struct ast_config *cfg;
404         struct enum_search *s, *sl;
405         struct ast_variable *v;
406
407         /* Destroy existing list */
408         ast_mutex_lock(&enumlock);
409         s = toplevs;
410         while(s) {
411                 sl = s;
412                 s = s->next;
413                 free(sl);
414         }
415         toplevs = NULL;
416         cfg = ast_load("enum.conf");
417         if (cfg) {
418                 sl = NULL;
419                 v = ast_variable_browse(cfg, "general");
420                 while(v) {
421                         if (!strcasecmp(v->name, "search")) {
422                                 s = enum_newtoplev(v->value);
423                                 if (s) {
424                                         if (sl)
425                                                 sl->next = s;
426                                         else
427                                                 toplevs = s;
428                                         sl = s;
429                                 }
430                         }
431                         v = v->next;
432                 }
433                 ast_destroy(cfg);
434         } else {
435                 toplevs = enum_newtoplev(TOPLEV);
436         }
437         enumver++;
438         ast_mutex_unlock(&enumlock);
439         return 0;
440 }
441
442 int ast_enum_reload(void)
443 {
444         return ast_enum_init();
445 }