00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
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
00148
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
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
00238 if (strlen(c->dst))
00239 return 1;
00240
00241 return 0;
00242 }
00243
00244 int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen)
00245 {
00246 struct enum_context context;
00247 char tmp[259 + 80];
00248 char naptrinput[80] = "+";
00249 int pos = strlen(number) - 1;
00250 int newpos = 0;
00251 int ret = -1;
00252 struct enum_search *s = NULL;
00253 int version = -1;
00254
00255 strncat(naptrinput, number, sizeof(naptrinput) - 2);
00256
00257 context.naptrinput = naptrinput;
00258 context.dst = dst;
00259 context.dstlen = dstlen;
00260 context.tech = tech;
00261 context.techlen = techlen;
00262
00263 if (pos > 128)
00264 pos = 128;
00265 while(pos >= 0) {
00266 tmp[newpos++] = number[pos--];
00267 tmp[newpos++] = '.';
00268 }
00269
00270 if (chan && ast_autoservice_start(chan) < 0)
00271 return -1;
00272
00273 for(;;) {
00274 ast_mutex_lock(&enumlock);
00275 if (version != enumver) {
00276
00277 s = toplevs;
00278 version = enumver;
00279 } else {
00280 s = s->next;
00281 }
00282 if (s) {
00283 strcpy(tmp + newpos, s->toplev);
00284 }
00285 ast_mutex_unlock(&enumlock);
00286 if (!s)
00287 break;
00288 ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
00289 if (ret > 0)
00290 break;
00291 }
00292 if (ret < 0) {
00293 ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
00294 ret = 0;
00295 }
00296 if (chan)
00297 ret |= ast_autoservice_stop(chan);
00298 return ret;
00299 }
00300
00301 static struct enum_search *enum_newtoplev(char *s)
00302 {
00303 struct enum_search *tmp;
00304 tmp = malloc(sizeof(struct enum_search));
00305 if (tmp) {
00306 memset(tmp, 0, sizeof(struct enum_search));
00307 strncpy(tmp->toplev, s, sizeof(tmp->toplev) - 1);
00308 }
00309 return tmp;
00310 }
00311
00312 int ast_enum_init(void)
00313 {
00314 struct ast_config *cfg;
00315 struct enum_search *s, *sl;
00316 struct ast_variable *v;
00317
00318
00319 ast_mutex_lock(&enumlock);
00320 s = toplevs;
00321 while(s) {
00322 sl = s;
00323 s = s->next;
00324 free(sl);
00325 }
00326 toplevs = NULL;
00327 cfg = ast_load("enum.conf");
00328 if (cfg) {
00329 sl = NULL;
00330 v = ast_variable_browse(cfg, "general");
00331 while(v) {
00332 if (!strcasecmp(v->name, "search")) {
00333 s = enum_newtoplev(v->value);
00334 if (s) {
00335 if (sl)
00336 sl->next = s;
00337 else
00338 toplevs = s;
00339 sl = s;
00340 }
00341 }
00342 v = v->next;
00343 }
00344 ast_destroy(cfg);
00345 } else {
00346 toplevs = enum_newtoplev(TOPLEV);
00347 }
00348 enumver++;
00349 ast_mutex_unlock(&enumlock);
00350 return 0;
00351 }
00352
00353 int ast_enum_reload(void)
00354 {
00355 return ast_enum_init();
00356 }