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