@velox0/cerver 0.4.1 → 0.4.3

package/runtime/router.c

@@ -11,6 +11,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <strings.h>
 
 /* ------------------------------------------------------------------ */
 /*  Request accessor helpers                                          */
@@ -18,8 +19,15 @@
 
 const char* cerver_req_param(const cerver_request_t* req, const char* key) {
   for (int i = 0; i < req->params_count; i++) {
-    if (strcmp(req->params[i].key, key) == 0) {
-      return req->params[i].value;
+    const char* pkey = req->params[i].key;
+    if (pkey && pkey[0] == key[0]) {
+      int j = 0;
+      while (key[j] && pkey[j] == key[j]) {
+        j++;
+      }
+      if (key[j] == '\0' && (pkey[j] == '\0' || pkey[j] == '/')) {
+        return req->params[i].value;
+      }
     }
   }
   return "";
@@ -84,7 +92,7 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
   }
 
   const char* pattern = route->pattern;
-  const char* path = req->path;
+  const char* path    = req->path;
 
   /* Fast path: exact match */
   if (strcmp(pattern, path) == 0) {
@@ -101,6 +109,8 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
   const char* rp = path;    /* request path pointer */
 
   int saved_params = req->params_count;
+  char* param_slashes[CERVER_MAX_PARAMS];
+  int param_slash_count = 0;
 
   /* Skip leading '/' */
   if (*pp == '/') pp++;
@@ -121,10 +131,12 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
       /* Dynamic segment — extract parameter */
       if (req->params_count < CERVER_MAX_PARAMS) {
         req->params[req->params_count].key = pp_seg + 1;
-        /* Temporarily NUL-terminate the key at the slash */
-        /* The key points into the route pattern (static/const) */
+        /* The key points into the route pattern (static/const, not NUL-terminated) */
         req->params[req->params_count].value = rp_seg;
         req->params_count++;
+        if (*rp == '/') {
+          param_slashes[param_slash_count++] = (char*)rp;
+        }
       }
     } else {
       /* Static segment — must match exactly */
@@ -145,6 +157,11 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
     return 0;
   }
 
+  /* Match succeeded, NUL-terminate extracted values in-place inside req->path */
+  for (int i = 0; i < param_slash_count; i++) {
+    *param_slashes[i] = '\0';
+  }
+
   return 1;
 }
 
@@ -152,6 +169,166 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
 /*  Dispatch: find and return the handler for a request               */
 /* ------------------------------------------------------------------ */
 
+/* ------------------------------------------------------------------ */
+/*  Trie/Radix Route Router                                           */
+/* ------------------------------------------------------------------ */
+
+static char* trie_strndup(const char* s, size_t n) {
+  char* p = malloc(n + 1);
+  if (p) {
+    memcpy(p, s, n);
+    p[n] = '\0';
+  }
+  return p;
+}
+
+typedef struct trie_node trie_node_t;
+
+struct trie_node {
+  char* segment;
+  int is_param;
+  char* param_name;
+
+  struct {
+    const char* method;
+    cerver_handler_fn handler;
+  } handlers[16];
+  int handler_count;
+
+  trie_node_t** children;
+  int children_count;
+  int children_cap;
+};
+
+void* cerver_trie_create(void) {
+  trie_node_t* node = calloc(1, sizeof(trie_node_t));
+  return node;
+}
+
+static trie_node_t* trie_create_node(const char* segment, size_t len) {
+  trie_node_t* node = calloc(1, sizeof(trie_node_t));
+  if (node && segment) {
+    node->segment = trie_strndup(segment, len);
+    if (node->segment[0] == ':') {
+      node->is_param = 1;
+      node->param_name = trie_strndup(node->segment + 1, len - 1);
+    }
+  }
+  return node;
+}
+
+void cerver_trie_insert(void* trie, const char* pattern, const char* method, cerver_handler_fn handler) {
+  if (!trie) return;
+  trie_node_t* curr = (trie_node_t*)trie;
+  const char* p = pattern;
+  while (*p == '/') p++;
+
+  while (*p) {
+    const char* seg_start = p;
+    while (*p && *p != '/') p++;
+    size_t len = (size_t)(p - seg_start);
+    if (len == 0) {
+      while (*p == '/') p++;
+      continue;
+    }
+
+    // Find if child exists
+    trie_node_t* child = NULL;
+    for (int i = 0; i < curr->children_count; i++) {
+      trie_node_t* c = curr->children[i];
+      if (strlen(c->segment) == len && memcmp(c->segment, seg_start, len) == 0) {
+        child = c;
+        break;
+      }
+    }
+
+    if (!child) {
+      child = trie_create_node(seg_start, len);
+      if (curr->children_count >= curr->children_cap) {
+        curr->children_cap = curr->children_cap == 0 ? 4 : curr->children_cap * 2;
+        curr->children = realloc(curr->children, curr->children_cap * sizeof(trie_node_t*));
+      }
+      curr->children[curr->children_count++] = child;
+    }
+
+    curr = child;
+    while (*p == '/') p++;
+  }
+
+  // Add handler to leaf
+  if (curr->handler_count < 16) {
+    curr->handlers[curr->handler_count].method = method;
+    curr->handlers[curr->handler_count].handler = handler;
+    curr->handler_count++;
+  }
+}
+
+void cerver_trie_free(void* trie) {
+  if (!trie) return;
+  trie_node_t* node = (trie_node_t*)trie;
+  for (int i = 0; i < node->children_count; i++) {
+    cerver_trie_free(node->children[i]);
+  }
+  free(node->children);
+  free(node->segment);
+  free(node->param_name);
+  free(node);
+}
+
+static int trie_match_recursive(trie_node_t* node, const char* path, cerver_request_t* req, cerver_handler_fn* out_handler, int param_start_idx) {
+  // Skip leading slashes
+  while (*path == '/') path++;
+
+  if (*path == '\0') {
+    // Check if node has a handler for req->method
+    for (int i = 0; i < node->handler_count; i++) {
+      if (strcmp(node->handlers[i].method, req->method) == 0) {
+        *out_handler = node->handlers[i].handler;
+        req->params_count = param_start_idx;
+        return 1;
+      }
+    }
+    return 0;
+  }
+
+  // Extract next segment from path
+  const char* seg_start = path;
+  while (*path && *path != '/') path++;
+  size_t seg_len = (size_t)(path - seg_start);
+
+  // Try static children first
+  for (int i = 0; i < node->children_count; i++) {
+    trie_node_t* child = node->children[i];
+    if (!child->is_param) {
+      if (strlen(child->segment) == seg_len && memcmp(child->segment, seg_start, seg_len) == 0) {
+        if (trie_match_recursive(child, path, req, out_handler, param_start_idx)) {
+          return 1;
+        }
+      }
+    }
+  }
+
+  // Try parameter/dynamic children next
+  for (int i = 0; i < node->children_count; i++) {
+    trie_node_t* child = node->children[i];
+    if (child->is_param) {
+      if (param_start_idx < CERVER_MAX_PARAMS) {
+        req->params[param_start_idx].key = child->param_name;
+        req->params[param_start_idx].value = seg_start;
+      }
+      if (trie_match_recursive(child, path, req, out_handler, param_start_idx + 1)) {
+        return 1;
+      }
+    }
+  }
+
+  return 0;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Dispatch: find and return the handler for a request               */
+/* ------------------------------------------------------------------ */
+
 cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req) {
   /* Try the generated compile-time dispatch first */
   if (srv->dispatch_override) {
@@ -159,13 +336,19 @@ cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req) {
     if (h) return h;
   }
 
-  /* Fall back to generic route table scan */
-  if (!srv->routes) return NULL;
+  /* Fall back to generic route table scan via Trie */
+  if (!srv->route_trie) return NULL;
 
-  for (int i = 0; i < srv->route_count; i++) {
-    if (cerver_route_match(&srv->routes[i], req)) {
-      return srv->routes[i].handler;
+  cerver_handler_fn handler = NULL;
+  req->params_count = 0;
+  if (trie_match_recursive((trie_node_t*)srv->route_trie, req->path, req, &handler, 0)) {
+    // NUL-terminate extracted values in-place inside req->path
+    for (int i = 0; i < req->params_count; i++) {
+      char* val = (char*)req->params[i].value;
+      while (*val && *val != '/') val++;
+      if (*val == '/') *val = '\0';
     }
+    return handler;
   }
 
   return NULL;

package/runtime/server.c

@@ -20,6 +20,7 @@
 #include <fcntl.h>
 #include <time.h>
 #include <sys/mman.h>
+#include <sys/time.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <netinet/in.h>
@@ -55,7 +56,7 @@
 static void* cerver_memmem(const void* hay, size_t haylen, const void* needle, size_t nlen) {
   if (nlen == 0) return (void*)hay;
   if (nlen > haylen) return NULL;
-  const char* p = (const char*)hay;
+  const char* p   = (const char*)hay;
   const char* end = p + haylen - nlen;
   for (; p <= end; p++) {
     if (memcmp(p, needle, nlen) == 0) return (void*)p;
@@ -91,12 +92,12 @@ static int get_cpu_count(void) {
 /* ------------------------------------------------------------------ */
 
 typedef struct {
-  int fds[CERVER_CONN_QUEUE_SIZE];
-  int head;
-  int tail;
-  int count;
+  int             fds[CERVER_CONN_QUEUE_SIZE];
+  int             head;
+  int             tail;
+  int             count;
   pthread_mutex_t lock;
-  pthread_cond_t not_empty;
+  pthread_cond_t  not_empty;
 } conn_queue_t;
 
 static void cq_init(conn_queue_t* q) {
@@ -119,7 +120,7 @@ static int cq_push(conn_queue_t* q, int fd) {
     return -1;
   }
   q->fds[q->tail] = fd;
-  q->tail = (q->tail + 1) % CERVER_CONN_QUEUE_SIZE;
+  q->tail         = (q->tail + 1) % CERVER_CONN_QUEUE_SIZE;
   q->count++;
   pthread_cond_signal(&q->not_empty);
   pthread_mutex_unlock(&q->lock);
@@ -140,7 +141,7 @@ static int cq_pop(conn_queue_t* q, volatile int* running) {
     pthread_mutex_unlock(&q->lock);
     return -1;
   }
-  int fd = q->fds[q->head];
+  int fd  = q->fds[q->head];
   q->head = (q->head + 1) % CERVER_CONN_QUEUE_SIZE;
   q->count--;
   pthread_mutex_unlock(&q->lock);
@@ -152,31 +153,31 @@ static conn_queue_t g_conn_queue;
 
 /* Global worker readiness tracking */
 typedef struct {
-  int workers_ready;
-  int workers_expected;
+  int             workers_ready;
+  int             workers_expected;
   pthread_mutex_t lock;
-  pthread_cond_t ready_cv;
+  pthread_cond_t  ready_cv;
 } worker_readiness_t;
 
-static worker_readiness_t g_worker_readiness = {.workers_ready = 0,
+static worker_readiness_t g_worker_readiness = {.workers_ready    = 0,
                                                 .workers_expected = 0,
-                                                .lock = PTHREAD_MUTEX_INITIALIZER,
-                                                .ready_cv = PTHREAD_COND_INITIALIZER};
+                                                .lock             = PTHREAD_MUTEX_INITIALIZER,
+                                                .ready_cv         = PTHREAD_COND_INITIALIZER};
 
 /* Global acceptor startup tracking */
 typedef struct {
-  int acceptors_ready;
-  int start_accepting;
+  int             acceptors_ready;
+  int             start_accepting;
   pthread_mutex_t lock;
-  pthread_cond_t ready_cv;
-  pthread_cond_t start_cv;
+  pthread_cond_t  ready_cv;
+  pthread_cond_t  start_cv;
 } acceptor_readiness_t;
 
 static acceptor_readiness_t g_acceptor_readiness = {.acceptors_ready = 0,
                                                     .start_accepting = 0,
-                                                    .lock = PTHREAD_MUTEX_INITIALIZER,
-                                                    .ready_cv = PTHREAD_COND_INITIALIZER,
-                                                    .start_cv = PTHREAD_COND_INITIALIZER};
+                                                    .lock            = PTHREAD_MUTEX_INITIALIZER,
+                                                    .ready_cv        = PTHREAD_COND_INITIALIZER,
+                                                    .start_cv        = PTHREAD_COND_INITIALIZER};
 
 /* ------------------------------------------------------------------ */
 /*  Buffered read                                                     */
@@ -185,7 +186,7 @@ static acceptor_readiness_t g_acceptor_readiness = {.acceptors_ready = 0,
 static char* read_full_request(int fd, size_t* out_len) {
   size_t cap = CERVER_READ_BUF;
   size_t len = 0;
-  char* buf = malloc(cap + 1);
+  char*  buf = malloc(cap + 1);
   if (!buf) return NULL;
 
   while (len < (size_t)CERVER_READ_BUF_MAX) {
@@ -227,16 +228,16 @@ static void handle_connection(cerver_server_t* srv, int client_fd) {
   setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
 
   int request_count = 0;
-  int keepalive = 1;
+  int keepalive     = 1;
 
   while (keepalive && srv->running && request_count < CERVER_KEEPALIVE_MAX) {
     struct timeval tv;
-    tv.tv_sec = (request_count == 0) ? 5 : CERVER_KEEPALIVE_TIMEOUT;
+    tv.tv_sec  = (request_count == 0) ? 5 : CERVER_KEEPALIVE_TIMEOUT;
     tv.tv_usec = 0;
     setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 
     size_t req_len = 0;
-    char* buf = read_full_request(client_fd, &req_len);
+    char*  buf     = read_full_request(client_fd, &req_len);
     if (!buf || req_len == 0) {
       if (buf) free(buf);
       break;
@@ -277,6 +278,8 @@ static void handle_connection(cerver_server_t* srv, int client_fd) {
       free((void*)res.body);
     else if (res._body_owned == 2 && res.body)
       munmap((void*)res.body, res.body_len);
+    else if (res._body_owned == 3 && res._file_fd >= 0)
+      close(res._file_fd);
 
     free(buf);
     if (write_err < 0) break;
@@ -347,7 +350,7 @@ static int create_listener(int port, int reuseport) {
   int opt = 1;
   setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
   if (reuseport) setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
 #else
   (void)reuseport;
@@ -355,9 +358,9 @@ static int create_listener(int port, int reuseport) {
 
   struct sockaddr_in addr;
   memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
+  addr.sin_family      = AF_INET;
   addr.sin_addr.s_addr = INADDR_ANY;
-  addr.sin_port = htons((uint16_t)port);
+  addr.sin_port        = htons((uint16_t)port);
 
   if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
     perror("cerver: bind");
@@ -380,7 +383,7 @@ static int create_listener(int port, int reuseport) {
 
 static int accept_connection(int listen_fd) {
   struct sockaddr_in ca;
-  socklen_t cl = sizeof(ca);
+  socklen_t          cl = sizeof(ca);
 #ifdef __linux__
   return accept4(listen_fd, (struct sockaddr*)&ca, &cl, SOCK_CLOEXEC);
 #else
@@ -394,7 +397,7 @@ static int accept_connection(int listen_fd) {
 
 #if CERVER_USE_KQUEUE
 static void* acceptor_loop(void* arg) {
-  cerver_worker_t* w = (cerver_worker_t*)arg;
+  cerver_worker_t* w   = (cerver_worker_t*)arg;
   cerver_server_t* srv = w->srv;
 
   int kq = kqueue();
@@ -419,8 +422,8 @@ static void* acceptor_loop(void* arg) {
   pthread_mutex_unlock(&g_acceptor_readiness.lock);
 
   while (srv->running) {
-    struct timespec ts = {1, 0};
-    int nev = kevent(kq, NULL, 0, events, CERVER_MAX_EVENTS, &ts);
+    struct timespec ts  = {1, 0};
+    int             nev = kevent(kq, NULL, 0, events, CERVER_MAX_EVENTS, &ts);
     if (nev < 0) {
       if (errno == EINTR) continue;
       break;
@@ -454,7 +457,7 @@ static void* acceptor_loop(void* arg) {
 
 #elif CERVER_USE_EPOLL
 static void* acceptor_loop(void* arg) {
-  cerver_worker_t* w = (cerver_worker_t*)arg;
+  cerver_worker_t* w   = (cerver_worker_t*)arg;
   cerver_server_t* srv = w->srv;
 
   int ep = epoll_create1(EPOLL_CLOEXEC);
@@ -511,7 +514,7 @@ static void* acceptor_loop(void* arg) {
 
 #else /* SELECT */
 static void* acceptor_loop(void* arg) {
-  cerver_worker_t* w = (cerver_worker_t*)arg;
+  cerver_worker_t* w   = (cerver_worker_t*)arg;
   cerver_server_t* srv = w->srv;
 
   pthread_mutex_lock(&g_acceptor_readiness.lock);
@@ -526,8 +529,8 @@ static void* acceptor_loop(void* arg) {
     fd_set rfds;
     FD_ZERO(&rfds);
     FD_SET(w->listen_fd, &rfds);
-    struct timeval tv = {1, 0};
-    int ret = select(w->listen_fd + 1, &rfds, NULL, NULL, &tv);
+    struct timeval tv  = {1, 0};
+    int            ret = select(w->listen_fd + 1, &rfds, NULL, NULL, &tv);
     if (ret < 0) {
       if (errno == EINTR) continue;
       break;
@@ -577,7 +580,7 @@ void cerver_stat_cache_store(cerver_stat_cache_t* cache, const char* path, size_
                              time_t mtime) {
   time_t now = time(NULL);
   pthread_mutex_lock(&cache->lock);
-  int best = 0;
+  int    best   = 0;
   time_t oldest = cache->entries[0].cached_at;
   for (int i = 0; i < CERVER_STAT_CACHE_SIZE; i++) {
     cerver_stat_entry_t* e = &cache->entries[i];
@@ -587,16 +590,16 @@ void cerver_stat_cache_store(cerver_stat_cache_t* cache, const char* path, size_
     }
     if (e->cached_at < oldest) {
       oldest = e->cached_at;
-      best = i;
+      best   = i;
     }
   }
   cerver_stat_entry_t* slot = &cache->entries[best];
   strncpy(slot->path, path, sizeof(slot->path) - 1);
   slot->path[sizeof(slot->path) - 1] = '\0';
-  slot->file_size = file_size;
-  slot->mtime = mtime;
-  slot->cached_at = now;
-  slot->valid = 1;
+  slot->file_size                    = file_size;
+  slot->mtime                        = mtime;
+  slot->cached_at                    = now;
+  slot->valid                        = 1;
   pthread_mutex_unlock(&cache->lock);
 }
 
@@ -606,25 +609,32 @@ void cerver_stat_cache_store(cerver_stat_cache_t* cache, const char* path, size_
 
 int cerver_init(cerver_server_t* srv, int port, int threads) {
   memset(srv, 0, sizeof(*srv));
-  srv->port = port;
-  srv->sock_fd = -1;
-  srv->running = 0;
-  srv->public_dir = NULL;
+  srv->port              = port;
+  srv->sock_fd           = -1;
+  srv->running           = 0;
+  srv->public_dir        = NULL;
   srv->dispatch_override = NULL;
-  srv->worker_count = (threads > 0) ? threads : get_cpu_count();
-  srv->workers = NULL;
+  srv->worker_count      = (threads > 0) ? threads : get_cpu_count();
+  srv->workers           = NULL;
   cerver_stat_cache_init(&srv->stat_cache);
   return 0;
 }
 
 int cerver_add_routes(cerver_server_t* srv, cerver_route_t* routes, int count) {
-  srv->routes = routes;
+  srv->routes      = routes;
   srv->route_count = count;
+
+  srv->route_trie = cerver_trie_create();
+  if (srv->route_trie) {
+    for (int i = 0; i < count; i++) {
+      cerver_trie_insert(srv->route_trie, routes[i].pattern, routes[i].method, routes[i].handler);
+    }
+  }
   return 0;
 }
 
 int cerver_set_assets(cerver_server_t* srv, cerver_asset_t* assets, int count) {
-  srv->assets = assets;
+  srv->assets      = assets;
   srv->asset_count = count;
   return 0;
 }
@@ -646,7 +656,7 @@ int cerver_listen(cerver_server_t* srv) {
   /* Determine pool and acceptor counts.
    * Acceptors: min(worker_count, cpu_count) — one per core for accept.
    * Pool workers: worker_count * 16 — enough to cover concurrent keep-alive. */
-  int cpu_count = get_cpu_count();
+  int cpu_count      = get_cpu_count();
   int acceptor_count = cpu_count;
   if (acceptor_count > srv->worker_count) acceptor_count = srv->worker_count;
   if (acceptor_count < 1) acceptor_count = 1;
@@ -660,7 +670,7 @@ int cerver_listen(cerver_server_t* srv) {
 
   /* Initialize worker readiness tracking */
   pthread_mutex_lock(&g_worker_readiness.lock);
-  g_worker_readiness.workers_ready = 0;
+  g_worker_readiness.workers_ready    = 0;
   g_worker_readiness.workers_expected = pool_size;
   pthread_mutex_unlock(&g_worker_readiness.lock);
 
@@ -701,7 +711,7 @@ int cerver_listen(cerver_server_t* srv) {
     return -1;
   }
 
-  srv->sock_fd = create_listener(srv->port, 0);
+  srv->sock_fd = create_listener(srv->port, 1);
   if (srv->sock_fd < 0) {
     srv->running = 0;
     for (int i = 0; i < pool_size; i++) pthread_join(pool_threads[i], NULL);
@@ -711,7 +721,7 @@ int cerver_listen(cerver_server_t* srv) {
   }
 
   /* Start acceptor threads */
-  srv->workers = calloc((size_t)acceptor_count, sizeof(cerver_worker_t));
+  srv->workers      = calloc((size_t)acceptor_count, sizeof(cerver_worker_t));
   srv->worker_count = acceptor_count;
   if (!srv->workers) {
     perror("cerver: calloc acceptors");
@@ -726,12 +736,16 @@ int cerver_listen(cerver_server_t* srv) {
 
   for (int i = 0; i < acceptor_count; i++) {
     cerver_worker_t* w = &srv->workers[i];
-    w->id = i;
-    w->srv = srv;
-    w->event_fd = -1;
-#ifdef __linux__
-    w->listen_fd = create_listener(srv->port, 1);
-    if (w->listen_fd < 0) w->listen_fd = srv->sock_fd;
+    w->id              = i;
+    w->srv             = srv;
+    w->event_fd        = -1;
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+    if (i == 0) {
+      w->listen_fd = srv->sock_fd;
+    } else {
+      w->listen_fd = create_listener(srv->port, 1);
+      if (w->listen_fd < 0) w->listen_fd = srv->sock_fd;
+    }
 #else
     w->listen_fd = srv->sock_fd;
 #endif
@@ -790,7 +804,7 @@ void cerver_shutdown(cerver_server_t* srv) {
 
   if (srv->workers) {
     for (int i = 0; i < srv->worker_count; i++) {
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
       if (srv->workers[i].listen_fd != srv->sock_fd && srv->workers[i].listen_fd >= 0)
         close(srv->workers[i].listen_fd);
 #endif
@@ -800,6 +814,11 @@ void cerver_shutdown(cerver_server_t* srv) {
     srv->workers = NULL;
   }
 
+  if (srv->route_trie) {
+    cerver_trie_free(srv->route_trie);
+    srv->route_trie = NULL;
+  }
+
   if (srv->sock_fd >= 0) {
     close(srv->sock_fd);
     srv->sock_fd = -1;