add IPv6 default route interface auto-detection for permanent/temporary IPv6 without netif

- get_default_route_netif_index(): UDP connect trick + getifaddrs to find default route iface
- etcp_socket_add(): auto-detect netif_index when not specified in config
- queue_new() API: explicit index_offset/index_size params instead of implicit from hash_size
- radix: cleanup types (uint8_t*), replace bzero/bcmp with memset/memcmp, remove kernel ifdefs
- route6_lib: new IPv6 routing library + get_node_v6_routes()

lib/Makefile.am

@@ -23,6 +23,8 @@ libuasync_a_SOURCES = \
 	swm_min.h \
 	mem.c \
 	mem.h \
+	radix.c \
+	radix.h \
 	serialize.c \
 	serialize.h
 

lib/ll_queue.c

@@ -51,7 +51,7 @@ static void remove_from_hash(struct ll_queue* q, struct ll_entry* entry);
 
 // ==================== Управление очередью ====================
 
-struct ll_queue* queue_new(struct UASYNC* ua, size_t hash_size, char* name) {
+struct ll_queue* queue_new(struct UASYNC* ua, size_t hash_size, uint16_t index_offset, uint16_t index_size, char* name) {
     if (!ua) return NULL;
     
     struct ll_queue* q = u_calloc(1, sizeof(struct ll_queue));
@@ -61,6 +61,8 @@ struct ll_queue* queue_new(struct UASYNC* ua, size_t hash_size, char* name) {
     q->ua = ua;
     q->size_limit = -1;  // Без ограничения по умолчанию
     q->hash_size = hash_size;
+    q->index_offset = index_offset;
+    q->index_size = index_size;
     
 #ifdef QUEUE_THREAD_CHECK
 #ifdef _WIN32
@@ -225,8 +227,8 @@ void queue_entry_free(struct ll_entry* entry) {
 static void add_to_hash(struct ll_queue* q, struct ll_entry* entry) {
     if (!q || !entry) return;
 
-    if (q->hash_size == 0 || entry->index_size == 0) {
-        DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "[%s] Empty hash_size=%d or index_size=%d",q->name, q->hash_size, entry->index_size);
+    if (q->hash_size == 0 || q->index_size == 0) {
+        DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "[%s] Empty hash_size=%d or index_size=%d",q->name, q->hash_size, q->index_size);
         return;
     }
 
@@ -291,10 +293,6 @@ int queue_data_put(struct ll_queue* q, struct ll_entry* entry) {
     queue_check_thread(q);
 #endif
 
-    entry->index_offset = 0;
-    entry->index_size = 0;
-    entry->index_hash = 0;
-
     if (q->hash_size > 0) {
         DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "[%s] Put no-hash data to hash queue",q->name);
         queue_dgram_free(entry);
@@ -330,23 +328,20 @@ int queue_data_put(struct ll_queue* q, struct ll_entry* entry) {
     return 0;
 }
 
-int queue_data_put_with_index(struct ll_queue* q, struct ll_entry* entry, uint16_t index_offset, uint16_t index_size) {
+int queue_data_put_with_index(struct ll_queue* q, struct ll_entry* entry) {
     if (!q || !entry) return -1;
 #ifdef QUEUE_THREAD_CHECK
     queue_check_thread(q);
 #endif
 
-    if (index_size == 0 || (size_t)index_offset + index_size > (size_t)entry->size) {
-        DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "[%s] invalid index: offset=%u size=%u (data_size=%u)",q->name, index_offset, index_size, entry->size);
+    if (q->index_size == 0 || (size_t)q->index_offset + q->index_size > (size_t)entry->size) {
+        DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "[%s] invalid index: offset=%u size=%u (data_size=%u)",q->name, q->index_offset, q->index_size, entry->size);
         queue_dgram_free(entry);
         queue_entry_free(entry);
         return -1;
     }
 
-    entry->index_offset = index_offset;
-    entry->index_size = index_size;
-
-    entry->index_hash = make_hash(entry->data + index_offset, index_size);
+    entry->index_hash = make_hash(entry->data + q->index_offset, q->index_size);
 
     if (q->size_limit >= 0 && q->count >= q->size_limit) {
         queue_dgram_free(entry);
@@ -382,18 +377,8 @@ int queue_data_put_first(struct ll_queue* q, struct ll_entry* entry) {
     queue_check_thread(q);
 #endif
 
-    entry->index_offset = 0;
-    entry->index_size = 0;
-    entry->index_hash = 0;
-
     if (q->hash_size > 0) {
         DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "[%s] Put no-hash data to hash queue",q->name);
-        queue_dgram_free(entry);
-        queue_entry_free(entry);
-        return -1;
-    }
-
-    if (q->size_limit >= 0 && q->count >= q->size_limit) {
         queue_dgram_free(entry);
         queue_entry_free(entry);   // как было в оригинале
         return -1;
@@ -419,22 +404,20 @@ int queue_data_put_first(struct ll_queue* q, struct ll_entry* entry) {
 }
 
 // С хешем для put_first
-int queue_data_put_first_with_index(struct ll_queue* q, struct ll_entry* entry, uint16_t index_offset, uint16_t index_size) {
+int queue_data_put_first_with_index(struct ll_queue* q, struct ll_entry* entry) {
     if (!q || !entry) return -1;
 #ifdef QUEUE_THREAD_CHECK
     queue_check_thread(q);
 #endif
 
-    if (index_size == 0 || (size_t)index_offset + index_size > (size_t)entry->size) {
-        DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "[%s] invalid index: offset=%u size=%u (data_size=%u)",q->name, index_offset, index_size, entry->size);
+    if (q->index_size == 0 || (size_t)q->index_offset + q->index_size > (size_t)entry->size) {
+        DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "[%s] invalid index: offset=%u size=%u (data_size=%u)",q->name, q->index_offset, q->index_size, entry->size);
         queue_dgram_free(entry);
         queue_entry_free(entry);
         return -1;
     }
 
-    entry->index_offset = index_offset;
-    entry->index_size = index_size;
-    entry->index_hash = make_hash(entry->data + index_offset, index_size);
+    entry->index_hash = make_hash(entry->data + q->index_offset, q->index_size);
 
     if (q->size_limit >= 0 && q->count >= q->size_limit) {
         queue_dgram_free(entry);
@@ -581,18 +564,32 @@ void queue_cancel_wait(struct ll_queue* q, struct queue_waiter* waiter) {
 
 // ==================== Поиск и удаление по ID ====================
 
-struct ll_entry* queue_find_data_by_index(struct ll_queue* q, const void* index_key, uint16_t index_size) {
-    if (!q || q->hash_size == 0 || !q->hash_table || index_size == 0 || !index_key) return NULL;
+struct ll_entry* queue_find_data_by_index(struct ll_queue* q, const void* index_key) {
+    if (!q || q->hash_size == 0 || !q->hash_table || q->index_size == 0 || !index_key) return NULL;
 
-    uint32_t hash_val = make_hash(index_key, index_size);
+    uint32_t hash_val = make_hash(index_key, q->index_size);
 
     uint32_t slot = hash_val % q->hash_size;
     struct ll_entry* entry = q->hash_table[slot];
 
     while (entry) {
-        if (entry->index_size == index_size &&
-            (size_t)entry->index_offset + index_size <= (size_t)entry->size &&
-            memcmp(entry->data + entry->index_offset, index_key, index_size) == 0) {
+        if ((size_t)q->index_offset + q->index_size <= (size_t)entry->size &&
+            memcmp(entry->data + q->index_offset, index_key, q->index_size) == 0) {
+            return entry;
+        }
+        entry = entry->hash_next;
+    }
+    return NULL;
+}
+
+struct ll_entry* queue_find_next_by_index(struct ll_queue* q, const void* index_key,
+                                           struct ll_entry* prev_entry) {
+    if (!q || q->hash_size == 0 || !index_key || q->index_size == 0 || !prev_entry) return NULL;
+
+    struct ll_entry* entry = prev_entry->hash_next;
+    while (entry) {
+        if ((size_t)q->index_offset + q->index_size <= (size_t)entry->size &&
+            memcmp(entry->data + q->index_offset, index_key, q->index_size) == 0) {
             return entry;
         }
         entry = entry->hash_next;

lib/ll_queue.h

@@ -63,8 +63,6 @@ struct ll_entry {
     uint8_t* dgram;                       // Указатель на данные пакета
     void (*dgram_free_fn)(uint8_t* data); // Кастомная функция освобождения dgram
     struct memory_pool* dgram_pool;       // Пул для dgram (если используется)
-    uint16_t index_offset;                // Смещение индекса в data[]
-    uint16_t index_size;                  // Длина индекса (0 = без индекса)
     uint32_t index_hash;                  // Хеш по первым 4 байтам индекса
     struct ll_entry* hash_next;           // Следующий в хеш-цепочке
     struct memory_pool* pool;             // Пул, из которого выделен сам entry (NULL = malloc)
@@ -126,6 +124,8 @@ struct ll_queue {
 
     struct ll_entry** hash_table;   // Хеш-таблица для поиска по id (если hash_size > 0)
     size_t hash_size;               // Размер хеш-таблицы
+    uint16_t index_offset;          // Смещение индекса в data[] (для всех entry очереди)
+    uint16_t index_size;            // Размер индекса (0 = без индекса)
 
 #ifdef QUEUE_THREAD_CHECK
 #ifdef _WIN32
@@ -142,9 +142,12 @@ struct ll_queue {
  * @brief Создаёт новую пустую очередь.
  * @param ua экземпляр uasync (обязателен для отложенного resume коллбэков)
  * @param hash_size размер хеш-таблицы (0 = поиск по id отключён)
+ * @param index_offset смещение ключа индекса в data[] каждого entry (0 если hash_size=0)
+ * @param index_size размер ключа индекса (0 если hash_size=0)
+ * @param name имя очереди для отладки
  * @return указатель на очередь или NULL при ошибке выделения памяти
  */
-struct ll_queue* queue_new(struct UASYNC* ua, size_t hash_size, char* name);
+struct ll_queue* queue_new(struct UASYNC* ua, size_t hash_size, uint16_t index_offset, uint16_t index_size, char* name);
 
 /**
  * @brief Освобождает структуру очереди.
@@ -229,26 +232,20 @@ int queue_data_put(struct ll_queue* q, struct ll_entry* entry);
 int queue_data_put_first(struct ll_queue* q, struct ll_entry* entry);
 
 /**
- * @brief Добавляет элемент в конец очереди с явным указанием смещения индекса для hash.
+ * @brief Добавляет элемент в конец очереди с хеш-индексом (использует index_offset/index_size из очереди).
  * @param q очередь
  * @param entry элемент
- * @param index_offset смещение индекса (node_id) в data[]
- * @param index_size размер индекса (8 для uint64_t node_id)
  * @return 0 — успех, -1 — ошибка
  */
-int queue_data_put_with_index(struct ll_queue* q, struct ll_entry* entry,
-                               uint16_t index_offset, uint16_t index_size);
+int queue_data_put_with_index(struct ll_queue* q, struct ll_entry* entry);
 
 /**
- * @brief Добавляет элемент в начало очереди с явным указанием смещения индекса для hash.
+ * @brief Добавляет элемент в начало очереди с хеш-индексом (использует index_offset/index_size из очереди).
  * @param q очередь
  * @param entry элемент
- * @param index_offset смещение индекса в data[]
- * @param index_size размер индекса
  * @return 0 — успех, -1 — ошибка
  */
-int queue_data_put_first_with_index(struct ll_queue* q, struct ll_entry* entry,
-                                    uint16_t index_offset, uint16_t index_size);
+int queue_data_put_first_with_index(struct ll_queue* q, struct ll_entry* entry);
 
 
 /**
@@ -311,14 +308,24 @@ void queue_dgram_free(struct ll_entry* entry);
 /* ==================== Поиск и удаление ==================== */
 
 /**
- * @brief Находит элемент по идентификатору (требуется hash_size > 0 при создании).
- * @param q очередь
- * @param id искомый идентификатор
+ * @brief Находит элемент по ключу индекса (требуется hash_size > 0 при создании).
+ * @param q очередь (размер ключа берётся из q->index_size)
+ * @param index_key искомый ключ
  * @return элемент или NULL
  */
 struct ll_entry* queue_find_data_by_index(struct ll_queue* q,
-                                          const void* index_key,
-                                          uint16_t index_size);
+                                          const void* index_key);
+
+/**
+ * @brief Находит следующий элемент с тем же ключом (продолжение поиска).
+ * @param q очередь (размер ключа берётся из q->index_size)
+ * @param index_key искомый ключ
+ * @param prev_entry предыдущий найденный элемент (от queue_find_data_by_index или предыдущего queue_find_next_by_index)
+ * @return следующий элемент с тем же ключом или NULL
+ */
+struct ll_entry* queue_find_next_by_index(struct ll_queue* q,
+                                           const void* index_key,
+                                           struct ll_entry* prev_entry);
 
 /**
  * @brief Удаляет элемент из очереди (не освобождает память).

lib/platform_compat.c

@@ -105,6 +105,80 @@ int get_interface_ipv6_by_index(uint32_t netif_index, int temporary, uint8_t* ad
     freeifaddrs(ifaddr);
     return found ? 0 : -1;
 }
+
+uint32_t get_default_route_netif_index(int family) {
+    if (family != AF_INET && family != AF_INET6) return 0;
+
+    int sock = socket(family, SOCK_DGRAM, IPPROTO_UDP);
+    if (sock < 0) return 0;
+
+    struct sockaddr_storage bind_addr;
+    memset(&bind_addr, 0, sizeof(bind_addr));
+    if (family == AF_INET) {
+        struct sockaddr_in* sin = (struct sockaddr_in*)&bind_addr;
+        sin->sin_family = AF_INET;
+        sin->sin_addr.s_addr = INADDR_ANY;
+    } else {
+        struct sockaddr_in6* sin6 = (struct sockaddr_in6*)&bind_addr;
+        sin6->sin6_family = AF_INET6;
+        sin6->sin6_addr = in6addr_any;
+    }
+
+    socklen_t bind_len = (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
+    if (bind(sock, (struct sockaddr*)&bind_addr, bind_len) != 0) { close(sock); return 0; }
+
+    struct sockaddr_storage remote;
+    memset(&remote, 0, sizeof(remote));
+    socklen_t remote_len;
+    if (family == AF_INET) {
+        struct sockaddr_in* sin = (struct sockaddr_in*)&remote;
+        sin->sin_family = AF_INET;
+        sin->sin_port = htons(53);
+        inet_pton(AF_INET, "8.8.8.8", &sin->sin_addr);
+        remote_len = sizeof(struct sockaddr_in);
+    } else {
+        struct sockaddr_in6* sin6 = (struct sockaddr_in6*)&remote;
+        sin6->sin6_family = AF_INET6;
+        sin6->sin6_port = htons(53);
+        inet_pton(AF_INET6, "2001:4860:4860::8888", &sin6->sin6_addr);
+        remote_len = sizeof(struct sockaddr_in6);
+    }
+
+    if (connect(sock, (struct sockaddr*)&remote, remote_len) != 0) { close(sock); return 0; }
+
+    struct sockaddr_storage src;
+    socklen_t src_len = sizeof(src);
+    if (getsockname(sock, (struct sockaddr*)&src, &src_len) != 0) { close(sock); return 0; }
+
+    close(sock);
+
+    struct ifaddrs *ifaddr, *ifa;
+    if (getifaddrs(&ifaddr) == -1) return 0;
+
+    uint32_t result = 0;
+    for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+        if (ifa->ifa_addr == NULL) continue;
+        if (ifa->ifa_addr->sa_family != family) continue;
+        if (family == AF_INET) {
+            struct sockaddr_in* src_sin = (struct sockaddr_in*)&src;
+            struct sockaddr_in* ifa_sin = (struct sockaddr_in*)ifa->ifa_addr;
+            if (src_sin->sin_addr.s_addr == ifa_sin->sin_addr.s_addr) {
+                if (ifa->ifa_name) result = if_nametoindex(ifa->ifa_name);
+                break;
+            }
+        } else {
+            struct sockaddr_in6* src_sin6 = (struct sockaddr_in6*)&src;
+            struct sockaddr_in6* ifa_sin6 = (struct sockaddr_in6*)ifa->ifa_addr;
+            if (memcmp(&src_sin6->sin6_addr, &ifa_sin6->sin6_addr, 16) == 0) {
+                if (ifa->ifa_name) result = if_nametoindex(ifa->ifa_name);
+                break;
+            }
+        }
+    }
+
+    freeifaddrs(ifaddr);
+    return result;
+}
 #else
 uint32_t get_interface_ip_by_index(uint32_t netif_index) {
     (void)netif_index;
@@ -116,4 +190,9 @@ int get_interface_ipv6_by_index(uint32_t netif_index, int temporary, uint8_t* ad
     if (addr_out) memset(addr_out, 0, 16);
     return -1;
 }
+
+uint32_t get_default_route_netif_index(int family) {
+    (void)family;
+    return 0;
+}
 #endif

lib/platform_compat.h

@@ -168,5 +168,10 @@ uint32_t get_interface_ip_by_index(uint32_t netif_index);
 // Returns 0 on success (fills addr_out with 16 bytes), -1 on error or not found
 int get_interface_ipv6_by_index(uint32_t netif_index, int temporary, uint8_t* addr_out);
 
+// Determine the interface index for the default route (outgoing traffic)
+// Creates a temp UDP socket, connects to a well-known address to force
+// kernel routing, then matches the chosen source IP to getifaddrs()
+// family: AF_INET or AF_INET6, returns ifindex (0 on failure)
+uint32_t get_default_route_netif_index(int family);
 
 #endif // PLATFORM_COMPAT_H

lib/radix.c

@@ -32,24 +32,13 @@
 /*
  * Routines to build and maintain radix trees for routing lookups.
  */
-#include <sys/param.h>
-#ifdef	_KERNEL
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/rmlock.h>
-#include <sys/systm.h>
-#include <sys/malloc.h>
-#include <sys/syslog.h>
-#include <net/radix.h>
-#else /* !_KERNEL */
-#include <stdio.h>
-#include <strings.h>
-#include <stdlib.h>
-#define log(x, arg...)	fprintf(stderr, ## arg)
-#define panic(x)	fprintf(stderr, "PANIC: %s", x), exit(1)
-#define min(a, b) ((a) < (b) ? (a) : (b) )
-#include <net/radix.h>
-#endif /* !_KERNEL */
+#include <string.h>
+#include <assert.h>
+#include "mem.h"
+#include "debug_config.h"
+#include "radix.h"
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
 
 static struct radix_node
 	 *rn_insert(void *, struct radix_head *, int *,
@@ -63,19 +52,19 @@ static void rn_detachhead_internal(struct radix_head *);
 
 #define	RADIX_MAX_KEY_LEN	32
 
-static char rn_zeros[RADIX_MAX_KEY_LEN];
-static char rn_ones[RADIX_MAX_KEY_LEN] = {
-	-1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1,
+static uint8_t rn_zeros[RADIX_MAX_KEY_LEN];
+static uint8_t rn_ones[RADIX_MAX_KEY_LEN] = {
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 };
 
 static int	rn_lexobetter(const void *m_arg, const void *n_arg);
 static struct radix_mask *
 		rn_new_radix_mask(struct radix_node *tt,
 		    struct radix_mask *next);
-static int	rn_satisfies_leaf(const char *trial, struct radix_node *leaf,
+static int	rn_satisfies_leaf(const uint8_t *trial, struct radix_node *leaf,
 		    int skip);
 
 /*
@@ -114,35 +103,20 @@ static int	rn_satisfies_leaf(const char *trial, struct radix_node *leaf,
 
 /*
  * Most of the functions in this code assume that the key/mask arguments
- * are sockaddr-like structures, where the first byte is an u_char
+ * are sockaddr-like structures, where the first byte is a uint8_t
  * indicating the size of the entire structure.
  *
  * To make the assumption more explicit, we use the LEN() macro to access
  * this field. It is safe to pass an expression with side effects
  * to LEN() as the argument is evaluated only once.
- * We cast the result to int as this is the dominant usage.
  */
-#define LEN(x) ( (int) (*(const u_char *)(x)) )
+#define LEN(x) ( (int) (*(const uint8_t *)(x)) )
 
-/*
- * XXX THIS NEEDS TO BE FIXED
- * In the code, pointers to keys and masks are passed as either
- * 'void *' (because callers use to pass pointers of various kinds), or
- * 'caddr_t' (which is fine for pointer arithmetics, but not very
- * clean when you dereference it to access data). Furthermore, caddr_t
- * is really 'char *', while the natural type to operate on keys and
- * masks would be 'u_char'. This mismatch require a lot of casts and
- * intermediate variables to adapt types that clutter the code.
- */
-
-/*
- * Search a node in the tree matching the key.
- */
 static struct radix_node *
 rn_search(const void *v_arg, struct radix_node *head)
 {
 	struct radix_node *x;
-	c_caddr_t v;
+	const uint8_t *v;
 
 	for (x = head, v = v_arg; x->rn_bit >= 0;) {
 		if (x->rn_bmask & v[x->rn_offset])
@@ -153,15 +127,11 @@ rn_search(const void *v_arg, struct radix_node *head)
 	return (x);
 }
 
-/*
- * Same as above, but with an additional mask.
- * XXX note this function is used only once.
- */
 static struct radix_node *
 rn_search_m(const void *v_arg, struct radix_node *head, void *m_arg)
 {
 	struct radix_node *x;
-	c_caddr_t v = v_arg, m = m_arg;
+	const uint8_t *v = v_arg, *m = m_arg;
 
 	for (x = head; x->rn_bit >= 0;) {
 		if ((x->rn_bmask & m[x->rn_offset]) &&
@@ -176,8 +146,8 @@ rn_search_m(const void *v_arg, struct radix_node *head, void *m_arg)
 int
 rn_refines(const void *m_arg, const void *n_arg)
 {
-	c_caddr_t m = m_arg, n = n_arg;
-	c_caddr_t lim, lim2 = lim = n + LEN(n);
+	const uint8_t *m = m_arg, *n = n_arg;
+	const uint8_t *lim, *lim2 = lim = n + LEN(n);
 	int longer = LEN(n++) - LEN(m++);
 	int masks_are_equal = 1;
 
@@ -199,22 +169,13 @@ rn_refines(const void *m_arg, const void *n_arg)
 	return (!masks_are_equal);
 }
 
-/*
- * Search for exact match in given @head.
- * Assume host bits are cleared in @v_arg if @m_arg is not NULL
- * Note that prefixes with /32 or /128 masks are treated differently
- * from host routes.
- */
 struct radix_node *
 rn_lookup(const void *v_arg, const void *m_arg, struct radix_head *head)
 {
 	struct radix_node *x;
-	caddr_t netmask;
+	uint8_t *netmask;
 
 	if (m_arg != NULL) {
-		/*
-		 * Most common case: search exact prefix/mask
-		 */
 		x = rn_addmask(m_arg, head->rnh_masks, 1,
 		    head->rnh_treetop->rn_offset);
 		if (x == NULL)
@@ -229,17 +190,12 @@ rn_lookup(const void *v_arg, const void *m_arg, struct radix_head *head)
 		return (x);
 	}
 
-	/*
-	 * Search for host address.
-	 */
 	if ((x = rn_match(v_arg, head)) == NULL)
 		return (NULL);
 
-	/* Check if found key is the same */
-	if (LEN(x->rn_key) != LEN(v_arg) || bcmp(x->rn_key, v_arg, LEN(v_arg)))
+	if (LEN(x->rn_key) != LEN(v_arg) || memcmp(x->rn_key, v_arg, LEN(v_arg)))
 		return (NULL);
 
-	/* Check if this is not host route */
 	if (x->rn_mask != NULL)
 		return (NULL);
 
@@ -247,10 +203,10 @@ rn_lookup(const void *v_arg, const void *m_arg, struct radix_head *head)
 }
 
 static int
-rn_satisfies_leaf(const char *trial, struct radix_node *leaf, int skip)
+rn_satisfies_leaf(const uint8_t *trial, struct radix_node *leaf, int skip)
 {
-	const char *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
-	const char *cplim;
+	const uint8_t *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
+	const uint8_t *cplim;
 	int length = min(LEN(cp), LEN(cp2));
 
 	if (cp3 == NULL)
@@ -264,92 +220,52 @@ rn_satisfies_leaf(const char *trial, struct radix_node *leaf, int skip)
 	return (1);
 }
 
-/*
- * Search for longest-prefix match in given @head
- */
 struct radix_node *
 rn_match(const void *v_arg, struct radix_head *head)
 {
-	c_caddr_t v = v_arg;
+	const uint8_t *v = v_arg;
 	struct radix_node *t = head->rnh_treetop, *x;
-	c_caddr_t cp = v, cp2;
-	c_caddr_t cplim;
+	const uint8_t *cp = v, *cp2;
+	const uint8_t *cplim;
 	struct radix_node *saved_t, *top = t;
 	int off = t->rn_offset, vlen = LEN(cp), matched_off;
 	int test, b, rn_bit;
 
-	/*
-	 * Open code rn_search(v, top) to avoid overhead of extra
-	 * subroutine call.
-	 */
 	for (; t->rn_bit >= 0; ) {
 		if (t->rn_bmask & cp[t->rn_offset])
 			t = t->rn_right;
 		else
 			t = t->rn_left;
 	}
-	/*
-	 * See if we match exactly as a host destination
-	 * or at least learn how many bits match, for normal mask finesse.
-	 *
-	 * It doesn't hurt us to limit how many bytes to check
-	 * to the length of the mask, since if it matches we had a genuine
-	 * match and the leaf we have is the most specific one anyway;
-	 * if it didn't match with a shorter length it would fail
-	 * with a long one.  This wins big for class B&C netmasks which
-	 * are probably the most common case...
-	 */
 	if (t->rn_mask)
-		vlen = *(u_char *)t->rn_mask;
+		vlen = *t->rn_mask;
 	cp += off; cp2 = t->rn_key + off; cplim = v + vlen;
 	for (; cp < cplim; cp++, cp2++)
 		if (*cp != *cp2)
 			goto on1;
-	/*
-	 * This extra grot is in case we are explicitly asked
-	 * to look up the default.  Ugh!
-	 *
-	 * Never return the root node itself, it seems to cause a
-	 * lot of confusion.
-	 */
 	if (t->rn_flags & RNF_ROOT)
 		t = t->rn_dupedkey;
 	return (t);
 on1:
-	test = (*cp ^ *cp2) & 0xff; /* find first bit that differs */
+	test = (*cp ^ *cp2) & 0xff;
 	for (b = 7; (test >>= 1) > 0;)
 		b--;
 	matched_off = cp - v;
 	b += matched_off << 3;
 	rn_bit = -1 - b;
-	/*
-	 * If there is a host route in a duped-key chain, it will be first.
-	 */
 	if ((saved_t = t)->rn_mask == 0)
 		t = t->rn_dupedkey;
 	for (; t; t = t->rn_dupedkey)
-		/*
-		 * Even if we don't match exactly as a host,
-		 * we may match if the leaf we wound up at is
-		 * a route to a net.
-		 */
 		if (t->rn_flags & RNF_NORMAL) {
 			if (rn_bit <= t->rn_bit)
 				return (t);
 		} else if (rn_satisfies_leaf(v, t, matched_off))
 				return (t);
 	t = saved_t;
-	/* start searching up the tree */
 	do {
 		struct radix_mask *m;
 		t = t->rn_parent;
 		m = t->rn_mklist;
-		/*
-		 * If non-contiguous masks ever become important
-		 * we can restore the masking and open coding of
-		 * the search and satisfaction test and put the
-		 * calculation of "off" back before the "do".
-		 */
 		while (m) {
 			if (m->rm_flags & RNF_NORMAL) {
 				if (rn_bit <= m->rm_bit)
@@ -368,10 +284,6 @@ on1:
 	return (0);
 }
 
-/*
- * Returns the next (wider) prefix for the key defined by @rn
- *  if exists.
- */
 struct radix_node *
 rn_nextprefix(struct radix_node *rn)
 {
@@ -382,24 +294,6 @@ rn_nextprefix(struct radix_node *rn)
 	return (NULL);
 }
 
-#ifdef RN_DEBUG
-int	rn_nodenum;
-struct	radix_node *rn_clist;
-int	rn_saveinfo;
-int	rn_debug =  1;
-#endif
-
-/*
- * Whenever we add a new leaf to the tree, we also add a parent node,
- * so we allocate them as an array of two elements: the first one must be
- * the leaf (see RNTORT() in route.c), the second one is the parent.
- * This routine initializes the relevant fields of the nodes, so that
- * the leaf is the left child of the parent node, and both nodes have
- * (almost) all all fields filled as appropriate.
- * (XXX some fields are left unset, see the '#if 0' section).
- * The function returns a pointer to the parent node.
- */
-
 static struct radix_node *
 rn_newpair(void *v, int b, struct radix_node nodes[2])
 {
@@ -408,25 +302,16 @@ rn_newpair(void *v, int b, struct radix_node nodes[2])
 	t->rn_bmask = 0x80 >> (b & 7);
 	t->rn_left = tt;
 	t->rn_offset = b >> 3;
-
-#if 0  /* XXX perhaps we should fill these fields as well. */
 	t->rn_parent = t->rn_right = NULL;
 
+	tt->rn_bit = -1;
 	tt->rn_mask = NULL;
 	tt->rn_dupedkey = NULL;
 	tt->rn_bmask = 0;
-#endif
-	tt->rn_bit = -1;
-	tt->rn_key = (caddr_t)v;
+	tt->rn_key = (uint8_t *)v;
 	tt->rn_parent = t;
 	tt->rn_flags = t->rn_flags = RNF_ACTIVE;
 	tt->rn_mklist = t->rn_mklist = 0;
-#ifdef RN_DEBUG
-	tt->rn_info = rn_nodenum++; t->rn_info = rn_nodenum++;
-	tt->rn_twin = t;
-	tt->rn_ybro = rn_clist;
-	rn_clist = tt;
-#endif
 	return (t);
 }
 
@@ -434,19 +319,16 @@ static struct radix_node *
 rn_insert(void *v_arg, struct radix_head *head, int *dupentry,
     struct radix_node nodes[2])
 {
-	caddr_t v = v_arg;
+	uint8_t *v = v_arg;
 	struct radix_node *top = head->rnh_treetop;
 	int head_off = top->rn_offset, vlen = LEN(v);
 	struct radix_node *t = rn_search(v_arg, top);
-	caddr_t cp = v + head_off;
+	uint8_t *cp = v + head_off;
 	unsigned b;
 	struct radix_node *p, *tt, *x;
-    	/*
-	 * Find first bit at which v and t->rn_key differ
-	 */
-	caddr_t cp2 = t->rn_key + head_off;
+	uint8_t *cp2 = t->rn_key + head_off;
 	int cmp_res;
-	caddr_t cplim = v + vlen;
+	uint8_t *cplim = v + vlen;
 
 	while (cp < cplim)
 		if (*cp2++ != *cp++)
@@ -468,43 +350,35 @@ on1:
 		else
 			x = x->rn_left;
 	} while (b > (unsigned) x->rn_bit);
-				/* x->rn_bit < b && x->rn_bit >= 0 */
-#ifdef RN_DEBUG
-	if (rn_debug)
-		log(LOG_DEBUG, "rn_insert: Going In:\n"), traverse(p);
-#endif
-	t = rn_newpair(v_arg, b, nodes); 
+
+	t = rn_newpair(v_arg, b, nodes);
 	tt = t->rn_left;
 	if ((cp[p->rn_offset] & p->rn_bmask) == 0)
 		p->rn_left = t;
 	else
 		p->rn_right = t;
 	x->rn_parent = t;
-	t->rn_parent = p; /* frees x, p as temp vars below */
+	t->rn_parent = p;
 	if ((cp[t->rn_offset] & t->rn_bmask) == 0) {
 		t->rn_right = x;
 	} else {
 		t->rn_right = tt;
 		t->rn_left = x;
 	}
-#ifdef RN_DEBUG
-	if (rn_debug)
-		log(LOG_DEBUG, "rn_insert: Coming Out:\n"), traverse(p);
-#endif
 	return (tt);
 }
 
 static struct radix_node *
 rn_addmask(const void *n_arg, struct radix_mask_head *maskhead, int search, int skip)
 {
-	const unsigned char *netmask = n_arg;
-	const unsigned char *c, *clim;
-	unsigned char *cp;
+	const uint8_t *netmask = n_arg;
+	const uint8_t *c, *clim;
+	uint8_t *cp;
 	struct radix_node *x;
 	int b = 0, mlen, j;
 	int maskduplicated, isnormal;
 	struct radix_node *saved_x;
-	unsigned char addmask_key[RADIX_MAX_KEY_LEN];
+	uint8_t addmask_key[RADIX_MAX_KEY_LEN];
 
 	if ((mlen = LEN(netmask)) > RADIX_MAX_KEY_LEN)
 		mlen = RADIX_MAX_KEY_LEN;
@@ -513,13 +387,10 @@ rn_addmask(const void *n_arg, struct radix_mask_head *maskhead, int search, int
 	if (mlen <= skip)
 		return (maskhead->mask_nodes);
 
-	bzero(addmask_key, RADIX_MAX_KEY_LEN);
+	memset(addmask_key, 0, RADIX_MAX_KEY_LEN);
 	if (skip > 1)
-		bcopy(rn_ones + 1, addmask_key + 1, skip - 1);
-	bcopy(netmask + skip, addmask_key + skip, mlen - skip);
-	/*
-	 * Trim trailing zeroes.
-	 */
+		memcpy(addmask_key + 1, rn_ones + 1, skip - 1);
+	memcpy(addmask_key + skip, netmask + skip, mlen - skip);
 	for (cp = addmask_key + mlen; (cp > addmask_key) && cp[-1] == 0;)
 		cp--;
 	mlen = cp - addmask_key;
@@ -527,33 +398,25 @@ rn_addmask(const void *n_arg, struct radix_mask_head *maskhead, int search, int
 		return (maskhead->mask_nodes);
 	*addmask_key = mlen;
 	x = rn_search(addmask_key, maskhead->head.rnh_treetop);
-	if (bcmp(addmask_key, x->rn_key, mlen) != 0)
+	if (memcmp(addmask_key, x->rn_key, mlen) != 0)
 		x = NULL;
 	if (x || search)
 		return (x);
 	R_Zalloc(x, struct radix_node *, RADIX_MAX_KEY_LEN + 2 * sizeof (*x));
 	if ((saved_x = x) == NULL)
 		return (0);
-	netmask = cp = (unsigned char *)(x + 2);
-	bcopy(addmask_key, cp, mlen);
+	netmask = cp = (uint8_t *)(x + 2);
+	memcpy(cp, addmask_key, mlen);
 	x = rn_insert(cp, &maskhead->head, &maskduplicated, x);
 	if (maskduplicated) {
-		log(LOG_ERR, "rn_addmask: mask impossibly already in tree");
+		DEBUG_ERROR(DEBUG_CATEGORY_ROUTING, "rn_addmask: mask impossibly already in tree");
 		R_Free(saved_x);
 		return (x);
 	}
-	/*
-	 * Calculate index of mask, and check for normalcy.
-	 * First find the first byte with a 0 bit, then if there are
-	 * more bits left (remember we already trimmed the trailing 0's),
-	 * the bits should be contiguous, otherwise we have got
-	 * a non-contiguous mask.
-	 */
-#define	CONTIG(_c)	(((~(_c) + 1) & (_c)) == (unsigned char)(~(_c) + 1))
+#define	CONTIG(_c)	(((~(_c) + 1) & (_c)) == (uint8_t)(~(_c) + 1))
 	clim = netmask + mlen;
 	isnormal = 1;
-	for (c = netmask + skip; (c < clim) && *(const u_char *)c == 0xff;)
-		c++;
+	for (c = netmask + skip; c < clim && *c == 0xff; c++);
 	if (c != clim) {
 		for (j = 0x80; (j & *c) != 0; j >>= 1)
 			b++;
@@ -567,13 +430,13 @@ rn_addmask(const void *n_arg, struct radix_mask_head *maskhead, int search, int
 	return (x);
 }
 
-static int	/* XXX: arbitrary ordering for non-contiguous masks */
+static int
 rn_lexobetter(const void *m_arg, const void *n_arg)
 {
-	const u_char *mp = m_arg, *np = n_arg, *lim;
+	const uint8_t *mp = m_arg, *np = n_arg, *lim;
 
 	if (LEN(mp) > LEN(np))
-		return (1);  /* not really, but need to check longer one first */
+		return (1);
 	if (LEN(mp) == LEN(np))
 		for (lim = mp + LEN(mp); mp < lim;)
 			if (*mp++ > *np++)
@@ -588,10 +451,10 @@ rn_new_radix_mask(struct radix_node *tt, struct radix_mask *next)
 
 	R_Malloc(m, struct radix_mask *, sizeof (struct radix_mask));
 	if (m == NULL) {
-		log(LOG_ERR, "Failed to allocate route mask\n");
+		DEBUG_ERROR(DEBUG_CATEGORY_ROUTING, "Failed to allocate route mask");
 		return (0);
 	}
-	bzero(m, sizeof(*m));
+	memset(m, 0, sizeof(*m));
 	m->rm_bit = tt->rn_bit;
 	m->rm_flags = tt->rn_flags;
 	if (tt->rn_flags & RNF_NORMAL)
@@ -607,21 +470,14 @@ struct radix_node *
 rn_addroute(void *v_arg, const void *n_arg, struct radix_head *head,
     struct radix_node treenodes[2])
 {
-	caddr_t v = (caddr_t)v_arg, netmask = NULL;
+	uint8_t *v = (uint8_t *)v_arg, *netmask = NULL;
 	struct radix_node *t, *x = NULL, *tt;
 	struct radix_node *saved_tt, *top = head->rnh_treetop;
 	short b = 0, b_leaf = 0;
 	int keyduplicated;
-	caddr_t mmask;
+	uint8_t *mmask;
 	struct radix_mask *m, **mp;
 
-	/*
-	 * In dealing with non-contiguous masks, there may be
-	 * many different routes which have the same mask.
-	 * We will find it useful to have a unique pointer to
-	 * the mask to speed avoiding duplicate references at
-	 * nodes and possibly save time in calculating indices.
-	 */
 	if (n_arg)  {
 		x = rn_addmask(n_arg, head->rnh_masks, 0, top->rn_offset);
 		if (x == NULL)
@@ -630,9 +486,6 @@ rn_addroute(void *v_arg, const void *n_arg, struct radix_head *head,
 		b = -1 - x->rn_bit;
 		netmask = x->rn_key;
 	}
-	/*
-	 * Deal with duplicated keys: attach node to previous instance
-	 */
 	saved_tt = tt = rn_insert(v, head, &keyduplicated, treenodes);
 	if (keyduplicated) {
 		for (t = tt; tt; t = tt, tt = tt->rn_dupedkey) {
@@ -640,31 +493,17 @@ rn_addroute(void *v_arg, const void *n_arg, struct radix_head *head,
 				return (0);
 			if (netmask == 0 ||
 			    (tt->rn_mask &&
-			     ((b_leaf < tt->rn_bit) /* index(netmask) > node */
+			     ((b_leaf < tt->rn_bit)
 			      || rn_refines(netmask, tt->rn_mask)
 			      || rn_lexobetter(netmask, tt->rn_mask))))
 				break;
 		}
-		/*
-		 * If the mask is not duplicated, we wouldn't
-		 * find it among possible duplicate key entries
-		 * anyway, so the above test doesn't hurt.
-		 *
-		 * We sort the masks for a duplicated key the same way as
-		 * in a masklist -- most specific to least specific.
-		 * This may require the unfortunate nuisance of relocating
-		 * the head of the list.
-		 *
-		 * We also reverse, or doubly link the list through the
-		 * parent pointer.
-		 */
 		if (tt == saved_tt) {
 			struct	radix_node *xx = x;
-			/* link in at head of list */
 			(tt = treenodes)->rn_dupedkey = t;
 			tt->rn_flags = t->rn_flags;
 			tt->rn_parent = x = t->rn_parent;
-			t->rn_parent = tt;	 		/* parent */
+			t->rn_parent = tt;
 			if (x->rn_left == t)
 				x->rn_left = tt;
 			else
@@ -673,21 +512,14 @@ rn_addroute(void *v_arg, const void *n_arg, struct radix_head *head,
 		} else {
 			(tt = treenodes)->rn_dupedkey = t->rn_dupedkey;
 			t->rn_dupedkey = tt;
-			tt->rn_parent = t;			/* parent */
-			if (tt->rn_dupedkey)			/* parent */
-				tt->rn_dupedkey->rn_parent = tt; /* parent */
+			tt->rn_parent = t;
+			if (tt->rn_dupedkey)
+				tt->rn_dupedkey->rn_parent = tt;
 		}
-#ifdef RN_DEBUG
-		t=tt+1; tt->rn_info = rn_nodenum++; t->rn_info = rn_nodenum++;
-		tt->rn_twin = t; tt->rn_ybro = rn_clist; rn_clist = tt;
-#endif
-		tt->rn_key = (caddr_t) v;
+		tt->rn_key = (uint8_t *) v;
 		tt->rn_bit = -1;
 		tt->rn_flags = RNF_ACTIVE;
 	}
-	/*
-	 * Put mask in tree.
-	 */
 	if (netmask) {
 		tt->rn_mask = netmask;
 		tt->rn_bit = x->rn_bit;
@@ -701,7 +533,6 @@ rn_addroute(void *v_arg, const void *n_arg, struct radix_head *head,
 		x = t->rn_left;
 	else
 		x = t->rn_right;
-	/* Promote general routes from below */
 	if (x->rn_bit < 0) {
 	    for (mp = &t->rn_mklist; x; x = x->rn_dupedkey)
 		if (x->rn_mask && (x->rn_bit >= b_leaf) && x->rn_mklist == 0) {
@@ -710,29 +541,19 @@ rn_addroute(void *v_arg, const void *n_arg, struct radix_head *head,
 				mp = &m->rm_mklist;
 		}
 	} else if (x->rn_mklist) {
-		/*
-		 * Skip over masks whose index is > that of new node
-		 */
 		for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
 			if (m->rm_bit >= b_leaf)
 				break;
 		t->rn_mklist = m; *mp = NULL;
 	}
 on2:
-	/* Add new route to highest possible ancestor's list */
 	if ((netmask == 0) || (b > t->rn_bit ))
-		return (tt); /* can't lift at all */
+		return (tt);
 	b_leaf = tt->rn_bit;
 	do {
 		x = t;
 		t = t->rn_parent;
 	} while (b <= t->rn_bit && x != top);
-	/*
-	 * Search through routes associated with node to
-	 * insert new route according to index.
-	 * Need same criteria as when sorting dupedkeys to avoid
-	 * double loop on deletion.
-	 */
 	for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist) {
 		if (m->rm_bit < b_leaf)
 			continue;
@@ -741,8 +562,8 @@ on2:
 		if (m->rm_flags & RNF_NORMAL) {
 			mmask = m->rm_leaf->rn_mask;
 			if (tt->rn_flags & RNF_NORMAL) {
-			    log(LOG_ERR,
-			        "Non-unique normal route, mask not entered\n");
+			    DEBUG_ERROR(DEBUG_CATEGORY_ROUTING,
+			        "Non-unique normal route, mask not entered");
 				return (tt);
 			}
 		} else
@@ -766,8 +587,8 @@ rn_delete(const void *v_arg, const void *netmask_arg, struct radix_head *head)
 	struct radix_node *t, *p, *x, *tt;
 	struct radix_mask *m, *saved_m, **mp;
 	struct radix_node *dupedkey, *saved_tt, *top;
-	c_caddr_t v;
-	c_caddr_t netmask;
+	const uint8_t *v;
+	const uint8_t *netmask;
 	int b, head_off, vlen;
 
 	v = v_arg;
@@ -779,11 +600,8 @@ rn_delete(const void *v_arg, const void *netmask_arg, struct radix_head *head)
 	saved_tt = tt;
 	top = x;
 	if (tt == NULL ||
-	    bcmp(v + head_off, tt->rn_key + head_off, vlen - head_off))
+	    memcmp(v + head_off, tt->rn_key + head_off, vlen - head_off))
 		return (0);
-	/*
-	 * Delete our route from mask lists.
-	 */
 	if (netmask) {
 		x = rn_addmask(netmask, head->rnh_masks, 1, head_off);
 		if (x == NULL)
@@ -797,12 +615,12 @@ rn_delete(const void *v_arg, const void *netmask_arg, struct radix_head *head)
 		goto on1;
 	if (tt->rn_flags & RNF_NORMAL) {
 		if (m->rm_leaf != tt || m->rm_refs > 0) {
-			log(LOG_ERR, "rn_delete: inconsistent annotation\n");
-			return (0);  /* dangling ref could cause disaster */
+			DEBUG_ERROR(DEBUG_CATEGORY_ROUTING, "rn_delete: inconsistent annotation");
+			return (0);
 		}
 	} else {
 		if (m->rm_mask != tt->rn_mask) {
-			log(LOG_ERR, "rn_delete: inconsistent annotation\n");
+			DEBUG_ERROR(DEBUG_CATEGORY_ROUTING, "rn_delete: inconsistent annotation");
 			goto on1;
 		}
 		if (--m->rm_refs >= 0)
@@ -811,7 +629,7 @@ rn_delete(const void *v_arg, const void *netmask_arg, struct radix_head *head)
 	b = -1 - tt->rn_bit;
 	t = saved_tt->rn_parent;
 	if (b > t->rn_bit)
-		goto on1; /* Wasn't lifted at all */
+		goto on1;
 	do {
 		x = t;
 		t = t->rn_parent;
@@ -823,57 +641,35 @@ rn_delete(const void *v_arg, const void *netmask_arg, struct radix_head *head)
 			break;
 		}
 	if (m == NULL) {
-		log(LOG_ERR, "rn_delete: couldn't find our annotation\n");
+		DEBUG_ERROR(DEBUG_CATEGORY_ROUTING, "rn_delete: couldn't find our annotation");
 		if (tt->rn_flags & RNF_NORMAL)
-			return (0); /* Dangling ref to us */
+			return (0);
 	}
 on1:
-	/*
-	 * Eliminate us from tree
-	 */
 	if (tt->rn_flags & RNF_ROOT)
 		return (0);
-#ifdef RN_DEBUG
-	/* Get us out of the creation list */
-	for (t = rn_clist; t && t->rn_ybro != tt; t = t->rn_ybro) {}
-	if (t) t->rn_ybro = tt->rn_ybro;
-#endif
 	t = tt->rn_parent;
 	dupedkey = saved_tt->rn_dupedkey;
 	if (dupedkey) {
-		/*
-		 * Here, tt is the deletion target and
-		 * saved_tt is the head of the dupekey chain.
-		 */
 		if (tt == saved_tt) {
-			/* remove from head of chain */
 			x = dupedkey; x->rn_parent = t;
 			if (t->rn_left == tt)
 				t->rn_left = x;
 			else
 				t->rn_right = x;
 		} else {
-			/* find node in front of tt on the chain */
 			for (x = p = saved_tt; p && p->rn_dupedkey != tt;)
 				p = p->rn_dupedkey;
 			if (p) {
 				p->rn_dupedkey = tt->rn_dupedkey;
-				if (tt->rn_dupedkey)		/* parent */
+				if (tt->rn_dupedkey)
 					tt->rn_dupedkey->rn_parent = p;
-								/* parent */
-			} else log(LOG_ERR, "rn_delete: couldn't find us\n");
+			} else DEBUG_ERROR(DEBUG_CATEGORY_ROUTING, "rn_delete: couldn't find us");
 		}
 		t = tt + 1;
 		if  (t->rn_flags & RNF_ACTIVE) {
-#ifndef RN_DEBUG
 			*++x = *t;
 			p = t->rn_parent;
-#else
-			b = t->rn_info;
-			*++x = *t;
-			t->rn_info = b;
-			p = t->rn_parent;
-#endif
 			if (p->rn_left == t)
 				p->rn_left = x;
 			else
@@ -893,18 +689,12 @@ on1:
 	else
 		p->rn_left = x;
 	x->rn_parent = p;
-	/*
-	 * Demote routes attached to us.
-	 */
 	if (t->rn_mklist) {
 		if (x->rn_bit >= 0) {
 			for (mp = &x->rn_mklist; (m = *mp);)
 				mp = &m->rm_mklist;
 			*mp = t->rn_mklist;
 		} else {
-			/* If there are any key,mask pairs in a sibling
-			   duped-key chain, some subset will appear sorted
-			   in the same order attached to our mklist */
 			for (m = t->rn_mklist; m && x; x = x->rn_dupedkey)
 				if (m == x->rn_mklist) {
 					struct radix_mask *mm = m->rm_mklist;
@@ -914,23 +704,13 @@ on1:
 					m = mm;
 				}
 			if (m)
-				log(LOG_ERR,
-				    "rn_delete: Orphaned Mask %p at %p\n",
-				    m, x);
+				DEBUG_ERROR(DEBUG_CATEGORY_ROUTING,
+				    "rn_delete: Orphaned Mask %p at %p", m, x);
 		}
 	}
-	/*
-	 * We may be holding an active internal node in the tree.
-	 */
 	x = tt + 1;
 	if (t != x) {
-#ifndef RN_DEBUG
 		*t = *x;
-#else
-		b = t->rn_info;
-		*t = *x;
-		t->rn_info = b;
-#endif
 		t->rn_left->rn_parent = t;
 		t->rn_right->rn_parent = t;
 		p = x->rn_parent;
@@ -945,111 +725,62 @@ out:
 	return (tt);
 }
 
-/*
- * This is the same as rn_walktree() except for the parameters and the
- * exit.
- */
 int
 rn_walktree_from(struct radix_head *h, void *a, void *m,
     walktree_f_t *f, void *w)
 {
 	int error;
 	struct radix_node *base, *next;
-	u_char *xa = (u_char *)a;
-	u_char *xm = (u_char *)m;
-	struct radix_node *rn, *last = NULL; /* shut up gcc */
+	uint8_t *xa = (uint8_t *)a;
+	uint8_t *xm = (uint8_t *)m;
+	struct radix_node *rn, *last = NULL;
 	int stopping = 0;
 	int lastb;
 
-	KASSERT(m != NULL, ("%s: mask needs to be specified", __func__));
+	assert(m != NULL);
 
-	/*
-	 * rn_search_m is sort-of-open-coded here. We cannot use the
-	 * function because we need to keep track of the last node seen.
-	 */
-	/* printf("about to search\n"); */
 	for (rn = h->rnh_treetop; rn->rn_bit >= 0; ) {
 		last = rn;
-		/* printf("rn_bit %d, rn_bmask %x, xm[rn_offset] %x\n",
-		       rn->rn_bit, rn->rn_bmask, xm[rn->rn_offset]); */
-		if (!(rn->rn_bmask & xm[rn->rn_offset])) {
+		if (!(rn->rn_bmask & xm[rn->rn_offset]))
 			break;
-		}
-		if (rn->rn_bmask & xa[rn->rn_offset]) {
+		if (rn->rn_bmask & xa[rn->rn_offset])
 			rn = rn->rn_right;
-		} else {
+		else
 			rn = rn->rn_left;
-		}
 	}
-	/* printf("done searching\n"); */
 
-	/*
-	 * Two cases: either we stepped off the end of our mask,
-	 * in which case last == rn, or we reached a leaf, in which
-	 * case we want to start from the leaf.
-	 */
 	if (rn->rn_bit >= 0)
 		rn = last;
 	lastb = last->rn_bit;
 
-	/* printf("rn %p, lastb %d\n", rn, lastb);*/
-
-	/*
-	 * This gets complicated because we may delete the node
-	 * while applying the function f to it, so we need to calculate
-	 * the successor node in advance.
-	 */
 	while (rn->rn_bit >= 0)
 		rn = rn->rn_left;
 
 	while (!stopping) {
-		/* printf("node %p (%d)\n", rn, rn->rn_bit); */
 		base = rn;
-		/* If at right child go back up, otherwise, go right */
 		while (rn->rn_parent->rn_right == rn
 		       && !(rn->rn_flags & RNF_ROOT)) {
 			rn = rn->rn_parent;
-
-			/* if went up beyond last, stop */
-			if (rn->rn_bit <= lastb) {
+			if (rn->rn_bit <= lastb)
 				stopping = 1;
-				/* printf("up too far\n"); */
-				/*
-				 * XXX we should jump to the 'Process leaves'
-				 * part, because the values of 'rn' and 'next'
-				 * we compute will not be used. Not a big deal
-				 * because this loop will terminate, but it is
-				 * inefficient and hard to understand!
-				 */
-			}
 		}
-		
-		/* 
-		 * At the top of the tree, no need to traverse the right
-		 * half, prevent the traversal of the entire tree in the
-		 * case of default route.
-		 */
+
 		if (rn->rn_parent->rn_flags & RNF_ROOT)
 			stopping = 1;
 
-		/* Find the next *leaf* since next node might vanish, too */
 		for (rn = rn->rn_parent->rn_right; rn->rn_bit >= 0;)
 			rn = rn->rn_left;
 		next = rn;
-		/* Process leaves */
 		while ((rn = base) != NULL) {
 			base = rn->rn_dupedkey;
-			/* printf("leaf %p\n", rn); */
 			if (!(rn->rn_flags & RNF_ROOT)
 			    && (error = (*f)(rn, w)))
 				return (error);
 		}
 		rn = next;
 
-		if (rn->rn_flags & RNF_ROOT) {
-			/* printf("root, stopping"); */
+		if (rn->rn_flags & RNF_ROOT)
 			stopping = 1;
-		}
 	}
 	return (0);
 }
@@ -1060,26 +791,17 @@ rn_walktree(struct radix_head *h, walktree_f_t *f, void *w)
 	int error;
 	struct radix_node *base, *next;
 	struct radix_node *rn = h->rnh_treetop;
-	/*
-	 * This gets complicated because we may delete the node
-	 * while applying the function f to it, so we need to calculate
-	 * the successor node in advance.
-	 */
 
-	/* First time through node, go left */
 	while (rn->rn_bit >= 0)
 		rn = rn->rn_left;
 	for (;;) {
 		base = rn;
-		/* If at right child go back up, otherwise, go right */
 		while (rn->rn_parent->rn_right == rn
 		       && (rn->rn_flags & RNF_ROOT) == 0)
 			rn = rn->rn_parent;
-		/* Find the next *leaf* since next node might vanish, too */
 		for (rn = rn->rn_parent->rn_right; rn->rn_bit >= 0;)
 			rn = rn->rn_left;
 		next = rn;
-		/* Process leaves */
 		while ((rn = base)) {
 			base = rn->rn_dupedkey;
 			if (!(rn->rn_flags & RNF_ROOT)
@@ -1090,16 +812,8 @@ rn_walktree(struct radix_head *h, walktree_f_t *f, void *w)
 		if (rn->rn_flags & RNF_ROOT)
 			return (0);
 	}
-	/* NOTREACHED */
 }
 
-/*
- * Initialize an empty tree. This has 3 nodes, which are passed
- * via base_nodes (in the order <left,root,right>) and are
- * marked RNF_ROOT so they cannot be freed.
- * The leaves have all-zero and all-one keys, with significant
- * bits starting at 'off'.
- */
 void
 rn_inithead_internal(struct radix_head *rh, struct radix_node *base_nodes, int off)
 {
@@ -1109,7 +823,7 @@ rn_inithead_internal(struct radix_head *rh, struct radix_node *base_nodes, int o
 	ttt = base_nodes + 2;
 	t->rn_right = ttt;
 	t->rn_parent = t;
-	tt = t->rn_left;	/* ... which in turn is base_nodes */
+	tt = t->rn_left;
 	tt->rn_flags = t->rn_flags = RNF_ROOT | RNF_ACTIVE;
 	tt->rn_bit = -1 - off;
 	*ttt = *tt;
@@ -1121,16 +835,10 @@ rn_inithead_internal(struct radix_head *rh, struct radix_node *base_nodes, int o
 static void
 rn_detachhead_internal(struct radix_head *head)
 {
-
-	KASSERT((head != NULL),
-	    ("%s: head already freed", __func__));
-
-	/* Free <left,root,right> nodes. */
+	assert(head != NULL);
 	R_Free(head);
 }
 
-/* Functions used by 'struct radix_node_head' users */
-
 int
 rn_inithead(void **head, int off)
 {
@@ -1153,13 +861,11 @@ rn_inithead(void **head, int off)
 		return (0);
 	}
 
-	/* Init trees */
 	rn_inithead_internal(&rnh->rh, rnh->rnh_nodes, off);
 	rn_inithead_internal(&rmh->head, rmh->mask_nodes, 0);
 	*head = rnh;
 	rnh->rh.rnh_masks = rmh;
 
-	/* Finally, set base callbacks */
 	rnh->rnh_addaddr = rn_addroute;
 	rnh->rnh_deladdr = rn_delete;
 	rnh->rnh_matchaddr = rn_match;
@@ -1187,9 +893,7 @@ rn_detachhead(void **head)
 {
 	struct radix_node_head *rnh;
 
-	KASSERT((head != NULL && *head != NULL),
-	    ("%s: head already freed", __func__));
-
+	assert(head != NULL && *head != NULL);
 	rnh = (struct radix_node_head *)(*head);
 
 	rn_walktree(&rnh->rh.rnh_masks->head, rn_freeentry, rnh->rh.rnh_masks);

lib/radix.h

@@ -32,15 +32,8 @@
 #ifndef _RADIX_H_
 #define	_RADIX_H_
 
-#ifdef _KERNEL
-#include <sys/_lock.h>
-#include <sys/_mutex.h>
-#include <sys/_rmlock.h>
-#endif
-
-#ifdef MALLOC_DECLARE
-MALLOC_DECLARE(M_RTABLE);
-#endif
+#include <stdint.h>
+#include "mem.h"
 
 /*
  * Radix search tree node layout.
@@ -51,14 +44,14 @@ struct radix_node {
 	struct	radix_node *rn_parent;	/* parent */
 	short	rn_bit;			/* bit offset; -1-index(netmask) */
 	char	rn_bmask;		/* node: mask for bit test*/
-	u_char	rn_flags;		/* enumerated next */
+	uint8_t	rn_flags;		/* enumerated next */
 #define RNF_NORMAL	1		/* leaf contains normal route */
 #define RNF_ROOT	2		/* leaf is root leaf for tree */
 #define RNF_ACTIVE	4		/* This node is alive (for rtfree) */
 	union {
 		struct {			/* leaf only data: */
-			caddr_t	rn_Key;		/* object of search */
-			caddr_t	rn_Mask;	/* netmask, if present */
+			uint8_t	*rn_Key;	/* object of search */
+			uint8_t	*rn_Mask;	/* netmask, if present */
 			struct	radix_node *rn_Dupedkey;
 		} rn_leaf;
 		struct {			/* node only data: */
@@ -67,11 +60,6 @@ struct radix_node {
 			struct	radix_node *rn_R;/* progeny */
 		} rn_node;
 	}		rn_u;
-#ifdef RN_DEBUG
-	int rn_info;
-	struct radix_node *rn_twin;
-	struct radix_node *rn_ybro;
-#endif
 };
 
 #define	rn_dupedkey	rn_u.rn_leaf.rn_Dupedkey
@@ -88,10 +76,10 @@ struct radix_node {
 struct radix_mask {
 	short	rm_bit;			/* bit offset; -1-index(netmask) */
 	char	rm_unused;		/* cf. rn_bmask */
-	u_char	rm_flags;		/* cf. rn_flags */
+	uint8_t	rm_flags;		/* cf. rn_flags */
 	struct	radix_mask *rm_mklist;	/* more masks to try */
 	union	{
-		caddr_t	rmu_mask;		/* the mask */
+		uint8_t	*rmu_mask;	/* the mask */
 		struct	radix_node *rmu_leaf;	/* for normal routes */
 	}	rm_rmu;
 	int	rm_refs;		/* # of references to this struct */
@@ -135,9 +123,6 @@ struct radix_node_head {
 	rn_walktree_from_t	*rnh_walktree_from; /* traverse tree below a */
 	rn_close_t	*rnh_close;	/*do something when the last ref drops*/
 	struct	radix_node rnh_nodes[3];	/* empty tree for common case */
-#ifdef _KERNEL
-	struct	rmlock rnh_lock;		/* locks entire radix tree */
-#endif
 };
 
 struct radix_mask_head {
@@ -148,28 +133,20 @@ struct radix_mask_head {
 void rn_inithead_internal(struct radix_head *rh, struct radix_node *base_nodes,
     int off);
 
-#ifndef _KERNEL
-#define R_Malloc(p, t, n) (p = (t) malloc((unsigned int)(n)))
-#define R_Zalloc(p, t, n) (p = (t) calloc(1,(unsigned int)(n)))
-#define R_Free(p) free((char *)p);
-#else
-#define R_Malloc(p, t, n) (p = (t) malloc((unsigned long)(n), M_RTABLE, M_NOWAIT))
-#define R_Zalloc(p, t, n) (p = (t) malloc((unsigned long)(n), M_RTABLE, M_NOWAIT | M_ZERO))
-#define R_Free(p) free((caddr_t)p, M_RTABLE);
+#define R_Malloc(p, t, n) (p = (t) u_malloc((unsigned int)(n)))
+#define R_Zalloc(p, t, n) (p = (t) u_calloc(1, (unsigned int)(n)))
+#define R_Free(p) u_free(p)
 
-#define	RADIX_NODE_HEAD_RLOCK_TRACKER	struct rm_priotracker _rnh_tracker
-#define	RADIX_NODE_HEAD_LOCK_INIT(rnh)	\
-    rm_init(&(rnh)->rnh_lock, "radix node head")
-#define	RADIX_NODE_HEAD_LOCK(rnh)	rm_wlock(&(rnh)->rnh_lock)
-#define	RADIX_NODE_HEAD_UNLOCK(rnh)	rm_wunlock(&(rnh)->rnh_lock)
-#define	RADIX_NODE_HEAD_RLOCK(rnh)	rm_rlock(&(rnh)->rnh_lock,\
-    &_rnh_tracker)
-#define	RADIX_NODE_HEAD_RUNLOCK(rnh)	rm_runlock(&(rnh)->rnh_lock,\
-    &_rnh_tracker)
-#define	RADIX_NODE_HEAD_DESTROY(rnh)	rm_destroy(&(rnh)->rnh_lock)
-#define	RADIX_NODE_HEAD_LOCK_ASSERT(rnh) rm_assert(&(rnh)->rnh_lock, RA_LOCKED)
-#define	RADIX_NODE_HEAD_WLOCK_ASSERT(rnh) rm_assert(&(rnh)->rnh_lock, RA_WLOCKED)
-#endif /* _KERNEL */
+/* Stub lock macros — single-threaded with u_async */
+#define	RADIX_NODE_HEAD_RLOCK_TRACKER
+#define	RADIX_NODE_HEAD_LOCK_INIT(rnh)
+#define	RADIX_NODE_HEAD_LOCK(rnh)
+#define	RADIX_NODE_HEAD_UNLOCK(rnh)
+#define	RADIX_NODE_HEAD_RLOCK(rnh)
+#define	RADIX_NODE_HEAD_RUNLOCK(rnh)
+#define	RADIX_NODE_HEAD_DESTROY(rnh)
+#define	RADIX_NODE_HEAD_LOCK_ASSERT(rnh)
+#define	RADIX_NODE_HEAD_WLOCK_ASSERT(rnh)
 
 int	 rn_inithead(void **, int);
 int	 rn_detachhead(void **);