Addressed two more copilot's comments.

danielinux · danielinux · commit f9982fd6bad2 · 2026-04-22T14:53:19.000+02:00
diff --git a/src/test/unit/unit.c b/src/test/unit/unit.c
@@ -238,6 +238,8 @@ Suite *wolf_suite(void)
     tcase_add_test(tc_utils, test_multicast_if_pins_egress_interface);
     tcase_add_test(tc_utils, test_multicast_loop_does_not_fire_on_blocked_send);
     tcase_add_test(tc_utils, test_multicast_recv_rejects_short_frame);
+    tcase_add_test(tc_utils, test_multicast_setsockopt_accepts_unaligned_mreq);
+    tcase_add_test(tc_utils, test_multicast_getsockopt_ttl_loop_accepts_uint8);
 #endif
     tcase_add_test(tc_utils, test_tcp_no_rst_for_broadcast_dst);
     tcase_add_test(tc_utils, test_tcp_no_rst_for_multicast_dst);
diff --git a/src/test/unit/unit_tests_multicast.c b/src/test/unit/unit_tests_multicast.c
@@ -471,4 +471,104 @@ START_TEST(test_multicast_recv_rejects_short_frame)
 }
 END_TEST
 
+START_TEST(test_multicast_setsockopt_accepts_unaligned_mreq)
+{
+    struct wolfIP s;
+    int sd;
+    /* 1 byte of padding before the mreq so the struct lands at odd alignment
+     * even on strict-alignment toolchains. A direct (const struct *)cast on
+     * this pointer would be an unaligned uint32_t load; UBSAN
+     * -fsanitize=alignment flags that as undefined behaviour. */
+    uint8_t raw[1 + sizeof(struct wolfIP_ip_mreq)];
+    struct wolfIP_ip_mreq mreq_native;
+    uint8_t raw_if[1 + sizeof(struct wolfIP_mreq_addr)];
+    struct wolfIP_mreq_addr if_native;
+    ip4 group = 0xE9010209U;
+    ip4 iface_ip = 0x0A000002U;
+
+    wolfIP_init(&s);
+    mock_link_init(&s);
+    wolfIP_ipconfig_set(&s, iface_ip, 0xFFFFFF00U, 0);
+    sd = wolfIP_sock_socket(&s, AF_INET, IPSTACK_SOCK_DGRAM, WI_IPPROTO_UDP);
+    ck_assert_int_gt(sd, 0);
+
+    /* IP_ADD_MEMBERSHIP via a misaligned mreq. */
+    multicast_mreq(&mreq_native, group, IPADDR_ANY);
+    memset(raw, 0, sizeof(raw));
+    memcpy(raw + 1, &mreq_native, sizeof(mreq_native));
+    ck_assert_int_eq(wolfIP_sock_setsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_ADD_MEMBERSHIP, raw + 1,
+            (socklen_t)sizeof(mreq_native)), 0);
+    ck_assert_uint_eq(s.mcast[0].refs, 1);
+
+    /* IP_DROP_MEMBERSHIP via a misaligned mreq. */
+    memset(raw, 0, sizeof(raw));
+    memcpy(raw + 1, &mreq_native, sizeof(mreq_native));
+    ck_assert_int_eq(wolfIP_sock_setsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_DROP_MEMBERSHIP, raw + 1,
+            (socklen_t)sizeof(mreq_native)), 0);
+    ck_assert_uint_eq(s.mcast[0].refs, 0);
+
+    /* IP_MULTICAST_IF via a misaligned wolfIP_mreq_addr. */
+    if_native.s_addr = ee32(iface_ip);
+    memset(raw_if, 0, sizeof(raw_if));
+    memcpy(raw_if + 1, &if_native, sizeof(if_native));
+    ck_assert_int_eq(wolfIP_sock_setsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_MULTICAST_IF, raw_if + 1,
+            (socklen_t)sizeof(if_native)), 0);
+    ck_assert_uint_eq(s.udpsockets[SOCKET_UNMARK(sd)].sock.udp.mcast_if_set, 1);
+}
+END_TEST
+
+START_TEST(test_multicast_getsockopt_ttl_loop_accepts_uint8)
+{
+    struct wolfIP s;
+    int sd;
+    int ttl_in = 7;
+    int loop_in = 0;
+    uint8_t byte_buf;
+    int int_buf;
+    socklen_t len;
+
+    wolfIP_init(&s);
+    mock_link_init(&s);
+    wolfIP_ipconfig_set(&s, 0x0A000002U, 0xFFFFFF00U, 0);
+    sd = wolfIP_sock_socket(&s, AF_INET, IPSTACK_SOCK_DGRAM, WI_IPPROTO_UDP);
+    ck_assert_int_gt(sd, 0);
+    ck_assert_int_eq(wolfIP_sock_setsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_MULTICAST_TTL, &ttl_in, sizeof(ttl_in)), 0);
+    ck_assert_int_eq(wolfIP_sock_setsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_MULTICAST_LOOP, &loop_in, sizeof(loop_in)), 0);
+
+    /* getsockopt with a uint8_t buffer must succeed and write one byte,
+     * mirroring setsockopt which already accepts either size. */
+    byte_buf = 0xff;
+    len = sizeof(byte_buf);
+    ck_assert_int_eq(wolfIP_sock_getsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_MULTICAST_TTL, &byte_buf, &len), 0);
+    ck_assert_uint_eq(len, sizeof(byte_buf));
+    ck_assert_uint_eq(byte_buf, 7U);
+
+    byte_buf = 0xff;
+    len = sizeof(byte_buf);
+    ck_assert_int_eq(wolfIP_sock_getsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_MULTICAST_LOOP, &byte_buf, &len), 0);
+    ck_assert_uint_eq(len, sizeof(byte_buf));
+    ck_assert_uint_eq(byte_buf, 0U);
+
+    /* The larger int path still works and returns sizeof(int). */
+    int_buf = -1;
+    len = sizeof(int_buf);
+    ck_assert_int_eq(wolfIP_sock_getsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_MULTICAST_TTL, &int_buf, &len), 0);
+    ck_assert_uint_eq(len, sizeof(int_buf));
+    ck_assert_int_eq(int_buf, 7);
+
+    /* Zero-length buffer is still rejected. */
+    len = 0;
+    ck_assert_int_eq(wolfIP_sock_getsockopt(&s, sd, WOLFIP_SOL_IP,
+            WOLFIP_IP_MULTICAST_TTL, &byte_buf, &len), -WOLFIP_EINVAL);
+}
+END_TEST
+
 #endif /* IP_MULTICAST */
diff --git a/src/wolfip.c b/src/wolfip.c
@@ -6329,17 +6329,20 @@ int wolfIP_sock_setsockopt(struct wolfIP *s, int sockfd, int level, int optname,
     if (level == WOLFIP_SOL_IP && IS_SOCKET_UDP(sockfd)) {
         if (optname == WOLFIP_IP_ADD_MEMBERSHIP ||
                 optname == WOLFIP_IP_DROP_MEMBERSHIP) {
-            const struct wolfIP_ip_mreq *mreq =
-                (const struct wolfIP_ip_mreq *)optval;
+            struct wolfIP_ip_mreq mreq;
             unsigned int if_idx;
             ip4 group;
             ip4 if_addr;
             int ret;
 
-            if (!mreq || optlen < (socklen_t)sizeof(*mreq))
+            /* Copy into an aligned local to avoid unaligned 32-bit loads on
+             * strict-alignment targets when the caller's optval buffer is
+             * not naturally aligned. */
+            if (!optval || optlen < (socklen_t)sizeof(mreq))
                 return -WOLFIP_EINVAL;
-            group = ee32(mreq->imr_multiaddr.s_addr);
-            if_addr = ee32(mreq->imr_interface.s_addr);
+            memcpy(&mreq, optval, sizeof(mreq));
+            group = ee32(mreq.imr_multiaddr.s_addr);
+            if_addr = ee32(mreq.imr_interface.s_addr);
             ret = mcast_if_from_addr(s, if_addr, group, &if_idx);
             if (ret < 0)
                 return ret;
@@ -6348,15 +6351,15 @@ int wolfIP_sock_setsockopt(struct wolfIP *s, int sockfd, int level, int optname,
             return udp_mcast_drop(s, ts, group, if_idx);
         }
         if (optname == WOLFIP_IP_MULTICAST_IF) {
-            const struct wolfIP_mreq_addr *addr =
-                (const struct wolfIP_mreq_addr *)optval;
+            struct wolfIP_mreq_addr addr;
             unsigned int if_idx;
             ip4 if_addr;
             int ret;
 
-            if (!addr || optlen < (socklen_t)sizeof(*addr))
+            if (!optval || optlen < (socklen_t)sizeof(addr))
                 return -WOLFIP_EINVAL;
-            if_addr = ee32(addr->s_addr);
+            memcpy(&addr, optval, sizeof(addr));
+            if_addr = ee32(addr.s_addr);
             /* Linux IP_MULTICAST_IF with INADDR_ANY clears the pinned
              * interface and reverts to per-destination routing. */
             if (if_addr == IPADDR_ANY) {
@@ -6499,12 +6502,22 @@ int wolfIP_sock_getsockopt(struct wolfIP *s, int sockfd, int level, int optname,
                 optname == WOLFIP_IP_MULTICAST_LOOP) {
             int value;
 
-            if (!optval || !optlen || *optlen < (socklen_t)sizeof(int))
+            if (!optval || !optlen || *optlen < (socklen_t)sizeof(uint8_t))
                 return -WOLFIP_EINVAL;
             value = (optname == WOLFIP_IP_MULTICAST_TTL) ?
                 ts->sock.udp.mcast_ttl : ts->sock.udp.mcast_loop;
-            memcpy(optval, &value, sizeof(value));
-            *optlen = sizeof(value);
+            /* Linux get_ip_sockopt writes IP_MULTICAST_TTL/LOOP as int when
+             * the caller provided room for one and as a single byte when the
+             * buffer is exactly sizeof(uint8_t) — keeps get/set symmetric
+             * with setsockopt, which accepts either width. */
+            if (*optlen >= (socklen_t)sizeof(value)) {
+                memcpy(optval, &value, sizeof(value));
+                *optlen = sizeof(value);
+            } else {
+                uint8_t value8 = (uint8_t)value;
+                memcpy(optval, &value8, sizeof(value8));
+                *optlen = sizeof(value8);
+            }
             return 0;
         }
         if (optname == WOLFIP_IP_MULTICAST_IF) {
