int
lwres_getrrsetbyname_read(struct lwres_async_state **plas,
lwres_context_t *ctx,
struct rrsetinfo **res)
{
lwres_result_t lwresult;
lwres_grbnresponse_t *response = NULL;
char *buffer;
struct rrsetinfo *rrset = NULL;
int recvlen;
int ret, result;
unsigned int i;
lwres_buffer_t b_in;
struct lwres_async_state *las;
struct lwres_async_state **las_prev;
lwres_lwpacket_t pkt;
buffer = NULL;
buffer = CTXMALLOC(LWRES_RECVLENGTH);
if (buffer == NULL) {
return ERRSET_NOMEMORY;
}
ret = LWRES_R_SUCCESS;
lwresult = lwres_context_recv(ctx, buffer, LWRES_RECVLENGTH, &recvlen);
if (lwresult == LWRES_R_RETRY) {
ret = LWRES_R_RETRY;
goto out;
}
if (ret != LWRES_R_SUCCESS)
goto out;
lwres_buffer_init(&b_in, buffer, recvlen);
b_in.used = recvlen;
/*
* Parse the packet header.
*/
ret = lwres_lwpacket_parseheader(&b_in, &pkt);
if (ret != LWRES_R_SUCCESS)
goto out;
/*
* find an appropriate waiting las entry. This is a linear search.
* we can do MUCH better, since we control the serial number!
* do that later.
*/
las_prev = &ctx->pending;
las = ctx->pending;
while(las && las->serial != pkt.serial) {
las_prev=&las->next;
las=las->next;
}
if(las == NULL) {
/* no matching serial number! */
return(LWRES_R_RETRY);
}
/* okay, remove it from the receive queue */
*las_prev = las->next;
las->next = NULL;
las->inqueue = 0;
*plas = las;
/*
* Free what we've transmitted, long ago.
*/
CTXFREE(las->b_out.base, las->b_out.length);
las->b_out.base = NULL;
las->b_out.length = 0;
if (pkt.result != LWRES_R_SUCCESS) {
ret = pkt.result;
goto out;
}
/*
* Parse the response.
*/
ret = lwres_grbnresponse_parse(ctx, &b_in, &pkt, &response);
if (ret != LWRES_R_SUCCESS) {
out:
if (buffer != NULL)
CTXFREE(buffer, LWRES_RECVLENGTH);
if (response != NULL)
lwres_grbnresponse_free(ctx, &response);
result = lwresult_to_result(ret);
goto fail;
}
response->base = buffer;
response->baselen = LWRES_RECVLENGTH;
buffer = NULL; /* don't free this below */
lwresult = LWRES_R_SUCCESS;
rrset = sane_malloc(sizeof(struct rrsetinfo));
if (rrset == NULL) {
result = ERRSET_NOMEMORY;
goto fail;
}
rrset->rri_name = NULL;
rrset->rri_rdclass = response->rdclass;
rrset->rri_rdtype = response->rdtype;
rrset->rri_ttl = response->ttl;
rrset->rri_flags = 0;
rrset->rri_nrdatas = 0;
rrset->rri_rdatas = NULL;
rrset->rri_nsigs = 0;
rrset->rri_sigs = NULL;
rrset->rri_name = sane_malloc(response->realnamelen + 1);
if (rrset->rri_name == NULL) {
result = ERRSET_NOMEMORY;
goto fail;
}
strncpy(rrset->rri_name, response->realname, response->realnamelen);
rrset->rri_name[response->realnamelen] = 0;
if ((response->flags & LWRDATA_VALIDATED) != 0)
rrset->rri_flags |= RRSET_VALIDATED;
rrset->rri_nrdatas = response->nrdatas;
rrset->rri_rdatas = sane_calloc(rrset->rri_nrdatas,
sizeof(struct rdatainfo));
if (rrset->rri_rdatas == NULL) {
result = ERRSET_NOMEMORY;
goto fail;
}
for (i = 0; i < rrset->rri_nrdatas; i++) {
rrset->rri_rdatas[i].rdi_length = response->rdatalen[i];
rrset->rri_rdatas[i].rdi_data =
sane_malloc(rrset->rri_rdatas[i].rdi_length);
if (rrset->rri_rdatas[i].rdi_data == NULL) {
result = ERRSET_NOMEMORY;
goto fail;
}
memcpy(rrset->rri_rdatas[i].rdi_data, response->rdatas[i],
rrset->rri_rdatas[i].rdi_length);
}
rrset->rri_nsigs = response->nsigs;
rrset->rri_sigs = sane_calloc(rrset->rri_nsigs,
sizeof(struct rdatainfo));
if (rrset->rri_sigs == NULL) {
result = ERRSET_NOMEMORY;
goto fail;
}
for (i = 0; i < rrset->rri_nsigs; i++) {
rrset->rri_sigs[i].rdi_length = response->siglen[i];
rrset->rri_sigs[i].rdi_data =
sane_malloc(rrset->rri_sigs[i].rdi_length);
if (rrset->rri_sigs[i].rdi_data == NULL) {
result = ERRSET_NOMEMORY;
goto fail;
}
memcpy(rrset->rri_sigs[i].rdi_data, response->sigs[i],
rrset->rri_sigs[i].rdi_length);
}
lwres_grbnresponse_free(ctx, &response);
*res = rrset;
return (ERRSET_SUCCESS);
fail:
if (rrset != NULL)
lwres_freerrset(rrset);
if (response != NULL)
lwres_grbnresponse_free(ctx, &response);
return (result);
}
/*% Get rdata by name. */
lwres_result_t
lwres_getrdatabyname(lwres_context_t *ctx, const char *name,
lwres_uint16_t rdclass, lwres_uint16_t rdtype,
lwres_uint32_t flags, lwres_grbnresponse_t **structp)
{
int ret;
int recvlen;
lwres_buffer_t b_in, b_out;
lwres_lwpacket_t pkt;
lwres_uint32_t serial;
char *buffer;
lwres_grbnrequest_t request;
lwres_grbnresponse_t *response;
char target_name[1024];
unsigned int target_length;
REQUIRE(ctx != NULL);
REQUIRE(name != NULL);
REQUIRE(structp != NULL && *structp == NULL);
b_in.base = NULL;
b_out.base = NULL;
response = NULL;
buffer = NULL;
serial = lwres_context_nextserial(ctx);
buffer = CTXMALLOC(LWRES_RECVLENGTH);
if (buffer == NULL) {
ret = LWRES_R_NOMEMORY;
goto out;
}
target_length = strlen(name);
if (target_length >= sizeof(target_name))
return (LWRES_R_FAILURE);
strcpy(target_name, name); /* strcpy is safe */
/*
* Set up our request and render it to a buffer.
*/
request.rdclass = rdclass;
request.rdtype = rdtype;
request.flags = flags;
request.name = target_name;
request.namelen = target_length;
pkt.pktflags = 0;
pkt.serial = serial;
pkt.result = 0;
pkt.recvlength = LWRES_RECVLENGTH;
again:
ret = lwres_grbnrequest_render(ctx, &request, &pkt, &b_out);
if (ret != LWRES_R_SUCCESS)
goto out;
ret = lwres_context_sendrecv(ctx, b_out.base, b_out.length, buffer,
LWRES_RECVLENGTH, &recvlen);
if (ret != LWRES_R_SUCCESS)
goto out;
lwres_buffer_init(&b_in, buffer, recvlen);
b_in.used = recvlen;
/*
* Parse the packet header.
*/
ret = lwres_lwpacket_parseheader(&b_in, &pkt);
if (ret != LWRES_R_SUCCESS)
goto out;
/*
* Sanity check.
*/
if (pkt.serial != serial)
goto again;
if (pkt.opcode != LWRES_OPCODE_GETRDATABYNAME)
goto again;
/*
* Free what we've transmitted
*/
CTXFREE(b_out.base, b_out.length);
b_out.base = NULL;
b_out.length = 0;
if (pkt.result != LWRES_R_SUCCESS) {
ret = pkt.result;
goto out;
}
/*
* Parse the response.
*/
ret = lwres_grbnresponse_parse(ctx, &b_in, &pkt, &response);
if (ret != LWRES_R_SUCCESS)
goto out;
response->base = buffer;
response->baselen = LWRES_RECVLENGTH;
buffer = NULL; /* don't free this below */
*structp = response;
return (LWRES_R_SUCCESS);
out:
if (b_out.base != NULL)
CTXFREE(b_out.base, b_out.length);
if (buffer != NULL)
CTXFREE(buffer, LWRES_RECVLENGTH);
if (response != NULL)
lwres_grbnresponse_free(ctx, &response);
return (ret);
}
