mqttbroker.cpp

Go to the documentation of this file.

/*
 * MQTTSuite - A lightweight MQTT Integration System
 * Copyright (C) Volker Christian <me@vchrist.at>
 *               2022, 2023, 2024, 2025
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
/*
 * MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#include "SocketContextFactory.h"                         // IWYU pragma: keep
#include "config.h"
#include "lib/Mqtt.h"
#include "lib/MqttModel.h"
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#ifdef __has_warning
#if __has_warning("-Wcovered-switch-default")
#pragma GCC diagnostic ignored "-Wcovered-switch-default"
#endif
#if __has_warning("-Wnrvo")
#pragma GCC diagnostic ignored "-Wnrvo"
#endif
#endif
#endif
#include "lib/inja.hpp"
#ifdef __GNUC_
#pragma GCC diagnostic pop
#endif
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
#include <core/SNodeC.h>
#include <iot/mqtt/MqttContext.h>
#include <utils/Config.h>
//
 
#ifdef CONFIG_MQTTSUITE_BROKER_TCP_IPV4
#include <express/legacy/in/Server.h>
#ifdef CONFIG_MQTTSUITE_BROKER_TLS_IPV4
#include <express/tls/in/Server.h>
#endif
#endif
 
#ifdef CONFIG_MQTTSUITE_BROKER_TCP_IPV6
#include <express/legacy/in6/Server.h>
#ifdef CONFIG_MQTTSUITE_BROKER_TLS_IPV6
#include <express/tls/in6/Server.h>
#endif
#endif
 
#ifdef CONFIG_MQTTSUITE_BROKER_UNIX
#include <express/legacy/un/Server.h>
#ifdef CONFIG_MQTTSUITE_BROKER_UNIX_TLS
#include <express/tls/un/Server.h>
#endif
#endif
 
//
#ifdef CONFIG_MQTTSUITE_BROKER_TCP_IPV4
#include <net/in/stream/legacy/SocketServer.h>
#ifdef CONFIG_MQTTSUITE_BROKER_TLS_IPV4
#include <net/in/stream/tls/SocketServer.h>
#endif
#endif
 
#ifdef CONFIG_MQTTSUITE_BROKER_TCP_IPV6
#include <net/in6/stream/legacy/SocketServer.h>
#ifdef CONFIG_MQTTSUITE_BROKER_TLS_IPV6
#include <net/in6/stream/tls/SocketServer.h>
#endif
#endif
 
#ifdef CONFIG_MQTTSUITE_BROKER_UNIX
#include <net/un/stream/legacy/SocketServer.h>
#ifdef CONFIG_MQTTSUITE_BROKER_UNIX_TLS
#include <net/un/stream/tls/SocketServer.h>
#endif
#endif
 
#include <web/http/http_utils.h>
//
#include <express/middleware/JsonMiddleware.h>
#include <iot/mqtt/server/broker/Broker.h>
//
#include <log/Logger.h>
//
#include <nlohmann/json.hpp>
// IWYU pragma: no_include <nlohmann/json_fwd.hpp>
// IWYU pragma: no_include <nlohmann/detail/json_ref.hpp>
//
#include <cctype>
#include <cstdlib>
#include <iomanip>
#include <iterator>
#include <list>
#include <sstream>
#include <string>
#include <utility>
 
#endif
 
static void upgrade APPLICATION(req, res) {
    const std::string connectionName = res->getSocketContext()->getSocketConnection()->getConnectionName();
 
    VLOG(2) << connectionName << " HTTP: Upgrade request:\n"
            << httputils::toString(req->method,
                                   req->url,
                                   "HTTP/" + std::to_string(req->httpMajor) + "." + std::to_string(req->httpMinor),
                                   req->queries,
                                   req->headers,
                                   req->trailer,
                                   req->cookies,
                                   std::vector<char>());
 
    if (req->get("sec-websocket-protocol").find("mqtt") != std::string::npos) {
        res->upgrade(req, [req, res, connectionName](const std::string& name) {
            if (!name.empty()) {
                VLOG(1) << connectionName << ": Successful upgrade:";
                VLOG(1) << connectionName << ":    Selected: " << name;
                VLOG(1) << connectionName << ":   Requested: " << req->get("sec-websocket-protocol");
 
                res->end();
            } else {
                VLOG(1) << connectionName << ": Can not upgrade to any of '" << req->get("upgrade") << "'";
 
                res->sendStatus(404);
            }
        });
    } else {
        VLOG(1) << connectionName << ": Unsupported subprotocol(s):";
        VLOG(1) << "    Expected: mqtt";
        VLOG(1) << "   Requested: " << req->get("sec-websocket-protocol");
 
        res->sendStatus(404);
    }
}
 
static std::string href(const std::string& text, const std::string& link) {
    return "<a href=\"" + link + "\" style=\"color:inherit;\">" + text + "</a>";
}
 
static std::string href(const std::string& text, const std::string& url, const std::string& windowId, uint16_t width, uint16_t height) {
    return "<a href=\"#\" onClick=\""
           "let key = '" +
           windowId +
           "'; "
           "if (!localStorage.getItem(key)) "
           "  localStorage.setItem(key, key + '-' + Math.random().toString(36).substr(2, 6)); "
           "let uniqueId = localStorage.getItem(key); "
           "if (!window._openWindows) window._openWindows = {}; "
           "if (!window._openWindows[uniqueId] || window._openWindows[uniqueId].closed) { "
           "  window._openWindows[uniqueId] = window.open('" +
           url + "', uniqueId, 'width=" + std::to_string(width) + ", height=" + std::to_string(height) +
           ",location=no, menubar=no, status=no, toolbar=no'); "
           "} else { "
           "  window._openWindows[uniqueId].focus(); "
           "} return false;\" "
           "style=\"color:inherit;\">" +
           text + "</a>";
}
 
static std::string getOverviewPage(inja::Environment environment,
                                   std::shared_ptr<iot::mqtt::server::broker::Broker> broker,
                                   mqtt::mqttbroker::lib::MqttModel& mqttModel) {
    inja::json json;
 
    json["table-id"] = "overview";
    json["title"] = "MQTTBroker | Active Clients";
    json["voc"] = href("Volker Christian", "https://github.com/VolkerChristian/");
    json["broker"] = href("MQTTBroker", "https://github.com/SNodeC/mqttsuite/tree/master/mqttbroker");
    json["suite"] = href("MQTTSuite", "https://github.com/SNodeC/mqttsuite");
    json["snodec"] = "Powered by " + href("SNode.C", "https://github.com/SNodeC/snode.c");
    json["since"] = mqttModel.onlineSince();
    json["duration"] = mqttModel.onlineDuration();
    json["header_row"] = {"Client ID", "Online Since", "Duration", "Connection", "Local Address", "Remote Address", "Action"};
    json["data_rows"] = inja::json::array();
    json["subscribed_topics"] = inja::json::array();
    json["retained_topics"] = inja::json::array();
 
    const std::map<std::string, std::list<std::pair<std::string, uint8_t>>>& subscribedTopics = broker->getSubscriptionTree();
 
    inja::json& subscribedTopicsJson = json["subscribed_topics"];
    for (const auto& [topic, clients] : subscribedTopics) {
        inja::json topicJson;
 
        topicJson["key"] = topic;
        for (const auto& client : clients) {
            std::ostringstream windowId("window");
            for (char ch : client.first) {
                if (std::isalnum(static_cast<unsigned char>(ch))) {
                    windowId << ch;
                } else {
                    windowId << std::hex << std::uppercase << std::setw(2) << std::setfill('0')
                             << static_cast<int>(static_cast<unsigned char>(ch));
                }
            }
 
            topicJson["values"].push_back({{"client_id", client.first},
                                           {"link", href(client.first, "/client?" + client.first, windowId.str(), 450, 900)},
                                           {"topic", topic},
                                           {"qos", std::to_string(static_cast<int>(client.second))}});
        }
 
        subscribedTopicsJson.push_back(topicJson);
    }
 
    std::list<std::pair<std::string, std::string>> retainTree = broker->getRetainTree();
 
    inja::json& retainedTopicsJson = json["retained_topics"];
    for (const auto& [topic, message] : retainTree) {
        inja::json topicJson;
 
        topicJson["key"] = topic;
        topicJson["values"].push_back(message);
 
        retainedTopicsJson.push_back(topicJson);
    }
 
    return environment.render_file("OverviewPage.html", json);
}
 
static std::string getDetailedPage(inja::Environment environment, const mqtt::mqttbroker::lib::Mqtt* mqtt) {
    return environment.render_file("DetailPage.html",
                                   {{"table-id", "detail"},
                                    {"client_id", mqtt->getClientId()},
                                    {"title", mqtt->getClientId()},
                                    {"header_row", {"Attribute", "Value"}},
                                    {"data_rows",
                                     inja::json::array({{"Client ID", mqtt->getClientId()},
                                                        {"Connection", mqtt->getConnectionName()},
                                                        {"Clean Session", mqtt->getCleanSession() ? "true" : "false"},
                                                        {"Connect Flags", std::to_string(mqtt->getConnectFlags())},
                                                        {"Username", mqtt->getUsername()},
                                                        {"Username Flag", mqtt->getUsernameFlag() ? "true" : "false"},
                                                        {"Password", mqtt->getPassword()},
                                                        {"Password Flag", mqtt->getPasswordFlag() ? "true" : "false"},
                                                        {"Keep Alive", std::to_string(mqtt->getKeepAlive())},
                                                        {"Protocol", mqtt->getProtocol()},
                                                        {"Protocol Level", std::to_string(mqtt->getLevel())},
                                                        {"Loop Prevention", !mqtt->getReflect() ? "true" : "false"},
                                                        {"Will Message", mqtt->getWillMessage()},
                                                        {"Will Topic", mqtt->getWillTopic()},
                                                        {"Will QoS", std::to_string(mqtt->getWillQoS())},
                                                        {"Will Flag", mqtt->getWillFlag() ? "true" : "false"},
                                                        {"Will Retain", mqtt->getWillRetain() ? "true" : "false"}})},
                                    {"client_id", mqtt->getClientId()},
                                    {"topics", mqtt->getSubscriptions()}});
}
 
static std::string getRedirectSpinnerPage(inja::Environment environment, const std::string& location) {
    return environment.render_file("Spinner.html", {{"location", location}});
}
 
static std::string urlDecode(const std::string& encoded) {
    std::string decoded;
    size_t i = 0;
 
    while (i < encoded.length()) {
        char ch = encoded[i];
        if (ch == '%') {
            // Make sure there are at least two characters after '%'
            if (i + 2 < encoded.length() && std::isxdigit(encoded[i + 1]) && std::isxdigit(encoded[i + 2])) {
                // Convert the two hex digits to a character
                std::string hexValue = encoded.substr(i + 1, 2);
                char decodedChar = static_cast<char>(std::stoi(hexValue, nullptr, 16));
                decoded.push_back(decodedChar);
                i += 3; // Skip over the % and the two hex digits
            } else {
                // Malformed encoding, just add the '%' as is.
                decoded.push_back(ch);
                ++i;
            }
        } else if (ch == '+') {
            // Convert '+' to space (common in URL encoding)
            decoded.push_back(' ');
            ++i;
        } else {
            // Regular character, just append it.
            decoded.push_back(ch);
            ++i;
        }
    }
 
    return decoded;
}
 
static express::Router getRouter(const inja::Environment& environment, std::shared_ptr<iot::mqtt::server::broker::Broker> broker) {
    const express::Router& jsonRouter = express::middleware::JsonMiddleware();
 
    jsonRouter.post("/disconnect", [] APPLICATION(req, res) { // cppcheck-suppress unknownMacro
        VLOG(1) << "POST /disconnect";
 
        req->getAttribute<nlohmann::json>(
            [&res](nlohmann::json& json) {
                std::string jsonString = json.dump(4);
 
                VLOG(1) << jsonString;
 
                std::string clientId = json["client_id"].get<std::string>();
                const mqtt::mqttbroker::lib::Mqtt* mqtt = mqtt::mqttbroker::lib::MqttModel::instance().getMqtt(clientId);
 
                if (mqtt != nullptr) {
                    mqtt->getMqttContext()->getSocketConnection()->close();
                    res->send(jsonString);
                } else {
                    res->status(404).send("MQTT client has never existed or already gone away: '" + clientId + "'");
                }
            },
            [&res](const std::string& key) {
                VLOG(1) << "Attribute type not found: " << key;
 
                res->status(400).send("Attribute type not found: " + key);
            });
    });
 
    jsonRouter.post("/unsubscribe", [] APPLICATION(req, res) {
        VLOG(1) << "POST /unsubscribe";
 
        req->getAttribute<nlohmann::json>(
            [&res](nlohmann::json& json) {
                std::string jsonString = json.dump(4);
 
                VLOG(1) << jsonString;
 
                std::string clientId = json["client_id"].get<std::string>();
                std::string topic = json["topic"].get<std::string>();
 
                const mqtt::mqttbroker::lib::Mqtt* mqtt = mqtt::mqttbroker::lib::MqttModel::instance().getMqtt(clientId);
 
                if (mqtt != nullptr) {
                    mqtt->unsubscribe(topic);
                    res->send(jsonString);
                } else {
                    res->status(404).send("MQTT client has never existed or already gone away: '" + clientId + "'");
                }
            },
            [&res](const std::string& key) {
                VLOG(1) << "Attribute type not found: " << key;
 
                res->status(400).send("Attribute type not found: " + key);
            });
    });
 
    jsonRouter.post("/release", [broker] APPLICATION(req, res) {
        VLOG(1) << "POST /release";
 
        req->getAttribute<nlohmann::json>(
            [&res, broker](nlohmann::json& json) {
                std::string jsonString = json.dump(4);
 
                VLOG(1) << jsonString;
 
                std::string topic = json["topic"].get<std::string>();
 
                broker->release(topic);
 
                res->send(jsonString);
            },
            [&res](const std::string& key) {
                VLOG(1) << "Attribute type not found: " << key;
 
                res->status(400).send("Attribute type not found: " + key);
            });
    });
 
    jsonRouter.post("/subscribe", [] APPLICATION(req, res) {
        VLOG(1) << "POST /subscribe";
 
        req->getAttribute<nlohmann::json>(
            [&res](nlohmann::json& json) {
                std::string jsonString = json.dump(4);
 
                VLOG(1) << jsonString;
 
                std::string clientId = json["client_id"].get<std::string>();
                std::string topic = json["topic"].get<std::string>();
                uint8_t qoS = json["qos"].get<uint8_t>();
 
                const mqtt::mqttbroker::lib::Mqtt* mqtt = mqtt::mqttbroker::lib::MqttModel::instance().getMqtt(clientId);
 
                if (mqtt != nullptr) {
                    mqtt->subscribe(topic, qoS);
                    res->send(jsonString);
                } else {
                    res->status(404).send("MQTT client has never existed or already gone away: '" + clientId + "'");
                }
            },
            [&res](const std::string& key) {
                VLOG(1) << "Attribute type not found: " << key;
 
                res->status(400).send("Attribute type not found: " + key);
            });
    });
    const express::Router router;
 
    router.use(jsonRouter);
 
    router.get("/clients", [environment, broker] APPLICATION(req, res) {
        std::string responseString;
        int responseStatus = 200;
 
        try {
            responseString = getOverviewPage(environment, broker, mqtt::mqttbroker::lib::MqttModel::instance());
        } catch (const inja::InjaError& error) {
            responseStatus = 500;
            responseString = "Internal Server Error\n";
            responseString += std::string(error.what()) + " " + error.type + " " + error.message + " " +
                              std::to_string(error.location.line) + ":" + std::to_string(error.location.column);
        }
 
        res->status(responseStatus).send(responseString);
    });
 
    router.get("/client", [environment] APPLICATION(req, res) {
        std::string responseString;
        int responseStatus = 200;
 
        if (req->queries.size() == 1) {
            const mqtt::mqttbroker::lib::Mqtt* mqtt =
                mqtt::mqttbroker::lib::MqttModel::instance().getMqtt(urlDecode(req->queries.begin()->first));
 
            if (mqtt != nullptr) {
                VLOG(1) << "Subscriptions for client " << mqtt->getClientId();
                for (const std::string& subscription : mqtt->getSubscriptions()) {
                    VLOG(1) << "  " << subscription;
                }
 
                try {
                    responseString = getDetailedPage(environment, mqtt);
                } catch (const inja::InjaError& error) {
                    responseStatus = 500;
                    responseString = "Internal Server Error\n";
                    responseString += std::string(error.what()) + " " + error.type + " " + error.message + " " +
                                      std::to_string(error.location.line) + ":" + std::to_string(error.location.column);
                }
            } else {
                responseStatus = 404;
                responseString = "Not Found: " + urlDecode(req->queries.begin()->first);
            }
        } else {
            responseStatus = 400;
            responseString = "Bad Request: No Client requested";
        }
 
        res->status(responseStatus).send(responseString);
    });
 
    router.get("/spinner", [environment] APPLICATION(req, res) {
        std::string responseString;
        int responseStatus = 200;
 
        if (req->queries.size() == 1) {
            responseString = getRedirectSpinnerPage(environment, req->queries.begin()->first);
        } else {
            responseStatus = 400;
            responseString = "Bad Request: No Client requested";
        }
        res->status(responseStatus).send(responseString);
    });
 
    router.get("/ws", [] APPLICATION(req, res) {
        if (req->headers.contains("upgrade")) {
            upgrade(req, res);
        } else {
            res->redirect("/spinner?/clients");
        }
    });
 
    router.get("/mqtt", [] APPLICATION(req, res) {
        if (req->headers.contains("upgrade")) {
            upgrade(req, res);
        } else {
            res->redirect("/spinner?/clients");
        }
    });
 
    router.get("/", [] APPLICATION(req, res) {
        if (req->headers.contains("upgrade")) {
            upgrade(req, res);
        } else {
            res->redirect("/spinner?/clients");
        }
    });
 
    router.get("/sse", [] APPLICATION(req, res) {
        if (web::http::ciContains(req->get("Accept"), "text/event-stream")) {
            res->set("Content-Type", "text/event-stream") //
                .set("Cache-Control", "no-cache")
                .set("Connection", "keep-alive");
            res->sendHeader();
 
            mqtt::mqttbroker::lib::MqttModel::instance().addEventReceiver(res, req->get("Last-Event-ID"));
        } else {
            res->redirect("/spinner?/clients");
        }
    });
 
    return router;
}
 
static void
reportState(const std::string& instanceName, const core::socket::SocketAddress& socketAddress, const core::socket::State& state) {
    switch (state) {
        case core::socket::State::OK:
            VLOG(1) << instanceName << ": listening on '" << socketAddress.toString() << "'";
            break;
        case core::socket::State::DISABLED:
            VLOG(1) << instanceName << ": disabled";
            break;
        case core::socket::State::ERROR:
            VLOG(1) << instanceName << ": " << socketAddress.toString() << ": " << state.what();
            break;
        case core::socket::State::FATAL:
            VLOG(1) << instanceName << ": " << socketAddress.toString() << ": " << state.what();
            break;
    }
}
 
int main(int argc, char* argv[]) {
    utils::Config::addStringOption("--mqtt-mapping-file", "MQTT mapping file (json format) for integration", "[path]", "");
    utils::Config::addStringOption("--mqtt-session-store", "Path to file for the persistent session store", "[path]", "");
    utils::Config::addStringOption(
        "--html-dir", "Path to html source directory", "[path]", std::string(CMAKE_INSTALL_PREFIX) + "/var/www/mqttsuite/mqttbroker");
 
    core::SNodeC::init(argc, argv);
 
    std::shared_ptr<iot::mqtt::server::broker::Broker> broker =
        iot::mqtt::server::broker::Broker::instance(SUBSCRIPTION_MAX_QOS, utils::Config::getStringOptionValue("--mqtt-session-store"));
 
#ifdef CONFIG_MQTTSUITE_BROKER_TCP_IPV4
    net::in::stream::legacy::Server<mqtt::mqttbroker::SocketContextFactory>(
        "in-mqtt",
        [](auto& config) {
            config.setPort(1883);
            config.setRetry();
            config.setDisableNagleAlgorithm();
        },
        broker)
        .listen([](const auto& socketAddress, core::socket::State state) {
            reportState("in-mqtt", socketAddress, state);
        });
 
#ifdef CONFIG_MQTTSUITE_BROKER_TLS_IPV4
    net::in::stream::tls::Server<mqtt::mqttbroker::SocketContextFactory>(
        "in-mqtts",
        [](auto& config) {
            config.setPort(8883);
            config.setRetry();
            config.setDisableNagleAlgorithm();
        },
        broker)
        .listen([](const auto& socketAddress, core::socket::State state) {
            reportState("in-mqtts", socketAddress, state);
        });
#endif
#endif
 
#ifdef CONFIG_MQTTSUITE_BROKER_TCP_IPV6
    net::in6::stream::legacy::Server<mqtt::mqttbroker::SocketContextFactory>(
        "in6-mqtt",
        [](auto& config) {
            config.setPort(1883);
            config.setRetry();
            config.setDisableNagleAlgorithm();
 
            config.setIPv6Only();
        },
        broker)
        .listen([](const auto& socketAddress, core::socket::State state) {
            reportState("in6-mqtt", socketAddress, state);
        });
 
#ifdef CONFIG_MQTTSUITE_BROKER_TLS_IPV6
    net::in6::stream::tls::Server<mqtt::mqttbroker::SocketContextFactory>(
        "in6-mqtts",
        [](auto& config) {
            config.setPort(8883);
            config.setRetry();
            config.setDisableNagleAlgorithm();
 
            config.setIPv6Only();
        },
        broker)
        .listen([](const auto& socketAddress, core::socket::State state) {
            reportState("in6-mqtts", socketAddress, state);
        });
#endif
#endif
 
#ifdef CONFIG_MQTTSUITE_BROKER_UNIX
    net::un::stream::legacy::Server<mqtt::mqttbroker::SocketContextFactory>(
        "un-mqtt",
        [](auto& config) {
            config.setSunPath("/tmp/" + utils::Config::getApplicationName() + "-" + config.getInstanceName());
            config.setRetry();
        },
        broker)
        .listen([](const auto& socketAddress, core::socket::State state) {
            reportState("un-mqtt", socketAddress, state);
        });
 
#ifdef CONFIG_MQTTSUITE_BROKER_UNIX_TLS
    net::un::stream::tls::Server<mqtt::mqttbroker::SocketContextFactory>(
        "un-mqtts",
        [](auto& config) {
            config.setSunPath("/tmp/" + utils::Config::getApplicationName() + "-" + config.getInstanceName());
            config.setRetry();
        },
        broker)
        .listen([](const auto& socketAddress, core::socket::State state) {
            reportState("un-mqtts", socketAddress, state);
        });
#endif
#endif
 
    inja::Environment environment{utils::Config::getStringOptionValue("--html-dir") + "/"};
    express::Router router = getRouter(environment, broker);
 
#ifdef CONFIG_MQTTSUITE_BROKER_TCP_IPV4
    express::legacy::in::Server("in-http", router, reportState, [](auto& config) {
        config.setPort(8080);
        config.setRetry();
        config.setDisableNagleAlgorithm();
    });
 
#ifdef CONFIG_MQTTSUITE_BROKER_TLS_IPV4
    express::tls::in::Server("in-https", router, reportState, [](auto& config) {
        config.setPort(8088);
        config.setRetry();
        config.setDisableNagleAlgorithm();
    });
#endif
#endif
 
#ifdef CONFIG_MQTTSUITE_BROKER_TCP_IPV6
    express::legacy::in6::Server("in6-http", router, reportState, [](auto& config) {
        config.setPort(8080);
        config.setRetry();
        config.setDisableNagleAlgorithm();
 
        config.setIPv6Only();
    });
 
#ifdef CONFIG_MQTTSUITE_BROKER_TLS_IPV6
    express::tls::in6::Server("in6-https", router, reportState, [](auto& config) {
        config.setPort(8088);
        config.setRetry();
        config.setDisableNagleAlgorithm();
 
        config.setIPv6Only();
    });
#endif
#endif
 
#ifdef CONFIG_MQTTSUITE_BROKER_UNIX
    express::legacy::un::Server("un-http", router, reportState, [](auto& config) {
        config.setSunPath("/tmp/" + utils::Config::getApplicationName() + "-" + config.getInstanceName());
    });
 
#ifdef CONFIG_MQTTSUITE_BROKER_UNIX_TLS
    express::tls::un::Server("un-https", router, reportState, [](auto& config) {
        config.setSunPath("/tmp/" + utils::Config::getApplicationName() + "-" + config.getInstanceName());
    });
#endif
#endif
 
    return core::SNodeC::start();
}