Adding loopback interface support

Author: gershnik

src/command_line.cpp

@@ -274,6 +274,11 @@ void CommandLine::parse(int argc, char * argv[]) {
                handler([this](std::string_view val){
         this->sourcePort = Argum::parseIntegral<unsigned>(val);
     }));
+    parser.add(Option("--enable-loopback").
+               help("enable receiving/sending on loopback interface.").
+               handler([this]() {
+        this->enableLoopback = true;
+    }));
 
     //Machine info
     parser.add(Option("--uuid").
@@ -432,6 +437,12 @@ void CommandLine::parseConfigKey(std::string_view keyName, const toml::node & va
             this->sourcePort = uint16_t(*val);
         });
 
+    } else if (keyName == "enable-loopback"sv) {
+        
+        setConfigValue<bool>(bool(this->enableLoopback), keyName, value, [this](const toml::value<bool> & val) {
+            this->enableLoopback = *val;
+        });
+        
     } else
 
     //Machine info

src/command_line.h

@@ -15,6 +15,7 @@ struct CommandLine {
     std::optional<AllowedAddressFamily> allowedAddressFamily;
     std::optional<int> hoplimit;
     std::optional<uint16_t> sourcePort;
+    std::optional<bool> enableLoopback;
 
     std::optional<Uuid> uuid;
     std::optional<sys_string> hostname;

src/config.cpp

@@ -12,6 +12,7 @@ Config::Config(const CommandLine & cmdline):
     m_allowedAddressFamily = cmdline.allowedAddressFamily.value_or(BothIPv4AndIPv6);
     m_interfaceWhitelist.insert(cmdline.interfaces.begin(), cmdline.interfaces.end());
     m_sourcePort = cmdline.sourcePort.value_or(0);
+    m_enableLoopback = cmdline.enableLoopback.value_or(false);
 
     m_fullHostName = getHostName();
     m_simpleHostName = m_fullHostName.prefix_before_first(U'.').value_or(m_fullHostName);

src/config.h

@@ -48,6 +48,7 @@ class Config : public ref_counted<Config> {
     auto enableIPv4() const -> bool                         { return m_allowedAddressFamily != IPv6Only; }
     auto enableIPv6() const -> bool                         { return m_allowedAddressFamily != IPv4Only; }
     auto hopLimit() const -> int                            { return m_hopLimit; }
+    auto enableLoopback() const -> bool                     { return m_enableLoopback; }
     auto isAllowedInterface(const sys_string & name) const -> bool {
         return m_interfaceWhitelist.empty() || m_interfaceWhitelist.contains(name);
     }
@@ -82,6 +83,7 @@ class Config : public ref_counted<Config> {
     int m_hopLimit = 1;
     std::set<sys_string> m_interfaceWhitelist;
     uint16_t m_sourcePort;
+    bool m_enableLoopback;
 
     size_t m_pageSize;
 };

src/interface_monitor_bsd.cpp

@@ -118,7 +118,7 @@ class InterfaceMonitorImpl : public InterfaceMonitor {
             sys_string name(req.lifr_name);
 
             auto interfaceFlags = ioctlSocket<GetLInterfaceFlags>(m_socket, name).value();
-            if ((interfaceFlags & IFF_LOOPBACK) || !(interfaceFlags & IFF_MULTICAST))
+            if (isUnusableInterface(interfaceFlags))
                 continue;
             auto index = ioctlSocket<GetLInterfaceIndex>(m_socket, name).value();
             m_handler->addAddress(NetworkInterface(index, name), addr);
@@ -204,7 +204,7 @@ class InterfaceMonitorImpl : public InterfaceMonitor {
                 }
 
                 if (header->rtm_type == RTM_IFINFO) {
-                    knownIfaces[result.iface->index] = (interfaceFlags & IFF_LOOPBACK) || !(interfaceFlags & IFF_MULTICAST);
+                    knownIfaces[result.iface->index] = isUnusableInterface(interfaceFlags);
                 } else {
                     if (auto it = knownIfaces.find(result.iface->index); it == knownIfaces.end()) {
                         #if HAVE_SIOCGLIFCONF
@@ -214,7 +214,7 @@ class InterfaceMonitorImpl : public InterfaceMonitor {
                         #endif
                         if (auto flagsRes = ioctlSocket<GetInterfaceFlagsType>(m_socket, result.iface->name)) {
                             interfaceFlags = flagsRes.assume_value();
-                            bool ignore = (interfaceFlags & IFF_LOOPBACK) || !(interfaceFlags & IFF_MULTICAST);
+                            bool ignore = isUnusableInterface(interfaceFlags);
                             knownIfaces.emplace(result.iface->index, ignore);
                         }
                     }
@@ -288,17 +288,29 @@ class InterfaceMonitorImpl : public InterfaceMonitor {
                 ignore = it->second;
             }
 
-            if (!ignore)
+            if (!ignore) {
                 m_handler->addAddress(iface, addr);
-            else
+            } else if (m_config->enableLoopback()) {
+                WSDLOG_DEBUG("Interface {} doesn't support multicast - ignoring", iface);
+            } else {
                 WSDLOG_DEBUG("Interface {} is loopback or doesn't support multicast - ignoring", iface);
+            }
 
         } else {
 
             m_handler->removeAddress(iface, addr);
         }
     }
 
+    template<class T>
+    bool isUnusableInterface(T interfaceFlags) {
+        bool res = !(interfaceFlags & IFF_MULTICAST);
+        if (!res && !m_config->enableLoopback()) {
+            res = (interfaceFlags & IFF_LOOPBACK);
+        }
+        return res;
+    }
+
 private:
     const refcnt_ptr<Config> m_config;
     Handler * m_handler = nullptr;

src/interface_monitor_linux.cpp

@@ -226,7 +226,10 @@ class InterfaceMonitorImpl : public InterfaceMonitor {
             if (auto it = knownIfaces.find(iface.index); it == knownIfaces.end()) {
                 if (auto flagsRes = ioctlSocket<GetInterfaceFlags>(m_socket, iface.name)) {
                     auto flags = flagsRes.assume_value();
-                    ignore = (flags & IFF_LOOPBACK) || !(flags & IFF_MULTICAST);
+                    ignore = !(interfaceFlags & IFF_MULTICAST);
+                    if (!ignore && !m_config->enableLoopback()) {
+                        ignore = (interfaceFlags & IFF_LOOPBACK);
+                    }
                     knownIfaces[iface.index] = ignore;
                 } else {
                     WSDLOG_ERROR("Unable to obtain flags for interface {0}, {1}", iface, flagsRes.assume_error().message());
@@ -237,6 +240,8 @@ class InterfaceMonitorImpl : public InterfaceMonitor {
 
             if (!ignore)
                 m_handler->addAddress(iface, addr);
+            else if (m_config->enableLoopback())
+                WSDLOG_DEBUG("Interface {} doesn't support multicast - ignoring", iface);
             else
                 WSDLOG_DEBUG("Interface {} is loopback or doesn't support multicast - ignoring", iface);
         } else {