Packet Api Rewrite

So, here it is #8 (closed) and more in the wiki page. It's a lot of code, but feel free to ask anything.

Here's the general overview of the state of things:

• Packet API
  • Streamlined, compression reworked, checks in one place, ...
• Query processing
  • Basically everything from the old name-server.c was remade so it stacks
  1. name-server.h and the ns_proc_* API, which is an API for a state machine that just accepts wireformat and does all the conversions between parsed packets and backwards.
  2. ns_proc_query.h is the implementation of query processing and implements the ns_proc_* API
  • It serves as a generic query -> response machine using solvers.
  • It also covers transaction security and stuff, so the solvers don't need to worry about this.
  3. internet.h, chaos.h, axfr.h, ixfr.h, update.h, notify.h
  • Solver implementations for various queries
    • IN answers / DNSSEC proofs are now RFC compliant in several cases
    • Transfers now also show message and byte counts
  • Since all the bitpushing is done by the upper layers, they just do answer solving
• UDP & TCP handlers
  • Simplified, using memory context for query processing
  • TCP threads are now coherent, no through-the-pipe "fair" queueing
• XFR handler is simplified as well (all threads coherent)
• Basic unit tests for packet, query processing and stuff
• I don't know what else, just ask.

Pitfalls

• UPDATE forwarding is disabled until #189 (closed) is finished, as to not create more duplicated code and this is already complex enough.

Review

0.0% src/knot/ 0.0% src/knot/conf/ 0.0% src/knot/stat/ 0.0% src/libknot/dnssec/ 0.0% tests-extra/data/ 0.0% tests-extra/tests/basic/nsec/ 0.0% tests-extra/tests/basic/nsec3/ 0.0% tests-extra/tests/security/protos/ 0.1% src/ 0.4% src/utils/nsupdate/ 0.7% src/common/ 1.2% src/utils/dig/ 1.4% src/utils/common/ 1.5% src/libknot/ 1.8% src/knot/ctl/ 2.3% src/libknot/zone/ 3.1% src/libknot/updates/ 3.5% tests/ 4.2% src/libknot/util/ 15.5% src/knot/server/ 25.4% src/libknot/packet/ 37.8% src/libknot/nameserver/ (with the exception of nsec3_proofs)

src/common/acl.c

@@ -26,6 +26,7 @@
#include "common/errcode.h"
#include "common/acl.h"
#include "libknot/util/endian.h"
+#include "libknot/tsig.h"
static inline uint32_t ipv4_chunk(const sockaddr_t *a)
{
@@ -81,7 +82,7 @@ static uint32_t acl_fill_mask32(short nbits)
return htonl(r);
}
-static int acl_compare(const sockaddr_t *a1, const sockaddr_t *a2)
+static int addr_match(const sockaddr_t *a1, const sockaddr_t *a2)
{
int ret = 0;
uint32_t mask = 0xffffffff;
@@ -141,55 +142,27 @@ void acl_delete(acl_t **acl)
*acl = 0;
}
-int acl_insert(acl_t *acl, const sockaddr_t *addr, void *val)
+int acl_insert(acl_t *acl, const sockaddr_t *addr, knot_tsig_key_t *key)
{
if (acl == NULL || addr == NULL) {
return KNOT_EINVAL;
}
/* Create new match. */
-	acl_match_t *key = malloc(sizeof(acl_match_t));
-	if (key == NULL) {
+	acl_match_t *match = malloc(sizeof(acl_match_t));
+	if (match == NULL) {
return KNOT_ENOMEM;
}
-	memcpy(&key->addr, addr, sizeof(sockaddr_t));
-	key->val = val;
-
-	/* Sort by prefix length.
-	 * This way the longest prefix match always goes first.
-	 */
-	if (EMPTY_LIST(*acl)) {
-		add_head(acl, &key->n);
-	} else {
-		bool inserted = false;
-		acl_match_t *cur = NULL, *prev = NULL;
-		WALK_LIST(cur, *acl) {
-			/* Next node prefix is equal/shorter than current key.
-			 * This means we need to insert before the next node.
-			 */
-			if (cur->addr.prefix < addr->prefix) {
-				if (prev == NULL) { /* First node. */
-					add_head(acl, &key->n);
-				} else {
-					insert_node(&key->n, &prev->n);
-				}
-				inserted = true;
-				break;
-			}
-			prev = cur;
-		}
-		/* Didn't find any better fit, insert at the end. */
-		if (!inserted) {
-			add_tail(acl, &key->n);
-		}
-	}
+	sockaddr_copy(&match->addr, addr);
+	match->key = key;
+	add_tail(acl, &match->n);
return KNOT_EOK;
}
-acl_match_t* acl_find(acl_t *acl, const sockaddr_t *addr)
+acl_match_t* acl_find(acl_t *acl, const sockaddr_t *addr, const knot_dname_t *key_name)
{
if (acl == NULL || addr == NULL) {
return NULL;
@@ -197,11 +170,25 @@ acl_match_t* acl_find(acl_t *acl, const sockaddr_t *addr)
acl_match_t *cur = NULL;
WALK_LIST(cur, *acl) {
-		/* Since the list is sorted by prefix length, the first match
-		 * is guaranteed to be longest prefix match (most precise).
-		 */
-		if (acl_compare(&cur->addr, addr) == 0) {
-			return cur;
+		if (addr_match(&cur->addr, addr) == 0) {
+			/* NOKEY entry. */
+			if (cur->key == NULL) {
+				if (key_name == NULL) {
+					return cur;
+				}
+				/* NOKEY entry, but key provided. */
+				continue;
+			}
+			
+			/* NOKEY provided, but key required. */
+			if (key_name == NULL) {
+				continue;
+			}
+
+			/* Key name match. */
+			if (knot_dname_is_equal(cur->key->name, key_name)) {
+				return cur;
+			}
}
}