update DNS resolver
[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 #include <resolv.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <ctype.h>
22 #include <regex.h>
23 #include <unistd.h>
24 #include <errno.h>
25
26 #include <asterisk/logger.h>
27 #include <asterisk/options.h>
28 #include <asterisk/enum.h>
29 #include <asterisk/dns.h>
30 #include <asterisk/channel.h>
31 #include <asterisk/config.h>
32
33 #define TOPLEV "e164.arpa."
34
35 static struct enum_search {
36         char toplev[80];
37         struct enum_search *next;
38 } *toplevs;
39
40 static int enumver = 0;
41
42 static ast_mutex_t enumlock = AST_MUTEX_INITIALIZER;
43
44 struct naptr {
45         unsigned short order;
46         unsigned short pref;
47 } __attribute__ ((__packed__));
48
49 static int parse_ie(unsigned char *data, int maxdatalen, unsigned char *src, int srclen)
50 {
51         int len, olen;
52         len = olen = (int)src[0];
53         src++;
54         srclen--;
55         if (len > srclen) {
56                 ast_log(LOG_WARNING, "Want %d, got %d\n", len, srclen);
57                 return -1;
58         }
59         if (len > maxdatalen)
60                 len = maxdatalen;
61         memcpy(data, src, len);
62         return olen + 1;
63 }
64
65 static int parse_naptr(unsigned char *dst, int dstsize, char *tech, int techsize, unsigned char *answer, int len, char *naptrinput)
66 {
67         unsigned char *oanswer = answer;
68         unsigned char flags[80] = "";
69         unsigned char services[80] = "";
70         unsigned char regexp[80] = "";
71         unsigned char repl[80] = "";
72         unsigned char temp[80] = "";
73         unsigned char delim;
74         unsigned char *delim2;
75         unsigned char *pattern, *subst, *d;
76         int res;
77         int regexp_len, size, backref;
78         int d_len = sizeof(temp) - 1;
79         regex_t preg;
80         regmatch_t pmatch[9];
81
82         
83         if (len < sizeof(struct naptr)) {
84                 printf("Length too short\n");
85                 return -1;
86         }
87         answer += sizeof(struct naptr);
88         len -= sizeof(struct naptr);
89         if ((res = parse_ie(flags, sizeof(flags) - 1, answer, len)) < 0) {
90                 ast_log(LOG_WARNING, "Failed to get flags\n");
91                 return -1; 
92         } else { answer += res; len -= res; }
93         if ((res = parse_ie(services, sizeof(services) - 1, answer, len)) < 0) {
94                 ast_log(LOG_WARNING, "Failed to get services\n");
95                 return -1; 
96         } else { answer += res; len -= res; }
97         if ((res = parse_ie(regexp, sizeof(regexp) - 1, answer, len)) < 0)
98                 return -1; else { answer += res; len -= res; }
99         if ((res = dn_expand(oanswer,answer + len,answer, repl, sizeof(repl) - 1)) < 0) {
100                 ast_log(LOG_WARNING, "Failed to expand hostname\n");
101                 return -1;
102         } 
103
104         ast_log(LOG_DEBUG, "input='%s', flags='%s', services='%s', regexp='%s', repl='%s'\n",
105                     naptrinput, flags, services, regexp, repl);
106
107         if (tolower(flags[0]) != 'u') {
108                 ast_log(LOG_WARNING, "Flag must be 'U' or 'u'.\n");
109                 return -1;
110         }
111
112         if ((!strncasecmp(services, "e2u+sip", 7)) || 
113             (!strncasecmp(services, "sip+e2u", 7))) {
114                 strncpy(tech, "sip", techsize -1); 
115         } else if ((!strncasecmp(services, "e2u+h323", 7)) || 
116             (!strncasecmp(services, "h323+e2u", 7))) {
117                 strncpy(tech, "h323", techsize -1); 
118         } else if ((!strncasecmp(services, "e2u+iax", 7)) || 
119             (!strncasecmp(services, "iax+e2u", 7))) {
120                 strncpy(tech, "iax", techsize -1); 
121         } else if ((!strncasecmp(services, "e2u+iax2", 7)) || 
122             (!strncasecmp(services, "iax2+e2u", 7))) {
123                 strncpy(tech, "iax2", techsize -1); 
124         } else if ((!strncasecmp(services, "e2u+tel", 7)) || 
125             (!strncasecmp(services, "tel+e2u", 7))) {
126                 strncpy(tech, "tel", techsize -1); 
127         } else if (strncasecmp(services, "e2u+voice:", 10)) {
128                 ast_log(LOG_WARNING, "Services must be e2u+sip, sip+e2u, e2u+h323, h323+e2u, e2u+iax, iax+e2u, e2u+iax2, iax2+e2u, e2u+tel, tel+e2u or e2u+voice:\n");
129                 return -1;
130         }
131
132         /* DEDBUGGING STUB
133         strcpy(regexp, "!^\\+43(.*)$!\\1@bla.fasel!");
134         */
135
136         regexp_len = strlen(regexp);
137         if (regexp_len < 7) {
138                 ast_log(LOG_WARNING, "Regex too short to be meaningful.\n");
139                 return -1;
140         } 
141
142
143         delim = regexp[0];
144         delim2 = strchr(regexp + 1, delim);
145         if ((delim2 == NULL) || (regexp[regexp_len-1] != delim)) {
146                 ast_log(LOG_WARNING, "Regex delimiter error (on \"%s\").\n",regexp);
147                 return -1;
148         }
149
150         pattern = regexp + 1;
151         *delim2 = 0;
152         subst   = delim2 + 1;
153         regexp[regexp_len-1] = 0;
154
155 #if 0
156         printf("Pattern: %s\n", pattern);
157         printf("Subst: %s\n", subst);
158 #endif
159
160 /*
161  * now do the regex wizardry.
162  */
163
164         if (regcomp(&preg, pattern, REG_EXTENDED | REG_NEWLINE)) {
165                 ast_log(LOG_WARNING, "Regex compilation error (regex = \"%s\").\n",regexp);
166                 return -1;
167         }
168
169         if (preg.re_nsub > 9) {
170                 ast_log(LOG_WARNING, "Regex compilation error: too many subs.\n");
171                 regfree(&preg);
172                 return -1;
173         }
174
175         if (regexec(&preg, naptrinput, 9, pmatch, 0)) {
176                 ast_log(LOG_WARNING, "Regex match failed.\n");
177                 regfree(&preg);
178                 return -1;
179         }
180         regfree(&preg);
181
182         d = temp; d_len--; 
183         while( *subst && (d_len > 0) ) {
184                 if ((subst[0] == '\\') && isdigit(subst[1]) && (pmatch[subst[1]-'0'].rm_so != -1)) {
185                         backref = subst[1]-'0';
186                         size = pmatch[backref].rm_eo - pmatch[backref].rm_so;
187                         if (size > d_len) {
188                                 ast_log(LOG_WARNING, "Not enough space during regex substitution.\n");
189                                 return -1;
190                                 }
191                         memcpy(d, naptrinput + pmatch[backref].rm_so, size);
192                         d += size;
193                         d_len -= size;
194                         subst += 2;
195                 } else if (isprint(*subst)) {
196                         *d++ = *subst++;
197                         d_len--;
198                 } else {
199                         ast_log(LOG_WARNING, "Error during regex substitution.\n");
200                         return -1;
201                 }
202         }
203         *d = 0;
204         strncpy(dst, temp, dstsize);
205         d = strchr(services, ':');
206         if (d) 
207                 strncpy(tech, d+1, techsize -1); 
208         return 0;
209 }
210
211 struct enum_context {
212         char *dst;
213         int dstlen;
214         char *tech;
215         int techlen;
216         char *naptrinput;
217 };
218
219 static int enum_callback(void *context, u_char *answer, int len, u_char *fullanswer)
220 {
221         struct enum_context *c = (struct enum_context *)context;
222
223         if (parse_naptr(c->dst, c->dstlen, c->tech, c->techlen, answer, len, c->naptrinput))
224                 ast_log(LOG_WARNING, "Failed to parse naptr :(\n");
225
226         if (strlen(c->dst))
227                 return 1;
228
229         return 0;
230 }
231
232 int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen)
233 {
234         struct enum_context context;
235         char tmp[259 + 80];
236         char naptrinput[80] = "+";
237         int pos = strlen(number) - 1;
238         int newpos = 0;
239         int ret = -1;
240         struct enum_search *s = NULL;
241         int version = -1;
242
243         strncat(naptrinput, number, sizeof(naptrinput) - 2);
244
245         context.naptrinput = naptrinput;
246         context.dst = dst;
247         context.dstlen = dstlen;
248         context.tech = tech;
249         context.techlen = techlen;
250
251         if (pos > 128)
252                 pos = 128;
253         while(pos >= 0) {
254                 tmp[newpos++] = number[pos--];
255                 tmp[newpos++] = '.';
256         }
257         
258         if (chan && ast_autoservice_start(chan) < 0)
259                 return -1;
260
261         for(;;) {
262                 ast_mutex_lock(&enumlock);
263                 if (version != enumver) {
264                         /* Ooh, a reload... */
265                         s = toplevs;
266                         version = enumver;
267                 } else {
268                         s = s->next;
269                 }
270                 if (s) {
271                         strcpy(tmp + newpos, s->toplev);
272                 }
273                 ast_mutex_unlock(&enumlock);
274                 if (!s)
275                         break;
276                 ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
277                 if (ret > 0)
278                         break;
279         }
280         if (ret < 0) {
281                 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
282                 ret = 0;
283         }
284         if (chan)
285                 ret |= ast_autoservice_stop(chan);
286         return ret;
287 }
288
289 static struct enum_search *enum_newtoplev(char *s)
290 {
291         struct enum_search *tmp;
292         tmp = malloc(sizeof(struct enum_search));
293         if (tmp) {
294                 memset(tmp, 0, sizeof(struct enum_search));
295                 strncpy(tmp->toplev, s, sizeof(tmp->toplev) - 1);
296         }
297         return tmp;
298 }
299
300 int ast_enum_init(void)
301 {
302         struct ast_config *cfg;
303         struct enum_search *s, *sl;
304         struct ast_variable *v;
305
306         /* Destroy existing list */
307         ast_mutex_lock(&enumlock);
308         s = toplevs;
309         while(s) {
310                 sl = s;
311                 s = s->next;
312                 free(sl);
313         }
314         toplevs = NULL;
315         cfg = ast_load("enum.conf");
316         if (cfg) {
317                 sl = NULL;
318                 v = ast_variable_browse(cfg, "general");
319                 while(v) {
320                         if (!strcasecmp(v->name, "search")) {
321                                 s = enum_newtoplev(v->value);
322                                 if (s) {
323                                         if (sl)
324                                                 sl->next = s;
325                                         else
326                                                 toplevs = s;
327                                         sl = s;
328                                 }
329                         }
330                         v = v->next;
331                 }
332                 ast_destroy(cfg);
333         } else {
334                 toplevs = enum_newtoplev(TOPLEV);
335         }
336         enumver++;
337         ast_mutex_unlock(&enumlock);
338         return 0;
339 }
340
341 int ast_enum_reload(void)
342 {
343         return ast_enum_init();
344 }