summaryrefslogtreecommitdiff
path: root/testcode/fake_event.c
diff options
context:
space:
mode:
Diffstat (limited to 'testcode/fake_event.c')
-rw-r--r--testcode/fake_event.c250
1 files changed, 125 insertions, 125 deletions
diff --git a/testcode/fake_event.c b/testcode/fake_event.c
index 085068c67c56..47e4b78da0bf 100644
--- a/testcode/fake_event.c
+++ b/testcode/fake_event.c
@@ -21,16 +21,16 @@
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
@@ -57,9 +57,12 @@
#include "services/outside_network.h"
#include "services/cache/infra.h"
#include "testcode/replay.h"
-#include "testcode/ldns-testpkts.h"
+#include "testcode/testpkts.h"
#include "util/log.h"
#include "util/fptr_wlist.h"
+#include "ldns/sbuffer.h"
+#include "ldns/wire2str.h"
+#include "ldns/str2wire.h"
#include <signal.h>
struct worker;
struct daemon_remote;
@@ -106,13 +109,13 @@ fake_event_cleanup(void)
saved_scenario = NULL;
}
-/** helper function that logs a ldns_pkt packet to logfile */
+/** helper function that logs a sldns_pkt packet to logfile */
static void
-log_pkt(const char* desc, ldns_pkt* pkt)
+log_pkt(const char* desc, uint8_t* pkt, size_t len)
{
- char* str = ldns_pkt2str(pkt);
+ char* str = sldns_wire2str_pkt(pkt, len);
if(!str)
- log_info("%s: (failed)", desc);
+ fatal_exit("%s: (failed out of memory wire2str_pkt)", desc);
else {
log_info("%s%s", desc, str);
free(str);
@@ -149,8 +152,8 @@ delete_fake_pending(struct fake_pending* pend)
if(!pend)
return;
free(pend->zone);
- ldns_buffer_free(pend->buffer);
- ldns_pkt_free(pend->pkt);
+ sldns_buffer_free(pend->buffer);
+ free(pend->pkt);
free(pend);
}
@@ -161,10 +164,10 @@ delete_replay_answer(struct replay_answer* a)
if(!a)
return;
if(a->repinfo.c) {
- ldns_buffer_free(a->repinfo.c->buffer);
+ sldns_buffer_free(a->repinfo.c->buffer);
free(a->repinfo.c);
}
- ldns_pkt_free(a->pkt);
+ free(a->pkt);
free(a);
}
@@ -186,7 +189,8 @@ pending_matches_current(struct replay_runtime* runtime,
sockaddr_cmp(&p->addr, p->addrlen, &runtime->now->addr,
runtime->now->addrlen) != 0)
continue;
- if((e=find_match(runtime->now->match, p->pkt, p->transport))) {
+ if((e=find_match(runtime->now->match, p->pkt, p->pkt_len,
+ p->transport))) {
*entry = e;
*pend = p;
return 1;
@@ -212,13 +216,16 @@ pending_find_match(struct replay_runtime* runtime, struct entry** entry,
if(p->start_step <= timenow && timenow <= p->end_step &&
(p->addrlen == 0 || sockaddr_cmp(&p->addr, p->addrlen,
&pend->addr, pend->addrlen) == 0) &&
- (*entry = find_match(p->match, pend->pkt, pend->transport))) {
+ (*entry = find_match(p->match, pend->pkt, pend->pkt_len,
+ pend->transport))) {
log_info("matched query time %d in range [%d, %d] "
"with entry line %d", timenow,
p->start_step, p->end_step, (*entry)->lineno);
if(p->addrlen != 0)
log_addr(0, "matched ip", &p->addr, p->addrlen);
- log_pkt("matched pkt: ", (*entry)->reply_list->reply);
+ log_pkt("matched pkt: ",
+ (*entry)->reply_list->reply_pkt,
+ (*entry)->reply_list->reply_len);
return 1;
}
p = p->next_range;
@@ -275,32 +282,27 @@ pending_list_delete(struct replay_runtime* runtime, struct fake_pending* pend)
* Fill buffer with reply from the entry.
*/
static void
-fill_buffer_with_reply(ldns_buffer* buffer, struct entry* entry, ldns_pkt* q)
+fill_buffer_with_reply(sldns_buffer* buffer, struct entry* entry, uint8_t* q,
+ size_t qlen)
{
- ldns_status status;
- ldns_pkt* answer_pkt = NULL;
+ uint8_t* c;
+ size_t clen;
log_assert(entry && entry->reply_list);
- ldns_buffer_clear(buffer);
+ sldns_buffer_clear(buffer);
if(entry->reply_list->reply_from_hex) {
- status = ldns_buffer2pkt_wire(&answer_pkt,
- entry->reply_list->reply_from_hex);
- if(status != LDNS_STATUS_OK) {
- log_err("testbound: hex packet unparsable, used asis.");
- ldns_buffer_write(buffer,
- ldns_buffer_begin(entry->reply_list->reply_from_hex),
- ldns_buffer_limit(entry->reply_list->reply_from_hex));
- }
+ c = sldns_buffer_begin(entry->reply_list->reply_from_hex);
+ clen = sldns_buffer_limit(entry->reply_list->reply_from_hex);
+ if(!c) fatal_exit("out of memory");
} else {
- answer_pkt = ldns_pkt_clone(entry->reply_list->reply);
+ c = entry->reply_list->reply_pkt;
+ clen = entry->reply_list->reply_len;
}
- if(answer_pkt) {
- if(q) adjust_packet(entry, answer_pkt, q);
- status = ldns_pkt2buffer_wire(buffer, answer_pkt);
- if(status != LDNS_STATUS_OK)
- fatal_exit("ldns: cannot pkt2buffer_wire parsed pkt");
+ if(c) {
+ if(q) adjust_packet(entry, &c, &clen, q, qlen);
+ sldns_buffer_write(buffer, c, clen);
+ if(q) free(c);
}
- ldns_pkt_free(answer_pkt);
- ldns_buffer_flip(buffer);
+ sldns_buffer_flip(buffer);
}
/**
@@ -320,11 +322,11 @@ answer_callback_from_entry(struct replay_runtime* runtime,
memset(&c, 0, sizeof(c));
c.fd = -1;
- c.buffer = ldns_buffer_new(runtime->bufsize);
+ c.buffer = sldns_buffer_new(runtime->bufsize);
c.type = comm_udp;
if(pend->transport == transport_tcp)
c.type = comm_tcp;
- fill_buffer_with_reply(c.buffer, entry, pend->pkt);
+ fill_buffer_with_reply(c.buffer, entry, pend->pkt, pend->pkt_len);
repinfo.c = &c;
repinfo.addrlen = pend->addrlen;
memcpy(&repinfo.addr, &pend->addr, pend->addrlen);
@@ -333,7 +335,7 @@ answer_callback_from_entry(struct replay_runtime* runtime,
if((*cb)(&c, cb_arg, NETEVENT_NOERROR, &repinfo)) {
fatal_exit("testbound: unexpected: callback returned 1");
}
- ldns_buffer_free(c.buffer);
+ sldns_buffer_free(c.buffer);
}
/** Check the now moment answer check event */
@@ -351,7 +353,8 @@ answer_check_it(struct replay_runtime* runtime)
if((runtime->now->addrlen == 0 || sockaddr_cmp(
&runtime->now->addr, runtime->now->addrlen,
&ans->repinfo.addr, ans->repinfo.addrlen) == 0) &&
- find_match(runtime->now->match, ans->pkt, tr)) {
+ find_match(runtime->now->match, ans->pkt,
+ ans->pkt_len, tr)) {
log_info("testbound matched event entry from line %d",
runtime->now->match->lineno);
log_info("testbound: do STEP %d %s",
@@ -390,13 +393,14 @@ fake_front_query(struct replay_runtime* runtime, struct replay_moment *todo)
}
repinfo.c->fd = -1;
repinfo.c->ev = (struct internal_event*)runtime;
- repinfo.c->buffer = ldns_buffer_new(runtime->bufsize);
+ repinfo.c->buffer = sldns_buffer_new(runtime->bufsize);
if(todo->match->match_transport == transport_tcp)
repinfo.c->type = comm_tcp;
else repinfo.c->type = comm_udp;
- fill_buffer_with_reply(repinfo.c->buffer, todo->match, NULL);
+ fill_buffer_with_reply(repinfo.c->buffer, todo->match, NULL, 0);
log_info("testbound: incoming QUERY");
- log_pkt("query pkt", todo->match->reply_list->reply);
+ log_pkt("query pkt", todo->match->reply_list->reply_pkt,
+ todo->match->reply_list->reply_len);
/* call the callback for incoming queries */
if((*runtime->callback_query)(repinfo.c, runtime->cb_arg,
NETEVENT_NOERROR, &repinfo)) {
@@ -424,13 +428,13 @@ fake_pending_callback(struct replay_runtime* runtime,
if(!p) fatal_exit("No pending queries.");
cb_arg = p->cb_arg;
cb = p->callback;
- log_assert(todo->qname == NULL); /* or find that one */
- c.buffer = ldns_buffer_new(runtime->bufsize);
+ c.buffer = sldns_buffer_new(runtime->bufsize);
c.type = comm_udp;
if(p->transport == transport_tcp)
c.type = comm_tcp;
if(todo->evt_type == repevt_back_reply && todo->match) {
- fill_buffer_with_reply(c.buffer, todo->match, p->pkt);
+ fill_buffer_with_reply(c.buffer, todo->match, p->pkt,
+ p->pkt_len);
}
repinfo.c = &c;
repinfo.addrlen = p->addrlen;
@@ -441,7 +445,7 @@ fake_pending_callback(struct replay_runtime* runtime,
fatal_exit("unexpected: pending callback returned 1");
}
/* delete the pending item. */
- ldns_buffer_free(c.buffer);
+ sldns_buffer_free(c.buffer);
}
/** pass time */
@@ -552,16 +556,17 @@ do_infra_rtt(struct replay_runtime* runtime)
{
struct replay_moment* now = runtime->now;
int rto;
- ldns_rdf* dp = ldns_dname_new_frm_str(now->variable);
+ size_t dplen = 0;
+ uint8_t* dp = sldns_str2wire_dname(now->variable, &dplen);
if(!dp) fatal_exit("cannot parse %s", now->variable);
- rto = infra_rtt_update(runtime->infra, &now->addr,
- now->addrlen, ldns_rdf_data(dp), ldns_rdf_size(dp),
- LDNS_RR_TYPE_A, atoi(now->string), -1, runtime->now_secs);
+ rto = infra_rtt_update(runtime->infra, &now->addr, now->addrlen,
+ dp, dplen, LDNS_RR_TYPE_A, atoi(now->string),
+ -1, runtime->now_secs);
log_addr(0, "INFRA_RTT for", &now->addr, now->addrlen);
log_info("INFRA_RTT(%s roundtrip %d): rto of %d", now->variable,
atoi(now->string), rto);
if(rto == 0) fatal_exit("infra_rtt_update failed");
- ldns_rdf_deep_free(dp);
+ free(dp);
}
/** perform exponential backoff on the timout */
@@ -712,7 +717,7 @@ run_scenario(struct replay_runtime* runtime)
struct fake_pending* p;
log_err("testbound: there are still messages pending.");
for(p = runtime->pending_list; p; p=p->next) {
- log_pkt("pending msg", p->pkt);
+ log_pkt("pending msg", p->pkt, p->pkt_len);
log_addr(0, "pending to", &p->addr, p->addrlen);
}
fatal_exit("testbound: there are still messages pending.");
@@ -736,7 +741,7 @@ listen_create(struct comm_base* base, struct listen_port* ATTR_UNUSED(ports),
if(!l)
return NULL;
l->base = base;
- l->udp_buff = ldns_buffer_new(bufsize);
+ l->udp_buff = sldns_buffer_new(bufsize);
if(!l->udp_buff) {
free(l);
return NULL;
@@ -752,7 +757,7 @@ listen_delete(struct listen_dnsport* listen)
{
if(!listen)
return;
- ldns_buffer_free(listen->udp_buff);
+ sldns_buffer_free(listen->udp_buff);
free(listen);
}
@@ -856,7 +861,6 @@ comm_point_send_reply(struct comm_reply* repinfo)
{
struct replay_answer* ans = (struct replay_answer*)calloc(1,
sizeof(struct replay_answer));
- ldns_status status;
struct replay_runtime* runtime = (struct replay_runtime*)repinfo->c->ev;
log_info("testbound: comm_point_send_reply fake");
/* dump it into the todo list */
@@ -869,13 +873,11 @@ comm_point_send_reply(struct comm_reply* repinfo)
runtime->answer_last = ans;
/* try to parse packet */
- status = ldns_buffer2pkt_wire(&ans->pkt, ans->repinfo.c->buffer);
- if(status != LDNS_STATUS_OK) {
- log_err("ldns error parsing packet: %s",
- ldns_get_errorstr_by_id(status));
- fatal_exit("Sending unparseable DNS replies to clients!");
- }
- log_pkt("reply pkt: ", ans->pkt);
+ ans->pkt = memdup(sldns_buffer_begin(ans->repinfo.c->buffer),
+ sldns_buffer_limit(ans->repinfo.c->buffer));
+ ans->pkt_len = sldns_buffer_limit(ans->repinfo.c->buffer);
+ if(!ans->pkt) fatal_exit("out of memory");
+ log_pkt("reply pkt: ", ans->pkt, ans->pkt_len);
}
void
@@ -883,7 +885,7 @@ comm_point_drop_reply(struct comm_reply* repinfo)
{
log_info("comm_point_drop_reply fake");
if(repinfo->c) {
- ldns_buffer_free(repinfo->c->buffer);
+ sldns_buffer_free(repinfo->c->buffer);
free(repinfo->c);
}
}
@@ -898,7 +900,8 @@ outside_network_create(struct comm_base* base, size_t bufsize,
int ATTR_UNUSED(use_caps_for_id), int* ATTR_UNUSED(availports),
int ATTR_UNUSED(numavailports), size_t ATTR_UNUSED(unwanted_threshold),
void (*unwanted_action)(void*), void* ATTR_UNUSED(unwanted_param),
- int ATTR_UNUSED(do_udp), void* ATTR_UNUSED(sslctx))
+ int ATTR_UNUSED(do_udp), void* ATTR_UNUSED(sslctx),
+ int ATTR_UNUSED(delayclose))
{
struct replay_runtime* runtime = (struct replay_runtime*)base;
struct outside_network* outnet = calloc(1,
@@ -908,7 +911,7 @@ outside_network_create(struct comm_base* base, size_t bufsize,
return NULL;
runtime->infra = infra;
outnet->base = base;
- outnet->udp_buff = ldns_buffer_new(bufsize);
+ outnet->udp_buff = sldns_buffer_new(bufsize);
if(!outnet->udp_buff) {
free(outnet);
return NULL;
@@ -921,7 +924,7 @@ outside_network_delete(struct outside_network* outnet)
{
if(!outnet)
return;
- ldns_buffer_free(outnet->udp_buff);
+ sldns_buffer_free(outnet->udp_buff);
free(outnet);
}
@@ -931,20 +934,19 @@ outside_network_quit_prepare(struct outside_network* ATTR_UNUSED(outnet))
}
struct pending*
-pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
+pending_udp_query(struct outside_network* outnet, sldns_buffer* packet,
struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* callback, void* callback_arg)
{
struct replay_runtime* runtime = (struct replay_runtime*)outnet->base;
struct fake_pending* pend = (struct fake_pending*)calloc(1,
sizeof(struct fake_pending));
- ldns_status status;
log_assert(pend);
- pend->buffer = ldns_buffer_new(ldns_buffer_capacity(packet));
+ pend->buffer = sldns_buffer_new(sldns_buffer_capacity(packet));
log_assert(pend->buffer);
- ldns_buffer_write(pend->buffer, ldns_buffer_begin(packet),
- ldns_buffer_limit(packet));
- ldns_buffer_flip(pend->buffer);
+ sldns_buffer_write(pend->buffer, sldns_buffer_begin(packet),
+ sldns_buffer_limit(packet));
+ sldns_buffer_flip(pend->buffer);
memcpy(&pend->addr, addr, addrlen);
pend->addrlen = addrlen;
pend->callback = callback;
@@ -955,20 +957,18 @@ pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
pend->zone = NULL;
pend->serviced = 0;
pend->runtime = runtime;
- status = ldns_buffer2pkt_wire(&pend->pkt, packet);
- if(status != LDNS_STATUS_OK) {
- log_err("ldns error parsing udp output packet: %s",
- ldns_get_errorstr_by_id(status));
- fatal_exit("Sending unparseable DNS packets to servers!");
- }
- log_pkt("pending udp pkt: ", pend->pkt);
+ pend->pkt_len = sldns_buffer_limit(packet);
+ pend->pkt = memdup(sldns_buffer_begin(packet), pend->pkt_len);
+ if(!pend->pkt) fatal_exit("out of memory");
+ log_pkt("pending udp pkt: ", pend->pkt, pend->pkt_len);
/* see if it matches the current moment */
if(runtime->now && runtime->now->evt_type == repevt_back_query &&
(runtime->now->addrlen == 0 || sockaddr_cmp(
&runtime->now->addr, runtime->now->addrlen,
&pend->addr, pend->addrlen) == 0) &&
- find_match(runtime->now->match, pend->pkt, pend->transport)) {
+ find_match(runtime->now->match, pend->pkt, pend->pkt_len,
+ pend->transport)) {
log_info("testbound: matched pending to event. "
"advance time between events.");
log_info("testbound: do STEP %d %s", runtime->now->time_step,
@@ -984,7 +984,7 @@ pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
}
struct waiting_tcp*
-pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
+pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet,
struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* callback, void* callback_arg,
int ATTR_UNUSED(ssl_upstream))
@@ -992,13 +992,12 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
struct replay_runtime* runtime = (struct replay_runtime*)outnet->base;
struct fake_pending* pend = (struct fake_pending*)calloc(1,
sizeof(struct fake_pending));
- ldns_status status;
log_assert(pend);
- pend->buffer = ldns_buffer_new(ldns_buffer_capacity(packet));
+ pend->buffer = sldns_buffer_new(sldns_buffer_capacity(packet));
log_assert(pend->buffer);
- ldns_buffer_write(pend->buffer, ldns_buffer_begin(packet),
- ldns_buffer_limit(packet));
- ldns_buffer_flip(pend->buffer);
+ sldns_buffer_write(pend->buffer, sldns_buffer_begin(packet),
+ sldns_buffer_limit(packet));
+ sldns_buffer_flip(pend->buffer);
memcpy(&pend->addr, addr, addrlen);
pend->addrlen = addrlen;
pend->callback = callback;
@@ -1009,20 +1008,18 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
pend->zone = NULL;
pend->runtime = runtime;
pend->serviced = 0;
- status = ldns_buffer2pkt_wire(&pend->pkt, packet);
- if(status != LDNS_STATUS_OK) {
- log_err("ldns error parsing tcp output packet: %s",
- ldns_get_errorstr_by_id(status));
- fatal_exit("Sending unparseable DNS packets to servers!");
- }
- log_pkt("pending tcp pkt: ", pend->pkt);
+ pend->pkt_len = sldns_buffer_limit(packet);
+ pend->pkt = memdup(sldns_buffer_begin(packet), pend->pkt_len);
+ if(!pend->pkt) fatal_exit("out of memory");
+ log_pkt("pending tcp pkt: ", pend->pkt, pend->pkt_len);
/* see if it matches the current moment */
if(runtime->now && runtime->now->evt_type == repevt_back_query &&
(runtime->now->addrlen == 0 || sockaddr_cmp(
&runtime->now->addr, runtime->now->addrlen,
&pend->addr, pend->addrlen) == 0) &&
- find_match(runtime->now->match, pend->pkt, pend->transport)) {
+ find_match(runtime->now->match, pend->pkt, pend->pkt_len,
+ pend->transport)) {
log_info("testbound: matched pending to event. "
"advance time between events.");
log_info("testbound: do STEP %d %s", runtime->now->time_step,
@@ -1043,13 +1040,12 @@ struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
int ATTR_UNUSED(tcp_upstream), int ATTR_UNUSED(ssl_upstream),
struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
size_t zonelen, comm_point_callback_t* callback, void* callback_arg,
- ldns_buffer* ATTR_UNUSED(buff))
+ sldns_buffer* ATTR_UNUSED(buff))
{
struct replay_runtime* runtime = (struct replay_runtime*)outnet->base;
struct fake_pending* pend = (struct fake_pending*)calloc(1,
sizeof(struct fake_pending));
char z[256];
- ldns_status status;
log_assert(pend);
log_nametypeclass(VERB_OPS, "pending serviced query",
qname, qtype, qclass);
@@ -1059,18 +1055,18 @@ struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
(flags&~(BIT_RD|BIT_CD))?" MORE":"", (dnssec)?" DO":"");
/* create packet with EDNS */
- pend->buffer = ldns_buffer_new(512);
+ pend->buffer = sldns_buffer_new(512);
log_assert(pend->buffer);
- ldns_buffer_write_u16(pend->buffer, 0); /* id */
- ldns_buffer_write_u16(pend->buffer, flags);
- ldns_buffer_write_u16(pend->buffer, 1); /* qdcount */
- ldns_buffer_write_u16(pend->buffer, 0); /* ancount */
- ldns_buffer_write_u16(pend->buffer, 0); /* nscount */
- ldns_buffer_write_u16(pend->buffer, 0); /* arcount */
- ldns_buffer_write(pend->buffer, qname, qnamelen);
- ldns_buffer_write_u16(pend->buffer, qtype);
- ldns_buffer_write_u16(pend->buffer, qclass);
- ldns_buffer_flip(pend->buffer);
+ sldns_buffer_write_u16(pend->buffer, 0); /* id */
+ sldns_buffer_write_u16(pend->buffer, flags);
+ sldns_buffer_write_u16(pend->buffer, 1); /* qdcount */
+ sldns_buffer_write_u16(pend->buffer, 0); /* ancount */
+ sldns_buffer_write_u16(pend->buffer, 0); /* nscount */
+ sldns_buffer_write_u16(pend->buffer, 0); /* arcount */
+ sldns_buffer_write(pend->buffer, qname, qnamelen);
+ sldns_buffer_write_u16(pend->buffer, qtype);
+ sldns_buffer_write_u16(pend->buffer, qclass);
+ sldns_buffer_flip(pend->buffer);
if(1) {
/* add edns */
struct edns_data edns;
@@ -1096,20 +1092,18 @@ struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
pend->pkt = NULL;
pend->runtime = runtime;
pend->serviced = 1;
- status = ldns_buffer2pkt_wire(&pend->pkt, pend->buffer);
- if(status != LDNS_STATUS_OK) {
- log_err("ldns error parsing serviced output packet: %s",
- ldns_get_errorstr_by_id(status));
- fatal_exit("internal error");
- }
- /*log_pkt("pending serviced query: ", pend->pkt);*/
+ pend->pkt_len = sldns_buffer_limit(pend->buffer);
+ pend->pkt = memdup(sldns_buffer_begin(pend->buffer), pend->pkt_len);
+ if(!pend->pkt) fatal_exit("out of memory");
+ /*log_pkt("pending serviced query: ", pend->pkt, pend->pkt_len);*/
/* see if it matches the current moment */
if(runtime->now && runtime->now->evt_type == repevt_back_query &&
(runtime->now->addrlen == 0 || sockaddr_cmp(
&runtime->now->addr, runtime->now->addrlen,
&pend->addr, pend->addrlen) == 0) &&
- find_match(runtime->now->match, pend->pkt, pend->transport)) {
+ find_match(runtime->now->match, pend->pkt, pend->pkt_len,
+ pend->transport)) {
log_info("testbound: matched pending to event. "
"advance time between events.");
log_info("testbound: do STEP %d %s", runtime->now->time_step,
@@ -1137,8 +1131,8 @@ void outnet_serviced_query_stop(struct serviced_query* sq, void* cb_arg)
if(prev)
prev->next = p->next;
else runtime->pending_list = p->next;
- ldns_buffer_free(p->buffer);
- ldns_pkt_free(p->pkt);
+ sldns_buffer_free(p->buffer);
+ free(p->pkt);
free(p->zone);
free(p);
return;
@@ -1149,7 +1143,8 @@ void outnet_serviced_query_stop(struct serviced_query* sq, void* cb_arg)
log_info("double delete of pending serviced query");
}
-struct listen_port* listening_ports_open(struct config_file* ATTR_UNUSED(cfg))
+struct listen_port* listening_ports_open(struct config_file* ATTR_UNUSED(cfg),
+ int* ATTR_UNUSED(reuseport))
{
return calloc(1, 1);
}
@@ -1235,6 +1230,11 @@ void pending_udp_timer_cb(void *ATTR_UNUSED(arg))
log_assert(0);
}
+void pending_udp_timer_delay_cb(void *ATTR_UNUSED(arg))
+{
+ log_assert(0);
+}
+
void outnet_tcptimer(void* ATTR_UNUSED(arg))
{
log_assert(0);