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