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