/*
* Makes enum query on name. On success, rewrites user part and
* replaces Request-URI.
*/
int do_query(struct sip_msg* _msg, char *user, char *name, str *service) {
char uri[MAX_URI_SIZE];
char new_uri[MAX_URI_SIZE];
unsigned int priority, curr_prio, first;
qvalue_t q;
struct rdata* head;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result, new_result;
head = get_record(name, T_NAPTR);
if (head == 0) {
LM_DBG("No NAPTR record found for %s.\n", name);
return -1;
}
naptr_sort(&head);
q = MAX_Q - 10;
curr_prio = 0;
first = 1;
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_ERR("Null rdata in DNS response\n");
continue;
}
LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags '%.*s', "
"slen %u, services '%.*s', rlen %u, regexp '%.*s'\n",
name, naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp));
if (sip_match(naptr, service) == 0) continue;
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
LM_ERR("Parsing of NAPTR regexp failed\n");
continue;
}
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
if (reg_replace(pattern.s, replacement.s, user, &result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("Regexp replace failed\n");
continue;
}
LM_DBG("Resulted in replacement: '%.*s'\n", result.len, ZSW(result.s));
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
if (param.len > 0) {
if (result.len + param.len > MAX_URI_SIZE - 1) {
LM_ERR("URI is too long\n");
continue;
}
new_result.s = &(new_uri[0]);
new_result.len = MAX_URI_SIZE;
if (add_uri_param(&result, ¶m, &new_result) == 0) {
LM_ERR("Parsing of URI <%.*s> failed\n",
result.len, result.s);
continue;
}
if (new_result.len > 0) {
result = new_result;
}
}
if (first) {
if (set_ruri(_msg, &result) == -1) {
goto done;
}
set_ruri_q(q);
first = 0;
curr_prio = ((naptr->order) << 16) + naptr->pref;
} else {
priority = ((naptr->order) << 16) + naptr->pref;
if (priority > curr_prio) {
q = q - 10;
curr_prio = priority;
}
if (append_branch(_msg, &result, 0, 0, q, 0, 0) == -1) {
goto done;
}
}
}
done:
free_rdata_list(head);
return first ? -1 : 1;
}
int dp_can_connect_str(str *domain, int rec_level) {
struct rdata* head;
struct rdata* l;
struct naptr_rdata* naptr;
struct naptr_rdata* next_naptr;
int ret;
str newdomain;
char uri[MAX_URI_SIZE];
struct avp_stack stack;
int last_order = -1;
int failed = 0;
int found_anything = 0;
str pattern, replacement, result;
stack_reset(&stack);
/* If we're in a recursive call, set the domain-replacement */
if ( rec_level > 0 ) {
stack_push(&stack, domain_replacement_name.s.s, domain->s);
stack.succeeded = 0;
}
if (rec_level > MAX_DDDS_RECURSIONS) {
LM_ERR("too many indirect NAPTRs. Aborting at %.*s.\n", domain->len,
ZSW(domain->s));
return(DP_DDDS_RET_DNSERROR);
}
LM_INFO("looking up Domain itself: %.*s\n",domain->len, ZSW(domain->s));
ret = check_rule(domain,"D2P+sip:dom", 11, &stack);
if (ret == 1) {
LM_INFO("found a match on domain itself\n");
stack_to_avp(&stack);
return(DP_DDDS_RET_POSITIVE);
} else if (ret == 0) {
LM_INFO("no match on domain itself.\n");
stack_reset(&stack);
/* If we're in a recursive call, set the domain-replacement */
if ( rec_level > 0 ) {
stack_push(&stack, domain_replacement_name.s.s, (char *) domain->s);
stack.succeeded = 0;
}
} else {
return(DP_DDDS_RET_DNSERROR); /* actually: DB error */
}
LM_INFO("doing DDDS with %.*s\n",domain->len, ZSW(domain->s));
head = get_record(domain->s, T_NAPTR, RES_ONLY_TYPE);
if (head == 0) {
LM_NOTICE("no NAPTR record found for %.*s.\n",
domain->len, ZSW(domain->s));
return(DP_DDDS_RET_NOTFOUND);
}
LM_DBG("found the following NAPTRs: \n");
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) {
LM_DBG("found non-NAPTR record.\n");
continue; /*should never happen*/
}
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_CRIT("null rdata\n");
continue;
}
LM_DBG("order %u, pref %u, flen %u, flags '%.*s', slen %u, "
"services '%.*s', rlen %u, regexp '%.*s', repl '%s'\n",
naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp),
ZSW(naptr->repl)
);
}
LM_DBG("sorting...\n");
naptr_sort(&head);
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_CRIT("null rdata\n");
continue;
}
LM_DBG("considering order %u, pref %u, flen %u, flags '%.*s', slen %u, "
"services '%.*s', rlen %u, regexp '%.*s', repl '%s'\n",
naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp),
ZSW(naptr->repl)
);
/*
* New order? then we check whether the had success during the last one.
* If yes, we can leave the loop.
*/
if (last_order != naptr->order) {
last_order = naptr->order;
failed = 0;
if (stack_succeeded(&stack)) {
LM_INFO("we don't need to consider further orders "
"(starting with %d).\n",last_order);
break;
}
} else if (failed) {
LM_INFO("order %d has already failed.\n",last_order);
continue;
}
/*
* NAPTRs we don't care about
*/
if (!IS_D2PNAPTR(naptr))
continue;
/*
* once we've been here, don't return DP_DDDS_RET_NOTFOUND
*/
found_anything = 1;
next_naptr = NULL;
if (l->next && (l->next->type == T_NAPTR)) {
next_naptr = (struct naptr_rdata*)l->next->rdata;
}
/*
* Non-terminal?
*/
if ((naptr->services_len == 7) && !strncasecmp("D2P+SIP", naptr->services,7) && (naptr->flags_len == 0)){
LM_INFO("found non-terminal NAPTR\n");
/*
* This needs to be the only record with this order.
*/
if (next_naptr && (next_naptr->order == naptr->order) && IS_D2PNAPTR(next_naptr)) {
LM_ERR("non-terminal NAPTR needs to be the only one "
"with this order %.*s.\n", domain->len, ZSW(domain->s));
return(DP_DDDS_RET_DNSERROR);
}
newdomain.s = naptr->repl;
newdomain.len = strlen(naptr->repl);
ret = dp_can_connect_str(&newdomain, rec_level + 1);
if (ret == DP_DDDS_RET_POSITIVE) /* succeeded, we're done. */
return(ret);
if (ret == DP_DDDS_RET_NEGATIVE) /* found rules, did not work */
continue; /* look for more rules */
if (ret == DP_DDDS_RET_DNSERROR) /* errors during lookup */
return(ret); /* report them */
if (ret == DP_DDDS_RET_NOTFOUND) /* no entries in linked domain? */
return(ret); /* ok, fine. go with that */
continue; /* not reached */
}
/*
* wrong kind of terminal
*/
if ((naptr->flags_len != 1) || (tolower(naptr->flags[0]) != 'u')) {
LM_ERR("terminal NAPTR needs flag = 'u' and not '%.*s'.\n",
(int)naptr->flags_len, ZSW(naptr->flags));
/*
* It's not that clear what we should do now: Ignore this records or regard it as failed.
* We go with "ignore" for now.
*/
continue;
}
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
LM_ERR("parsing of NAPTR regexp failed\n");
continue;
}
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
if (reg_replace(pattern.s, replacement.s, domain->s,
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("regexp replace failed\n");
continue;
}
LM_INFO("resulted in replacement: '%.*s'\n", result.len, ZSW(result.s));
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
ret = check_rule(&result,naptr->services,naptr->services_len, &stack);
if (ret == 1) {
LM_INFO("positive return\n");
} else if (ret == 0) {
LM_INFO("check_rule failed.\n");
stack_reset(&stack);
/* If we're in a recursive call, set the domain-replacement */
if ( rec_level > 0 ) {
stack_push(&stack, domain_replacement_name.s.s, (char *) domain->s);
stack.succeeded = 0;
}
failed = 1;
} else {
return(DP_DDDS_RET_DNSERROR);
}
}
if (stack_succeeded(&stack)) {
LM_INFO("calling stack_to_avp.\n");
stack_to_avp(&stack);
return(DP_DDDS_RET_POSITIVE);
}
LM_INFO("returning %d.\n",
(found_anything ? DP_DDDS_RET_NEGATIVE : DP_DDDS_RET_NOTFOUND));
return( found_anything ? DP_DDDS_RET_NEGATIVE : DP_DDDS_RET_NOTFOUND );
}
int enum_pv_query_3(struct sip_msg* _msg, char* _sp, char* _suffix,
char* _service)
{
char *user_s;
int user_len, i, j, first;
char name[MAX_DOMAIN_SIZE];
char uri[MAX_URI_SIZE];
char new_uri[MAX_URI_SIZE];
unsigned int priority, curr_prio;
qvalue_t q;
char tostring[17];
struct rdata* head;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result, new_result;
str *suffix, *service;
char string[17];
pv_spec_t *sp;
pv_value_t pv_val;
sp = (pv_spec_t *)_sp;
suffix = (str*)_suffix;
service = (str*)_service;
/*
* Get R-URI user to tostring
*/
if (parse_sip_msg_uri(_msg) < 0) {
LM_ERR("R-URI parsing failed\n");
return -1;
}
user_s = _msg->parsed_uri.user.s;
user_len = _msg->parsed_uri.user.len;
memcpy(&(tostring[0]), user_s, user_len);
tostring[user_len] = (char)0;
/*
* Get E.164 number from pseudo variable
*/
if (sp && (pv_get_spec_value(_msg, sp, &pv_val) == 0)) {
if (pv_val.flags & PV_VAL_STR) {
if (pv_val.rs.len == 0 || pv_val.rs.s == NULL) {
LM_DBG("Missing E.164 number\n");
return -1;
}
} else {
LM_DBG("Pseudo variable value is not string\n");
return -1;
}
} else {
LM_DBG("Cannot get pseudo variable value\n");
return -1;
}
if (is_e164(&(pv_val.rs)) == -1) {
LM_ERR("pseudo variable does not contain an E164 number\n");
return -1;
}
user_s = pv_val.rs.s;
user_len = pv_val.rs.len;
memcpy(&(string[0]), user_s, user_len);
string[user_len] = (char)0;
j = 0;
for (i = user_len - 1; i > 0; i--) {
name[j] = user_s[i];
name[j + 1] = '.';
j = j + 2;
}
memcpy(name + j, suffix->s, suffix->len + 1);
head = get_record(name, T_NAPTR);
if (head == 0) {
LM_DBG("No NAPTR record found for %s.\n", name);
return -1;
}
naptr_sort(&head);
q = MAX_Q - 10;
curr_prio = 0;
first = 1;
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_ERR("Null rdata in DNS response\n");
continue;
}
LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags "
"'%.*s', slen %u, services '%.*s', rlen %u, "
"regexp '%.*s'\n",
name, naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp));
if (sip_match(naptr, service) == 0) continue;
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
LM_ERR("Parsing of NAPTR regexp failed\n");
continue;
}
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
if (reg_replace(pattern.s, replacement.s, &(tostring[0]),
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("Regexp replace failed\n");
continue;
}
LM_DBG("Resulted in replacement: '%.*s'\n",
result.len, ZSW(result.s));
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
if (param.len > 0) {
if (result.len + param.len > MAX_URI_SIZE - 1) {
LM_ERR("URI is too long\n");
continue;
}
new_result.s = &(new_uri[0]);
new_result.len = MAX_URI_SIZE;
if (add_uri_param(&result, ¶m, &new_result) == 0) {
LM_ERR("Parsing of URI <%.*s> failed\n",
result.len, result.s);
continue;
}
if (new_result.len > 0) {
result = new_result;
}
}
if (first) {
if (set_ruri(_msg, &result) == -1) {
goto done;
}
set_ruri_q(q);
first = 0;
curr_prio = ((naptr->order) << 16) + naptr->pref;
} else {
priority = ((naptr->order) << 16) + naptr->pref;
if (priority > curr_prio) {
q = q - 10;
curr_prio = priority;
}
if (append_branch(_msg, &result, 0, 0, q, 0, 0) == -1) {
goto done;
}
}
}
done:
free_rdata_list(head);
return first ? -1 : 1;
}
int enum_query_2(struct sip_msg* _msg, char* _suffix, char* _service)
{
char *user_s;
int user_len, i, j, first;
char name[MAX_DOMAIN_SIZE];
char uri[MAX_URI_SIZE];
char new_uri[MAX_URI_SIZE];
unsigned int priority, curr_prio;
qvalue_t q;
struct rdata* head;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result, new_result;
char string[17];
str *suffix, *service;
suffix = (str*)_suffix;
service = (str*)_service;
if (parse_sip_msg_uri(_msg) < 0) {
LOG(L_ERR, "enum_query(): uri parsing failed\n");
return -1;
}
if (is_e164(&(_msg->parsed_uri.user)) == -1) {
LOG(L_ERR, "enum_query(): uri user is not an E164 number\n");
return -1;
}
user_s = _msg->parsed_uri.user.s;
user_len = _msg->parsed_uri.user.len;
memcpy(&(string[0]), user_s, user_len);
string[user_len] = (char)0;
j = 0;
for (i = user_len - 1; i > 0; i--) {
name[j] = user_s[i];
name[j + 1] = '.';
j = j + 2;
}
memcpy(name + j, suffix->s, suffix->len + 1);
head = get_record(name, T_NAPTR);
if (head == 0) {
DBG("enum_query(): No NAPTR record found for %s.\n", name);
return -1;
}
naptr_sort(&head);
q = MAX_Q - 10;
curr_prio = 0;
first = 1;
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LOG(L_CRIT, "enum_query: BUG: null rdata\n");
continue;
}
DBG("enum_query(): order %u, pref %u, flen %u, flags '%.*s', slen %u, "
"services '%.*s', rlen %u, regexp '%.*s'\n", naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp));
if (sip_match(naptr, service) == 0) continue;
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
LOG(L_ERR, "enum_query(): parsing of NAPTR regexp failed\n");
continue;
}
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
if (reg_replace(pattern.s, replacement.s, &(string[0]),
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LOG(L_ERR, "enum_query(): regexp replace failed\n");
continue;
}
DBG("enum_query(): resulted in replacement: '%.*s'\n",
result.len, ZSW(result.s));
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
if (param.len > 0) {
if (result.len + param.len > MAX_URI_SIZE - 1) {
LOG(L_ERR, "ERROR: enum_query(): URI is too long\n");
continue;
}
new_result.s = &(new_uri[0]);
new_result.len = MAX_URI_SIZE;
if (add_uri_param(&result, ¶m, &new_result) == 0) {
LOG(L_ERR, "ERROR: enum_query(): Parsing of URI failed\n");
continue;
}
if (new_result.len > 0) {
result = new_result;
}
}
if (first) {
if (rewrite_uri(_msg, &result) == -1) {
goto done;
}
set_ruri_q(q);
first = 0;
curr_prio = ((naptr->order) << 16) + naptr->pref;
} else {
priority = ((naptr->order) << 16) + naptr->pref;
if (priority > curr_prio) {
q = q - 10;
curr_prio = priority;
}
if (append_branch(_msg, &result, 0, q, 0, 0) == -1) {
goto done;
}
}
}
done:
free_rdata_list(head);
return first ? -1 : 1;
}
