Main Page | Alphabetical List | Data Structures | 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 
00036 #ifdef __APPLE__
00037 #undef T_NAPTR
00038 #define T_NAPTR 35
00039 #endif
00040 
00041 #define TOPLEV "e164.arpa."
00042 
00043 static struct enum_search {
00044    char toplev[80];
00045    struct enum_search *next;
00046 } *toplevs;
00047 
00048 static int enumver = 0;
00049 
00050 static ast_mutex_t enumlock = AST_MUTEX_INITIALIZER;
00051 
00052 struct naptr {
00053    unsigned short order;
00054    unsigned short pref;
00055 } __attribute__ ((__packed__));
00056 
00057 static int parse_ie(unsigned char *data, int maxdatalen, unsigned char *src, int srclen)
00058 {
00059    int len, olen;
00060    len = olen = (int)src[0];
00061    src++;
00062    srclen--;
00063    if (len > srclen) {
00064       ast_log(LOG_WARNING, "Want %d, got %d\n", len, srclen);
00065       return -1;
00066    }
00067    if (len > maxdatalen)
00068       len = maxdatalen;
00069    memcpy(data, src, len);
00070    return olen + 1;
00071 }
00072 
00073 static int parse_naptr(unsigned char *dst, int dstsize, char *tech, int techsize, unsigned char *answer, int len, char *naptrinput)
00074 {
00075    unsigned char *oanswer = answer;
00076    unsigned char flags[80] = "";
00077    unsigned char services[80] = "";
00078    unsigned char regexp[80] = "";
00079    unsigned char repl[80] = "";
00080    unsigned char temp[80] = "";
00081    unsigned char delim;
00082    unsigned char *delim2;
00083    unsigned char *pattern, *subst, *d;
00084    int res;
00085    int regexp_len, size, backref;
00086    int d_len = sizeof(temp) - 1;
00087    regex_t preg;
00088    regmatch_t pmatch[9];
00089 
00090 
00091    strcpy(dst, "");
00092    
00093    if (len < sizeof(struct naptr)) {
00094       ast_log(LOG_WARNING, "Length too short\n");
00095       return -1;
00096    }
00097    answer += sizeof(struct naptr);
00098    len -= sizeof(struct naptr);
00099    if ((res = parse_ie(flags, sizeof(flags) - 1, answer, len)) < 0) {
00100       ast_log(LOG_WARNING, "Failed to get flags\n");
00101       return -1; 
00102    } else { answer += res; len -= res; }
00103    if ((res = parse_ie(services, sizeof(services) - 1, answer, len)) < 0) {
00104       ast_log(LOG_WARNING, "Failed to get services\n");
00105       return -1; 
00106    } else { answer += res; len -= res; }
00107    if ((res = parse_ie(regexp, sizeof(regexp) - 1, answer, len)) < 0)
00108       return -1; else { answer += res; len -= res; }
00109    if ((res = dn_expand(oanswer,answer + len,answer, repl, sizeof(repl) - 1)) < 0) {
00110       ast_log(LOG_WARNING, "Failed to expand hostname\n");
00111       return -1;
00112    } 
00113 
00114    ast_log(LOG_DEBUG, "input='%s', flags='%s', services='%s', regexp='%s', repl='%s'\n",
00115           naptrinput, flags, services, regexp, repl);
00116 
00117    if (tolower(flags[0]) != 'u') {
00118       ast_log(LOG_WARNING, "Flag must be 'U' or 'u'.\n");
00119       return -1;
00120    }
00121 
00122    if ((!strncasecmp(services, "e2u+sip", 7)) || 
00123        (!strncasecmp(services, "sip+e2u", 7))) {
00124       strncpy(tech, "sip", techsize -1); 
00125    } else if ((!strncasecmp(services, "e2u+h323", 8)) || 
00126        (!strncasecmp(services, "h323+e2u", 8))) {
00127       strncpy(tech, "h323", techsize -1); 
00128    } else if ((!strncasecmp(services, "e2u+x-iax2", 10)) || 
00129        (!strncasecmp(services, "e2u+iax2", 8)) ||
00130        (!strncasecmp(services, "iax2+e2u", 8))) {
00131       strncpy(tech, "iax2", techsize -1); 
00132    } else if ((!strncasecmp(services, "e2u+x-iax", 9)) ||
00133        (!strncasecmp(services, "e2u+iax", 7)) ||
00134        (!strncasecmp(services, "iax+e2u", 7))) {
00135       strncpy(tech, "iax", techsize -1); 
00136    } else if ((!strncasecmp(services, "e2u+tel", 7)) || 
00137        (!strncasecmp(services, "tel+e2u", 7))) {
00138       strncpy(tech, "tel", techsize -1); 
00139    } else if (!strncasecmp(services, "e2u+voice:", 10)) {
00140       strncpy(tech, services+10, techsize -1); 
00141    } else {
00142       ast_log(LOG_DEBUG, 
00143       "Services must be e2u+${tech}, ${tech}+e2u, or e2u+voice: where $tech is from (sip, h323, tel, iax, iax2). \n");
00144       return 0;
00145    }
00146 
00147    /* DEDBUGGING STUB
00148    strcpy(regexp, "!^\\+43(.*)$!\\1@bla.fasel!");
00149    */
00150 
00151    regexp_len = strlen(regexp);
00152    if (regexp_len < 7) {
00153       ast_log(LOG_WARNING, "Regex too short to be meaningful.\n");
00154       return -1;
00155    } 
00156 
00157 
00158    delim = regexp[0];
00159    delim2 = strchr(regexp + 1, delim);
00160    if ((delim2 == NULL) || (regexp[regexp_len-1] != delim)) {
00161       ast_log(LOG_WARNING, "Regex delimiter error (on \"%s\").\n",regexp);
00162       return -1;
00163    }
00164 
00165    pattern = regexp + 1;
00166    *delim2 = 0;
00167    subst   = delim2 + 1;
00168    regexp[regexp_len-1] = 0;
00169 
00170 #if 0
00171    printf("Pattern: %s\n", pattern);
00172    printf("Subst: %s\n", subst);
00173 #endif
00174 
00175 /*
00176  * now do the regex wizardry.
00177  */
00178 
00179    if (regcomp(&preg, pattern, REG_EXTENDED | REG_NEWLINE)) {
00180       ast_log(LOG_WARNING, "Regex compilation error (regex = \"%s\").\n",regexp);
00181       return -1;
00182    }
00183 
00184    if (preg.re_nsub > 9) {
00185       ast_log(LOG_WARNING, "Regex compilation error: too many subs.\n");
00186       regfree(&preg);
00187       return -1;
00188    }
00189 
00190    if (regexec(&preg, naptrinput, 9, pmatch, 0)) {
00191       ast_log(LOG_WARNING, "Regex match failed.\n");
00192       regfree(&preg);
00193       return -1;
00194    }
00195    regfree(&preg);
00196 
00197    d = temp; d_len--; 
00198    while( *subst && (d_len > 0) ) {
00199       if ((subst[0] == '\\') && isdigit(subst[1]) && (pmatch[subst[1]-'0'].rm_so != -1)) {
00200          backref = subst[1]-'0';
00201          size = pmatch[backref].rm_eo - pmatch[backref].rm_so;
00202          if (size > d_len) {
00203             ast_log(LOG_WARNING, "Not enough space during regex substitution.\n");
00204             return -1;
00205             }
00206          memcpy(d, naptrinput + pmatch[backref].rm_so, size);
00207          d += size;
00208          d_len -= size;
00209          subst += 2;
00210       } else if (isprint(*subst)) {
00211          *d++ = *subst++;
00212          d_len--;
00213       } else {
00214          ast_log(LOG_WARNING, "Error during regex substitution.\n");
00215          return -1;
00216       }
00217    }
00218    *d = 0;
00219    strncpy(dst, temp, dstsize);
00220    return 0;
00221 }
00222 
00223 struct enum_context {
00224    char *dst;
00225    int dstlen;
00226    char *tech;
00227    int techlen;
00228    char *naptrinput;
00229 };
00230 
00231 static int enum_callback(void *context, u_char *answer, int len, u_char *fullanswer)
00232 {
00233    struct enum_context *c = (struct enum_context *)context;
00234 
00235    if (parse_naptr(c->dst, c->dstlen, c->tech, c->techlen, answer, len, c->naptrinput)) {
00236       ast_log(LOG_WARNING, "Failed to parse naptr :(\n");
00237       return -1;
00238    }
00239 
00240    if (strlen(c->dst))
00241       return 1;
00242 
00243    return 0;
00244 }
00245 
00246 int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen)
00247 {
00248    struct enum_context context;
00249    char tmp[259 + 80];
00250    char naptrinput[80] = "+";
00251    int pos = strlen(number) - 1;
00252    int newpos = 0;
00253    int ret = -1;
00254    struct enum_search *s = NULL;
00255    int version = -1;
00256 
00257    strncat(naptrinput, number, sizeof(naptrinput) - 2);
00258 
00259    context.naptrinput = naptrinput;
00260    context.dst = dst;
00261    context.dstlen = dstlen;
00262    context.tech = tech;
00263    context.techlen = techlen;
00264 
00265    if (pos > 128)
00266       pos = 128;
00267    while(pos >= 0) {
00268       tmp[newpos++] = number[pos--];
00269       tmp[newpos++] = '.';
00270    }
00271    
00272    if (chan && ast_autoservice_start(chan) < 0)
00273       return -1;
00274 
00275    for(;;) {
00276       ast_mutex_lock(&enumlock);
00277       if (version != enumver) {
00278          /* Ooh, a reload... */
00279          s = toplevs;
00280          version = enumver;
00281       } else {
00282          s = s->next;
00283       }
00284       if (s) {
00285          strcpy(tmp + newpos, s->toplev);
00286       }
00287       ast_mutex_unlock(&enumlock);
00288       if (!s)
00289          break;
00290       ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
00291       if (ret > 0)
00292          break;
00293    }
00294    if (ret < 0) {
00295       ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
00296       ret = 0;
00297    }
00298    if (chan)
00299       ret |= ast_autoservice_stop(chan);
00300    return ret;
00301 }
00302 
00303 static struct enum_search *enum_newtoplev(char *s)
00304 {
00305    struct enum_search *tmp;
00306    tmp = malloc(sizeof(struct enum_search));
00307    if (tmp) {
00308       memset(tmp, 0, sizeof(struct enum_search));
00309       strncpy(tmp->toplev, s, sizeof(tmp->toplev) - 1);
00310    }
00311    return tmp;
00312 }
00313 
00314 int ast_enum_init(void)
00315 {
00316    struct ast_config *cfg;
00317    struct enum_search *s, *sl;
00318    struct ast_variable *v;
00319 
00320    /* Destroy existing list */
00321    ast_mutex_lock(&enumlock);
00322    s = toplevs;
00323    while(s) {
00324       sl = s;
00325       s = s->next;
00326       free(sl);
00327    }
00328    toplevs = NULL;
00329    cfg = ast_load("enum.conf");
00330    if (cfg) {
00331       sl = NULL;
00332       v = ast_variable_browse(cfg, "general");
00333       while(v) {
00334          if (!strcasecmp(v->name, "search")) {
00335             s = enum_newtoplev(v->value);
00336             if (s) {
00337                if (sl)
00338                   sl->next = s;
00339                else
00340                   toplevs = s;
00341                sl = s;
00342             }
00343          }
00344          v = v->next;
00345       }
00346       ast_destroy(cfg);
00347    } else {
00348       toplevs = enum_newtoplev(TOPLEV);
00349    }
00350    enumver++;
00351    ast_mutex_unlock(&enumlock);
00352    return 0;
00353 }
00354 
00355 int ast_enum_reload(void)
00356 {
00357    return ast_enum_init();
00358 }

Generated on Sun Apr 18 23:33:51 2004 for Asterisk by doxygen 1.3.6-20040222