Newer
Older
/*
* ENUM Support for Asterisk
*
* Copyright (C) 2003 Digium
*
* Written by Mark Spencer <markster@digium.com>
*
* Funding provided by nic.at
*
* Distributed under the terms of the GNU GPL
*
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <asterisk/logger.h>
#include <asterisk/options.h>
#include <asterisk/enum.h>
static struct enum_search {
char toplev[80];
struct enum_search *next;
} *toplevs;
static int enumver = 0;
static ast_mutex_t enumlock = AST_MUTEX_INITIALIZER;
struct naptr {
unsigned short order;
unsigned short pref;
} __attribute__ ((__packed__));
static int parse_ie(unsigned char *data, int maxdatalen, unsigned char *src, int srclen)
{
int len, olen;
len = olen = (int)src[0];
src++;
srclen--;
if (len > srclen) {
ast_log(LOG_WARNING, "Want %d, got %d\n", len, srclen);
return -1;
}
if (len > maxdatalen)
len = maxdatalen;
memcpy(data, src, len);
return olen + 1;
}
static int parse_naptr(unsigned char *dst, int dstsize, char *tech, int techsize, unsigned char *answer, int len, char *naptrinput)
{
unsigned char *oanswer = answer;
unsigned char flags[80] = "";
unsigned char services[80] = "";
unsigned char regexp[80] = "";
unsigned char repl[80] = "";
unsigned char temp[80] = "";
unsigned char delim;
unsigned char *delim2;
unsigned char *pattern, *subst, *d;
int regexp_len, size, backref;
int d_len = sizeof(temp) - 1;
regex_t preg;
regmatch_t pmatch[9];
if (len < sizeof(struct naptr)) {
printf("Length too short\n");
return -1;
}
answer += sizeof(struct naptr);
len -= sizeof(struct naptr);
if ((res = parse_ie(flags, sizeof(flags) - 1, answer, len)) < 0) {
ast_log(LOG_WARNING, "Failed to get flags\n");
return -1;
} else { answer += res; len -= res; }
if ((res = parse_ie(services, sizeof(services) - 1, answer, len)) < 0) {
ast_log(LOG_WARNING, "Failed to get services\n");
return -1;
} else { answer += res; len -= res; }
if ((res = parse_ie(regexp, sizeof(regexp) - 1, answer, len)) < 0)
return -1; else { answer += res; len -= res; }
if ((res = dn_expand(oanswer,answer + len,answer, repl, sizeof(repl) - 1)) < 0) {
ast_log(LOG_WARNING, "Failed to expand hostname\n");
return -1;
}
ast_log(LOG_DEBUG, "input='%s', flags='%s', services='%s', regexp='%s', repl='%s'\n",
naptrinput, flags, services, regexp, repl);
if (tolower(flags[0]) != 'u') {
ast_log(LOG_WARNING, "Flag must be 'U' or 'u'.\n");
return -1;
}
if ((!strncasecmp(services, "e2u+sip", 7)) ||
(!strncasecmp(services, "sip+e2u", 7))) {
strncpy(tech, "sip", techsize -1);
} else if ((!strncasecmp(services, "e2u+h323", 8)) ||
(!strncasecmp(services, "h323+e2u", 8))) {
strncpy(tech, "h323", techsize -1);
} else if ((!strncasecmp(services, "e2u+iax", 7)) ||
(!strncasecmp(services, "iax+e2u", 7))) {
strncpy(tech, "iax", techsize -1);
} else if ((!strncasecmp(services, "e2u+iax2", 8)) ||
(!strncasecmp(services, "iax2+e2u", 8))) {
strncpy(tech, "iax2", techsize -1);
} else if ((!strncasecmp(services, "e2u+tel", 7)) ||
(!strncasecmp(services, "tel+e2u", 7))) {
strncpy(tech, "tel", techsize -1);
} else if (!strncasecmp(services, "e2u+voice:", 10)) {
strncpy(tech, services+10, techsize -1);
} else {
ast_log(LOG_WARNING,
"Services must be e2u+${tech}, ${tech}+e2u, or e2u+voice: where $tech is from (sip, h323, tel, iax, iax2). \n");
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
return -1;
}
/* DEDBUGGING STUB
strcpy(regexp, "!^\\+43(.*)$!\\1@bla.fasel!");
*/
regexp_len = strlen(regexp);
if (regexp_len < 7) {
ast_log(LOG_WARNING, "Regex too short to be meaningful.\n");
return -1;
}
delim = regexp[0];
delim2 = strchr(regexp + 1, delim);
if ((delim2 == NULL) || (regexp[regexp_len-1] != delim)) {
ast_log(LOG_WARNING, "Regex delimiter error (on \"%s\").\n",regexp);
return -1;
}
pattern = regexp + 1;
*delim2 = 0;
subst = delim2 + 1;
regexp[regexp_len-1] = 0;
printf("Pattern: %s\n", pattern);
printf("Subst: %s\n", subst);
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
/*
* now do the regex wizardry.
*/
if (regcomp(&preg, pattern, REG_EXTENDED | REG_NEWLINE)) {
ast_log(LOG_WARNING, "Regex compilation error (regex = \"%s\").\n",regexp);
return -1;
}
if (preg.re_nsub > 9) {
ast_log(LOG_WARNING, "Regex compilation error: too many subs.\n");
regfree(&preg);
return -1;
}
if (regexec(&preg, naptrinput, 9, pmatch, 0)) {
ast_log(LOG_WARNING, "Regex match failed.\n");
regfree(&preg);
return -1;
}
regfree(&preg);
d = temp; d_len--;
while( *subst && (d_len > 0) ) {
if ((subst[0] == '\\') && isdigit(subst[1]) && (pmatch[subst[1]-'0'].rm_so != -1)) {
backref = subst[1]-'0';
size = pmatch[backref].rm_eo - pmatch[backref].rm_so;
if (size > d_len) {
ast_log(LOG_WARNING, "Not enough space during regex substitution.\n");
return -1;
}
memcpy(d, naptrinput + pmatch[backref].rm_so, size);
d += size;
d_len -= size;
subst += 2;
} else if (isprint(*subst)) {
*d++ = *subst++;
d_len--;
} else {
ast_log(LOG_WARNING, "Error during regex substitution.\n");
return -1;
}
*d = 0;
strncpy(dst, temp, dstsize);
struct enum_context {
char *dst;
int dstlen;
char *tech;
int techlen;
char *naptrinput;
};
static int enum_callback(void *context, u_char *answer, int len, u_char *fullanswer)
struct enum_context *c = (struct enum_context *)context;
if (parse_naptr(c->dst, c->dstlen, c->tech, c->techlen, answer, len, c->naptrinput))
ast_log(LOG_WARNING, "Failed to parse naptr :(\n");
if (strlen(c->dst))
return 1;
return 0;
}
int ast_get_enum(struct ast_channel *chan, const char *number, char *dst, int dstlen, char *tech, int techlen)
{
struct enum_search *s = NULL;
int version = -1;
strncat(naptrinput, number, sizeof(naptrinput) - 2);
context.naptrinput = naptrinput;
context.dst = dst;
context.dstlen = dstlen;
context.tech = tech;
context.techlen = techlen;
if (pos > 128)
pos = 128;
while(pos >= 0) {
tmp[newpos++] = number[pos--];
tmp[newpos++] = '.';
}
if (chan && ast_autoservice_start(chan) < 0)
return -1;
ast_mutex_lock(&enumlock);
if (version != enumver) {
/* Ooh, a reload... */
s = toplevs;
} else {
s = s->next;
}
if (s) {
strcpy(tmp + newpos, s->toplev);
}
ast_mutex_unlock(&enumlock);
ret = ast_search_dns(&context, tmp, C_IN, T_NAPTR, enum_callback);
if (ret > 0)
ast_log(LOG_DEBUG, "No such number found: %s (%s)\n", tmp, strerror(errno));
ret = 0;
}
if (chan)
ret |= ast_autoservice_stop(chan);
return ret;
}
static struct enum_search *enum_newtoplev(char *s)
{
struct enum_search *tmp;
tmp = malloc(sizeof(struct enum_search));
if (tmp) {
memset(tmp, 0, sizeof(struct enum_search));
strncpy(tmp->toplev, s, sizeof(tmp->toplev) - 1);
}
return tmp;
}
int ast_enum_init(void)
{
struct ast_config *cfg;
struct enum_search *s, *sl;
struct ast_variable *v;
/* Destroy existing list */
ast_mutex_lock(&enumlock);
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
s = toplevs;
while(s) {
sl = s;
s = s->next;
free(sl);
}
toplevs = NULL;
cfg = ast_load("enum.conf");
if (cfg) {
sl = NULL;
v = ast_variable_browse(cfg, "general");
while(v) {
if (!strcasecmp(v->name, "search")) {
s = enum_newtoplev(v->value);
if (s) {
if (sl)
sl->next = s;
else
toplevs = s;
sl = s;
}
}
v = v->next;
}
ast_destroy(cfg);
} else {
toplevs = enum_newtoplev(TOPLEV);
}
enumver++;
ast_mutex_unlock(&enumlock);
return 0;
}
int ast_enum_reload(void)
{
return ast_enum_init();
}