Add IPv6 support, with related listener options

This also adds configuration options for choosing what address to bind to.

Add IPv6 support, with related listener options
This also adds configuration options for choosing what address to bind to.
Wiebe Cazemier
1 parent cb40c2d2
Showing 12 changed files with 209 additions and 40 deletions
CMakeLists.txt
bindaddr.cpp
bindaddr.h
configfileparser.cpp
listener.cpp
listener.h
mainapp.cpp
mainapp.h
scopedsocket.cpp
scopedsocket.h
utils.cpp
utils.h
@@ -33,6 +33,8 @@ add_executable(FlashMQ
     settings.cpp
     listener.cpp
     unscopedlock.cpp
+    scopedsocket.cpp
+    bindaddr.cpp
     )
  
 target_link_libraries(FlashMQ pthread dl ssl crypto)
+#include "bindaddr.h"
+
+
+#ifndef BINDADDR_H
+#define BINDADDR_H
+
+#include <arpa/inet.h>
+#include <memory>
+
+/**
+ * @brief The BindAddr struct helps creating the resource for bind(). It uses an intermediate struct sockaddr to avoid compiler warnings, and
+ * this class helps a bit with resource management of it.
+ */
+struct BindAddr
+{
+    std::unique_ptr<sockaddr> p;
+    socklen_t len = 0;
+};
+
+#endif // BINDADDR_H
@@ -71,6 +71,9 @@ ConfigFileParser::ConfigFileParser(const std::string &amp;path) :
     validListenKeys.insert("protocol");
     validListenKeys.insert("fullchain");
     validListenKeys.insert("privkey");
+    validListenKeys.insert("inet_protocol");
+    validListenKeys.insert("inet4_bind_address");
+    validListenKeys.insert("inet6_bind_address");
  
     settings.reset(new Settings());
 }
@@ -93,7 +96,7 @@ void ConfigFileParser::loadFile(bool test)
  
     std::list<std::string> lines;
  
-    const std::regex key_value_regex("^([a-zA-Z0-9_\\-]+) +([a-zA-Z0-9_\\-/\\.]+)$");
+    const std::regex key_value_regex("^([a-zA-Z0-9_\\-]+) +([a-zA-Z0-9_\\-/\\.:]+)$");
     const std::regex block_regex_start("^([a-zA-Z0-9_\\-]+) *\\{$");
     const std::regex block_regex_end("^\\}$");
  
@@ -211,6 +214,25 @@ void ConfigFileParser::loadFile(bool test)
                 {
                     curListener->sslPrivkey = value;
                 }
+                if (key == "inet_protocol")
+                {
+                    if (value == "ip4")
+                        curListener->protocol = ListenerProtocol::IPv4;
+                    else if (value == "ip6")
+                        curListener->protocol = ListenerProtocol::IPv6;
+                    else if (value == "ip4_ip6")
+                        curListener->protocol = ListenerProtocol::IPv46;
+                    else
+                        throw ConfigFileException(formatString("Invalid inet protocol: %s", value.c_str()));
+                }
+                if (key == "inet4_bind_address")
+                {
+                    curListener->inet4BindAddress = value;
+                }
+                if (key == "inet6_bind_address")
+                {
+                    curListener->inet6BindAddress = value;
+                }
  
                 continue;
             }
@@ -76,3 +76,20 @@ void Listener::loadCertAndKeyFromConfig()
     if (SSL_CTX_use_PrivateKey_file(sslctx->get(), sslPrivkey.c_str(), SSL_FILETYPE_PEM) != 1)
         throw std::runtime_error("Loading key failed. This was after test loading the certificate, so is very unexpected.");
 }
+
+std::string Listener::getBindAddress(ListenerProtocol p)
+{
+    if (p == ListenerProtocol::IPv4)
+    {
+        if (inet4BindAddress.empty())
+            return "0.0.0.0";
+        return inet4BindAddress;
+    }
+    if (p == ListenerProtocol::IPv6)
+    {
+        if (inet6BindAddress.empty())
+            return "::";
+        return inet6BindAddress;
+    }
+    return "";
+}
@@ -6,8 +6,18 @@
  
 #include "sslctxmanager.h"
  
+enum class ListenerProtocol
+{
+    IPv46,
+    IPv4,
+    IPv6
+};
+
 struct Listener
 {
+    ListenerProtocol protocol = ListenerProtocol::IPv46;
+    std::string inet4BindAddress;
+    std::string inet6BindAddress;
     int port = 0;
     bool websocket = false;
     std::string sslFullchain;
@@ -18,5 +28,7 @@ struct Listener
     bool isSsl() const;
     std::string getProtocolName() const;
     void loadCertAndKeyFromConfig();
+
+    std::string getBindAddress(ListenerProtocol p);
 };
 #endif // LISTENER_H
@@ -5,6 +5,7 @@
 #include <unistd.h>
 #include <stdio.h>
 #include <sys/sysinfo.h>
+#include <arpa/inet.h>
  
 #include <openssl/ssl.h>
 #include <openssl/err.h>
@@ -205,47 +206,59 @@ void MainApp::showLicense()
     puts("Author: Wiebe Cazemier <wiebe@halfgaar.net>");
 }
  
-int MainApp::createListenSocket(const std::shared_ptr<Listener> &listener)
+std::list<ScopedSocket> MainApp::createListenSocket(const std::shared_ptr<Listener> &listener)
 {
-    if (listener->port <= 0)
-        return -2;
+    std::list<ScopedSocket> result;
  
-    logger->logf(LOG_NOTICE, "Creating %s listener on port %d", listener->getProtocolName().c_str(), listener->port);
+    if (listener->port <= 0)
+        return result;
  
-    try
+    for (ListenerProtocol p : std::list<ListenerProtocol>({ ListenerProtocol::IPv4, ListenerProtocol::IPv6}))
     {
-        int listen_fd = check<std::runtime_error>(socket(AF_INET, SOCK_STREAM, 0));
+        std::string pname = p == ListenerProtocol::IPv4 ? "IPv4" : "IPv6";
+        int family = p == ListenerProtocol::IPv4 ? AF_INET : AF_INET6;
  
-        // Not needed for now. Maybe I will make multiple accept threads later, with SO_REUSEPORT.
-        int optval = 1;
-        check<std::runtime_error>(setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &optval, sizeof(optval)));
+        if (!(listener->protocol == ListenerProtocol::IPv46 || listener->protocol == p))
+            continue;
  
-        int flags = fcntl(listen_fd, F_GETFL);
-        check<std::runtime_error>(fcntl(listen_fd, F_SETFL, flags | O_NONBLOCK ));
+        try
+        {
+            logger->logf(LOG_NOTICE, "Creating %s %s listener on [%s]:%d", pname.c_str(), listener->getProtocolName().c_str(),
+                         listener->getBindAddress(p).c_str(), listener->port);
  
-        struct sockaddr_in in_addr_plain;
-        in_addr_plain.sin_family = AF_INET;
-        in_addr_plain.sin_addr.s_addr = INADDR_ANY;
-        in_addr_plain.sin_port = htons(listener->port);
+            BindAddr bindAddr = getBindAddr(family, listener->getBindAddress(p), listener->port);
  
-        check<std::runtime_error>(bind(listen_fd, (struct sockaddr *)(&in_addr_plain), sizeof(struct sockaddr_in)));
-        check<std::runtime_error>(listen(listen_fd, 1024));
+            int listen_fd = check<std::runtime_error>(socket(family, SOCK_STREAM, 0));
  
-        struct epoll_event ev;
-        memset(&ev, 0, sizeof (struct epoll_event));
+            // Not needed for now. Maybe I will make multiple accept threads later, with SO_REUSEPORT.
+            int optval = 1;
+            check<std::runtime_error>(setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &optval, sizeof(optval)));
  
-        ev.data.fd = listen_fd;
-        ev.events = EPOLLIN;
-        check<std::runtime_error>(epoll_ctl(this->epollFdAccept, EPOLL_CTL_ADD, listen_fd, &ev));
+            int flags = fcntl(listen_fd, F_GETFL);
+            check<std::runtime_error>(fcntl(listen_fd, F_SETFL, flags | O_NONBLOCK ));
  
-        return listen_fd;
-    }
-    catch (std::exception &ex)
-    {
-        logger->logf(LOG_NOTICE, "Creating %s listener on port %d failed: %s", listener->getProtocolName().c_str(), listener->port, ex.what());
-        return -1;
+            check<std::runtime_error>(bind(listen_fd, bindAddr.p.get(), bindAddr.len));
+            check<std::runtime_error>(listen(listen_fd, 1024));
+
+            struct epoll_event ev;
+            memset(&ev, 0, sizeof (struct epoll_event));
+
+            ev.data.fd = listen_fd;
+            ev.events = EPOLLIN;
+            check<std::runtime_error>(epoll_ctl(this->epollFdAccept, EPOLL_CTL_ADD, listen_fd, &ev));
+
+            result.push_back(ScopedSocket(listen_fd));
+
+        }
+        catch (std::exception &ex)
+        {
+            logger->logf(LOG_ERR, "Creating %s %s listener on [%s]:%d failed: %s", pname.c_str(), listener->getProtocolName().c_str(),
+                         listener->getBindAddress(p).c_str(), listener->port, ex.what());
+            return std::list<ScopedSocket>();
+        }
     }
-    return -1;
+
+    return result;
 }
  
 void MainApp::wakeUpThread()
@@ -367,13 +380,19 @@ void MainApp::start()
 {
     timer.start();
  
-    std::map<int, std::shared_ptr<Listener>> listenerMap;
+    std::map<int, std::shared_ptr<Listener>> listenerMap; // For finding listeners by fd.
+    std::list<ScopedSocket> activeListenSockets; // For RAII/ownership
  
     for(std::shared_ptr<Listener> &listener : this->listeners)
     {
-        int fd = createListenSocket(listener);
-        if (fd > 0)
-            listenerMap[fd] = listener;
+        std::list<ScopedSocket> scopedSockets = createListenSocket(listener);
+
+        for (ScopedSocket &scopedSocket : scopedSockets)
+        {
+            if (scopedSocket.socket > 0)
+                listenerMap[scopedSocket.socket] = listener;
+            activeListenSockets.push_back(std::move(scopedSocket));
+        }
     }
  
 #ifdef NDEBUG
@@ -506,11 +525,6 @@ void MainApp::start()
     {
         thread->waitForQuit();
     }
-
-    for(auto pair : listenerMap)
-    {
-        close(pair.first);
-    }
 }
  
 void MainApp::quit()
@@ -596,3 +610,4 @@ void MainApp::queueCleanup()
  
     wakeUpThread();
 }
+
@@ -10,6 +10,7 @@
 #include <vector>
 #include <functional>
 #include <forward_list>
+#include <list>
  
 #include "forward_declarations.h"
  
@@ -20,6 +21,7 @@
 #include "subscriptionstore.h"
 #include "configfileparser.h"
 #include "timer.h"
+#include "scopedsocket.h"
  
 class MainApp
 {
@@ -48,7 +50,7 @@ class MainApp
     void reloadConfig();
     static void doHelp(const char *arg);
     static void showLicense();
-    int createListenSocket(const std::shared_ptr<Listener> &listener);
+    std::list<ScopedSocket> createListenSocket(const std::shared_ptr<Listener> &listener);
     void wakeUpThread();
     void queueKeepAliveCheckAtAllThreads();
     void setFuzzFile(const std::string &fuzzFilePath);
+#include "scopedsocket.h"
+
+ScopedSocket::ScopedSocket(int socket) : socket(socket)
+{
+
+}
+
+ScopedSocket::ScopedSocket(ScopedSocket &&other)
+{
+    this->socket = other.socket;
+    other.socket = 0;
+}
+
+ScopedSocket::~ScopedSocket()
+{
+    if (socket > 0)
+        close(socket);
+}
+#ifndef SCOPEDSOCKET_H
+#define SCOPEDSOCKET_H
+
+#include <fcntl.h>
+#include <unistd.h>
+
+/**
+ * @brief The ScopedSocket struct allows for a bit of RAII and move semantics on a socket fd.
+ */
+struct ScopedSocket
+{
+    int socket = 0;
+    ScopedSocket(int socket);
+    ScopedSocket(ScopedSocket &&other);
+    ~ScopedSocket();
+};
+
+#endif // SCOPEDSOCKET_H
@@ -427,3 +427,41 @@ std::string dirnameOf(const std::string&amp; path)
      return (std::string::npos == pos) ? "" : path.substr(0, pos);
 }
  
+
+BindAddr getBindAddr(int family, const std::string &bindAddress,  int port)
+{
+    BindAddr result;
+
+    if (family == AF_INET)
+    {
+        struct sockaddr_in *in_addr_v4 = new sockaddr_in();
+        result.len = sizeof(struct sockaddr_in);
+        memset(in_addr_v4, 0, result.len);
+
+        if (bindAddress.empty())
+            in_addr_v4->sin_addr.s_addr = INADDR_ANY;
+        else
+            inet_pton(AF_INET, bindAddress.c_str(), &in_addr_v4->sin_addr);
+
+        in_addr_v4->sin_family = AF_INET;
+        in_addr_v4->sin_port = htons(port);
+        result.p.reset(reinterpret_cast<sockaddr*>(in_addr_v4));
+    }
+    if (family == AF_INET6)
+    {
+        struct sockaddr_in6 *in_addr_v6 = new sockaddr_in6();
+        result.len = sizeof(struct sockaddr_in6);
+        memset(in_addr_v6, 0, result.len);
+
+        if (bindAddress.empty())
+            in_addr_v6->sin6_addr = IN6ADDR_ANY_INIT;
+        else
+            inet_pton(AF_INET6, bindAddress.c_str(), &in_addr_v6->sin6_addr);
+
+        in_addr_v6->sin6_family = AF_INET6;
+        in_addr_v6->sin6_port = htons(port);
+        result.p.reset(reinterpret_cast<sockaddr*>(in_addr_v6));
+    }
+
+    return result;
+}
@@ -9,8 +9,11 @@
 #include <vector>
 #include <algorithm>
 #include <openssl/evp.h>
+#include <memory>
+#include <arpa/inet.h>
  
 #include "cirbuf.h"
+#include "bindaddr.h"
  
 template<typename T> int check(int rc)
 {
@@ -62,5 +65,7 @@ std::string formatString(const std::string str, ...);
  
 std::string dirnameOf(const std::string& fname);
  
+BindAddr getBindAddr(int family, const std::string &bindAddress, int port);
+
  
 #endif // UTILS_H