00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014 #include <sys/types.h>
00015 #include <sys/socket.h>
00016 #include <netinet/in.h>
00017 #include <arpa/nameser.h>
00018 #if __APPLE_CC__ >= 1495
00019 #include <arpa/nameser_compat.h>
00020 #endif
00021 #include <resolv.h>
00022 #include <stdlib.h>
00023 #include <string.h>
00024 #include <ctype.h>
00025 #include <regex.h>
00026 #include <unistd.h>
00027 #include <errno.h>
00028
00029 #include <asterisk/logger.h>
00030 #include <asterisk/options.h>
00031 #include <asterisk/enum.h>
00032 #include <asterisk/dns.h>
00033 #include <asterisk/channel.h>
00034 #include <asterisk/config.h>
00035 #include <asterisk/utils.h>
00036
00037 #ifdef __APPLE__
00038 #undef T_NAPTR
00039 #define T_NAPTR 35
00040 #endif
00041
00042 #ifdef __APPLE__
00043 #undef T_TXT
00044 #define T_TXT 16
00045 #endif
00046
00047 #define TOPLEV "e164.arpa."
00048
00049 static struct enum_search {
00050 char toplev[80];
00051 struct enum_search *next;
00052 } *toplevs;
00053
00054 static int enumver = 0;
00055
00056 AST_MUTEX_DEFINE_STATIC(enumlock);
00057
00058 struct naptr {
00059 unsigned short order;
00060 unsigned short pref;
00061 } __attribute__ ((__packed__));
00062
00063 static int parse_ie(unsigned char *data, int maxdatalen, unsigned char *src, int srclen)
00064 {
00065 int len, olen;
00066 len = olen = (int)src[0];
00067 src++;
00068 srclen--;
00069 if (len > srclen) {
00070 ast_log(LOG_WARNING, "Want %d, got %d\n", len, srclen);
00071 return -1;
00072 }
00073 if (len > maxdatalen)
00074 len = maxdatalen;
00075 memcpy(data, src, len);
00076 return olen + 1;
00077 }
00078
00079 static int parse_naptr(unsigned char *dst, int dstsize, char *tech, int techsize, unsigned char *answer, int len, char *naptrinput)
00080 {
00081 unsigned char *oanswer = answer;
00082 unsigned char flags[80] = "";
00083 unsigned char services[80] = "";
00084 unsigned char regexp[80] = "";
00085 unsigned char repl[80] = "";
00086 unsigned char temp[80] = "";
00087 unsigned char delim;
00088 unsigned char *delim2;
00089 unsigned char *pattern, *subst, *d;
00090 int res;
00091 int regexp_len, size, backref;
00092 int d_len = sizeof(temp) - 1;
00093 regex_t preg;
00094 regmatch_t pmatch[9];
00095
00096
00097 dst[0] = '\0';
00098
00099 if (len < sizeof(struct naptr)) {
00100 ast_log(LOG_WARNING, "Length too short\n");
00101 return -1;
00102 }
00103 answer += sizeof(struct naptr);
00104 len -= sizeof(struct naptr);
00105 if ((res = parse_ie(flags, sizeof(flags) - 1, answer, len)) < 0) {
00106 ast_log(LOG_WARNING, "Failed to get flags\n");
00107 return -1;
00108 } else { answer += res; len -= res; }
00109 if ((res = parse_ie(services, sizeof(services) - 1, answer, len)) < 0) {
00110 ast_log(LOG_WARNING, "Failed to get services\n");
00111 return -1;
00112 } else { answer += res; len -= res; }
00113 if ((res = parse_ie(regexp, sizeof(regexp) - 1, answer, len)) < 0)
00114 return -1; else { answer += res; len -= res; }
00115 if ((res = dn_expand(oanswer,answer + len,answer, repl, sizeof(repl) - 1)) < 0) {
00116 ast_log(LOG_WARNING, "Failed to expand hostname\n");
00117 return -1;
00118 }
00119
00120 ast_log(LOG_DEBUG, "input='%s', flags='%s', services='%s', regexp='%s', repl='%s'\n",
00121 naptrinput, flags, services, regexp, repl);
00122
00123 if (tolower(flags[0]) != 'u') {
00124 ast_log(LOG_WARNING, "Flag must be 'U' or 'u'.\n");
00125 return -1;
00126 }
00127
00128 if ((!strncasecmp(services, "e2u+sip", 7)) ||
00129 (!strncasecmp(services, "sip+e2u", 7))) {
00130 strncpy(tech, "sip", techsize -1);
00131 } else if ((!strncasecmp(services, "e2u+h323", 8)) ||
00132 (!strncasecmp(services, "h323+e2u", 8))) {
00133 strncpy(tech, "h323", techsize -1);
00134 } else if ((!strncasecmp(services, "e2u+x-iax2", 10)) ||
00135 (!strncasecmp(services, "e2u+iax2", 8)) ||
00136 (!strncasecmp(services, "iax2+e2u", 8))) {
00137 strncpy(tech, "iax2", techsize -1);
00138 } else if ((!strncasecmp(services, "e2u+x-iax", 9)) ||
00139 (!strncasecmp(services, "e2u+iax", 7)) ||
00140 (!strncasecmp(services, "iax+e2u", 7))) {
00141 strncpy(tech, "iax", techsize -1);
00142 } else if ((!strncasecmp(services, "e2u+tel", 7)) ||
00143 (!strncasecmp(services, "tel+e2u", 7))) {
00144 strncpy(tech, "tel", techsize -1);
00145 } else if (!strncasecmp(services, "e2u+voice:", 10)) {
00146 strncpy(tech, services+10, techsize -1);
00147 } else {
00148 ast_log(LOG_DEBUG,
00149 "Services must be e2u+${tech}, ${tech}+e2u, or e2u+voice: where $tech is from (sip, h323, tel, iax, iax2). \n");
00150 return 0;
00151 }
00152
00153
00154
00155
00156
00157 regexp_len = strlen(regexp);
00158 if (regexp_len < 7) {
00159 ast_log(LOG_WARNING, "Regex too short to be meaningful.\n");
00160 return -1;
00161 }
00162
00163
00164 delim = regexp[0];
00165 delim2 = strchr(regexp + 1, delim);
00166 if ((delim2 == NULL) || (regexp[regexp_len-1] != delim)) {
00167 ast_log(LOG_WARNING, "Regex delimiter error (on \"%s\").\n",regexp);
00168 return -1;
00169 }
00170
00171 pattern = regexp + 1;
00172 *delim2 = 0;
00173 subst = delim2 + 1;
00174 regexp[regexp_len-1] = 0;
00175
00176 #if 0
00177 printf("Pattern: %s\n", pattern);
00178 printf("Subst: %s\n", subst);
00179 #endif
00180
00181
00182
00183
00184
00185 if (regcomp(&preg, pattern, REG_EXTENDED | REG_NEWLINE)) {
00186 ast_log(LOG_WARNING, "Regex compilation error (regex = \"%s\").\n",regexp);
00187 return -1;
00188 }
00189
00190 if (preg.re_nsub > 9) {
00191 ast_log(LOG_WARNING, "Regex compilation error: too many subs.\n");
00192 regfree(&preg);
00193 return -1;
00194 }
00195
00196 if (regexec(&preg, naptrinput, 9, pmatch, 0)) {
00197 ast_log(LOG_WARNING, "Regex match failed.\n");
00198 regfree(&preg);
00199 return -1;
00200 }
00201 regfree(&preg);
00202
00203 d = temp; d_len--;
00204 while( *subst && (d_len > 0) ) {
00205 if ((subst[0] == '\\') && isdigit(subst[1]) && (pmatch[subst[1]-'0'].rm_so != -1)) {
00206 backref = subst[1]-'0';
00207 size = pmatch[backref].rm_eo - pmatch[backref].rm_so;
00208 if (size > d_len) {
00209 ast_log(LOG_WARNING, "Not enough space during regex substitution.\n");
00210 return -1;
00211 }
00212 memcpy(d, naptrinput + pmatch[backref].rm_so, size);
00213 d += size;
00214 d_len -= size;
00215 subst += 2;
00216 } else if (isprint(*subst)) {
00217 *d++ = *subst++;
00218 d_len--;
00219 } else {
00220 ast_log(LOG_WARNING, "Error during regex substitution.\n");
00221 return -1;
00222 }
00223 }
00224 *d = 0;
00225 strncpy(dst, temp, dstsize - 1);
00226 dst[dstsize - 1] = '\0';
00227 return 0;
00228 }
00229
00230 struct enum_context {
00231 char *dst;
00232 int dstlen;
00233 char *tech;
00234 int techlen;
00235 char *txt;
00236 int txtlen;
00237 char *naptrinput;
00238 };
00239
00240 static int txt_callback(void *context, u_char *answer, int len, u_char *fullanswer)
00241 {
00242 struct enum_context *c = (struct enum_context *)context;
00243 #if 0
00244 printf("ENUMTXT Called\n");
00245 #endif
00246
00247 if (answer == NULL) {
00248 c->txt = NULL;
00249 c->txtlen = 0;
00250 return 0;
00251 }
00252
00253
00254 answer += 1;
00255 len -= 1;
00256
00257
00258
00259
00260 answer[len] = '\0';
00261
00262
00263 len +=1;
00264
00265
00266 strncpy(c->txt, answer, len < c->txtlen ? len-1 : (c->txtlen)-1);
00267
00268
00269 c->txt[(c->txtlen)-1] = '\0';
00270
00271 return 1;
00272 }
00273
00274 static int enum_callback(void *context, u_char *answer, int len, u_char *fullanswer)
00275 {
00276 struct enum_context *c = (struct enum_context *)context;
00277
00278 if (parse_naptr(c->dst, c->dstlen, c->tech, c->techlen, answer, len, c->naptrinput)) {
00279 ast_log(LOG_WARNING, "Failed to parse naptr :(\n");
00280 return -1;
00281 }
00282
00283 if (!ast_strlen_zero(c->dst))
00284 return 1;
00285
00286 return 0;
00287 }
00288
00289 int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen)
00290 {
00291 struct enum_context context;
00292 char tmp[259 + 80];
00293 char naptrinput[80] = "+";
00294 int pos = strlen(number) - 1;
00295 int newpos = 0;
00296 int ret = -1;
00297 struct enum_search *s = NULL;
00298 int version = -1;
00299
00300 strncat(naptrinput, number, sizeof(naptrinput) - 2);
00301
00302 context.naptrinput = naptrinput;
00303 context.dst = dst;
00304 context.dstlen = dstlen;
00305 context.tech = tech;
00306 context.techlen = techlen;
00307
00308 if (pos > 128)
00309 pos = 128;
00310 while(pos >= 0) {
00311 tmp[newpos++] = number[pos--];
00312 tmp[newpos++] = '.';
00313 }
00314
00315 if (chan && ast_autoservice_start(chan) < 0)
00316 return -1;
00317
00318 for(;;) {
00319 ast_mutex_lock(&enumlock);
00320 if (version != enumver) {
00321
00322 s = toplevs;
00323 version = enumver;
00324 } else {
00325 s = s->next;
00326 }
00327 if (s) {
00328 strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
00329 }
00330 ast_mutex_unlock(&enumlock);
00331 if (!s)
00332 break;
00333 ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
00334 if (ret > 0)
00335 break;
00336 }
00337 if (ret < 0) {
00338 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
00339 ret = 0;
00340 }
00341 if (chan)
00342 ret |= ast_autoservice_stop(chan);
00343 return ret;
00344 }
00345
00346 int ast_get_txt(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen, char *txt, int txtlen)
00347 {
00348 struct enum_context context;
00349 char tmp[259 + 80];
00350 char naptrinput[80] = "+";
00351 int pos = strlen(number) - 1;
00352 int newpos = 0;
00353 int ret = -1;
00354 struct enum_search *s = NULL;
00355 int version = -1;
00356
00357 strncat(naptrinput, number, sizeof(naptrinput) - 2);
00358
00359 context.naptrinput = naptrinput;
00360 context.dst = dst;
00361 context.dstlen = dstlen;
00362 context.tech = tech;
00363 context.techlen = techlen;
00364 context.txt = txt;
00365 context.txtlen = txtlen;
00366
00367 if (pos > 128)
00368 pos = 128;
00369 while(pos >= 0) {
00370 tmp[newpos++] = number[pos--];
00371 tmp[newpos++] = '.';
00372 }
00373
00374 if (chan && ast_autoservice_start(chan) < 0)
00375 return -1;
00376
00377 for(;;) {
00378 ast_mutex_lock(&enumlock);
00379 if (version != enumver) {
00380
00381 s = toplevs;
00382 version = enumver;
00383 } else {
00384 s = s->next;
00385 }
00386 if (s) {
00387 strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
00388 }
00389 ast_mutex_unlock(&enumlock);
00390 if (!s)
00391 break;
00392 ret = ast_search_dns(&context, tmp, C_IN, T_TXT, txt_callback);
00393 if (ret > 0)
00394 break;
00395 }
00396 if (ret < 0) {
00397 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
00398 ret = 0;
00399 }
00400 if (chan)
00401 ret |= ast_autoservice_stop(chan);
00402 return ret;
00403 }
00404
00405 static struct enum_search *enum_newtoplev(char *s)
00406 {
00407 struct enum_search *tmp;
00408 tmp = malloc(sizeof(struct enum_search));
00409 if (tmp) {
00410 memset(tmp, 0, sizeof(struct enum_search));
00411 strncpy(tmp->toplev, s, sizeof(tmp->toplev) - 1);
00412 }
00413 return tmp;
00414 }
00415
00416 int ast_enum_init(void)
00417 {
00418 struct ast_config *cfg;
00419 struct enum_search *s, *sl;
00420 struct ast_variable *v;
00421
00422
00423 ast_mutex_lock(&enumlock);
00424 s = toplevs;
00425 while(s) {
00426 sl = s;
00427 s = s->next;
00428 free(sl);
00429 }
00430 toplevs = NULL;
00431 cfg = ast_load("enum.conf");
00432 if (cfg) {
00433 sl = NULL;
00434 v = ast_variable_browse(cfg, "general");
00435 while(v) {
00436 if (!strcasecmp(v->name, "search")) {
00437 s = enum_newtoplev(v->value);
00438 if (s) {
00439 if (sl)
00440 sl->next = s;
00441 else
00442 toplevs = s;
00443 sl = s;
00444 }
00445 }
00446 v = v->next;
00447 }
00448 ast_destroy(cfg);
00449 } else {
00450 toplevs = enum_newtoplev(TOPLEV);
00451 }
00452 enumver++;
00453 ast_mutex_unlock(&enumlock);
00454 return 0;
00455 }
00456
00457 int ast_enum_reload(void)
00458 {
00459 return ast_enum_init();
00460 }