void dns_rexmit(dnskey_glob *gs, dnskey_lookup *dl, int force)
{
time_t now;
int ret;
time(&now);
if(!force) {
if(dl->resend_time==0 || dl->resend_time > now)
{
return;
}
}
dl->retry_count--;
if(dl->retry_count > 0) {
dl->resend_time = now + LWDNSQ_RETRANSMIT_INTERVAL;
output_transaction_line(gs, dl->tracking_id, 0, "TIMEOUT", "");
ret = lwres_getrrsetbyname_xmit(gs->lwctx, &dl->las);
if(ret != ERRSET_SUCCESS) {
output_transaction_line(gs, dl->tracking_id, 0, "FATAL write failed", "");
}
} else {
output_transaction_line(gs, dl->tracking_id, 0, "FATAL", "too many retries");
free_dl(gs, dl);
}
}
void lookup_thing(dnskey_glob *gs,
dns_rdatatype_t wantedtype,
const char *wantedtype_name,
char *id,
char *fqdn)
{
isc_mem_t *iscmem;
isc_buffer_t *iscbuf;
int success;
dnskey_lookup *dl;
extern void lwres_sanitize_list(lwres_context_t *ctx);
iscmem=NULL;
iscbuf=NULL;
dl = malloc(sizeof(*dl));
memset(dl, 0, sizeof(*dl));
dl->tracking_id = strdup(id);
dl->step = dkl_start;
output_transaction_line(gs, id, 0, "START", NULL);
success = lwres_getrrsetbyname_init(fqdn, dns_rdataclass_in,
wantedtype, 0 /*flags*/,
gs->lwctx, &dl->las);
if(success != ERRSET_SUCCESS) {
/* screwed: */
output_transaction_line(gs, id, 0, "FATAL", "isc buffer error");
return;
}
lwres_sanitize_list(gs->lwctx);
lwres_getrrsetbyname_xmit(gs->lwctx, &dl->las);
lwres_sanitize_list(gs->lwctx);
dl->step = dkl_first;
dl->wantedtype = wantedtype;
dl->wantedtype_name = xstrdup(wantedtype_name);
dl->fqdn = xstrdup(fqdn);
dl->tracking_id = xstrdup(id);
time(&dl->resend_time);
dl->resend_time += LWDNSQ_RETRANSMIT_INTERVAL;
dl->retry_count = LWDNSQ_RETRANSMIT_INTERVAL;
/* link it in */
dl->next = gs->dns_outstanding;
gs->dns_outstanding = dl;
gs->dns_inflight++;
return;
}
static void lookup_step(dnskey_glob *gs,
dnskey_lookup *dl,
struct rrsetinfo *ans,
int success)
{
/* char simplebuf[80]; */
int nextstate;
nextstate = dkl_done;
if(dl == NULL)
{
return;
}
switch(dl->step)
{
case dkl_start:
/* first request done, why are still in this state? */
break;
case dkl_first:
/* okay, got the reply from the first step! */
process_step_first(gs, dl, ans, success, 0);
nextstate = dl->step;
break;
case dkl_cname:
/*
* we asked for a cname, and we have some result to deal
* with here.
*/
process_step_cname(gs, dl, ans, success);
nextstate = dl->step;
break;
case dkl_second:
/*
* we had asked for something, for a cname, and we followed
* it, and we'll see what we got back.
*/
process_step_first(gs, dl, ans, success, 1);
nextstate = dl->step;
break;
case dkl_done:
/* this should not happen, really, just book keeping, so,
* just free up the structure, and return.
*/
nextstate = dl->step;
return;
}
/* we have been through, made a state transition, if we are
* done, then do that.
*/
if(nextstate == dkl_done)
{
output_transaction_line(gs, dl->tracking_id, 0, "DONE", NULL);
free_dl(gs, dl);
dl=NULL;
}
return;
}
static void process_step_first(dnskey_glob *gs,
dnskey_lookup *dl,
struct rrsetinfo *ans,
int success,
int attempt) /* attempt = 0 first time, 1 after cname */
{
char simplebuf[132], typebuf[16];
char txtbuf[1024];
unsigned int i;
switch(success) {
case ERRSET_NODATA:
if(attempt == 0) {
lwresd_has_spoken = 1;
setup_follow_possible_cname(gs, dl);
dl->step = dkl_cname;
return;
}
/* FALLTHROUGH */
case ERRSET_NONAME:
lwresd_has_spoken = 1;
snprintf(simplebuf, sizeof(simplebuf),
"RR of type %s for %s was not found",
dl->wantedtype_name,
dl->fqdn);
output_transaction_line(gs, dl->tracking_id, 0, "RETRY",
simplebuf);
dl->step = dkl_done;
goto done;
case ERRSET_NOMEMORY:
snprintf(simplebuf, sizeof(simplebuf),
"ran out of memory while looking up RR of type %s for %s",
dl->wantedtype_name, dl->fqdn);
output_transaction_line(gs, dl->tracking_id, 0, "FATAL", simplebuf);
dl->step = dkl_done;
goto done;
case ERRSET_FAIL:
snprintf(simplebuf, sizeof(simplebuf),
"unspecified failure while looking up RR of type %s for %s%s",
dl->wantedtype_name, dl->fqdn,
lwresd_has_spoken ? "" : " (is lwresd running?)");
output_transaction_line(gs, dl->tracking_id, 0, "FATAL", simplebuf);
dl->step = dkl_done;
goto done;
case ERRSET_INVAL:
snprintf(simplebuf, sizeof(simplebuf),
"invalid input while looking up RR of type %s for %s",
dl->wantedtype_name, dl->fqdn);
output_transaction_line(gs, dl->tracking_id, 0, "RETRY", simplebuf);
dl->step = dkl_done;
goto done;
default:
snprintf(simplebuf, sizeof(simplebuf), " unknown error %d", success);
output_transaction_line(gs, dl->tracking_id, 0, "RETRY", simplebuf);
dl->step = dkl_done;
done:
return;
case 0:
/* everything okay */
lwresd_has_spoken = 1;
dl->step = dkl_done;
break;
}
/* output the rest of the data */
if(ans->rri_flags & RRSET_VALIDATED) {
output_transaction_line(gs, dl->tracking_id, 0, "DNSSEC", "OKAY");
snprintf(typebuf, sizeof(typebuf), "AD-%s", dl->wantedtype_name);
if(dl->wantedtype_name) free(dl->wantedtype_name);
dl->wantedtype_name=xstrdup(typebuf);
} else {
output_transaction_line(gs, dl->tracking_id, 0, "DNSSEC", "not present");
}
output_transaction_line(gs, dl->tracking_id, 0, "NAME", ans->rri_name);
for(i=0; i<ans->rri_nrdatas; i++) {
struct rdatainfo *ri = &ans->rri_rdatas[i];
isc_region_t region;
dns_rdata_t rd;
isc_buffer_clear(gs->iscbuf);
memset(®ion, 0, sizeof(region));
memset(&rd, 0, sizeof(rd));
region.base = ri->rdi_data;
region.length = ri->rdi_length;
if(dl->wantedtype == dns_rdatatype_txt) {
/* special treatment for TXT records */
unsigned int len, rdatalen, totlen;
unsigned char *txtp, *rdata;
txtp = txtbuf;
totlen = 0;
rdatalen = ri->rdi_length;
rdata = ri->rdi_data;
while(rdatalen > 0) {
len= (unsigned)rdata[0];
memcpy(txtp, rdata+1, len);
totlen += len;
txtp += len;
rdata += len+1;
rdatalen -= len+1;
}
*txtp = '\0';
output_transaction_line_limited(gs, dl->tracking_id, 0,
dl->wantedtype_name,
totlen, txtbuf);
} else {
dns_rdata_fromregion(&rd, dns_rdataclass_in,
dl->wantedtype, ®ion);
if(dns_rdata_totext(&rd, NULL, gs->iscbuf) != ISC_R_SUCCESS) {
}
output_transaction_line_limited(gs, dl->tracking_id, 0,
dl->wantedtype_name,
(int)isc_buffer_usedlength(gs->iscbuf),
(char *)isc_buffer_base(gs->iscbuf));
}
}
for(i=0; i<ans->rri_nsigs; i++) {
struct rdatainfo *ri = &ans->rri_sigs[i];
isc_region_t region;
dns_rdata_t rd;
isc_buffer_clear(gs->iscbuf);
memset(®ion, 0, sizeof(region));
memset(&rd, 0, sizeof(rd));
region.base = ri->rdi_data;
region.length = ri->rdi_length;
dns_rdata_fromregion(&rd, dns_rdataclass_in,
dns_rdatatype_sig, ®ion);
if(dns_rdata_totext(&rd, NULL, gs->iscbuf) != ISC_R_SUCCESS) {
output_transaction_line(gs, dl->tracking_id, 0, "FATAL", "isc totext error");
return;
}
output_transaction_line_limited(gs, dl->tracking_id, 0, "SIG",
(int)isc_buffer_usedlength(gs->iscbuf),
(char *)isc_buffer_base(gs->iscbuf));
}
}
/*
* we asked for, and got a CNAME of some kind.
*/
static void process_step_cname(dnskey_glob *gs,
dnskey_lookup *dl,
struct rrsetinfo *ans,
int success)
{
struct rdatainfo *ri;
isc_region_t region;
dns_rdata_t rd;
dns_rdata_cname_t cn;
char simplebuf[80];
isc_buffer_t *cname_text;
char cname_buf[DNS_NAME_MAXTEXT];
/* char cname_buf2[DNS_NAME_MAXTEXT]; */
switch(success) {
case ERRSET_NONAME:
case ERRSET_NODATA:
/* no, no CNAME found, thing isn't there */
snprintf(simplebuf, sizeof(simplebuf),
"RR of type %s for %s was not found (tried CNAMEs)",
dl->wantedtype_name,
dl->fqdn);
output_transaction_line(gs, dl->tracking_id, 0, "RETRY",
simplebuf);
dl->step = dkl_done;
return;
case 0:
/* aha! found a CNAME */
break;
default:
fatal:
/* some other error */
snprintf(simplebuf, sizeof(simplebuf), "err=%d", success);
output_transaction_line(gs, dl->tracking_id, 0, "FATAL", simplebuf);
dl->step = dkl_done;
return;
}
/*
* now process out the CNAMEs, and look them up, one by one...
* there should be only one... We just use the first one that works.
*/
if(ans->rri_flags & RRSET_VALIDATED) {
output_transaction_line(gs, dl->tracking_id, 0, "DNSSEC", "OKAY");
} else {
output_transaction_line(gs, dl->tracking_id, 0, "DNSSEC", "not present");
}
if(ans->rri_nrdatas != 1) {
/* we got a number of CNAMEs different from 1! */
success=0;
snprintf(simplebuf, sizeof(simplebuf), "illegal number of CNAMES: %d", ans->rri_nrdatas);
output_transaction_line(gs, dl->tracking_id, 0, "FATAL", simplebuf);
dl->step = dkl_done;
return;
}
/* process first CNAME record */
ri= &ans->rri_rdatas[0];
memset(®ion, 0, sizeof(region));
memset(&rd, 0, sizeof(rd));
region.base = ri->rdi_data;
region.length = ri->rdi_length;
dns_rdata_fromregion(&rd, dns_rdataclass_in,
dns_rdatatype_cname, ®ion);
/* we set mctx to NULL, which means that the tenure for
* the stuff pointed to by cn will persist only as long
* as rd persists.
*/
if(dns_rdata_tostruct(&rd, &cn, NULL) != ISC_R_SUCCESS) {
/* failed, try next return error */
success=0;
goto fatal;
}
cname_text=NULL;
if(isc_buffer_allocate(gs->iscmem, &cname_text, DNS_NAME_MAXTEXT)) {
success=0;
goto fatal;
}
if(dns_name_totext(&cn.cname, ISC_TRUE, cname_text) !=
ISC_R_SUCCESS) {
success=0;
goto fatal;
}
cname_buf[0]='\0';
strncat(cname_buf,
isc_buffer_base(cname_text),
isc_buffer_usedlength(cname_text));
/* free up buffer */
isc_buffer_free(&cname_text);
{
/* add a trailing . */
char *end;
end = &cname_buf[strlen(cname_buf)];
if(*end != '.') {
strncat(cname_buf, ".", sizeof(cname_buf));
}
}
/* format out a text version */
output_transaction_line(gs, dl->tracking_id, 0, "CNAME", cname_buf);
output_transaction_line(gs, dl->tracking_id, 0, "CNAMEFROM", dl->fqdn);
/* check for loops in the CNAMEs! */
if(dns_name_equal(&dl->last_cname, &cn.cname) == ISC_TRUE) {
/* damn, we found a loop! */
dl->step = dkl_done;
return;
}
/* send new request. */
/* okay, so look this new thing up */
success = lwres_getrrsetbyname_init(cname_buf, dns_rdataclass_in,
dl->wantedtype, 0 /*flags*/,
gs->lwctx, &dl->las);
if(success != ERRSET_SUCCESS) {
return;
}
lwres_getrrsetbyname_xmit(gs->lwctx, &dl->las);
dl->step = dkl_second;
}
