Send multicast packets to each interface

Author: tstenner

src/api_config.cpp

@@ -1,4 +1,5 @@
 #include "api_config.h"
+#include "cast.h"
 #include "common.h"
 #include "inireader.h"
 #include <algorithm>
@@ -8,7 +9,7 @@
 #include <mutex>
 #include <stdexcept>
 
-using namespace lsl;
+namespace lsl {
 
 /// Substitute the "~" character by the full home directory (according to environment variables).
 std::string expand_tilde(const std::string &filename) {
@@ -183,6 +184,37 @@ void api_config::load_from_file(const std::string &filename) {
 		if (ttl_override >= 0) multicast_ttl_ = ttl_override;
 		if (!address_override.empty()) multicast_addresses_ = address_override;
 
+		// The network stack requires the source interfaces for multicast packets to be
+		// specified as IPv4 address or an IPv6 interface index
+		// Try getting the interfaces from the configuration files
+		using namespace lslboost::asio::ip;
+		std::vector<std::string> netifs = parse_set(pt.get("multicast.Interfaces", "{}"));
+		for (const auto &netifstr : netifs) {
+			netif if_;
+			if_.name = std::string("Configured in lslapi.cfg");
+			if_.addr = make_address(netifstr);
+			if (if_.addr.is_v6()) if_.ifindex = if_.addr.to_v6().scope_id();
+			multicast_interfaces.push_back(if_);
+		}
+		// Try getting the interfaces from the OS
+		if (multicast_interfaces.empty()) multicast_interfaces = get_local_interfaces();
+
+		// Otherwise, let the OS select an appropriate network interface
+		if (multicast_interfaces.empty()) {
+			LOG_F(ERROR,
+				"No local network interface addresses found, resolving streams will likely "
+				"only work for devices connected to the main network adapter\n");
+			// Add dummy interface with default settings
+			netif dummy;
+			dummy.name = "Dummy interface";
+			dummy.addr = address_v4::any();
+			multicast_interfaces.push_back(dummy);
+			dummy.name = "IPv6 dummy interface";
+			dummy.addr = address_v6::any();
+			multicast_interfaces.push_back(dummy);
+		}
+
+
 		// read the [lab] settings
 		known_peers_ = parse_set(pt.get("lab.KnownPeers", "{}"));
 		session_id_ = pt.get("lab.SessionID", "default");
@@ -212,7 +244,7 @@ void api_config::load_from_file(const std::string &filename) {
 		force_default_timestamps_ = pt.get("tuning.ForceDefaultTimestamps", false);
 
 		// read the [log] settings
-		int log_level = pt.get("log.level", (int) loguru::Verbosity_INFO);
+		int log_level = pt.get("log.level", (int)loguru::Verbosity_INFO);
 		if (log_level < -3 || log_level > 9)
 			throw std::runtime_error("Invalid log.level (valid range: -3 to 9");
 
@@ -251,3 +283,5 @@ api_config *api_config::get_instance_internal() {
 	static api_config cfg;
 	return &cfg;
 }
+
+}

src/api_config.h

@@ -1,6 +1,8 @@
 #ifndef API_CONFIG_H
 #define API_CONFIG_H
 
+#include "netinterfaces.h"
+#include <loguru.hpp>
 #include <cstdint>
 #include <string>
 #include <vector>
@@ -106,8 +108,16 @@ class api_config {
 	const std::string &listen_address() const { return listen_address_; }
 
 	/**
-	 * @brief The TTL setting (time-to-live) for the multicast packets.
+	 * A list of local interface addresses the multicast packets should be
+	 * sent from.
 	 *
+	 * The ini file may contain IPv4 addresses and/or IPv6 addresses with the
+	 * interface index as scope id, e.g. `1234:5678::2%3`
+	 **/
+	std::vector<lsl::netif> multicast_interfaces;
+
+	/**
+	 * The TTL setting (time-to-live) for the multicast packets.
 	 * This is determined according to the ResolveScope setting if not overridden by the TTLOverride
 	 * setting. The higher this number (0-255), the broader their distribution. Routers (if
 	 * correctly configured) employ various thresholds below which packets are not further

src/cast.cpp

@@ -36,5 +36,6 @@ template signed char from_string(const std::string &);
 template char from_string(const std::string &);
 template int16_t from_string(const std::string &);
 template int32_t from_string(const std::string &);
+template uint32_t from_string(const std::string &);
 template int64_t from_string(const std::string &);
 } // namespace lsl

src/resolve_attempt_udp.cpp

@@ -1,5 +1,6 @@
 #include "resolve_attempt_udp.h"
 #include "api_config.h"
+#include "netinterfaces.h"
 #include "resolver_impl.h"
 #include "socket_utils.h"
 #include <boost/asio/ip/multicast.hpp>
@@ -9,13 +10,16 @@
 using namespace lsl;
 namespace asio = lslboost::asio;
 using err_t = const lslboost::system::error_code &;
+using asio::ip::multicast::outbound_interface;
 
 resolve_attempt_udp::resolve_attempt_udp(asio::io_context &io, const udp &protocol,
 	const std::vector<udp::endpoint> &targets, const std::string &query, result_container &results,
 	std::mutex &results_mut, double cancel_after, cancellable_registry *registry)
 	: io_(io), results_(results), results_mut_(results_mut), cancel_after_(cancel_after),
 	  cancelled_(false), targets_(targets), query_(query), unicast_socket_(io),
-	  broadcast_socket_(io), multicast_socket_(io), recv_socket_(io), cancel_timer_(io) {
+	  broadcast_socket_(io), multicast_socket_(io),
+	  multicast_interfaces(api_config::get_instance()->multicast_interfaces), recv_socket_(io),
+	  cancel_timer_(io) {
 	// open the sockets that we might need
 	recv_socket_.open(protocol);
 	try {
@@ -69,7 +73,7 @@ void resolve_attempt_udp::begin() {
 	// initiate the result gathering chain
 	receive_next_result();
 	// initiate the send chain
-	send_next_query(targets_.begin());
+	send_next_query(targets_.begin(), multicast_interfaces.begin());
 
 	// also initiate the cancel event, if desired
 	if (cancel_after_ != FOREVER) {
@@ -143,27 +147,41 @@ void resolve_attempt_udp::handle_receive_outcome(error_code err, std::size_t len
 
 // === send loop ===
 
-void resolve_attempt_udp::send_next_query(endpoint_list::const_iterator next) {
-	if (next == targets_.end() || cancelled_) return;
-
-	udp::endpoint ep(*next++);
-	// endpoint matches our active protocol?
-	if (ep.protocol() == recv_socket_.local_endpoint().protocol()) {
-		// select socket to use
-		udp::socket &sock =
-			(ep.address() == asio::ip::address_v4::broadcast())
-				? broadcast_socket_
-				: (ep.address().is_multicast() ? multicast_socket_ : unicast_socket_);
-		// and send the query over it
-		sock.async_send_to(lslboost::asio::buffer(query_msg_), ep,
-			[shared_this = shared_from_this(), next](err_t err, size_t /*unused*/) {
-				if (!shared_this->cancelled_ && err != asio::error::operation_aborted &&
-					err != asio::error::not_connected && err != asio::error::not_socket)
-					shared_this->send_next_query(next);
-			});
+void resolve_attempt_udp::send_next_query(
+	endpoint_list::const_iterator next, mcast_interface_list::const_iterator mcit) {
+	if (cancelled_ || mcit == multicast_interfaces.end()) return;
+	auto proto = recv_socket_.local_endpoint().protocol();
+	if (next == targets_.begin()) {
+		// Mismatching protocols? Skip this round
+		if(mcit->addr.is_v4() != (proto==asio::ip::udp::v4()))
+			next = targets_.end();
+		else
+			multicast_socket_.set_option(mcit->addr.is_v4() ? outbound_interface(mcit->addr.to_v4())
+															: outbound_interface(mcit->ifindex));
+	}
+	if (next != targets_.end()) {
+		udp::endpoint ep(*next++);
+		// endpoint matches our active protocol?
+		if (ep.protocol() == recv_socket_.local_endpoint().protocol()) {
+			// select socket to use
+			udp::socket &sock =
+				(ep.address() == asio::ip::address_v4::broadcast())
+					? broadcast_socket_
+					: (ep.address().is_multicast() ? multicast_socket_ : unicast_socket_);
+			// and send the query over it
+			auto keepalive(shared_from_this());
+			sock.async_send_to(
+				lslboost::asio::buffer(query_msg_), ep, [shared_this = shared_from_this(), next, mcit](err_t err, size_t /*unused*/) {
+					if (!shared_this->cancelled_ && err != asio::error::operation_aborted &&
+						err != asio::error::not_connected && err != asio::error::not_socket)
+						shared_this->send_next_query(next, mcit);
+				});
+		} else
+			// otherwise just go directly to the next query
+			send_next_query(next, mcit);
 	} else
-		// otherwise just go directly to the next query
-		send_next_query(next);
+		// Restart from the next interface
+		send_next_query(targets_.begin(), ++mcit);
 }
 
 void resolve_attempt_udp::do_cancel() {

src/resolve_attempt_udp.h

@@ -2,7 +2,9 @@
 #define RESOLVE_ATTEMPT_UDP_H
 
 #include "cancellation.h"
+#include "netinterfaces.h"
 #include "stream_info_impl.h"
+#include <boost/asio/ip/multicast.hpp>
 #include <boost/asio/ip/udp.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <map>
@@ -20,6 +22,8 @@ namespace lsl {
 
 /// A container for resolve results (map from stream instance UID onto (stream_info,receive-time)).
 typedef std::map<std::string, std::pair<stream_info_impl, double>> result_container;
+/// A container for outgoing multicast interfaces
+typedef std::vector<class netif> mcast_interface_list;
 
 /**
  * An asynchronous resolve attempt for a single query targeted at a set of endpoints, via UDP.
@@ -78,7 +82,8 @@ class resolve_attempt_udp : public cancellable_obj,
 	void receive_next_result();
 
 	/// Thos function starts an async send operation for the given current endpoint.
-	void send_next_query(endpoint_list::const_iterator next);
+	void send_next_query(
+		endpoint_list::const_iterator next, mcast_interface_list::const_iterator mcit);
 
 	/// Handler that gets called when a receive has completed.
 	void handle_receive_outcome(error_code err, std::size_t len);
@@ -124,6 +129,8 @@ class resolve_attempt_udp : public cancellable_obj,
 	udp::socket broadcast_socket_;
 	/// socket to send data over (for multicasts)
 	udp::socket multicast_socket_;
+	/// Interface addresses to send multicast packets from
+	const mcast_interface_list &multicast_interfaces;
 	/// socket to receive replies (always unicast)
 	udp::socket recv_socket_;
 	/// timer to schedule the cancel action