/* This function expects the bep034_lock to be held by caller,
releases it while working and returns with the lock held
*/
static bep034_status bep034_fill_hostrecord( const char * hostname, bep034_hostrecord ** hostrecord, uintptr_t dns_handle ) {
uint8_t answer[NS_PACKETSZ];
bep034_hostrecord * hr = 0;
int answer_len, num_msgs, max_entries, i;
ns_msg msg;
ns_rr rr;
/* Reset hostrecord pointer */
* hostrecord = 0;
/* If we find a record in cache, return it */
hr = bep034_find_hostrecord( hostname, &i /* dummy */ );
if( hr ) {
*hostrecord = hr;
return BEP_034_INPROGRESS;
}
/* Return mutex, we'll be blocking now and do not
hold any resources in need of guarding */
bep034_dounlock();
/* Query resolver for TXT records for the trackers domain */
#ifdef __MACH__
{
struct sockaddr tmp;
uint32_t tmplen;
answer_len = dns_search( (dns_handle_t)dns_handle, hostname, ns_c_in, ns_t_txt, answer, sizeof(answer), &tmp, &tmplen );
}
#else
(void)dns_handle;
answer_len = res_search(hostname, ns_c_in, ns_t_txt, answer, sizeof(answer));
#endif
if( answer_len < 0 ) {
/* Here we enter race condition land */
switch( h_errno ) {
case NO_RECOVERY: case HOST_NOT_FOUND: return BEP_034_NXDOMAIN;
case NO_DATA: return BEP_034_NORECORD;
case NETDB_INTERNAL: case TRY_AGAIN: default: return BEP_034_TIMEOUT;
}
}
ns_initparse (answer, answer_len, &msg);
num_msgs = ns_msg_count (msg, ns_s_an);
for( i=0; i<num_msgs; ++i) {
ns_parserr (&msg, ns_s_an, i, &rr);
if (ns_rr_class(rr) == ns_c_in && ns_rr_type(rr) == ns_t_txt ) {
uint32_t record_ttl = ns_rr_ttl(rr);
uint16_t record_len = ns_rr_rdlen(rr);
const uint8_t *record_ptr = ns_rr_rdata(rr);
const char * string_ptr, * string_end;
/* First octet is length of (first) string in the txt record.
Since BEP034 does not say anything about multiple strings,
we ignore all but the first string in each TXT record. */
uint8_t string_len = *record_ptr;
/* If we would read beyond buffer end, ignore record */
if( record_ptr + 1 + string_len > answer + answer_len )
continue;
/* Sanitize string length against record length */
if( string_len + 1 > record_len )
string_len = record_len - 1;
/* Test if we are interested in the record */
if( string_len < 10 /* strlen( "BITTORRENT" ) */ )
continue;
/* Although the BEP is not very specific, we interpret the wording
"This should always be the first word in the record" as a requirment
to not start the record with a space */
if( memcmp( record_ptr + 1, "BITTORRENT", 10 ) )
continue;
/* We found a BITTORRENT TXT record. Now start parsing:
Given entries of the form "UDP:\d+\s" i.e. 6 bytes,
in a record of length N we have an upper bound of
( N - 11 ) / 6 records.
*/
max_entries = 1 + ( string_len - 11 ) / 6;
/* Allocate memory for host record */
hr = (bep034_hostrecord*)
malloc( sizeof(bep034_hostrecord) + sizeof( uint32_t ) * max_entries );
if( !hr )
return BEP_034_TIMEOUT;
/* Init host record */
hr->hostname = strdup( hostname );
hr->entries = 0;
hr->expiry = NOW() + record_ttl;
/* Look for "\s(TCP|UDP):\d+" */
string_ptr = record_ptr + 1;
string_end = string_ptr + string_len;
string_ptr += 10 /* strlen( "BITTORRENT" ) */;
while( string_ptr + 6 < string_end ) { /* We need at least 6 bytes for a word */
int found;
uint32_t port = 0;
++string_ptr;
if( string_ptr[-1] != ' ' || string_ptr[2] != 'P' || string_ptr[3] != ':' )
continue;
if( string_ptr[0] == 'T' && string_ptr[1] == 'C' )
found = 0;
else if( string_ptr[0] == 'U' && string_ptr[1] == 'D' )
found = 1;
else
continue;
/* Now we're sure, we've found UDP: or TCP: and assume, from string_ptr + 4 there's
a port number*/
string_ptr += 4;
while( string_ptr < string_end && (*string_ptr >= '0' && *string_ptr <= '9' ) )
port = port * 10 + *(string_ptr++) - '0';
/* If no digit was found, word is invalid */
if( string_ptr[-1] == ':' ) continue;
/* If number did not terminate on end of string or with a space, word is invalid */
if( string_ptr != string_end && *string_ptr != ' ' ) continue;
/* If we have an invalid port number, word is invalid */
if( port > 65335 ) continue;
/* Valid word found, add it to tracker list */
hr->trackers[ hr->entries++ ] = port | ( found ? 0x10000 : 0 );
}
/* Ensure exclusive access to the host record list, lock will be held
on return so that the caller can work with hr */
bep034_dolock();
/* Hand over record to cache, from now the cache has to release memory */
if( bep034_save_record( &hr ) )
return BEP_034_TIMEOUT;
/* Dump what we found */
bep034_dump_record( hr );
/* Once the first line in the first record has been parsed, return host record */
*hostrecord = hr;
return BEP_034_INPROGRESS;
}
}
}
/* Find all of the records for _<name>._<protocol>.<target> */
radiodns_app_t *
radiodns_resolve_app(radiodns_t *context, const char *name, const char *protocol)
{
char fqdn[MAXDNAME+1], dnbuf[MAXDNAME+1];
radiodns_app_t *defapp, *namedapps, *app;
ns_msg handle;
ns_rr rr;
int len, c, r;
unsigned char *abuf;
if(!context->target)
{
if(NULL == radiodns_resolve_target(context))
{
return NULL;
}
}
if(!protocol)
{
protocol = "tcp";
}
if(strlen(name) + strlen(protocol) + strlen(context->target) + 4 > MAXDNAME)
{
errno = ENAMETOOLONG;
return NULL;
}
sprintf(fqdn, "_%s._%s.%s", name, protocol, context->target);
if(0 >= (len = res_query(fqdn, ns_c_in, ns_t_any, context->answer, RDNS_ANSWERBUFLEN)))
{
return NULL;
}
if(0 > ns_initparse(context->answer, len, &handle))
{
return NULL;
}
if(0 > (len = ns_msg_count(handle, ns_s_an)))
{
return NULL;
}
defapp = NULL;
namedapps = NULL;
abuf = NULL;
r = 0; /* -1 == some catchable error, -2 == catastrophic error */
for(c = 0; c < len; c++)
{
if(ns_parserr(&handle, ns_s_an, c, &rr))
{
/* Parse failed? Hmm. */
continue;
}
if(ns_rr_class(rr) != ns_c_in)
{
continue;
}
if(ns_rr_type(rr) == ns_t_ptr)
{
if(!abuf)
{
if(!(abuf = (unsigned char *) malloc(RDNS_ANSWERBUFLEN)))
{
r = -2;
break;
}
}
if(!(app = app_create()))
{
r = -2;
break;
}
r = app_follow_ptr(app, abuf, handle, rr);
if(r == 0)
{
app->next = namedapps;
namedapps = app;
}
else if(r == -1)
{
radiodns_destroy_app(app);
continue;
}
else
{
radiodns_destroy_app(app);
break;
}
}
else if(ns_rr_type(rr) == ns_t_txt)
{
if(!defapp)
{
if(!(defapp = app_create()))
{
r = -2;
break;
}
}
if(-2 == (r = app_parse_txt(defapp, handle, rr, dnbuf)))
{
break;
}
}
else if(ns_rr_type(rr) == ns_t_srv)
{
if(!defapp)
{
if(!(defapp = app_create()))
{
r = -2;
break;
}
}
if(!defapp->srv)
{
if(!(defapp->srv = (radiodns_srv_t *) calloc(len, sizeof(radiodns_srv_t))))
{
r = -2;
break;
}
}
r = app_parse_srv(defapp, handle, rr, dnbuf, &(defapp->srv[defapp->nsrv]));
if(r == 0)
{
defapp->nsrv++;
}
else if(r == -2)
{
break;
}
}
}
free(abuf);
if(r == -2)
{
radiodns_destroy_app(defapp);
radiodns_destroy_app(namedapps);
return NULL;
}
if(defapp)
{
if(defapp->nsrv)
{
defapp->next = namedapps;
return defapp;
}
radiodns_destroy_app(defapp);
}
/* In the event that there actually wasn't anything worth returning,
* don't confuse matters by leaving errno set to something random.
*/
errno = 0;
return namedapps;
}
/* Returns 1 with an answer, 0 when reply was old, -1 on fatal errors */
int
nb_dns_activity(struct nb_dns_info *nd, struct nb_dns_result *nr, char *errstr)
{
register int msglen, qtype, atype, n, i;
register struct nb_dns_entry *ne, *lastne;
socklen_t fromlen;
struct sockaddr from;
u_long msg[MAXPACKET / sizeof(u_long)];
register char *bp, *ep;
register char **ap, **hap;
register u_int16_t id;
register const u_char *rdata;
register u_int32_t rttl = 0; // make compiler happy.
register struct hostent *he;
register size_t rdlen;
ns_msg handle;
ns_rr rr;
/* This comes from the second half of do_query() */
fromlen = sizeof(from);
msglen = recvfrom(nd->s, (char *)msg, sizeof(msg), 0, &from, &fromlen);
if (msglen <= 0) {
snprintf(errstr, NB_DNS_ERRSIZE, "recvfrom(): %s",
my_strerror(errno));
return (-1);
}
if (msglen < HFIXEDSZ) {
snprintf(errstr, NB_DNS_ERRSIZE, "recvfrom(): undersized: %d",
msglen);
return (-1);
}
if (ns_initparse((u_char *)msg, msglen, &handle) < 0) {
snprintf(errstr, NB_DNS_ERRSIZE, "ns_initparse(): %s",
my_strerror(errno));
nr->host_errno = NO_RECOVERY;
return (-1);
}
/* RES_INSECURE1 style check */
if (_nb_dns_cmpsockaddr((struct sockaddr *)&nd->server, &from,
errstr) < 0) {
nr->host_errno = NO_RECOVERY;
return (-1);
}
/* Search for this request */
lastne = NULL;
id = ns_msg_id(handle);
for (ne = nd->list; ne != NULL; ne = ne->next) {
if (ne->id == id)
break;
lastne = ne;
}
/* Not an answer to a question we care about anymore */
if (ne == NULL)
return (0);
/* Unlink this entry */
if (lastne == NULL)
nd->list = ne->next;
else
lastne->next = ne->next;
ne->next = NULL;
/* RES_INSECURE2 style check */
/* XXX not implemented */
/* Initialize result struct */
memset(nr, 0, sizeof(*nr));
nr->cookie = ne->cookie;
qtype = ne->qtype;
/* Deal with various errors */
switch (ns_msg_getflag(handle, ns_f_rcode)) {
case ns_r_nxdomain:
nr->host_errno = HOST_NOT_FOUND;
free(ne);
return (1);
case ns_r_servfail:
nr->host_errno = TRY_AGAIN;
free(ne);
return (1);
case ns_r_noerror:
break;
case ns_r_formerr:
case ns_r_notimpl:
case ns_r_refused:
default:
nr->host_errno = NO_RECOVERY;
free(ne);
return (1);
}
/* Loop through records in packet */
memset(&rr, 0, sizeof(rr));
memset(&nd->dns_hostent, 0, sizeof(nd->dns_hostent));
he = &nd->dns_hostent.hostent;
/* XXX no support for aliases */
he->h_aliases = nd->dns_hostent.host_aliases;
he->h_addr_list = nd->dns_hostent.h_addr_ptrs;
he->h_addrtype = ne->atype;
he->h_length = ne->asize;
free(ne);
bp = nd->dns_hostent.hostbuf;
ep = bp + sizeof(nd->dns_hostent.hostbuf);
hap = he->h_addr_list;
ap = he->h_aliases;
for (i = 0; i < ns_msg_count(handle, ns_s_an); i++) {
/* Parse next record */
if (ns_parserr(&handle, ns_s_an, i, &rr) < 0) {
if (errno != ENODEV) {
nr->host_errno = NO_RECOVERY;
return (1);
}
/* All done */
break;
}
/* Ignore records that don't answer our query (e.g. CNAMEs) */
atype = ns_rr_type(rr);
if (atype != qtype)
continue;
rdata = ns_rr_rdata(rr);
rdlen = ns_rr_rdlen(rr);
rttl = ns_rr_ttl(rr);
switch (atype) {
case T_A:
case T_AAAA:
if (rdlen != (unsigned int) he->h_length) {
snprintf(errstr, NB_DNS_ERRSIZE,
"nb_dns_activity(): bad rdlen %d",
(int) rdlen);
nr->host_errno = NO_RECOVERY;
return (-1);
}
if (bp + rdlen >= ep) {
snprintf(errstr, NB_DNS_ERRSIZE,
"nb_dns_activity(): overflow 1");
nr->host_errno = NO_RECOVERY;
return (-1);
}
if (nd->dns_hostent.numaddrs + 1 >= MAXADDRS) {
snprintf(errstr, NB_DNS_ERRSIZE,
"nb_dns_activity(): overflow 2");
nr->host_errno = NO_RECOVERY;
return (-1);
}
memcpy(bp, rdata, rdlen);
*hap++ = bp;
bp += rdlen;
++nd->dns_hostent.numaddrs;
/* Keep looking for more A records */
break;
case T_PTR:
n = dn_expand((const u_char *)msg,
(const u_char *)msg + msglen, rdata, bp, ep - bp);
if (n < 0) {
/* XXX return -1 here ??? */
nr->host_errno = NO_RECOVERY;
return (1);
}
he->h_name = bp;
/* XXX check for overflow */
bp += n; /* returned len includes EOS */
/* "Find first satisfactory answer" */
nr->hostent = he;
nr->ttl = rttl;
return (1);
}
}
nr->hostent = he;
nr->ttl = rttl;
return (1);
}
static void
do_section(const res_state statp,
ns_msg *handle, ns_sect section,
int pflag, FILE *file)
{
int n, sflag, rrnum;
static int buflen = 2048;
char *buf;
ns_opcode opcode;
ns_rr rr;
/*
* Print answer records.
*/
sflag = (statp->pfcode & pflag);
if (statp->pfcode && !sflag)
return;
buf = malloc(buflen);
if (buf == NULL) {
fprintf(file, ";; memory allocation failure\n");
return;
}
opcode = (ns_opcode) ns_msg_getflag(*handle, ns_f_opcode);
rrnum = 0;
for (;;) {
if (ns_parserr(handle, section, rrnum, &rr)) {
if (errno != ENODEV)
fprintf(file, ";; ns_parserr: %s\n",
strerror(errno));
else if (rrnum > 0 && sflag != 0 &&
(statp->pfcode & RES_PRF_HEAD1))
putc('\n', file);
goto cleanup;
}
if (rrnum == 0 && sflag != 0 && (statp->pfcode & RES_PRF_HEAD1))
fprintf(file, ";; %s SECTION:\n",
p_section(section, opcode));
if (section == ns_s_qd)
fprintf(file, ";;\t%s, type = %s, class = %s\n",
ns_rr_name(rr),
p_type(ns_rr_type(rr)),
p_class(ns_rr_class(rr)));
else {
n = ns_sprintrr(handle, &rr, NULL, NULL,
buf, buflen);
if (n < 0) {
if (errno == ENOSPC) {
free(buf);
buf = NULL;
if (buflen < 131072)
buf = malloc(buflen += 1024);
if (buf == NULL) {
fprintf(file,
";; memory allocation failure\n");
return;
}
continue;
}
fprintf(file, ";; ns_sprintrr: %s\n",
strerror(errno));
goto cleanup;
}
fputs(buf, file);
fputc('\n', file);
}
rrnum++;
}
cleanup:
if (buf != NULL)
free(buf);
}
static int should_filter_query(ns_msg msg, struct in_addr dns_addr) {
ns_rr rr;
int rrnum, rrmax;
void *r;
// TODO cache result for each dns server
int dns_is_chn = 0;
int dns_is_foreign = 0;
if (chnroute_file && (dns_servers_len > 1)) {
dns_is_chn = test_ip_in_list(dns_addr, &chnroute_list);
dns_is_foreign = !dns_is_chn;
}
rrmax = ns_msg_count(msg, ns_s_an);
if (rrmax == 0) {
if (compression) {
// Wait for foreign dns
if (dns_is_chn) {
return 1;
} else {
return 0;
}
}
return -1;
}
for (rrnum = 0; rrnum < rrmax; rrnum++) {
if (ns_parserr(&msg, ns_s_an, rrnum, &rr)) {
ERR("ns_parserr");
return 0;
}
u_int type;
const u_char *rd;
type = ns_rr_type(rr);
rd = ns_rr_rdata(rr);
if (type == ns_t_a) {
if (verbose)
printf("%s, ", inet_ntoa(*(struct in_addr *)rd));
if (!compression) {
r = bsearch(rd, ip_list.ips, ip_list.entries, sizeof(struct in_addr),
cmp_in_addr);
if (r) {
return 1;
}
}
if (test_ip_in_list(*(struct in_addr *)rd, &chnroute_list)) {
// result is chn
if (dns_is_foreign) {
if (bidirectional) {
// filter DNS result from foreign dns if result is inside chn
return 1;
}
}
} else {
// result is foreign
if (dns_is_chn) {
// filter DNS result from chn dns if result is outside chn
return 1;
}
}
} else if (type == ns_t_aaaa || type == ns_t_ptr) {
// if we've got an IPv6 result or a PTR result, pass
return 0;
}
}
if (rrmax == 1) {
if (compression) {
return 0;
} else {
return -1;
}
}
return 0;
}
static void
dump_dns_rr(ns_msg *msg, ns_rr *rr, ns_sect sect, FILE *trace) {
char buf[NS_MAXDNAME];
u_int class, type;
const u_char *rd;
u_int32_t soa[5];
u_int16_t mx;
int n;
memset(buf, 0, sizeof(buf));
class = ns_rr_class(*rr);
type = ns_rr_type(*rr);
fprintf(trace, "%s,%s,%s",
ns_rr_name(*rr),
p_class(class),
p_type(type));
if (sect == ns_s_qd)
return;
fprintf(trace, ",%lu", (u_long)ns_rr_ttl(*rr));
rd = ns_rr_rdata(*rr);
switch (type) {
case ns_t_soa:
n = ns_name_uncompress(ns_msg_base(*msg), ns_msg_end(*msg),
rd, buf, sizeof buf);
if (n < 0)
goto error;
putc(',', trace);
fputs(buf, trace);
rd += n;
n = ns_name_uncompress(ns_msg_base(*msg), ns_msg_end(*msg),
rd, buf, sizeof buf);
if (n < 0)
goto error;
putc(',', trace);
fputs(buf, trace);
rd += n;
if (ns_msg_end(*msg) - rd < 5*NS_INT32SZ)
goto error;
for (n = 0; n < 5; n++)
MY_GET32(soa[n], rd);
sprintf(buf, "%u,%u,%u,%u,%u",
soa[0], soa[1], soa[2], soa[3], soa[4]);
break;
case ns_t_a:
if (ns_msg_end(*msg) - rd < 4)
goto error;
inet_ntop(AF_INET, rd, buf, sizeof buf);
break;
case ns_t_aaaa:
if (ns_msg_end(*msg) - rd < 16)
goto error;
inet_ntop(AF_INET6, rd, buf, sizeof buf);
break;
case ns_t_mx:
if (ns_msg_end(*msg) - rd < 2)
goto error;
MY_GET16(mx, rd);
fprintf(trace, ",%u", mx);
/* FALLTHROUGH */
case ns_t_ns:
case ns_t_ptr:
case ns_t_cname:
n = ns_name_uncompress(ns_msg_base(*msg), ns_msg_end(*msg),
rd, buf, sizeof buf);
if (n < 0)
goto error;
break;
/*
* GGM 2014/09/04 deal with edns0 a bit more clearly
*/
case ns_t_opt:
{
u_long edns0csize;
u_short edns0version;
u_short edns0rcode;
u_char edns0dobit;
u_char edns0z;
/* class encodes client UDP size accepted */
edns0csize = (u_long)(class);
/*
* the first two bytes of ttl encode edns0 version, and the extended rcode
*/
edns0version = ((u_long)ns_rr_ttl(*rr) & 0x00ff0000) >> 16;
edns0rcode = ((u_long)ns_rr_ttl(*rr) & 0xff000000) >> 24;
/*
* the next two bytes of ttl encode DO bit as the top bit, and the remainder is the 'z' value
*/
edns0dobit = (u_long)ns_rr_ttl(*rr) & 0x8000 ? '1' : '0';
edns0z = (u_long)ns_rr_ttl(*rr) & 0x7fff;
/* optlen is the size of the OPT rdata */
u_short optlen = ns_rr_rdlen(*rr);
fprintf(trace, ",edns0[len=%d,UDP=%lu,ver=%d,rcode=%d,DO=%c,z=%d] %c\n\t",
optlen, edns0csize, edns0version, edns0rcode, edns0dobit, edns0z, '\\');
/* if we have any data */
while (optlen >= 4) {
/* the next two shorts are the edns0 opt code, and the length of the optionsection */
u_short edns0optcod;
u_short edns0lenopt;
MY_GET16(edns0optcod, rd);
MY_GET16(edns0lenopt, rd);
optlen -= 4;
fprintf(trace, "edns0[code=%d,codelen=%d] ", edns0optcod, edns0lenopt);
/*
* Check that the OPTION-LENGTH for this EDNS0 option doesn't
* exceed the size of the remaining OPT record rdata. If it does,
* just bail.
*/
if (edns0lenopt > optlen)
goto error;
/*
* "pre-consume" edns0lenopt bytes from optlen here because
* below we're going to decrement edns0lenopt as we go.
* At this point optlen will refer to the size of the remaining
* OPT_T rdata after parsing the current option.
*/
optlen -= edns0lenopt;
/* if we have edns0_client_subnet */
if (edns0optcod == 0x08) {
if (edns0lenopt < 4)
goto error;
u_short afi;
MY_GET16(afi, rd);
u_short masks;
MY_GET16(masks, rd);
edns0lenopt -= 4;
u_short srcmask = (masks & 0xff00) >> 8;
u_short scomask = (masks & 0xff);
char buf[128];
u_char addr[16];
memset(addr, 0, sizeof addr);
memcpy(addr, rd, edns0lenopt < sizeof(addr) ? edns0lenopt : sizeof(addr));
if (afi == 0x1) {
inet_ntop(AF_INET, addr, buf, sizeof buf);
} else if (afi == 0x2) {
inet_ntop(AF_INET6, addr, buf, sizeof buf);
} else {
fprintf(trace, "unknown AFI %d\n", afi);
strcpy(buf,"<unknown>");
}
fprintf(trace, "edns0_client_subnet=%s/%d (scope %d)", buf, srcmask, scomask);
}
/* increment the rd pointer by the remaining option data size */
rd += edns0lenopt;
}
}
break;
default:
error:
sprintf(buf, "[%u]", ns_rr_rdlen(*rr));
}
if (buf[0] != '\0') {
putc(',', trace);
fputs(buf, trace);
}
}
int
dns_get_mx_list(const char *host, int port, struct mx_hostentry **he, int no_mx)
{
char outname[MAXDNAME];
ns_msg msg;
ns_rr rr;
const char *searchhost;
const unsigned char *cp;
unsigned char *ans;
struct mx_hostentry *hosts = NULL;
size_t nhosts = 0;
size_t anssz;
int pref;
int cname_recurse;
int have_mx = 0;
int err;
int i;
res_init();
searchhost = host;
cname_recurse = 0;
anssz = 65536;
ans = malloc(anssz);
if (ans == NULL)
return (1);
if (no_mx)
goto out;
repeat:
err = res_search(searchhost, ns_c_in, ns_t_mx, ans, anssz);
if (err < 0) {
switch (h_errno) {
case NO_DATA:
/*
* Host exists, but no MX (or CNAME) entry.
* Not an error, use host name instead.
*/
goto out;
case TRY_AGAIN:
/* transient error */
goto transerr;
case NO_RECOVERY:
case HOST_NOT_FOUND:
default:
errno = ENOENT;
goto err;
}
}
if (!ns_initparse(ans, anssz, &msg))
goto transerr;
switch (ns_msg_getflag(msg, ns_f_rcode)) {
case ns_r_noerror:
break;
case ns_r_nxdomain:
goto err;
default:
goto transerr;
}
for (i = 0; i < ns_msg_count(msg, ns_s_an); i++) {
if (ns_parserr(&msg, ns_s_an, i, &rr))
goto transerr;
cp = ns_rr_rdata(rr);
switch (ns_rr_type(rr)) {
case ns_t_mx:
have_mx = 1;
pref = ns_get16(cp);
cp += 2;
err = ns_name_uncompress(ns_msg_base(msg), ns_msg_end(msg),
cp, outname, sizeof(outname));
if (err < 0)
goto transerr;
err = add_host(pref, outname, port, &hosts, &nhosts);
if (err == -1)
goto err;
break;
case ns_t_cname:
err = ns_name_uncompress(ns_msg_base(msg), ns_msg_end(msg),
cp, outname, sizeof(outname));
if (err < 0)
goto transerr;
/* Prevent a CNAME loop */
if (cname_recurse++ > 10)
goto err;
searchhost = outname;
goto repeat;
default:
break;
}
}
out:
err = 0;
if (0) {
transerr:
if (nhosts == 0)
err = 1;
}
if (0) {
err:
err = -1;
}
free(ans);
if (err == 0) {
if (!have_mx) {
/*
* If we didn't find any MX, use the hostname instead.
*/
err = add_host(0, host, port, &hosts, &nhosts);
} else if (nhosts == 0) {
/*
* We did get MX, but couldn't resolve any of them
* due to transient errors.
*/
err = 1;
}
}
if (nhosts > 0) {
qsort(hosts, nhosts, sizeof(*hosts), sort_pref);
/* terminate list */
*hosts[nhosts].host = 0;
} else {
if (hosts != NULL)
free(hosts);
hosts = NULL;
}
*he = hosts;
return (err);
free(ans);
if (hosts != NULL)
free(hosts);
return (err);
}
static void
do_section(const res_state statp,
ns_msg *handle, ns_sect section,
int pflag, FILE *file)
{
int n, sflag, rrnum;
static int buflen = 2048;
char *buf;
ns_opcode opcode;
ns_rr rr;
/*
* Print answer records.
*/
sflag = (statp->pfcode & pflag);
if (statp->pfcode && !sflag)
return;
buf = malloc((size_t)buflen);
if (buf == NULL) {
fprintf(file, ";; memory allocation failure\n");
return;
}
opcode = (ns_opcode) ns_msg_getflag(*handle, ns_f_opcode);
rrnum = 0;
for (;;) {
if (ns_parserr(handle, section, rrnum, &rr)) {
if (errno != ENODEV)
fprintf(file, ";; ns_parserr: %s\n",
strerror(errno));
else if (rrnum > 0 && sflag != 0 &&
(statp->pfcode & RES_PRF_HEAD1))
putc('\n', file);
goto cleanup;
}
if (rrnum == 0 && sflag != 0 && (statp->pfcode & RES_PRF_HEAD1))
fprintf(file, ";; %s SECTION:\n",
p_section(section, opcode));
if (section == ns_s_qd)
fprintf(file, ";;\t%s, type = %s, class = %s\n",
ns_rr_name(rr),
p_type(ns_rr_type(rr)),
p_class(ns_rr_class(rr)));
else if (section == ns_s_ar && ns_rr_type(rr) == ns_t_opt) {
u_int16_t optcode, optlen, rdatalen = ns_rr_rdlen(rr);
u_int32_t ttl = ns_rr_ttl(rr);
fprintf(file,
"; EDNS: version: %u, udp=%u, flags=%04x\n",
(ttl>>16)&0xff, ns_rr_class(rr), ttl&0xffff);
while (rdatalen >= 4) {
const u_char *cp = ns_rr_rdata(rr);
int i;
GETSHORT(optcode, cp);
GETSHORT(optlen, cp);
if (optcode == NS_OPT_NSID) {
fputs("; NSID: ", file);
if (optlen == 0) {
fputs("; NSID\n", file);
} else {
fputs("; NSID: ", file);
for (i = 0; i < optlen; i++)
fprintf(file, "%02x ",
cp[i]);
fputs(" (",file);
for (i = 0; i < optlen; i++)
fprintf(file, "%c",
isprint(cp[i])?
cp[i] : '.');
fputs(")\n", file);
}
} else {
if (optlen == 0) {
fprintf(file, "; OPT=%u\n",
optcode);
} else {
fprintf(file, "; OPT=%u: ",
optcode);
for (i = 0; i < optlen; i++)
fprintf(file, "%02x ",
cp[i]);
fputs(" (",file);
for (i = 0; i < optlen; i++)
fprintf(file, "%c",
isprint(cp[i]) ?
cp[i] : '.');
fputs(")\n", file);
}
}
rdatalen -= 4 + optlen;
}
} else {
int srv_getaddrinfo(const char *node, const char *service,
const struct addrinfo *hints,
struct addrinfo **res)
{
char *srv_name;
size_t srv_name_size;
char tgt_port[6];
#ifdef WIN32
PDNS_RECORD resp, entry;
char *tgt_name;
#else
char tgt_name[BINKD_FQDNLEN + 1];
unsigned char resp[SRVGAI_DNSRESPLEN];
ns_msg nsb;
ns_rr rrb;
int rlen, i, rrlen;
const unsigned char *p;
struct in_addr dummy_addr;
#endif
int rc;
struct addrinfo *ai, **ai_last = res;
/* we need sensible information for all parameters */
if (!node || (node && !*node) || !service || (service && !*service) ||
!hints || !res)
return getaddrinfo(node, service, hints, res);
/* only domain names are supported */
if (hints->ai_flags & AI_NUMERICHOST)
return getaddrinfo(node, service, hints, res);
/* detect IP addresses */
if ((hints->ai_family == AF_INET || hints->ai_family == AF_UNSPEC) &&
#ifdef WIN32
inet_addr(node) != INADDR_NONE
#else
inet_aton(node, &dummy_addr) != 0
#endif
)
return getaddrinfo(node, service, hints, res);
#ifdef AF_INET6
if ((hints->ai_family == AF_INET6 || hints->ai_family == AF_UNSPEC) &&
strchr(node, ':'))
return getaddrinfo(node, service, hints, res);
#endif
/* only named services are supported */
if ((hints->ai_flags & AI_NUMERICSERV) || *service == '0' ||
atoi(service) > 0)
return getaddrinfo(node, service, hints, res);
/* only TCP and UDP are supported */
if (hints->ai_socktype != SOCK_STREAM && hints->ai_socktype != SOCK_DGRAM)
return getaddrinfo(node, service, hints, res);
/* _ <service> ._ tcp . <node> \0 */
srv_name_size = 1 + strlen(service) + 2 + 3 + 1 + strlen(node) + 1;
srv_name = malloc(srv_name_size);
if (!srv_name)
return EAI_MEMORY;
/* construct domain name for SRV query */
snprintf(srv_name, srv_name_size, "_%s._%s.%s", service,
hints->ai_socktype == SOCK_STREAM ? "tcp" : "udp", node);
#ifdef WIN32
rc = DnsQuery(srv_name, DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, &resp, NULL);
#else
rlen = res_search(srv_name, ns_c_in, ns_t_srv, resp, sizeof(resp));
#endif
free(srv_name);
/* fallback if DNS query does not return a single entry */
#ifdef WIN32
if (rc != ERROR_SUCCESS)
#else
if (rlen < 1)
#endif
return getaddrinfo(node, service, hints, res);
#ifndef WIN32
/* fallback in case we cannot parse the response */
if (ns_initparse(resp, rlen, &nsb) < 0)
return getaddrinfo(node, service, hints, res);
#endif
/* iterate through result set -- might be incomplete */
#ifdef WIN32
for (entry = resp; entry != NULL; entry = entry->pNext) {
switch (entry->wType) {
case DNS_TYPE_SRV:
snprintf(tgt_port, sizeof(tgt_port), "%d", entry->Data.SRV.wPort);
tgt_name = entry->Data.SRV.pNameTarget;
#else
for (i = 0; i < ns_msg_count(nsb, ns_s_an); i++) {
rc = ns_parserr(&nsb, ns_s_an, i, &rrb);
if (rc < 0)
continue;
if (ns_rr_class(rrb) != ns_c_in)
continue;
switch (ns_rr_type(rrb)) {
case ns_t_srv:
rrlen = ns_rr_rdlen(rrb);
if (rrlen < 8) /* 2+2+2 and at least 2 for host */
break;
/* extract host and port */
p = ns_rr_rdata(rrb);
rc = dn_expand(resp, resp+rlen, p+6, tgt_name, sizeof(tgt_name));
if (rc < 2)
break;
snprintf(tgt_port, sizeof(tgt_port), "%u",
(unsigned int)p[4] << 8 | (unsigned int)p[5]);
#endif
/* resolve and add to end of list */
if (getaddrinfo(tgt_name, tgt_port, hints, ai_last) != 0)
break;
/* get end of list */
for (ai=*ai_last; ai != NULL; ai = ai->ai_next)
ai_last = &(ai->ai_next);
break;
default: /* someone stupid might use CNAME */
break;
}
}
#ifdef WIN32
/* free result set */
DnsRecordListFree(resp, DnsFreeRecordList);
#endif
/* fallback in case no resolution via SRV is possible */
if (ai_last == res)
return getaddrinfo(node, service, hints, res);
return 0;
}
/*! \brief Returns a MEM STACK with the requested DNS records */
PKI_MEM_STACK *URL_get_data_dns_url(URL *url, ssize_t size) {
PKI_MEM_STACK *ret = NULL;
#ifdef HAVE_LIBRESOLV
int type = T_A;
PKI_MEM *obj = NULL;
if( (!url) || (!url->addr)) {
return NULL;
}
unsigned char response[NS_PACKETSZ];
ns_msg dnsMessage;
ns_rr dnsRecord;
int dnsRecordSection = ns_s_an;
int dns_msgCount = 0;
int len = 0;
// Check the Type of record
if ((type = URL_get_dns_type(url->attrs)) == -1) return NULL;
PKI_log_debug("DNS URI: Searching for %s (%s/%d)",
url->addr, url->attrs, type);
if ((len = res_search(url->addr, C_IN, type, response, sizeof(response))) < 0)
{
// An Error Occurred
PKI_log_err("DNS URI: search failed\n");
return NULL;
}
if (ns_initparse(response, len, &dnsMessage) < 0)
{
// This should not happen if the record is correct
PKI_log_err("DNS URI: can not init DNS parsing of the dnsMessage\n");
return NULL;
}
len = ns_msg_count(dnsMessage, dnsRecordSection);
PKI_log_debug("DNS_URI: msg count ==> %d\n", len);
if (len <= 0) return NULL;
if((ret = PKI_STACK_MEM_new()) == NULL ) {
PKI_log_debug ("DNS URI: Memory Failure");
return NULL;
}
for (dns_msgCount = 0; dns_msgCount < len; dns_msgCount++)
{
PKI_log_debug("DNS URI: Retrieving DNS record #%d",dns_msgCount);
if (ns_parserr(&dnsMessage, dnsRecordSection, dns_msgCount, &dnsRecord))
{
// ERROR: ns_parserr failed, let's continue to the next record
PKI_log_err("DNS URI: Can not parse record %d of %d", dns_msgCount, len);
continue;
}
PKI_log_debug("DNS URI: type = %d (req: %d)\n", ns_rr_type(dnsRecord), type);
if (type == pki_ns_t_address)
{
switch (ns_rr_type(dnsRecord))
{
case T_A:
case T_AAAA:
case T_CNAME:
break;
default:
continue;
}
}
else if (type != ns_rr_type(dnsRecord))
{
PKI_log_debug("DNS URI: recived type %d is different from requested (%d)",
type, ns_rr_type(dnsRecord));
// continue;
}
// int i = 0;
int rv = 0;
// int len = 0;
int offset = 0;
char dnsRecordName[MAXDNAME];
memset(dnsRecordName, '\x0', MAXDNAME);
// Parse the different types of DNS records
if ((ns_rr_type(dnsRecord) == T_A) || (ns_rr_type(dnsRecord) == T_AAAA))
{
// These require Translation using IPv4/IPv6 functions
int family = AF_INET;
if (ns_rr_type(dnsRecord) == T_A) family = AF_INET;
else family = AF_INET6;
if(inet_ntop(family, ns_rr_rdata(dnsRecord), dnsRecordName,
sizeof(dnsRecordName)) == NULL)
{
// Can not convert
continue;
}
}
else if ((ns_rr_type(dnsRecord) == T_CNAME) || (ns_rr_type(dnsRecord) == T_MX) ||
(ns_rr_type(dnsRecord) == T_NS))
{
if (ns_rr_type(dnsRecord) == T_MX) offset = NS_INT16SZ;
rv = ns_name_uncompress(ns_msg_base(dnsMessage), ns_msg_end(dnsMessage),
ns_rr_rdata(dnsRecord) + offset, dnsRecordName, MAXDNAME);
// ERROR, can not uncompress the names
if (rv < 0) continue;
}
else if (ns_rr_type(dnsRecord) == T_SRV)
{
// This requires special handling, the format is [SHORT][SHORT][SHORT][DATA]
// unsigned short *pri = (unsigned short *) ns_rr_rdata(dnsRecord);
// unsigned short *weight = (unsigned short *) &(ns_rr_rdata(dnsRecord)[2]);
// unsigned short *port = (unsigned short *) &(ns_rr_rdata(dnsRecord)[4]);
// Shall we return the additional data too ?
// printf("PRI : %d\n", *pri);
// printf("WEIGHT : %d\n", ntohs(*weight));
// printf("PORT : %d\n", ntohs(*port));
offset = 6;
rv = ns_name_uncompress(ns_msg_base(dnsMessage), ns_msg_end(dnsMessage),
ns_rr_rdata(dnsRecord) + offset, dnsRecordName, MAXDNAME);
if (rv < 0) continue;
}
else if (ns_rr_type(dnsRecord) == T_TXT)
{
// Special handling required. Format is [BYTE][DATA]
unsigned char *p = (unsigned char *)ns_rr_rdata(dnsRecord);
snprintf(dnsRecordName, (size_t) *p+1, "%s", &ns_rr_rdata(dnsRecord)[1]);
}
else
{
PKI_log_debug("DNS URI: record type not supported [%d]", ns_rr_type(dnsRecord));
continue;
}
if((obj = PKI_MEM_new_null()) == NULL ) {
// Memory Allocation Error, we abort
break;
}
if (strlen(dnsRecordName) > 0) {
// If it is a printable value, we add the parsed version of the
// record
if(PKI_MEM_add(obj, (char *) dnsRecordName, strlen(dnsRecordName)) == PKI_ERR) {
/* ERROR in memory growth */;
PKI_log_err("DNS URI: Memory Allocation Error");
break;
}
} else {
// The value is not parsed/parsable, we return the raw data
// the application should know what to do with the data!
if(PKI_MEM_add(obj, (char *) ns_rr_rdata(dnsRecord),
ns_rr_rdlen(dnsRecord)) == PKI_ERR) {
/* ERROR in memory growth */;
PKI_log_err("DNS URI: Memory Allocation Error");
break;
}
}
/*
printf("MSG Data [%d]:\n", ns_rr_rdlen(dnsRecord));
for (i=0; i < ns_rr_rdlen(dnsRecord); i++)
{
unsigned char *kk;
kk = (unsigned char *) &ns_rr_rdata(dnsRecord)[i];
printf("%x:", *kk);
};
printf("\n");
fprintf(stderr, "DEBUG: RV => %d (err: %d, %s)\n", rv, h_errno, hstrerror(h_errno));
fprintf(stderr, "DEBUG: name => %s (%s)\n", ns_rr_name(dnsRecord), url->addr);
fprintf(stderr, "DEBUG: value => %s\n", dnsRecordName);
fprintf(stderr, "DEBUG: type => %d\n", ns_rr_type(dnsRecord));
fprintf(stderr, "DEBUG: class => %d\n", ns_rr_class(dnsRecord));
*/
PKI_STACK_MEM_push(ret, obj);
// PKI_log_debug("DNS URI: Added object #%d to stack", PKI_STACK_MEM_elements(ret));
}
#endif
return ret;
};
/*
* Fill out host list, based on DNS lookups.
* This is not reentrant. Better be called before any other threads
* are started.
*/
int cldc_getaddr(GList **host_list, const char *thishost, struct hail_log *log)
{
enum { hostsz = 64 };
char cldb[hostsz];
unsigned char resp[512];
int rlen;
ns_msg nsb;
ns_rr rrb;
int rrlen;
char hostb[hostsz];
int i;
struct cldc_host hp;
const unsigned char *p;
int rc;
int search_retries = 10;
/*
* We must create FQDN or else the first thing the resolver does
* is a lookup in the DNS root (probably the standard-compliant
* dot between "_cld" and "_udp" hurts us here).
*/
if (cldc_make_fqdn(cldb, hostsz, "_cld._udp", thishost) != 0) {
HAIL_INFO(log, "internal error in cldc_make_fqdn(%s)",
thishost);
return -1;
}
do_try_again:
rc = res_search(cldb, ns_c_in, ns_t_srv, resp, 512);
if (rc < 0) {
switch (h_errno) {
case HOST_NOT_FOUND:
HAIL_INFO(log, "%s: No _cld._udp SRV record", __func__);
return -1;
case NO_DATA:
HAIL_INFO(log, "%s: Cannot find _cld._udp"
" SRV record", __func__);
return -1;
case TRY_AGAIN:
if (search_retries-- > 0)
goto do_try_again;
/* fall through */
case NO_RECOVERY:
default:
HAIL_ERR(log, "%s: res_search error (%d): %s",
__func__, h_errno, hstrerror(h_errno));
return -1;
}
}
rlen = rc;
if (rlen == 0) {
HAIL_INFO(log, "%s: res_search returned empty reply", __func__);
return -1;
}
if (ns_initparse(resp, rlen, &nsb) < 0) {
HAIL_ERR(log, "%s: ns_initparse error", __func__);
return -1;
}
for (i = 0; i < ns_msg_count(nsb, ns_s_an); i++) {
rc = ns_parserr(&nsb, ns_s_an, i, &rrb);
if (rc < 0)
continue;
if (ns_rr_class(rrb) != ns_c_in)
continue;
memset(&hp, 0, sizeof(hp));
switch (ns_rr_type(rrb)) {
case ns_t_srv:
rrlen = ns_rr_rdlen(rrb);
if (rrlen < 8) { /* 2+2+2 and 2 for host */
HAIL_DEBUG(log, "%s: SRV len %d",
__func__, rrlen);
break;
}
p = ns_rr_rdata(rrb);
rc = dn_expand(resp, resp+rlen, p+6, hostb, hostsz);
if (rc < 0) {
HAIL_DEBUG(log, "%s: dn_expand error %d",
__func__, rc);
break;
}
if (rc < 2) {
HAIL_DEBUG(log, "%s: dn_expand short %d",
__func__, rc);
break;
}
if (cldc_saveaddr(&hp, ns_get16(p+0),
ns_get16(p+2), ns_get16(p+4),
rc, hostb, NULL))
break;
HAIL_DEBUG(log, "%s: found CLD host %s port %u"
" prio %d weight %d",
__func__, hp.host, hp.port,
hp.prio, hp.weight);
push_host(host_list, &hp);
break;
case ns_t_cname: /* impossible, but */
HAIL_DEBUG(log, "%s: CNAME in SRV request, ignored",
__func__);
break;
default:
;
}
}
return 0;
}
