Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals

enum.c

Go to the documentation of this file.
00001 /*
00002  * ENUM Support for Asterisk
00003  *
00004  * Copyright (C) 2003 Digium
00005  *
00006  * Written by Mark Spencer <markster@digium.com>
00007  *
00008  * Funding provided by nic.at
00009  *
00010  * Distributed under the terms of the GNU GPL
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    /* DEDBUGGING STUB
00154    strncpy(regexp, "!^\\+43(.*)$!\\1@bla.fasel!", sizeof(regexp) - 1);
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  * now do the regex wizardry.
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    /* skip over first byte, as for some reason it's a vertical tab character */
00254    answer += 1;
00255    len -= 1;
00256 
00257    /* answer is not null-terminated, but should be */
00258    /* this is safe to do, as answer has extra bytes on the end we can 
00259            safely overwrite with a null */
00260    answer[len] = '\0';
00261    /* now increment len so that len includes the null, so that we can
00262       compare apples to apples */
00263    len +=1;
00264 
00265    /* finally, copy the answer into c->txt */
00266    strncpy(c->txt, answer, len < c->txtlen ? len-1 : (c->txtlen)-1);
00267    
00268    /* just to be safe, let's make sure c->txt is null terminated */
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          /* Ooh, a reload... */
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          /* Ooh, a reload... */
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    /* Destroy existing list */
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 }

Generated on Thu Nov 29 22:50:23 2007 for Asterisk by  doxygen 1.4.2