00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include <sys/types.h>
00028 #include <sys/socket.h>
00029 #include <netinet/in.h>
00030 #include <arpa/nameser.h>
00031 #if __APPLE_CC__ >= 1495
00032 #include <arpa/nameser_compat.h>
00033 #endif
00034 #include <resolv.h>
00035 #include <stdlib.h>
00036 #include <string.h>
00037 #include <ctype.h>
00038 #include <regex.h>
00039 #include <unistd.h>
00040 #include <errno.h>
00041
00042 #include "asterisk.h"
00043
00044 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 37691 $")
00045
00046 #include "asterisk/logger.h"
00047 #include "asterisk/options.h"
00048 #include "asterisk/enum.h"
00049 #include "asterisk/dns.h"
00050 #include "asterisk/channel.h"
00051 #include "asterisk/config.h"
00052 #include "asterisk/utils.h"
00053
00054 #ifdef __APPLE__
00055 #undef T_NAPTR
00056 #define T_NAPTR 35
00057 #endif
00058
00059 #ifdef __APPLE__
00060 #undef T_TXT
00061 #define T_TXT 16
00062 #endif
00063
00064
00065 #define TOPLEV "e164.arpa."
00066
00067
00068 static struct enum_search {
00069 char toplev[512];
00070 struct enum_search *next;
00071 } *toplevs;
00072
00073 static int enumver = 0;
00074
00075 AST_MUTEX_DEFINE_STATIC(enumlock);
00076
00077 struct naptr {
00078 unsigned short order;
00079 unsigned short pref;
00080 } __attribute__ ((__packed__));
00081
00082
00083 static unsigned int parse_ie(unsigned char *data, unsigned int maxdatalen, unsigned char *src, unsigned int srclen)
00084 {
00085 unsigned int len, olen;
00086
00087 len = olen = (unsigned int) src[0];
00088 src++;
00089 srclen--;
00090
00091 if (len > srclen) {
00092 ast_log(LOG_WARNING, "ENUM parsing failed: Wanted %d characters, got %d\n", len, srclen);
00093 return -1;
00094 }
00095
00096 if (len > maxdatalen)
00097 len = maxdatalen;
00098 memcpy(data, src, len);
00099
00100 return olen + 1;
00101 }
00102
00103
00104 static int parse_naptr(unsigned char *dst, int dstsize, char *tech, int techsize, unsigned char *answer, int len, unsigned char *naptrinput)
00105 {
00106 char tech_return[80];
00107 char *oanswer = answer;
00108 char flags[512] = "";
00109 char services[512] = "";
00110 char *p;
00111 char regexp[512] = "";
00112 char repl[512] = "";
00113 char temp[512] = "";
00114 char delim;
00115 char *delim2;
00116 char *pattern, *subst, *d;
00117 int res;
00118 int regexp_len, size, backref;
00119 int d_len = sizeof(temp) - 1;
00120 regex_t preg;
00121 regmatch_t pmatch[9];
00122
00123 tech_return[0] = '\0';
00124
00125 dst[0] = '\0';
00126
00127 if (len < sizeof(struct naptr)) {
00128 ast_log(LOG_WARNING, "NAPTR record length too short\n");
00129 return -1;
00130 }
00131 answer += sizeof(struct naptr);
00132 len -= sizeof(struct naptr);
00133 if ((res = parse_ie(flags, sizeof(flags) - 1, answer, len)) < 0) {
00134 ast_log(LOG_WARNING, "Failed to get flags from NAPTR record\n");
00135 return -1;
00136 } else {
00137 answer += res;
00138 len -= res;
00139 }
00140 if ((res = parse_ie(services, sizeof(services) - 1, answer, len)) < 0) {
00141 ast_log(LOG_WARNING, "Failed to get services from NAPTR record\n");
00142 return -1;
00143 } else {
00144 answer += res;
00145 len -= res;
00146 }
00147 if ((res = parse_ie(regexp, sizeof(regexp) - 1, answer, len)) < 0) {
00148 ast_log(LOG_WARNING, "Failed to get regexp from NAPTR record\n");
00149 return -1;
00150 } else {
00151 answer += res;
00152 len -= res;
00153 }
00154
00155 if ((res = dn_expand((unsigned char *)oanswer, (unsigned char *)answer + len, (unsigned char *)answer, repl, sizeof(repl) - 1)) < 0) {
00156 ast_log(LOG_WARNING, "Failed to expand hostname\n");
00157 return -1;
00158 }
00159
00160 if (option_debug > 2)
00161 ast_log(LOG_DEBUG, "NAPTR input='%s', flags='%s', services='%s', regexp='%s', repl='%s'\n",
00162 naptrinput, flags, services, regexp, repl);
00163
00164 if (tolower(flags[0]) != 'u') {
00165 ast_log(LOG_WARNING, "NAPTR Flag must be 'U' or 'u'.\n");
00166 return -1;
00167 }
00168
00169 p = strstr(services, "e2u+");
00170 if (p == NULL)
00171 p = strstr(services, "E2U+");
00172 if (p){
00173 p = p + 4;
00174 if (strchr(p, ':')){
00175 p = strchr(p, ':') + 1;
00176 }
00177 ast_copy_string(tech_return, p, sizeof(tech_return));
00178 } else {
00179
00180 p = strstr(services, "+e2u");
00181 if (p == NULL)
00182 p = strstr(services, "+E2U");
00183 if (p) {
00184 *p = 0;
00185 p = strchr(services, ':');
00186 if (p)
00187 *p = 0;
00188 ast_copy_string(tech_return, services, sizeof(tech_return));
00189 }
00190 }
00191
00192
00193
00194
00195
00196 regexp_len = strlen(regexp);
00197 if (regexp_len < 7) {
00198 ast_log(LOG_WARNING, "Regex too short to be meaningful.\n");
00199 return -1;
00200 }
00201
00202
00203 delim = regexp[0];
00204 delim2 = strchr(regexp + 1, delim);
00205 if ((delim2 == NULL) || (regexp[regexp_len-1] != delim)) {
00206 ast_log(LOG_WARNING, "Regex delimiter error (on \"%s\").\n",regexp);
00207 return -1;
00208 }
00209
00210 pattern = regexp + 1;
00211 *delim2 = 0;
00212 subst = delim2 + 1;
00213 regexp[regexp_len-1] = 0;
00214
00215
00216
00217
00218
00219 if (regcomp(&preg, pattern, REG_EXTENDED | REG_NEWLINE)) {
00220 ast_log(LOG_WARNING, "NAPTR Regex compilation error (regex = \"%s\").\n",regexp);
00221 return -1;
00222 }
00223
00224 if (preg.re_nsub > 9) {
00225 ast_log(LOG_WARNING, "NAPTR Regex compilation error: too many subs.\n");
00226 regfree(&preg);
00227 return -1;
00228 }
00229
00230 if (regexec(&preg, naptrinput, 9, pmatch, 0)) {
00231 ast_log(LOG_WARNING, "NAPTR Regex match failed.\n");
00232 regfree(&preg);
00233 return -1;
00234 }
00235 regfree(&preg);
00236
00237 d = temp;
00238 d_len--;
00239 while (*subst && (d_len > 0)) {
00240 if ((subst[0] == '\\') && isdigit(subst[1]) && (pmatch[subst[1]-'0'].rm_so != -1)) {
00241 backref = subst[1]-'0';
00242 size = pmatch[backref].rm_eo - pmatch[backref].rm_so;
00243 if (size > d_len) {
00244 ast_log(LOG_WARNING, "Not enough space during NAPTR regex substitution.\n");
00245 return -1;
00246 }
00247 memcpy(d, naptrinput + pmatch[backref].rm_so, size);
00248 d += size;
00249 d_len -= size;
00250 subst += 2;
00251 } else if (isprint(*subst)) {
00252 *d++ = *subst++;
00253 d_len--;
00254 } else {
00255 ast_log(LOG_WARNING, "Error during regex substitution.\n");
00256 return -1;
00257 }
00258 }
00259 *d = 0;
00260 ast_copy_string(dst, temp, dstsize);
00261 dst[dstsize - 1] = '\0';
00262
00263 if (*tech != '\0'){
00264 if (!strncasecmp(tech, "ALL", techsize)){
00265 return 1;
00266 }
00267 if (!strncasecmp(tech_return, tech, sizeof(tech_return)<techsize?sizeof(tech_return):techsize)){
00268 ast_copy_string(tech, tech_return, techsize);
00269 return 1;
00270 } else {
00271 return 0;
00272 }
00273 }
00274
00275
00276 ast_copy_string(tech, tech_return, techsize);
00277
00278 return 1;
00279 }
00280
00281
00282 #define ENUMLOOKUP_OPTIONS_COUNT 1
00283
00284 struct enum_naptr_rr {
00285 struct naptr naptr;
00286 char *result;
00287 char *tech;
00288 int sort_pos;
00289 };
00290
00291 struct enum_context {
00292 char *dst;
00293 int dstlen;
00294 char *tech;
00295 int techlen;
00296 char *txt;
00297 int txtlen;
00298 char *naptrinput;
00299 int position;
00300 int options;
00301 struct enum_naptr_rr *naptr_rrs;
00302 int naptr_rrs_count;
00303 };
00304
00305
00306 static int txt_callback(void *context, char *answer, int len, char *fullanswer)
00307 {
00308 struct enum_context *c = (struct enum_context *)context;
00309
00310 if (answer == NULL) {
00311 c->txt = NULL;
00312 c->txtlen = 0;
00313 return 0;
00314 }
00315
00316
00317 answer += 1;
00318 len -= 1;
00319
00320
00321
00322
00323 answer[len] = '\0';
00324
00325
00326 len +=1;
00327
00328
00329 ast_copy_string(c->txt, answer, len < c->txtlen ? len : (c->txtlen));
00330
00331
00332 c->txt[(c->txtlen)-1] = '\0';
00333
00334 return 1;
00335 }
00336
00337
00338 static int enum_callback(void *context, char *answer, int len, char *fullanswer)
00339 {
00340 struct enum_context *c = (struct enum_context *)context;
00341 void *p = NULL;
00342 int res;
00343
00344 res = parse_naptr(c->dst, c->dstlen, c->tech, c->techlen, answer, len, c->naptrinput);
00345
00346 if (res < 0) {
00347 ast_log(LOG_WARNING, "Failed to parse naptr :(\n");
00348 return -1;
00349 } else if (res > 0 && !ast_strlen_zero(c->dst)){
00350 if (c->options & ENUMLOOKUP_OPTIONS_COUNT){
00351 c->position++;
00352 snprintf(c->dst, c->dstlen, "%d", c->position);
00353 } else {
00354 p = realloc(c->naptr_rrs, sizeof(struct enum_naptr_rr)*(c->naptr_rrs_count+1));
00355 if (p) {
00356 c->naptr_rrs = (struct enum_naptr_rr*)p;
00357 memcpy(&c->naptr_rrs[c->naptr_rrs_count].naptr, answer, sizeof(struct naptr));
00358 c->naptr_rrs[c->naptr_rrs_count].result = strdup(c->dst);
00359 c->naptr_rrs[c->naptr_rrs_count].tech = strdup(c->tech);
00360 c->naptr_rrs[c->naptr_rrs_count].sort_pos = c->naptr_rrs_count;
00361 c->naptr_rrs_count++;
00362 }
00363 c->dst[0] = 0;
00364 }
00365 return 0;
00366 }
00367
00368 if (c->options & ENUMLOOKUP_OPTIONS_COUNT) {
00369 snprintf(c->dst, c->dstlen, "%d", c->position);
00370 }
00371
00372 return 0;
00373 }
00374
00375
00376 int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen, char* suffix, char* options)
00377 {
00378 struct enum_context context;
00379 char tmp[259 + 512];
00380 char naptrinput[512];
00381 int pos = strlen(number) - 1;
00382 int newpos = 0;
00383 int ret = -1;
00384 struct enum_search *s = NULL;
00385 int version = -1;
00386
00387 char *p1 = NULL;
00388 char *p2 = NULL;
00389 int k = 0;
00390 int i = 0;
00391 int z = 0;
00392
00393 if (number[0] == 'n') {
00394 strncpy(naptrinput, number+1, sizeof(naptrinput));
00395 } else {
00396 strncpy(naptrinput, number, sizeof(naptrinput));
00397 }
00398
00399 context.naptrinput = naptrinput;
00400 context.dst = dst;
00401 context.dstlen = dstlen;
00402 context.tech = tech;
00403 context.techlen = techlen;
00404 context.options = 0;
00405 context.position = 1;
00406 context.naptr_rrs = NULL;
00407 context.naptr_rrs_count = 0;
00408
00409 if (options != NULL){
00410 if (*options == 'c'){
00411 context.options = ENUMLOOKUP_OPTIONS_COUNT;
00412 context.position = 0;
00413 } else {
00414 context.position = atoi(options);
00415 if (context.position < 1)
00416 context.position = 1;
00417 }
00418 }
00419
00420 if (pos > 128)
00421 pos = 128;
00422
00423
00424 p1 = strchr(number, '*');
00425
00426 if (number[0] == 'n') {
00427 p1 = NULL;
00428 k = 1;
00429 }
00430
00431 if (p1 != NULL) {
00432 p2 = p1+1;
00433 while (p1 > number){
00434 p1--;
00435 tmp[newpos++] = *p1;
00436 tmp[newpos++] = '.';
00437 }
00438 if (*p2) {
00439 while(*p2 && newpos < 128){
00440 tmp[newpos++] = *p2;
00441 p2++;
00442 }
00443 tmp[newpos++] = '.';
00444 }
00445
00446 } else {
00447 while (pos >= k) {
00448 if (isdigit(number[pos])) {
00449 tmp[newpos++] = number[pos];
00450 tmp[newpos++] = '.';
00451 }
00452 pos--;
00453 }
00454 }
00455
00456 if (chan && ast_autoservice_start(chan) < 0)
00457 return -1;
00458
00459 for (;;) {
00460 ast_mutex_lock(&enumlock);
00461 if (version != enumver) {
00462
00463 s = toplevs;
00464 version = enumver;
00465 } else {
00466 s = s->next;
00467 }
00468 if (suffix != NULL) {
00469 strncpy(tmp + newpos, suffix, sizeof(tmp) - newpos - 1);
00470 } else if (s) {
00471 strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
00472 }
00473 ast_mutex_unlock(&enumlock);
00474 if (!s)
00475 break;
00476 ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
00477 if (ret > 0)
00478 break;
00479 if (suffix != NULL)
00480 break;
00481 }
00482 if (ret < 0) {
00483 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
00484 ret = 0;
00485 }
00486
00487 if (context.naptr_rrs_count >= context.position && ! (context.options & ENUMLOOKUP_OPTIONS_COUNT)) {
00488
00489 for (k = 0; k < context.naptr_rrs_count; k++) {
00490 for (i = 0; i < context.naptr_rrs_count; i++) {
00491
00492 if ((ntohs(context.naptr_rrs[k].naptr.order) < ntohs(context.naptr_rrs[i].naptr.order)
00493 && context.naptr_rrs[k].sort_pos > context.naptr_rrs[i].sort_pos)
00494 || (ntohs(context.naptr_rrs[k].naptr.order) > ntohs(context.naptr_rrs[i].naptr.order)
00495 && context.naptr_rrs[k].sort_pos < context.naptr_rrs[i].sort_pos)){
00496 z = context.naptr_rrs[k].sort_pos;
00497 context.naptr_rrs[k].sort_pos = context.naptr_rrs[i].sort_pos;
00498 context.naptr_rrs[i].sort_pos = z;
00499 } else if (ntohs(context.naptr_rrs[k].naptr.order) == ntohs(context.naptr_rrs[i].naptr.order)) {
00500
00501 if (ntohs(context.naptr_rrs[k].naptr.pref) == ntohs(context.naptr_rrs[i].naptr.pref)) {
00502
00503 if ((strcmp(context.naptr_rrs[k].tech, context.naptr_rrs[i].tech) < 0
00504 && context.naptr_rrs[k].sort_pos > context.naptr_rrs[i].sort_pos)
00505 || (strcmp(context.naptr_rrs[k].tech, context.naptr_rrs[i].tech) > 0
00506 && context.naptr_rrs[k].sort_pos < context.naptr_rrs[i].sort_pos)) {
00507 z = context.naptr_rrs[k].sort_pos;
00508 context.naptr_rrs[k].sort_pos = context.naptr_rrs[i].sort_pos;
00509 context.naptr_rrs[i].sort_pos = z;
00510 }
00511 } else if ((ntohs(context.naptr_rrs[k].naptr.pref) < ntohs(context.naptr_rrs[i].naptr.pref)
00512 && context.naptr_rrs[k].sort_pos > context.naptr_rrs[i].sort_pos)
00513 || (ntohs(context.naptr_rrs[k].naptr.pref) > ntohs(context.naptr_rrs[i].naptr.pref)
00514 && context.naptr_rrs[k].sort_pos < context.naptr_rrs[i].sort_pos)){
00515 z = context.naptr_rrs[k].sort_pos;
00516 context.naptr_rrs[k].sort_pos = context.naptr_rrs[i].sort_pos;
00517 context.naptr_rrs[i].sort_pos = z;
00518 }
00519 }
00520 }
00521 }
00522 for (k = 0; k < context.naptr_rrs_count; k++) {
00523 if (context.naptr_rrs[k].sort_pos == context.position - 1) {
00524 ast_copy_string(context.dst, context.naptr_rrs[k].result, dstlen);
00525 ast_copy_string(context.tech, context.naptr_rrs[k].tech, techlen);
00526 break;
00527 }
00528 }
00529 } else if (!(context.options & ENUMLOOKUP_OPTIONS_COUNT)) {
00530 context.dst[0] = 0;
00531 }
00532
00533 if (chan)
00534 ret |= ast_autoservice_stop(chan);
00535
00536 for (k=0; k<context.naptr_rrs_count; k++) {
00537 free(context.naptr_rrs[k].result);
00538 free(context.naptr_rrs[k].tech);
00539 }
00540
00541 free(context.naptr_rrs);
00542
00543 return ret;
00544 }
00545
00546
00547
00548
00549 int ast_get_txt(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen, char *txt, int txtlen)
00550 {
00551 struct enum_context context;
00552 char tmp[259 + 512];
00553 char naptrinput[512] = "+";
00554 int pos = strlen(number) - 1;
00555 int newpos = 0;
00556 int ret = -1;
00557 struct enum_search *s = NULL;
00558 int version = -1;
00559
00560 strncat(naptrinput, number, sizeof(naptrinput) - 2);
00561
00562 context.naptrinput = naptrinput;
00563 context.dst = dst;
00564 context.dstlen = dstlen;
00565 context.tech = tech;
00566 context.techlen = techlen;
00567 context.txt = txt;
00568 context.txtlen = txtlen;
00569
00570 if (pos > 128)
00571 pos = 128;
00572 while (pos >= 0) {
00573 tmp[newpos++] = number[pos--];
00574 tmp[newpos++] = '.';
00575 }
00576
00577 if (chan && ast_autoservice_start(chan) < 0)
00578 return -1;
00579
00580 for (;;) {
00581 ast_mutex_lock(&enumlock);
00582 if (version != enumver) {
00583
00584 s = toplevs;
00585 version = enumver;
00586 } else {
00587 s = s->next;
00588 }
00589 if (s) {
00590 strncpy(tmp + newpos, s->toplev, sizeof(tmp) - newpos - 1);
00591 }
00592 ast_mutex_unlock(&enumlock);
00593 if (!s)
00594 break;
00595
00596 ret = ast_search_dns(&context, tmp, C_IN, T_TXT, txt_callback);
00597 if (ret > 0)
00598 break;
00599 }
00600 if (ret < 0) {
00601 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
00602 ret = 0;
00603 }
00604 if (chan)
00605 ret |= ast_autoservice_stop(chan);
00606 return ret;
00607 }
00608
00609
00610 static struct enum_search *enum_newtoplev(char *s)
00611 {
00612 struct enum_search *tmp;
00613
00614 tmp = malloc(sizeof(struct enum_search));
00615 if (tmp) {
00616 memset(tmp, 0, sizeof(struct enum_search));
00617 ast_copy_string(tmp->toplev, s, sizeof(tmp->toplev));
00618 }
00619 return tmp;
00620 }
00621
00622
00623 int ast_enum_init(void)
00624 {
00625 struct ast_config *cfg;
00626 struct enum_search *s, *sl;
00627 struct ast_variable *v;
00628
00629
00630 ast_mutex_lock(&enumlock);
00631 s = toplevs;
00632 while(s) {
00633 sl = s;
00634 s = s->next;
00635 free(sl);
00636 }
00637 toplevs = NULL;
00638 cfg = ast_config_load("enum.conf");
00639 if (cfg) {
00640 sl = NULL;
00641 v = ast_variable_browse(cfg, "general");
00642 while(v) {
00643 if (!strcasecmp(v->name, "search")) {
00644 s = enum_newtoplev(v->value);
00645 if (s) {
00646 if (sl)
00647 sl->next = s;
00648 else
00649 toplevs = s;
00650 sl = s;
00651 }
00652 }
00653 v = v->next;
00654 }
00655 ast_config_destroy(cfg);
00656 } else {
00657 toplevs = enum_newtoplev(TOPLEV);
00658 }
00659 enumver++;
00660 ast_mutex_unlock(&enumlock);
00661 return 0;
00662 }
00663
00664 int ast_enum_reload(void)
00665 {
00666 return ast_enum_init();
00667 }