static int query(struct dns_query **qp, struct dnsc *dnsc, uint8_t opcode,
const char *name, uint16_t type, uint16_t dnsclass,
const struct dnsrr *ans_rr, int proto,
const struct sa *srvv, const uint32_t *srvc,
bool aa, bool rd, dns_query_h *qh, void *arg)
{
struct dns_query *q = NULL;
struct dnshdr hdr;
int err = 0;
uint32_t i;
if (!dnsc || !name || !srvv || !srvc || !(*srvc))
return EINVAL;
if (DNS_QTYPE_AXFR == type)
proto = IPPROTO_TCP;
q = mem_zalloc(sizeof(*q), query_destructor);
if (!q)
goto nmerr;
hash_append(dnsc->ht_query, hash_joaat_str_ci(name), &q->le, q);
tmr_init(&q->tmr);
mbuf_init(&q->mb);
for (i=0; i<ARRAY_SIZE(q->rrlv); i++)
list_init(&q->rrlv[i]);
err = str_dup(&q->name, name);
if (err)
goto error;
q->srvv = srvv;
q->srvc = srvc;
q->id = rand_u16();
q->type = type;
q->opcode = opcode;
q->dnsclass = dnsclass;
q->dnsc = dnsc;
memset(&hdr, 0, sizeof(hdr));
hdr.id = q->id;
hdr.opcode = q->opcode;
hdr.aa = aa;
hdr.rd = rd;
hdr.nq = 1;
hdr.nans = ans_rr ? 1 : 0;
if (proto == IPPROTO_TCP)
q->mb.pos += 2;
err = dns_hdr_encode(&q->mb, &hdr);
if (err)
goto error;
err = dns_dname_encode(&q->mb, name, NULL, 0, false);
if (err)
goto error;
err |= mbuf_write_u16(&q->mb, htons(type));
err |= mbuf_write_u16(&q->mb, htons(dnsclass));
if (err)
goto error;
if (ans_rr) {
err = dns_rr_encode(&q->mb, ans_rr, 0, NULL, 0);
if (err)
goto error;
}
q->qh = qh;
q->arg = arg;
switch (proto) {
case IPPROTO_TCP:
q->mb.pos = 0;
(void)mbuf_write_u16(&q->mb, htons(q->mb.end - 2));
err = send_tcp(q);
if (err)
goto error;
tmr_start(&q->tmr, 60 * 1000, tcp_timeout_handler, q);
break;
case IPPROTO_UDP:
err = send_udp(q);
if (err)
goto error;
tmr_start(&q->tmr, 500, udp_timeout_handler, q);
break;
default:
err = EPROTONOSUPPORT;
goto error;
}
if (qp) {
q->qp = qp;
*qp = q;
}
return 0;
nmerr:
err = ENOMEM;
error:
mem_deref(q);
return err;
}
static void decode_dns_query(struct dns_server *srv,
const struct sa *src, struct mbuf *mb)
{
struct list rrl = LIST_INIT;
struct dnshdr hdr;
struct le *le;
char *qname = NULL;
size_t start, end;
uint16_t type, dnsclass;
int err = 0;
start = mb->pos;
end = mb->end;
if (dns_hdr_decode(mb, &hdr) || hdr.qr || hdr.nq != 1) {
DEBUG_WARNING("unable to decode query header\n");
return;
}
err = dns_dname_decode(mb, &qname, start);
if (err) {
DEBUG_WARNING("unable to decode query name\n");
goto out;
}
if (mbuf_get_left(mb) < 4) {
err = EBADMSG;
DEBUG_WARNING("unable to decode query type/class\n");
goto out;
}
type = ntohs(mbuf_read_u16(mb));
dnsclass = ntohs(mbuf_read_u16(mb));
DEBUG_INFO("dnssrv: type=%s query-name='%s'\n",
dns_rr_typename(type), qname);
if (dnsclass == DNS_CLASS_IN) {
dns_server_match(srv, &rrl, qname, type);
}
hdr.qr = true;
hdr.tc = false;
hdr.rcode = DNS_RCODE_OK;
hdr.nq = 1;
hdr.nans = list_count(&rrl);
mb->pos = start;
err = dns_hdr_encode(mb, &hdr);
if (err)
goto out;
mb->pos = end;
DEBUG_INFO("dnssrv: @@ found %u answers for %s\n",
list_count(&rrl), qname);
for (le = rrl.head; le; le = le->next) {
struct dnsrr *rr = le->data;
err = dns_rr_encode(mb, rr, 0, NULL, start);
if (err)
goto out;
}
mb->pos = start;
(void)udp_send(srv->us, src, mb);
out:
list_clear(&rrl);
mem_deref(qname);
}