/*
* Check if from user is an e164 number
*/
int is_from_user_e164(struct sip_msg* _msg, char* _s1, char* _s2)
{
struct to_body* body;
struct sip_uri uri;
int result;
body = get_parsed_from_body(_msg);
if (!body) return -1;
if (parse_uri(body->uri.s, body->uri.len, &uri) < 0) {
LOG(L_ERR, "is_from_user_e164(): Error while parsing From uri\n");
return -1;
}
result = is_e164(&(uri.user));
return result;
}
/*
* Check if URI in RPID AVP contains an E164 user part
*/
int is_rpid_user_e164(struct sip_msg* _m, char* _s1, char* _s2)
{
struct usr_avp *avp;
name_addr_t parsed;
str tmp, rpid;
struct sip_uri uri;
int_str val;
if (rpid_avp_name==-1) {
LM_ERR("rpid avp not defined\n");
return -1;
}
if ( (avp=search_first_avp( rpid_avp_type , rpid_avp_name, &val, 0))==0 ) {
LM_DBG("no rpid AVP\n");
goto err;
}
if ( !(avp->flags&AVP_VAL_STR) || !val.s.s || !val.s.len) {
LM_DBG("empty or non-string rpid, nothing to append\n");
return -1;
}
rpid = val.s;
if (find_not_quoted(&rpid, '<')) {
if (parse_nameaddr(&rpid, &parsed) < 0) {
LM_ERR("failed to parse RPID\n");
goto err;
}
tmp = parsed.uri;
} else {
tmp = rpid;
}
if (parse_uri(tmp.s, tmp.len, &uri) < 0) {
LM_ERR("failed to parse RPID URI\n");
goto err;
}
return is_e164(&uri.user);
err:
return -1;
}
/*
* See documentation in README file.
*/
int enum_query_2(struct sip_msg* _msg, char* _suffix, char* _service)
{
char *user_s;
int user_len, i, j;
char name[MAX_DOMAIN_SIZE];
char string[17];
str *suffix, *service;
suffix = (str*)_suffix;
service = (str*)_service;
if (parse_sip_msg_uri(_msg) < 0) {
LM_ERR("Parsing of R-URI failed\n");
return -1;
}
if (is_e164(&(_msg->parsed_uri.user)) == -1) {
LM_ERR("R-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);
return do_query(_msg, string, name, service);
}
/*
* See documentation in README file.
*/
int enum_query(struct sip_msg* _msg, str* suffix, str* service)
{
char *user_s;
int user_len, i, j;
char name[MAX_DOMAIN_SIZE];
char string[MAX_NUM_LEN];
LM_DBG("enum_query on suffix <%.*s> service <%.*s>\n",
suffix->len, suffix->s, service->len, service->s);
if (parse_sip_msg_uri(_msg) < 0) {
LM_ERR("Parsing of R-URI failed\n");
return -1;
}
user_s = _msg->parsed_uri.user.s;
user_len = _msg->parsed_uri.user.len;
if (is_e164(&(_msg->parsed_uri.user)) == -1) {
LM_ERR("R-URI user '<%.*s>' is not an E164 number\n",
user_len, user_s);
return -1;
}
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);
return do_query(_msg, string, name, service);
}
int i_enum_query_2(struct sip_msg* _msg, char* _suffix, char* _service)
{
char *user_s;
int user_len, i, j;
char name[MAX_DOMAIN_SIZE];
char apex[MAX_COMPONENT_SIZE + 1];
char separator[MAX_COMPONENT_SIZE + 1];
int sdl = 0; /* subdomain location: infrastructure enum offset */
int cc_len;
struct rdata* head;
char string[17];
str *suffix, *service;
suffix = (str*)_suffix;
service = (str*)_service;
if (parse_sip_msg_uri(_msg) < 0) {
LM_ERR("Parsing of R-URI failed\n");
return -1;
}
if (is_e164(&(_msg->parsed_uri.user)) == -1) {
LM_ERR("R-URI user is not an E164 number\n");
return -1;
}
user_s = _msg->parsed_uri.user.s;
user_len = _msg->parsed_uri.user.len;
/* make sure we don't run out of space in strings */
if (( 2*user_len + MAX_COMPONENT_SIZE + MAX_COMPONENT_SIZE + 4) > MAX_DOMAIN_SIZE) {
LM_ERR("Strings too long\n");
return -1;
}
if ( i_branchlabel.len > MAX_COMPONENT_SIZE ) {
LM_ERR("i_branchlabel too long\n");
return -1;
}
if ( suffix->len > MAX_COMPONENT_SIZE ) {
LM_ERR("Suffix too long\n");
return -1;
}
memcpy(&(string[0]), user_s, user_len);
string[user_len] = (char)0;
/* Set up parameters as for user-enum */
memcpy(apex, suffix->s , suffix->len);
apex[suffix->len] = (char)0;
sdl = 0; /* where to insert i-enum separator */
separator[0] = 0; /* don't insert anything */
cc_len = cclen(string + 1);
if (!strncasecmp(i_bl_alg.s,"ebl",i_bl_alg.len)) {
sdl = cc_len; /* default */
j = 0;
memcpy(name, i_branchlabel.s, i_branchlabel.len);
j += i_branchlabel.len;
name[j++] = '.';
for (i = cc_len ; i > 0; i--) {
name[j++] = user_s[i];
name[j++] = '.';
}
memcpy(name + j, suffix->s, suffix->len + 1);
LM_DBG("Looking for EBL record for %s.\n", name);
head = get_record(name, T_EBL);
if (head == 0) {
LM_DBG("No EBL found for %s. Defaulting to user ENUM.\n",name);
} else {
struct ebl_rdata* ebl;
ebl = (struct ebl_rdata *) head->rdata;
LM_DBG("EBL record for %s is %d / %.*s / %.*s.\n",
name, ebl->position, (int)ebl->separator_len,
ebl->separator,(int)ebl->apex_len, ebl->apex);
if ((ebl->apex_len > MAX_COMPONENT_SIZE) || (ebl->separator_len > MAX_COMPONENT_SIZE)) {
LM_ERR("EBL strings too long\n");
return -1;
}
if (ebl->position > 15) {
LM_ERR("EBL position too large (%d)\n",
ebl->position);
return -1;
}
sdl = ebl->position;
memcpy(separator, ebl->separator, ebl->separator_len);
separator[ebl->separator_len] = 0;
memcpy(apex, ebl->apex, ebl->apex_len);
apex[ebl->apex_len] = 0;
free_rdata_list(head);
}
} else if (!strncasecmp(i_bl_alg.s,"txt",i_bl_alg.len)) {
sdl = cc_len; /* default */
memcpy(separator, i_branchlabel.s, i_branchlabel.len);
separator[i_branchlabel.len] = 0;
/* no change to apex */
j = 0;
memcpy(name, i_branchlabel.s, i_branchlabel.len);
j += i_branchlabel.len;
name[j++] = '.';
for (i = cc_len ; i > 0; i--) {
name[j++] = user_s[i];
name[j++] = '.';
}
memcpy(name + j, suffix->s, suffix->len + 1);
head = get_record(name, T_TXT);
if (head == 0) {
LM_DBG("TXT found for %s. Defaulting to %d\n",
name, cc_len);
} else {
sdl = atoi(((struct txt_rdata*)head->rdata)->txt);
LM_DBG("TXT record for %s is %d.\n", name, sdl);
if ((sdl < 0) || (sdl > 10)) {
LM_ERR("Sdl %d out of bounds. Set back to cc_len.\n", sdl);
sdl = cc_len;
}
free_rdata_list(head);
}
} else { /* defaults to CC */
sdl = cc_len;
memcpy(separator, i_branchlabel.s, i_branchlabel.len);
separator[i_branchlabel.len] = 0;
/* no change to apex */
}
j = 0;
sdl++; /* to avoid comparing i to (sdl+1) */
for (i = user_len - 1; i > 0; i--) {
name[j] = user_s[i];
name[j + 1] = '.';
j = j + 2;
if (separator[0] && (i == sdl)) { /* insert the I-ENUM separator here? */
strcpy(name + j, separator); /* we've checked string sizes. */
j += strlen(separator);
name[j++] = '.';
}
}
memcpy(name + j, apex, strlen(apex)+1);
return do_query(_msg, string, name, service);
}
/*
* Check if from user is a valid enum based user, and check to make sure
* that the src_ip == an srv record that maps to the enum from user.
*/
int is_from_user_enum_2(struct sip_msg* _msg, char* _suffix, char* _service)
{
struct ip_addr addr;
struct hostent* he;
unsigned short zp;
unsigned short proto;
char *user_s;
int user_len, i, j;
char name[MAX_DOMAIN_SIZE];
char uri[MAX_URI_SIZE];
struct sip_uri *furi;
struct sip_uri luri;
struct rdata* head;
str* suffix;
str* service;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result;
char string[17];
if (parse_from_header(_msg) < 0) {
LM_ERR("Failed to parse From header\n");
return -1;
}
if(_msg->from==NULL || get_from(_msg)==NULL) {
LM_DBG("No From header\n");
return -1;
}
if ((furi = parse_from_uri(_msg)) == NULL) {
LM_ERR("Failed to parse From URI\n");
return -1;
}
suffix = (str*)_suffix;
service = (str*)_service;
if (is_e164(&(furi->user)) == -1) {
LM_ERR("From URI user is not an E164 number\n");
return -1;
}
/* assert: the from user is a valid formatted e164 string */
user_s = furi->user.s;
user_len = furi->user.len;
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 -3;
}
/* we have the naptr records, loop and find an srv record with */
/* same ip address as source ip address, if we do then true is returned */
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");
free_rdata_list(head);
return -4;
}
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) {
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
free_rdata_list(head); /*clean up*/
LM_ERR("Parsing of NAPTR regexp failed\n");
return -5;
}
#ifdef LATER
if ((pattern.len == 4) && (strncmp(pattern.s, "^.*$", 4) == 0)) {
LM_DBG("Resulted in replacement: '%.*s'\n",
replacement.len, ZSW(replacement.s));
retval = set_uri(_msg, replacement.s, replacement.len);
free_rdata_list(head); /*clean up*/
return retval;
}
#endif
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;
/* We have already checked the size of
_msg->parsed_uri.user.s */
memcpy(&(string[0]), user_s, user_len);
string[user_len] = (char)0;
if (reg_replace(pattern.s, replacement.s, &(string[0]),
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("Regexp replace failed\n");
free_rdata_list(head); /*clean up*/
return -6;
}
LM_DBG("Resulted in replacement: '%.*s'\n",
result.len, ZSW(result.s));
if(parse_uri(result.s, result.len, &luri) < 0)
{
LM_ERR("Parsing of URI <%.*s> failed\n",
result.len, result.s);
free_rdata_list(head); /*clean up*/
return -7;
}
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
zp = 0;
proto = PROTO_NONE;
he = sip_resolvehost(&luri.host, &zp, &proto,
(luri.type==SIPS_URI_T)?1:0 , 0);
hostent2ip_addr(&addr, he, 0);
if(ip_addr_cmp(&addr, &_msg->rcv.src_ip))
{
free_rdata_list(head);
return(1);
}
}
}
free_rdata_list(head); /*clean up*/
LM_DBG("FAIL\n");
/* must not have found the record */
return(-8);
}
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;
}
/*
* See documentation in README file.
*/
int enum_query_2(struct sip_msg* _msg, char* _suffix, char* _service)
{
char *user_s;
int user_len, i, j;
char name[MAX_DOMAIN_SIZE];
char string[17];
gparam_p gp = NULL;
pv_value_t value;
str __suffix = {0, 0}, __service = {0, 0};
/* Use the suffix module parameter */
if (_suffix == NULL) {
__suffix.s = suffix.s;
__suffix.len = suffix.len;
} else {
gp = (gparam_p) _suffix;
if (gp->type == GPARAM_TYPE_PVS) {
if (pv_get_spec_value(_msg, gp->v.pvs, &value) != 0 ||
value.flags & PV_VAL_NULL || value.flags & PV_VAL_EMPTY) {
LM_ERR("No PV or NULL value specified for suffix\n");
return E_CFG;
}
if (value.flags & PV_VAL_STR) {
__suffix.s = value.rs.s;
__suffix.len = value.rs.len;
} else {
LM_ERR("Unsupported PV value type\n");
return E_CFG;
}
} else if (gp->type == GPARAM_TYPE_STR) {
__suffix.s = gp->v.sval.s;
__suffix.len = gp->v.sval.len;
}
}
/* Use the internal service */
if (_service == NULL) {
__service.s = service.s;
__service.len = service.len;
} else {
gp = (gparam_p) _service;
if (gp->type == GPARAM_TYPE_PVS) {
if (pv_get_spec_value(_msg, gp->v.pvs, &value) != 0 ||
value.flags & PV_VAL_NULL || value.flags & PV_VAL_EMPTY) {
LM_ERR("No PV or NULL value specified for suffix\n");
return E_CFG;
}
if (value.flags & PV_VAL_STR) {
__service.s = value.rs.s;
__service.len = value.rs.len;
} else {
LM_ERR("Unsupported PV value type\n");
return E_CFG;
}
} else if (gp->type == GPARAM_TYPE_STR) {
__service.s = gp->v.sval.s;
__service.len = gp->v.sval.len;
}
}
if (parse_sip_msg_uri(_msg) < 0) {
LM_ERR("Parsing of R-URI failed\n");
return -1;
}
if (is_e164(&(_msg->parsed_uri.user)) == -1) {
LM_ERR("R-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);
return do_query(_msg, string, name, &__service);
}
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;
}
