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