int main(int argc, char *argv[])
{
plan(TESTS_COUNT);
mm_ctx_t mm;
mm_ctx_mempool(&mm, MM_DEFAULT_BLKSIZE);
knot_pkt_t *buf = knot_pkt_new(NULL, 512, &mm);
knot_pkt_put_question(buf, (const uint8_t *)"", 0, 0);
/* Initialize overlay. */
struct knot_overlay overlay;
knot_overlay_init(&overlay, &mm);
/* Add FSMs. */
knot_overlay_add(&overlay, &fsm1_module, NULL);
knot_overlay_add(&overlay, &fsm2_module, NULL);
/* Run the sequence. */
int state = knot_overlay_consume(&overlay, buf);
is_int(KNOT_STATE_DONE, state, "overlay: in");
state = knot_overlay_reset(&overlay);
is_int(KNOT_STATE_PRODUCE, state, "overlay: reset");
state = knot_overlay_produce(&overlay, buf);
is_int(KNOT_STATE_DONE, state, "overlay: out");
state = knot_overlay_finish(&overlay);
is_int(KNOT_STATE_NOOP, state, "overlay: finish");
/* Cleanup. */
knot_overlay_deinit(&overlay);
mp_delete((struct mempool *)mm.ctx);
return 0;
}
static struct knot_request *make_query(struct knot_requestor *requestor, conf_remote_t *remote)
{
knot_pkt_t *pkt = knot_pkt_new(NULL, KNOT_WIRE_MAX_PKTSIZE, requestor->mm);
assert(pkt);
knot_pkt_put_question(pkt, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_SOA);
const struct sockaddr *dst = (const struct sockaddr *)&remote->addr;
const struct sockaddr *src = (const struct sockaddr *)&remote->via;
return knot_request_make(requestor->mm, dst, src, pkt, 0);
}
static int wrk_resolve(lua_State *L)
{
struct worker_ctx *worker = wrk_luaget(L);
if (!worker) {
return 0;
}
/* Create query packet */
knot_pkt_t *pkt = knot_pkt_new(NULL, KNOT_EDNS_MAX_UDP_PAYLOAD, NULL);
if (!pkt) {
lua_pushstring(L, strerror(ENOMEM));
lua_error(L);
}
uint8_t dname[KNOT_DNAME_MAXLEN];
knot_dname_from_str(dname, lua_tostring(L, 1), sizeof(dname));
/* Check class and type */
uint16_t rrtype = lua_tointeger(L, 2);
if (!lua_isnumber(L, 2)) {
lua_pushstring(L, "invalid RR type");
lua_error(L);
}
uint16_t rrclass = lua_tointeger(L, 3);
if (!lua_isnumber(L, 3)) { /* Default class is IN */
rrclass = KNOT_CLASS_IN;
}
knot_pkt_put_question(pkt, dname, rrclass, rrtype);
knot_wire_set_rd(pkt->wire);
/* Add OPT RR */
pkt->opt_rr = knot_rrset_copy(worker->engine->resolver.opt_rr, NULL);
if (!pkt->opt_rr) {
return kr_error(ENOMEM);
}
/* Add completion callback */
int ret = 0;
unsigned options = lua_tointeger(L, 4);
if (lua_isfunction(L, 5)) {
/* Store callback in registry */
lua_pushvalue(L, 5);
int cb = luaL_ref(L, LUA_REGISTRYINDEX);
ret = worker_resolve(worker, pkt, options, resolve_callback, (void *) (intptr_t)cb);
} else {
ret = worker_resolve(worker, pkt, options, NULL, NULL);
}
knot_rrset_free(&pkt->opt_rr, NULL);
knot_pkt_free(&pkt);
lua_pushboolean(L, ret == 0);
return 1;
}
static int answer_query(knot_pkt_t *pkt, pack_t *addr_set, struct kr_query *qry)
{
uint16_t rrtype = qry->stype;
uint16_t rrclass = qry->sclass;
if (rrtype != KNOT_RRTYPE_A && rrtype != KNOT_RRTYPE_AAAA) {
return kr_error(ENOENT);
}
knot_dname_t *qname = knot_dname_copy(qry->sname, &pkt->mm);
knot_rrset_t rr;
knot_rrset_init(&rr, qname, rrtype, rrclass);
int family_len = sizeof(struct in_addr);
if (rr.type == KNOT_RRTYPE_AAAA) {
family_len = sizeof(struct in6_addr);
}
/* Append address records from hints */
uint8_t *addr = pack_head(*addr_set);
while (addr != pack_tail(*addr_set)) {
size_t len = pack_obj_len(addr);
void *addr_val = pack_obj_val(addr);
if (len == family_len) {
knot_rrset_add_rdata(&rr, addr_val, len, 0, &pkt->mm);
}
addr = pack_obj_next(addr);
}
int ret = kr_error(ENOENT);
if (!knot_rrset_empty(&rr)) {
/* Update packet question */
if (!knot_dname_is_equal(knot_pkt_qname(pkt), qname)) {
KR_PKT_RECYCLE(pkt);
knot_pkt_put_question(pkt, qname, rrclass, rrtype);
}
/* Append to packet */
ret = knot_pkt_put(pkt, KNOT_COMPR_HINT_QNAME, &rr, KNOT_PF_FREE);
}
/* Clear RR if failed */
if (ret != 0) {
knot_rrset_clear(&rr, &pkt->mm);
}
return ret;
}
/*! \brief Create zone query packet. */
static knot_pkt_t *zone_query(const zone_t *zone, uint16_t pkt_type, knot_mm_t *mm)
{
/* Determine query type and opcode. */
uint16_t query_type = KNOT_RRTYPE_SOA;
uint16_t opcode = KNOT_OPCODE_QUERY;
switch(pkt_type) {
case KNOT_QUERY_AXFR: query_type = KNOT_RRTYPE_AXFR; break;
case KNOT_QUERY_IXFR: query_type = KNOT_RRTYPE_IXFR; break;
case KNOT_QUERY_NOTIFY: opcode = KNOT_OPCODE_NOTIFY; break;
}
knot_pkt_t *pkt = knot_pkt_new(NULL, KNOT_WIRE_MAX_PKTSIZE, mm);
if (pkt == NULL) {
return NULL;
}
knot_wire_set_id(pkt->wire, dnssec_random_uint16_t());
knot_wire_set_opcode(pkt->wire, opcode);
if (pkt_type == KNOT_QUERY_NOTIFY) {
knot_wire_set_aa(pkt->wire);
}
knot_pkt_put_question(pkt, zone->name, KNOT_CLASS_IN, query_type);
/* Put current SOA (optional). */
zone_contents_t *contents = zone->contents;
if (pkt_type == KNOT_QUERY_IXFR) { /* RFC1995, SOA in AUTHORITY. */
knot_pkt_begin(pkt, KNOT_AUTHORITY);
knot_rrset_t soa_rr = node_rrset(contents->apex, KNOT_RRTYPE_SOA);
knot_pkt_put(pkt, KNOT_COMPR_HINT_QNAME, &soa_rr, 0);
} else if (pkt_type == KNOT_QUERY_NOTIFY) { /* RFC1996, SOA in ANSWER. */
knot_pkt_begin(pkt, KNOT_ANSWER);
knot_rrset_t soa_rr = node_rrset(contents->apex, KNOT_RRTYPE_SOA);
knot_pkt_put(pkt, KNOT_COMPR_HINT_QNAME, &soa_rr, 0);
}
return pkt;
}
int main(int argc, char *argv[])
{
plan(25);
/* Create memory pool context. */
int ret = 0;
knot_mm_t mm;
mm_ctx_mempool(&mm, MM_DEFAULT_BLKSIZE);
/* Create names and data. */
knot_dname_t* dnames[NAMECOUNT] = {0};
knot_rrset_t* rrsets[NAMECOUNT] = {0};
for (unsigned i = 0; i < NAMECOUNT; ++i) {
dnames[i] = knot_dname_from_str_alloc(g_names[i]);
}
uint8_t *edns_str = (uint8_t *)"ab";
/* Create OPT RR. */
knot_rrset_t opt_rr;
ret = knot_edns_init(&opt_rr, 1024, 0, 0, &mm);
if (ret != KNOT_EOK) {
skip_block(25, "Failed to initialize OPT RR.");
return 0;
}
/* Add NSID */
ret = knot_edns_add_option(&opt_rr, KNOT_EDNS_OPTION_NSID,
strlen((char *)edns_str), edns_str, &mm);
if (ret != KNOT_EOK) {
knot_rrset_clear(&opt_rr, &mm);
skip_block(25, "Failed to add NSID to OPT RR.");
return 0;
}
/*
* Packet writer tests.
*/
/* Create packet. */
knot_pkt_t *out = knot_pkt_new(NULL, MM_DEFAULT_BLKSIZE, &mm);
ok(out != NULL, "pkt: new");
/* Mark as response (not part of the test). */
knot_wire_set_qr(out->wire);
/* Secure packet. */
const char *tsig_secret = "abcd";
knot_tsig_key_t tsig_key;
tsig_key.algorithm = DNSSEC_TSIG_HMAC_MD5;
tsig_key.name = dnames[0];
tsig_key.secret.data = (uint8_t *)strdup(tsig_secret);
tsig_key.secret.size = strlen(tsig_secret);
ret = knot_pkt_reserve(out, knot_tsig_wire_maxsize(&tsig_key));
ok(ret == KNOT_EOK, "pkt: set TSIG key");
/* Write question. */
ret = knot_pkt_put_question(out, dnames[0], KNOT_CLASS_IN, KNOT_RRTYPE_A);
ok(ret == KNOT_EOK, "pkt: put question");
/* Add OPT to packet (empty NSID). */
ret = knot_pkt_reserve(out, knot_edns_wire_size(&opt_rr));
ok(ret == KNOT_EOK, "pkt: reserve OPT RR");
/* Begin ANSWER section. */
ret = knot_pkt_begin(out, KNOT_ANSWER);
ok(ret == KNOT_EOK, "pkt: begin ANSWER");
/* Write ANSWER section. */
rrsets[0] = knot_rrset_new(dnames[0], KNOT_RRTYPE_A, KNOT_CLASS_IN, NULL);
knot_dname_free(&dnames[0], NULL);
knot_rrset_add_rdata(rrsets[0], RDVAL(0), RDLEN(0), TTL, NULL);
ret = knot_pkt_put(out, KNOT_COMPR_HINT_QNAME, rrsets[0], 0);
ok(ret == KNOT_EOK, "pkt: write ANSWER");
/* Begin AUTHORITY. */
ret = knot_pkt_begin(out, KNOT_AUTHORITY);
ok(ret == KNOT_EOK, "pkt: begin AUTHORITY");
/* Write rest to AUTHORITY. */
ret = KNOT_EOK;
for (unsigned i = 1; i < NAMECOUNT; ++i) {
rrsets[i] = knot_rrset_new(dnames[i], KNOT_RRTYPE_NS, KNOT_CLASS_IN, NULL);
knot_dname_free(&dnames[i], NULL);
knot_rrset_add_rdata(rrsets[i], RDVAL(i), RDLEN(i), TTL, NULL);
ret |= knot_pkt_put(out, KNOT_COMPR_HINT_NONE, rrsets[i], 0);
}
ok(ret == KNOT_EOK, "pkt: write AUTHORITY(%u)", NAMECOUNT - 1);
/* Begin ADDITIONALS */
ret = knot_pkt_begin(out, KNOT_ADDITIONAL);
ok(ret == KNOT_EOK, "pkt: begin ADDITIONALS");
/* Encode OPT RR. */
ret = knot_pkt_put(out, KNOT_COMPR_HINT_NONE, &opt_rr, 0);
ok(ret == KNOT_EOK, "pkt: write OPT RR");
/*
* Packet reader tests.
*/
/* Create new packet from query packet. */
knot_pkt_t *in = knot_pkt_new(out->wire, out->size, &out->mm);
ok(in != NULL, "pkt: create packet for parsing");
/* Read packet header. */
ret = knot_pkt_parse_question(in);
ok(ret == KNOT_EOK, "pkt: read header");
/* Read packet payload. */
ret = knot_pkt_parse_payload(in, 0);
ok(ret == KNOT_EOK, "pkt: read payload");
/* Compare parsed packet to written packet. */
packet_match(in, out);
/*
* Copied packet tests.
*/
knot_pkt_t *copy = knot_pkt_new(NULL, in->max_size, &in->mm);
ret = knot_pkt_copy(copy, in);
ok(ret == KNOT_EOK, "pkt: create packet copy");
/* Compare copied packet to original. */
packet_match(in, copy);
/* Free packets. */
knot_pkt_free(©);
knot_pkt_free(&out);
knot_pkt_free(&in);
ok(in == NULL && out == NULL && copy == NULL, "pkt: free");
/* Free extra data. */
for (unsigned i = 0; i < NAMECOUNT; ++i) {
knot_rrset_free(&rrsets[i], NULL);
}
free(tsig_key.secret.data);
mp_delete((struct mempool *)mm.ctx);
return 0;
}
int main(int argc, char *argv[])
{
plan(10);
/* Prepare query. */
knot_pkt_t *query = knot_pkt_new(NULL, 512, NULL);
if (query == NULL) {
return KNOT_ERROR; /* Fatal */
}
knot_dname_t *qname = knot_dname_from_str("beef.");
int ret = knot_pkt_put_question(query, qname, KNOT_CLASS_IN, KNOT_RRTYPE_A);
knot_dname_free(&qname, NULL);
if (ret != KNOT_EOK) {
knot_pkt_free(&query);
return KNOT_ERROR; /* Fatal */
}
/* Prepare response */
uint8_t rbuf[65535];
size_t rlen = sizeof(rbuf);
memcpy(rbuf, query->wire, query->size);
knot_wire_flags_set_qr(rbuf);
rrl_req_t rq;
rq.w = rbuf;
rq.len = rlen;
rq.query = query;
rq.flags = 0;
/* 1. create rrl table */
rrl_table_t *rrl = rrl_create(RRL_SIZE);
ok(rrl != NULL, "rrl: create");
/* 2. set rate limit */
uint32_t rate = 10;
rrl_setrate(rrl, rate);
is_int(rate, rrl_rate(rrl), "rrl: setrate");
/* 3. setlocks */
ret = rrl_setlocks(rrl, RRL_LOCKS);
is_int(KNOT_EOK, ret, "rrl: setlocks");
/* 4. N unlimited requests. */
conf_zone_t *zone_conf = malloc(sizeof(conf_zone_t));
conf_init_zone(zone_conf);
zone_conf->name = strdup("rrl.");
zone_t *zone = zone_new(zone_conf);
struct sockaddr_storage addr;
struct sockaddr_storage addr6;
sockaddr_set(&addr, AF_INET, "1.2.3.4", 0);
sockaddr_set(&addr6, AF_INET6, "1122:3344:5566:7788::aabb", 0);
ret = 0;
for (unsigned i = 0; i < rate; ++i) {
if (rrl_query(rrl, &addr, &rq, zone) != KNOT_EOK ||
rrl_query(rrl, &addr6, &rq, zone) != KNOT_EOK) {
ret = KNOT_ELIMIT;
break;
}
}
is_int(0, ret, "rrl: unlimited IPv4/v6 requests");
#ifdef ENABLE_TIMED_TESTS
/* 5. limited request */
ret = rrl_query(rrl, &addr, &rq, zone);
is_int(0, ret, "rrl: throttled IPv4 request");
/* 6. limited IPv6 request */
ret = rrl_query(rrl, &addr6, &rq, zone);
is_int(0, ret, "rrl: throttled IPv6 request");
#else
skip_block(2, "Timed tests not enabled");
#endif
/* 7. invalid values. */
ret = 0;
rrl_create(0); // NULL
ret += rrl_setrate(0, 0); // 0
ret += rrl_rate(0); // 0
ret += rrl_setlocks(0,0); // -1
ret += rrl_query(0, 0, 0, 0); // -1
ret += rrl_query(rrl, 0, 0, 0); // -1
ret += rrl_query(rrl, (void*)0x1, 0, 0); // -1
ret += rrl_destroy(0); // -1
is_int(-488, ret, "rrl: not crashed while executing functions on NULL context");
#ifdef ENABLE_TIMED_TESTS
/* 8. hopscotch test */
struct runnable_data rd = {
1, rrl, &addr, &rq, zone
};
rrl_hopscotch(&rd);
ok(rd.passed, "rrl: hashtable is ~ consistent");
/* 9. reseed */
is_int(0, rrl_reseed(rrl), "rrl: reseed");
/* 10. hopscotch after reseed. */
rrl_hopscotch(&rd);
ok(rd.passed, "rrl: hashtable is ~ consistent");
#else
skip_block(3, "Timed tests not enabled");
#endif
zone_free(&zone);
knot_pkt_free(&query);
rrl_destroy(rrl);
return 0;
}
int main(int argc, char *argv[])
{
plan(8*6 + 3); /* exec_query = 6 TAP tests */
/* Create processing context. */
knot_process_t query_ctx;
memset(&query_ctx, 0, sizeof(knot_process_t));
mm_ctx_mempool(&query_ctx.mm, sizeof(knot_pkt_t));
/* Create name server. */
server_t server;
server_init(&server);
server.opt_rr = knot_edns_new();
knot_edns_set_version(server.opt_rr, EDNS_VERSION);
knot_edns_set_payload(server.opt_rr, 4096);
conf()->identity = strdup("bogus.ns");
conf()->version = strdup("0.11");
/* Insert root zone. */
create_root_zone(&server, &query_ctx.mm);
zone_t *zone = knot_zonedb_find(server.zone_db, ROOT_DNAME);
/* Prepare. */
int state = NS_PROC_FAIL;
uint8_t query_wire[KNOT_WIRE_MAX_PKTSIZE];
uint16_t query_len = KNOT_WIRE_MAX_PKTSIZE;
knot_pkt_t *query = knot_pkt_new(query_wire, query_len, &query_ctx.mm);
/* Create query processing parameter. */
struct sockaddr_storage ss;
memset(&ss, 0, sizeof(struct sockaddr_storage));
sockaddr_set(&ss, AF_INET, "127.0.0.1", 53);
struct process_query_param param = {0};
param.query_source = &ss;
param.server = &server;
/* Query processor (CH zone) */
state = knot_process_begin(&query_ctx, ¶m, NS_PROC_QUERY);
const uint8_t chaos_dname[] = "\2""id""\6""server"; /* id.server */
knot_pkt_clear(query);
knot_pkt_put_question(query, chaos_dname, KNOT_CLASS_CH, KNOT_RRTYPE_TXT);
exec_query(&query_ctx, "CH TXT", query->wire, query->size, KNOT_RCODE_NOERROR);
/* Query processor (valid input). */
state = knot_process_reset(&query_ctx);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_SOA);
exec_query(&query_ctx, "IN/root", query->wire, query->size, KNOT_RCODE_NOERROR);
/* Query processor (-1 bytes, not enough data). */
state = knot_process_reset(&query_ctx);
exec_query(&query_ctx, "IN/few-data", query->wire, query->size - 1, KNOT_RCODE_FORMERR);
/* Query processor (+1 bytes trailing). */
state = knot_process_reset(&query_ctx);
query->wire[query->size] = '\1'; /* Initialize the "garbage" value. */
exec_query(&query_ctx, "IN/trail-garbage", query->wire, query->size + 1, KNOT_RCODE_FORMERR);
/* Forge NOTIFY query from SOA query. */
state = knot_process_reset(&query_ctx);
knot_wire_set_opcode(query->wire, KNOT_OPCODE_NOTIFY);
exec_query(&query_ctx, "IN/notify", query->wire, query->size, KNOT_RCODE_NOTAUTH);
/* Forge AXFR query. */
knot_process_reset(&query_ctx);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_AXFR);
exec_query(&query_ctx, "IN/axfr", query->wire, query->size, KNOT_RCODE_NOTAUTH);
/* Forge IXFR query (badly formed, no SOA in AUTHORITY section). */
knot_process_reset(&query_ctx);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_IXFR);
exec_query(&query_ctx, "IN/ixfr-formerr", query->wire, query->size, KNOT_RCODE_FORMERR);
/* Forge IXFR query (well formed). */
knot_process_reset(&query_ctx);
/* Append SOA RR. */
knot_rrset_t soa_rr = node_rrset(zone->contents->apex, KNOT_RRTYPE_SOA);
knot_pkt_begin(query, KNOT_AUTHORITY);
knot_pkt_put(query, COMPR_HINT_NONE, &soa_rr, 0);
exec_query(&query_ctx, "IN/ixfr", query->wire, query->size, KNOT_RCODE_NOTAUTH);
/* \note Tests below are not possible without proper zone and zone data. */
/* #189 Process UPDATE query. */
/* #189 Process AXFR client. */
/* #189 Process IXFR client. */
/* Query processor (smaller than DNS header, ignore). */
state = knot_process_reset(&query_ctx);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_SOA);
state = knot_process_in(query->wire, KNOT_WIRE_HEADER_SIZE - 1, &query_ctx);
ok(state == NS_PROC_NOOP, "ns: IN/less-than-header query ignored");
/* Query processor (response, ignore). */
state = knot_process_reset(&query_ctx);
knot_wire_set_qr(query->wire);
state = knot_process_in(query->wire, query->size, &query_ctx);
ok(state == NS_PROC_NOOP, "ns: IN/less-than-header query ignored");
/* Finish. */
state = knot_process_finish(&query_ctx);
ok(state == NS_PROC_NOOP, "ns: processing end" );
/* Cleanup. */
mp_delete((struct mempool *)query_ctx.mm.ctx);
server_deinit(&server);
return 0;
}
int main(int argc, char *argv[])
{
plan(8*6 + 4); /* exec_query = 6 TAP tests */
knot_mm_t mm;
mm_ctx_mempool(&mm, MM_DEFAULT_BLKSIZE);
/* Create processing context. */
knot_layer_t proc;
memset(&proc, 0, sizeof(knot_layer_t));
proc.mm = &mm;
/* Create fake server environment. */
server_t server;
int ret = create_fake_server(&server, proc.mm);
ok(ret == KNOT_EOK, "ns: fake server initialization");
zone_t *zone = knot_zonedb_find(server.zone_db, ROOT_DNAME);
/* Prepare. */
knot_pkt_t *query = knot_pkt_new(NULL, KNOT_WIRE_MAX_PKTSIZE, proc.mm);
/* Create query processing parameter. */
struct sockaddr_storage ss;
memset(&ss, 0, sizeof(struct sockaddr_storage));
sockaddr_set(&ss, AF_INET, "127.0.0.1", 53);
struct process_query_param param = {0};
param.remote = &ss;
param.server = &server;
/* Query processor (CH zone) */
knot_layer_begin(&proc, NS_PROC_QUERY, ¶m);
knot_pkt_clear(query);
knot_pkt_put_question(query, IDSERVER_DNAME, KNOT_CLASS_CH, KNOT_RRTYPE_TXT);
exec_query(&proc, "CH TXT", query, KNOT_RCODE_NOERROR);
/* Query processor (valid input). */
knot_layer_reset(&proc);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_SOA);
exec_query(&proc, "IN/root", query, KNOT_RCODE_NOERROR);
/* Query processor (-1 bytes, not enough data). */
knot_layer_reset(&proc);
query->size -= 1;
exec_query(&proc, "IN/few-data", query, KNOT_RCODE_FORMERR);
query->size += 1;
/* Query processor (+1 bytes trailing). */
knot_layer_reset(&proc);
query->wire[query->size] = '\1'; /* Initialize the "garbage" value. */
query->size += 1;
exec_query(&proc, "IN/trail-garbage", query, KNOT_RCODE_FORMERR);
query->size -= 1;
/* Forge NOTIFY query from SOA query. */
knot_layer_reset(&proc);
knot_wire_set_opcode(query->wire, KNOT_OPCODE_NOTIFY);
exec_query(&proc, "IN/notify", query, KNOT_RCODE_NOTAUTH);
/* Forge AXFR query. */
knot_layer_reset(&proc);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_AXFR);
exec_query(&proc, "IN/axfr", query, KNOT_RCODE_NOTAUTH);
/* Forge IXFR query (badly formed, no SOA in AUTHORITY section). */
knot_layer_reset(&proc);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_IXFR);
exec_query(&proc, "IN/ixfr-formerr", query, KNOT_RCODE_FORMERR);
/* Forge IXFR query (well formed). */
knot_layer_reset(&proc);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_IXFR);
/* Append SOA RR. */
knot_rrset_t soa_rr = node_rrset(zone->contents->apex, KNOT_RRTYPE_SOA);
knot_pkt_begin(query, KNOT_AUTHORITY);
knot_pkt_put(query, KNOT_COMPR_HINT_NONE, &soa_rr, 0);
exec_query(&proc, "IN/ixfr", query, KNOT_RCODE_NOTAUTH);
/* \note Tests below are not possible without proper zone and zone data. */
/* #189 Process UPDATE query. */
/* #189 Process AXFR client. */
/* #189 Process IXFR client. */
/* Query processor (smaller than DNS header, ignore). */
knot_layer_reset(&proc);
knot_pkt_clear(query);
knot_pkt_put_question(query, ROOT_DNAME, KNOT_CLASS_IN, KNOT_RRTYPE_SOA);
size_t orig_query_size = query->size;
query->size = KNOT_WIRE_HEADER_SIZE - 1;
int state = knot_layer_consume(&proc, query);
ok(state == KNOT_STATE_NOOP, "ns: IN/less-than-header query ignored");
query->size = orig_query_size;
/* Query processor (response, ignore). */
knot_layer_reset(&proc);
knot_wire_set_qr(query->wire);
state = knot_layer_consume(&proc, query);
ok(state == KNOT_STATE_NOOP, "ns: IN/less-than-header query ignored");
/* Finish. */
state = knot_layer_finish(&proc);
ok(state == KNOT_STATE_NOOP, "ns: processing end" );
/* Cleanup. */
mp_delete((struct mempool *)mm.ctx);
server_deinit(&server);
conf_free(conf());
return 0;
}
