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