Add UDP multicast support by PeimonBot · Pull Request #79 · adityarao2005/WebCraft

PeimonBot · 2026-02-16T01:39:44Z

Adds UDP multicast support (join/leave groups, multicast_socket, sendto to group).

Closes #78

Made with Cursor

- Add multicast_group with resolve(addr) for IPv4/IPv6 multicast addresses - Add multicast_join_options (empty for now) for future options - Add multicast_socket with bind(), join(), leave(), recvfrom(), sendto(group), close() - Add make_multicast_socket() factory - Implement join_group/leave_group in udp_socket_descriptor (Linux io_uring, Windows IOCP, macOS kqueue); mock keeps default no-op - IPv4: IP_ADD_MEMBERSHIP/IP_DROP_MEMBERSHIP; IPv6: IPV6_JOIN_GROUP/IPV6_LEAVE_GROUP Co-authored-by: Cursor <cursoragent@cursor.com>

vercel · 2026-02-16T01:39:47Z

Someone is attempting to deploy a commit to the Aditya's projects Team on Vercel.

A member of the Team first needs to authorize it.

- Test multicast_group::resolve - Test join/leave multicast group - Test join with invalid address throws - Test send/receive over multicast - Test join/leave multiple groups Co-authored-by: Cursor <cursoragent@cursor.com>

Copilot

Pull request overview

Adds first-class UDP multicast capabilities to the async socket layer, enabling join/leave of multicast groups and sending/receiving multicast datagrams.

Changes:

Introduces multicast_group, multicast_join_options, and multicast_socket in the public socket API.
Implements multicast join/leave per platform backend (IOCP, io_uring, kqueue) in the UDP descriptor implementation.
Adds a new multicast-focused test suite covering resolve/join/leave and basic send/receive.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 9 comments.

File	Description
tests/src/test_async_io_multicast.cpp	Adds multicast tests (resolve, join/leave, invalid address, send/receive, multiple groups).
src/webcraft/async_udp.cpp	Implements `join_group`/`leave_group` in platform UDP backends and adds required platform headers.
include/webcraft/async/io/socket.hpp	Adds new multicast API types and `multicast_socket` wrapper on top of UDP descriptors.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-02-16T04:44:49Z

include/webcraft/async/io/socket.hpp

        uint16_t port;
    };

+    /// Options when joining a multicast group (e.g. interface index). Empty for default behavior.


The comment for multicast_join_options says it contains things like an interface index, but the struct is currently empty. Either add the intended option fields (e.g., interface index/address) or adjust the comment to avoid implying functionality that doesn't exist yet.

Suggested change

/// Options when joining a multicast group (e.g. interface index). Empty for default behavior.

/// Placeholder for options when joining a multicast group. Currently empty: an instance

/// of this type indicates default multicast join behavior. Fields may be added in the future.

Copilot · 2026-02-16T04:44:50Z

include/webcraft/async/io/socket.hpp

+        /// Resolve a multicast group from an address string (IPv4 or IPv6 multicast address).
+        static multicast_group resolve(std::string_view addr)
+        {
+            multicast_group g;
+            g.host = std::string(addr);
+            return g;
+        }


multicast_group::resolve() just stores the string without validating that it is a multicast address, but the docstring claims it resolves an IPv4/IPv6 multicast address. Consider validating (and throwing std::invalid_argument) for non-multicast addresses so the API matches its stated intent and errors are clearer.

Copilot · 2026-02-16T04:44:50Z

src/webcraft/async_udp.cpp

+        if (getaddrinfo(group.host.c_str(), nullptr, &hints, &res) != 0 || !res)
+            throw std::invalid_argument("Invalid multicast address: " + group.host);
+        if (res->ai_family == AF_INET)
+        {
+            auto *sa = (struct sockaddr_in *)res->ai_addr;
+            ip_mreq mreq{};
+            mreq.imr_multiaddr = sa->sin_addr;
+            mreq.imr_interface.s_addr = INADDR_ANY;
+            freeaddrinfo(res);
+            if (setsockopt(socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq)) == SOCKET_ERROR)
+                throw webcraft::async::detail::windows::overlapped_winsock2_runtime_error("Failed to join IPv4 multicast group");
+            return;


join_group() accepts any parsable IPv4 address and only relies on setsockopt(IP_ADD_MEMBERSHIP) failing to detect non-multicast addresses. It would be clearer (and match the API name) to explicitly validate that the address is multicast (e.g., IN_MULTICAST / IN6_IS_ADDR_MULTICAST) and throw std::invalid_argument when it is not.

Copilot · 2026-02-16T04:44:50Z

src/webcraft/async_udp.cpp

+        in_addr maddr4;
+        if (inet_pton(AF_INET, group.host.c_str(), &maddr4) == 1)
+        {
+            struct ip_mreq mreq{};
+            mreq.imr_multiaddr = maddr4;
+            mreq.imr_interface.s_addr = INADDR_ANY;
+            if (setsockopt(socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0)
+            {
+                std::error_code ec(errno, std::system_category());
+                throw std::system_error(ec, "Failed to join IPv4 multicast group");
+            }
+            return;
+        }
+        struct in6_addr maddr6;
+        if (inet_pton(AF_INET6, group.host.c_str(), &maddr6) == 1)
+        {
+            struct ipv6_mreq mreq6{};
+            mreq6.ipv6mr_multiaddr = maddr6;
+            mreq6.ipv6mr_interface = 0;
+            if (setsockopt(socket, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq6, sizeof(mreq6)) < 0)
+            {
+                std::error_code ec(errno, std::system_category());
+                throw std::system_error(ec, "Failed to join IPv6 multicast group");
+            }
+            return;
+        }
+        throw std::invalid_argument("Invalid multicast address: " + group.host);
+    }


Same as the other platforms: join_group() only validates that the string is a valid IP literal, not that it is a multicast address. Consider checking IN_MULTICAST / IN6_IS_ADDR_MULTICAST and throwing std::invalid_argument for non-multicast input to make behavior consistent and error messages clearer.

Copilot · 2026-02-16T04:44:50Z

include/webcraft/async/io/socket.hpp


 #include "core.hpp"
 #include <webcraft/async/fire_and_forget_task.hpp>
+#include <string_view>


socket.hpp uses std::string in connection_info/multicast_group but does not include <string>. The header currently relies on transitive includes, which can break compilation for translation units that include this header directly; add an explicit #include <string> here.

Suggested change

#include <string_view>

#include <string_view>

#include <string>

Copilot · 2026-02-16T04:44:51Z

include/webcraft/async/io/socket.hpp

+    struct multicast_group
+    {
+        std::string host;  ///< Multicast group address (e.g. "239.255.0.1")
+        uint16_t port{0};  ///< Port used when sending to the group (0 = use socket's bound port or set before sendto)


The struct comment says port == 0 will fall back to the socket's bound port, but multicast_socket::sendto() forwards group.port directly (so this will attempt to send to UDP port 0). Either implement the documented fallback behavior or require group.port != 0 and throw a clear std::invalid_argument when it is unset.

Suggested change

uint16_t port{0}; ///< Port used when sending to the group (0 = use socket's bound port or set before sendto)

uint16_t port{0}; ///< Port used when sending to the group; must be set to the desired (non-zero) UDP port before calling send functions.

Copilot · 2026-02-16T04:44:51Z

include/webcraft/async/io/socket.hpp

+        /// Send data to a multicast group. Uses group.host and group.port (if port is 0, send may use a default).
+        task<size_t> sendto(std::span<const char> buffer, const multicast_group &group)
+        {
+            connection_info info;
+            info.host = group.host;
+            info.port = group.port;
+            return descriptor->sendto(buffer, info);
+        }


multicast_socket::sendto() will happily send to group.port even when it is 0, which usually results in an invalid destination port and makes the earlier documentation misleading. Add validation here (or implement a real default/fallback port) so callers get a deterministic error instead of a runtime networking failure.

Copilot · 2026-02-16T04:44:51Z

src/webcraft/async_udp.cpp

+            in_addr maddr4;
+            if (inet_pton(AF_INET, group.host.c_str(), &maddr4) == 1)
+            {
+                struct ip_mreq mreq{};
+                mreq.imr_multiaddr = maddr4;
+                mreq.imr_interface.s_addr = INADDR_ANY;
+                if (setsockopt(socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0)
+                {
+                    std::error_code ec(errno, std::system_category());
+                    throw std::system_error(ec, "Failed to join IPv4 multicast group");
+                }
+                return;
+            }
+            struct in6_addr maddr6;
+            if (inet_pton(AF_INET6, group.host.c_str(), &maddr6) == 1)
+            {
+                struct ipv6_mreq mreq6{};
+                mreq6.ipv6mr_multiaddr = maddr6;
+                mreq6.ipv6mr_interface = 0;
+                if (setsockopt(socket, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq6, sizeof(mreq6)) < 0)
+                {
+                    std::error_code ec(errno, std::system_category());
+                    throw std::system_error(ec, "Failed to join IPv6 multicast group");
+                }
+                return;
+            }
+            throw std::invalid_argument("Invalid multicast address: " + group.host);


join_group() currently treats any valid IPv4/IPv6 literal as eligible and only fails later via setsockopt, which can produce a generic system error for non-multicast addresses. Add an explicit multicast check (IN_MULTICAST / IN6_IS_ADDR_MULTICAST) so non-multicast inputs fail fast with a clear std::invalid_argument.

Copilot · 2026-02-16T04:44:51Z

tests/src/test_async_io_multicast.cpp

+        std::vector<char> buffer(1024);
+        connection_info sender_info{};
+        size_t n = co_await recv_socket.recvfrom(std::span<char>(buffer.data(), buffer.size()), sender_info);
+        if (n > 0)
+        {
+            received_data.assign(buffer.data(), n);
+            received = true;


This test does an unbounded recvfrom() and can block indefinitely if multicast is unavailable in the CI/runtime environment (or if join/send fails), leading to hangs/timeouts. Add a timeout/cancellation path (e.g., race recvfrom with a timer) and fail with a clear message if no packet arrives.

On macOS, multicast loopback is disabled by default, so packets sent to a multicast group are not delivered to local receivers. This caused MulticastSocketTestSuite.TestMulticastSendReceive to fail when sender and receiver run on the same host. Enable IP_MULTICAST_LOOP (IPv4) and IPV6_MULTICAST_LOOP (IPv6) for UDP sockets in the kqueue implementation so same-host multicast send/receive works. Use SO_DOMAIN to set the correct option for the socket family. Co-authored-by: Cursor <cursoragent@cursor.com>

Copilot

Pull request overview

Copilot reviewed 3 out of 3 changed files in this pull request and generated 7 comments.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-02-16T04:52:32Z

include/webcraft/async/io/socket.hpp

+        static multicast_group resolve(std::string_view addr)
+        {
+            multicast_group g;
+            g.host = std::string(addr);
+            return g;
+        }


API design issue: The multicast_group::resolve method does not validate whether the provided address is actually a valid multicast address. It simply stores whatever string is provided. This can lead to confusing error messages later when join() is called with an invalid multicast address. Consider adding validation in resolve() to check if the address is within valid multicast ranges (224.0.0.0/4 for IPv4, ff00::/8 for IPv6) and throw a clear exception if not.

Copilot · 2026-02-16T04:52:33Z

src/webcraft/async_udp.cpp

+                setsockopt(socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq6, sizeof(mreq6));
+            }
+        }
+    };


The entire sendto method and the two multicast methods (join_group and leave_group) have incorrect indentation. They appear to be indented as if they are inside another block, but they should be at the same indentation level as the recvfrom method above them (line 783). This affects code readability and maintainability.

Suggested change

};

};

Copilot · 2026-02-16T04:52:33Z

src/webcraft/async_udp.cpp

+        freeaddrinfo(res);
+        throw std::invalid_argument("Invalid multicast address: " + group.host);


Memory leak: If getaddrinfo succeeds but the address family is neither AF_INET nor AF_INET6, the function throws an exception on line 600 without calling freeaddrinfo(res) first. This will leak memory. The fix is to call freeaddrinfo(res) before throwing the exception.

Copilot · 2026-02-16T04:52:33Z

tests/src/test_async_io_multicast.cpp

+    // Start receiver first, then sender
+    auto recv_task = receiver_fn();
+    auto send_task = sender_fn();
+
+    sync_wait(send_task);
+    sync_wait(recv_task);


Potential race condition: The test starts both receiver and sender tasks but doesn't ensure the receiver is ready to receive before the sender sends. The receiver needs to bind, join the group, and start waiting on recvfrom before the sender transmits. Consider adding synchronization (e.g., an atomic flag or event) to ensure the receiver is ready before the sender starts sending, or add a small delay in the sender. This could cause the test to fail intermittently.

Copilot · 2026-02-16T04:52:33Z

src/webcraft/async_udp.cpp

+        void leave_group(const webcraft::async::io::socket::multicast_group &group) override
+        {
+            if (socket < 0) return;
+            in_addr maddr4;
+            if (inet_pton(AF_INET, group.host.c_str(), &maddr4) == 1)
+            {
+                struct ip_mreq mreq{};
+                mreq.imr_multiaddr = maddr4;
+                mreq.imr_interface.s_addr = INADDR_ANY;
+                setsockopt(socket, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq));
+                return;
+            }
+            struct in6_addr maddr6;
+            if (inet_pton(AF_INET6, group.host.c_str(), &maddr6) == 1)
+            {
+                struct ipv6_mreq mreq6{};
+                mreq6.ipv6mr_multiaddr = maddr6;
+                mreq6.ipv6mr_interface = 0;
+                setsockopt(socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq6, sizeof(mreq6));
+            }
+        }


Inconsistent error handling: In leave_group for Linux/macOS (lines 899-919), if inet_pton returns a value other than 1 (e.g., 0 for invalid address or -1 for error), the function silently returns without doing anything. This differs from join_group which throws an exception. For consistency and better debugging, leave_group should either throw an exception or log a warning when given an invalid address, rather than silently failing.

Copilot · 2026-02-16T04:52:33Z

src/webcraft/async_udp.cpp

+    void leave_group(const webcraft::async::io::socket::multicast_group &group) override
+    {
+        if (socket == INVALID_SOCKET) return;
+        struct addrinfo hints{};
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_flags = AI_NUMERICHOST;
+        struct addrinfo *res = nullptr;
+        if (getaddrinfo(group.host.c_str(), nullptr, &hints, &res) != 0 || !res) return;
+        if (res->ai_family == AF_INET)
+        {
+            auto *sa = (struct sockaddr_in *)res->ai_addr;
+            ip_mreq mreq{};
+            mreq.imr_multiaddr = sa->sin_addr;
+            mreq.imr_interface.s_addr = INADDR_ANY;
+            freeaddrinfo(res);
+            setsockopt(socket, IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&mreq, sizeof(mreq));
+            return;
+        }
+        if (res->ai_family == AF_INET6)
+        {
+            auto *sa = (struct sockaddr_in6 *)res->ai_addr;
+            ipv6_mreq mreq6{};
+            mreq6.ipv6mr_multiaddr = sa->sin6_addr;
+            mreq6.ipv6mr_interface = 0;
+            freeaddrinfo(res);
+            setsockopt(socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP, (char *)&mreq6, sizeof(mreq6));
+        }
+        else
+            freeaddrinfo(res);


Inconsistent error handling: Similar to the Linux implementation, the Windows leave_group silently returns without action if getaddrinfo fails (line 610) or if the address family is neither AF_INET nor AF_INET6 (line 630-631). This is inconsistent with join_group which throws exceptions in these cases. For better consistency and debugging, leave_group should handle these cases consistently with join_group.

Copilot · 2026-02-16T04:52:34Z

src/webcraft/async_udp.cpp

+            setsockopt(socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq6, sizeof(mreq6));
+        }


Inconsistent error handling: Similar to the Linux implementation, leave_group for macOS silently returns without action if inet_pton fails to parse the address or returns a value other than 1. This is inconsistent with join_group which throws an exception for invalid addresses. For better consistency and debugging, leave_group should handle invalid addresses consistently with join_group.

Suggested change

setsockopt(socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq6, sizeof(mreq6));

}

setsockopt(socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq6, sizeof(mreq6));

return;

}

throw std::invalid_argument("Invalid multicast address: " + group.host);

… unsupported - Add CMake option WEBCRAFT_HAS_MULTICAST (default ON) to allow disabling multicast-dependent tests where loopback is unreliable (e.g. macOS runners). - Define WEBCRAFT_HAS_MULTICAST=0/1 for test target; tests that require multicast or loopback skip via GTEST_SKIP() when WEBCRAFT_HAS_MULTICAST=0. - Fix TestMulticastSendReceive race: run receiver in background thread so it is in recvfrom before sender runs; add runtime skip if no data received (loopback not available). - macOS CI: set WEBCRAFT_HAS_MULTICAST=OFF so MulticastSocketTestSuite tests are skipped and the suite passes. - TestMulticastGroupResolve always runs (no socket); JoinLeave, InvalidAddressThrows, SendReceive, JoinLeaveMultipleGroups are conditional. Co-authored-by: Cursor <cursoragent@cursor.com>

…o port check - socket.hpp: Add explicit #include <string> and #include <cstdio>, <stdexcept> - multicast_join_options: Clarify comment as placeholder (no implied interface index yet) - multicast_group::resolve(): Validate IPv4/IPv6 multicast, throw std::invalid_argument if not - multicast_group.port: Document that port must be non-zero before send - multicast_socket::sendto(): Throw std::invalid_argument when group.port == 0 - async_udp.cpp: In join_group() (IOCP, io_uring, kqueue), validate with IN_MULTICAST/IN6_IS_ADDR_MULTICAST and throw std::invalid_argument for non-multicast Co-authored-by: Cursor <cursoragent@cursor.com>

adityarao2005

LGTM!

vercel · 2026-02-16T05:34:22Z

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated (UTC)
web-craft-docs	Ready	Preview, Comment	Feb 16, 2026 5:34am

PeimonBot requested a review from adityarao2005 as a code owner February 16, 2026 01:39

adityarao2005 requested a review from Copilot February 16, 2026 04:38

Copilot started reviewing on behalf of adityarao2005 February 16, 2026 04:38 View session

Copilot AI reviewed Feb 16, 2026

View reviewed changes

adityarao2005 requested a review from Copilot February 16, 2026 04:47

Copilot started reviewing on behalf of adityarao2005 February 16, 2026 04:48 View session

Copilot AI reviewed Feb 16, 2026

View reviewed changes

PeimonBot and others added 2 commits February 16, 2026 04:55

adityarao2005 approved these changes Feb 16, 2026

View reviewed changes

adityarao2005 self-requested a review February 16, 2026 05:34

vercel bot deployed to Preview February 16, 2026 05:34 View deployment

adityarao2005 merged commit 2f1c2b4 into adityarao2005:main Feb 16, 2026
2 checks passed

adityarao2005 mentioned this pull request Feb 16, 2026

Revert "Add UDP multicast support" #81

Merged

Copilot AI mentioned this pull request Feb 17, 2026

Fix multicast build and validation logic #82

Open

	/// Options when joining a multicast group (e.g. interface index). Empty for default behavior.
	/// Placeholder for options when joining a multicast group. Currently empty: an instance
	/// of this type indicates default multicast join behavior. Fields may be added in the future.

	#include <string_view>
	#include <string_view>
	#include <string>

	uint16_t port{0}; ///< Port used when sending to the group (0 = use socket's bound port or set before sendto)
	uint16_t port{0}; ///< Port used when sending to the group; must be set to the desired (non-zero) UDP port before calling send functions.

		freeaddrinfo(res);
		throw std::invalid_argument("Invalid multicast address: " + group.host);

		setsockopt(socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq6, sizeof(mreq6));
		}

Conversation

PeimonBot commented Feb 16, 2026

Uh oh!

vercel bot commented Feb 16, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 16, 2026

Choose a reason for hiding this comment

Uh oh!

adityarao2005 left a comment

Choose a reason for hiding this comment

Uh oh!

vercel bot commented Feb 16, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

vercel bot commented Feb 16, 2026 •

edited

Loading