Disabled loopback by default in config. Addressed review comments.

Author: danielinux

.github/workflows/linux.yml

@@ -90,6 +90,12 @@ jobs:
           set -euo pipefail
           timeout --preserve-status 2m sudo LD_PRELOAD=$PWD/libwolfip.so ping -c 5 10.10.10.1
 
+      - name: Rebuild libwolfip.so with loopback enabled
+        run: |
+          set -euo pipefail
+          rm -f libwolfip.so build/pie/wolfip.o
+          make libwolfip.so EXTRA_CFLAGS="-DWOLFIP_ENABLE_LOOPBACK=1"
+
       - name: Testing ICMP loopback smoke (no TUN/TAP)
         timeout-minutes: 2
         run: |

Makefile

@@ -1,6 +1,7 @@
 CC?=gcc
 CFLAGS:=-Wall -Werror -Wextra -I. -D_GNU_SOURCE
 CFLAGS+=-g -ggdb -Wdeclaration-after-statement
+CFLAGS+=$(EXTRA_CFLAGS)
 LDFLAGS+=-pthread
 # additional debug flags:
 #   CFLAGS+=-DDEBUG_TAP

config.h

@@ -40,7 +40,7 @@
 #endif
 
 #ifndef WOLFIP_ENABLE_LOOPBACK
-#define WOLFIP_ENABLE_LOOPBACK 1
+#define WOLFIP_ENABLE_LOOPBACK 0
 #endif
 
 /* Enable HTTP server for POSIX builds */

src/test/unit/unit_esp.c

@@ -28,6 +28,7 @@
 #undef  WOLFIP_MAX_INTERFACES
 #define WOLFIP_MAX_INTERFACES 1
 #undef  WOLFIP_ENABLE_LOOPBACK
+#define WOLFIP_ENABLE_LOOPBACK 0
 
 #include "check.h"
 #include "../../../config.h"

src/test/unit/unit_tests_proto.c

@@ -2998,7 +2998,12 @@ START_TEST(test_wolfip_loopback_send_paths)
 
     ck_assert_int_eq(wolfIP_loopback_send(NULL, frame, sizeof(frame)), -1);
     ck_assert_int_eq(wolfIP_loopback_send(loop, NULL, sizeof(frame)), -1);
-    ck_assert_int_eq(wolfIP_loopback_send(loop, frame, sizeof(frame)), (int)sizeof(frame));
+    /* Fill the queue, each slot enqueue returns the byte count. */
+    for (unsigned int i = 0; i < WOLFIP_LOOPBACK_QUEUE_DEPTH; i++) {
+        ck_assert_int_eq(wolfIP_loopback_send(loop, frame, sizeof(frame)),
+                         (int)sizeof(frame));
+    }
+    /* Next send must be dropped because the queue is full. */
     ck_assert_int_eq(wolfIP_loopback_send(loop, frame, sizeof(frame)), 0);
 }
 END_TEST
@@ -3018,6 +3023,7 @@ START_TEST(test_wolfip_loopback_poll_paths)
     memset(rx, 0, sizeof(rx));
 
     ck_assert_int_eq(wolfIP_loopback_poll(NULL, rx, sizeof(rx)), 0);
+    ck_assert_int_eq(wolfIP_loopback_poll(loop, NULL, sizeof(rx)), 0);
     ck_assert_int_eq(wolfIP_loopback_poll(loop, rx, sizeof(rx)), 0);
 
     ck_assert_int_eq(wolfIP_loopback_send(loop, tx, sizeof(tx)), (int)sizeof(tx));
@@ -4890,10 +4896,12 @@ START_TEST(test_regression_loopback_pure_ack_uses_deferred_buffer_until_poll)
             (uint32_t)sizeof(seg)), 0);
     ck_assert_uint_eq(ts->sock.tcp.last_ack, ts->sock.tcp.ack);
     ck_assert_uint_eq(last_frame_sent_size, 0U);
-    ck_assert_uint_eq(s.loopback_pending_len, expected_pending_len);
+    ck_assert_uint_eq(s.loopback_count, 1U);
+    ck_assert_uint_eq(s.loopback_pending_len[s.loopback_head],
+                      expected_pending_len);
 
     (void)wolfIP_poll(&s, 200);
-    ck_assert_uint_eq(s.loopback_pending_len, 0U);
+    ck_assert_uint_eq(s.loopback_count, 0U);
 }
 END_TEST
 
@@ -4934,13 +4942,17 @@ START_TEST(test_regression_loopback_pure_ack_drain_allows_next_send_cycle)
     seg.flags = TCP_FLAG_ACK;
 
     ck_assert_int_eq(tcp_send_empty_immediate(ts, &seg, (uint32_t)sizeof(seg)), 0);
-    ck_assert_uint_eq(s.loopback_pending_len, expected_pending_len);
+    ck_assert_uint_eq(s.loopback_count, 1U);
+    ck_assert_uint_eq(s.loopback_pending_len[s.loopback_head],
+                      expected_pending_len);
 
     ck_assert_int_eq(loop->poll(loop, rx, sizeof(rx)), (int)expected_pending_len);
-    ck_assert_uint_eq(s.loopback_pending_len, 0U);
+    ck_assert_uint_eq(s.loopback_count, 0U);
 
     ck_assert_int_eq(tcp_send_empty_immediate(ts, &seg, (uint32_t)sizeof(seg)), 0);
-    ck_assert_uint_eq(s.loopback_pending_len, expected_pending_len);
+    ck_assert_uint_eq(s.loopback_count, 1U);
+    ck_assert_uint_eq(s.loopback_pending_len[s.loopback_head],
+                      expected_pending_len);
 }
 END_TEST
 

src/wolfip.c

@@ -1260,8 +1260,14 @@ struct wolfIP {
     struct arp_pending_entry arp_pending[WOLFIP_ARP_PENDING_MAX];
 #endif
 #if WOLFIP_ENABLE_LOOPBACK
-    uint8_t loopback_buf[IP_MTU_MAX];
-    uint32_t loopback_pending_len;
+#ifndef WOLFIP_LOOPBACK_QUEUE_DEPTH
+#define WOLFIP_LOOPBACK_QUEUE_DEPTH 4
+#endif
+    uint8_t loopback_buf[WOLFIP_LOOPBACK_QUEUE_DEPTH][IP_MTU_MAX];
+    uint32_t loopback_pending_len[WOLFIP_LOOPBACK_QUEUE_DEPTH];
+    uint8_t loopback_head;
+    uint8_t loopback_tail;
+    uint8_t loopback_count;
 #endif
 };
 
@@ -1369,39 +1375,47 @@ static inline uint32_t tcp_tx_payload_cap(const struct tsocket *t)
 static int wolfIP_loopback_send(struct wolfIP_ll_dev *ll, void *buf, uint32_t len)
 {
     struct wolfIP *s;
+    uint8_t slot;
     if (!ll || !buf)
         return -1;
     s = WOLFIP_CONTAINER_OF(ll, struct wolfIP, ll_dev);
     if (!s)
         return -1;
-    if (len > IP_MTU_MAX)
+    if (len == 0 || len > IP_MTU_MAX)
         return 0;
-    if (s->loopback_pending_len > 0)
-        return 0; /* buffer busy, drop */
+    if (s->loopback_count >= WOLFIP_LOOPBACK_QUEUE_DEPTH)
+        return 0; /* queue full, drop */
     /* buf is the IP payload (ETH header already stripped by
      * wolfIP_ll_send_frame for non-ethernet devices).
      * Store as-is; wolfIP_poll will re-add the ETH prefix. */
-    memcpy(s->loopback_buf, buf, len);
-    s->loopback_pending_len = len;
+    slot = s->loopback_tail;
+    memcpy(s->loopback_buf[slot], buf, len);
+    s->loopback_pending_len[slot] = len;
+    s->loopback_tail = (uint8_t)((slot + 1U) % WOLFIP_LOOPBACK_QUEUE_DEPTH);
+    s->loopback_count++;
     return (int)len;
 }
 
 static int wolfIP_loopback_poll(struct wolfIP_ll_dev *ll, void *buf, uint32_t len)
 {
     struct wolfIP *s;
+    uint8_t slot;
     uint32_t pending;
-    if (!ll)
+    if (!ll || !buf)
         return 0;
     s = WOLFIP_CONTAINER_OF(ll, struct wolfIP, ll_dev);
     if (!s)
         return 0;
-    pending = s->loopback_pending_len;
-    if (pending == 0)
+    if (s->loopback_count == 0)
         return 0;
+    slot = s->loopback_head;
+    pending = s->loopback_pending_len[slot];
     if (pending > len)
         return 0;
-    s->loopback_pending_len = 0;
-    memcpy(buf, s->loopback_buf, pending);
+    memcpy(buf, s->loopback_buf[slot], pending);
+    s->loopback_pending_len[slot] = 0;
+    s->loopback_head = (uint8_t)((slot + 1U) % WOLFIP_LOOPBACK_QUEUE_DEPTH);
+    s->loopback_count--;
     return (int)pending;
 }
 #endif