main.cpp

Go to the documentation of this file.

#include <cassert>
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <stdexcept>
#include <string>
#include <system_error>
#include <utility>
#include <vector>
 
extern "C" {
#include <arpa/inet.h>
#include <signal.h>
}
 
#include <boost/program_options.hpp>
 
#include "ArpwatchRequestHandler.hpp"
#include "XmlRpcServer.hpp"
#include "util/HiredisAdapter.hpp"
#include "util/HiredisMultiAdapter.hpp"
 
namespace bpo = boost::program_options;
 
namespace
{
constexpr std::uint16_t DEFAULT_XMLRPC_PORT{1082};
 
std::pair<bool, bpo::variables_map> parse_cmdline(int argc, char** argv);
std::pair<std::string_view, int> parse_ip_port_combo(std::string_view ip_port_combo);
aai::XmlRpcServer create_xmlrpc_server(const std::string& ip, uint16_t port);
 
std::ostream& info()
{
    std::cout << "[INFO] ";
    return std::cout;
}
 
std::ostream& warning()
{
    std::cout << "[WARN] ";
    return std::cout;
}
 
std::ostream& error()
{
    std::cout << "[ERR]  ";
    return std::cout;
}
 
bool block_signals(const sigset_t& signals)
{
    // We haven't spawned any threads at this point
    // NOLINTBEGIN(*-mt-unsafe)
    int r = sigprocmask(SIG_BLOCK, &signals, nullptr);
    if (r < 0) {
        error() << "Failed to block signals: " << strerror(errno) << std::endl;
        return false;
    }
    return true;
    // NOLINTEND(*-mt-unsafe)
}
 
bool wait_for_signals(const sigset_t& signals, std::chrono::seconds timeout)
{
    timespec ts{timeout.count(), 0};
    int r;
    // NOLINTNEXTLINE(*-avoid-do-while)
    do {
        r = sigtimedwait(&signals, nullptr, &ts);
    } while (r == -1 && errno == EINTR);
    if (r == -1 && errno != EAGAIN) {
        throw std::system_error(errno, std::system_category(), "Failed to wait for signals");
    }
    return r >= 0;
}
} // namespace
 
int main(int argc, char** argv)
{
    sigset_t signal_set;
    sigemptyset(&signal_set);
    for (int signal : {SIGTERM, SIGINT, SIGQUIT}) {
        sigaddset(&signal_set, signal);
    }
 
    if (!block_signals(signal_set)) {
        return 1;
    }
 
    const auto& [cmdline_valid, cmdline_vm] = parse_cmdline(argc, argv);
    if (!cmdline_valid) {
        return 1;
    }
 
    const std::string listen_ip{
      cmdline_vm.count("listen-ip") > 0 ? cmdline_vm["listen-ip"].as<std::string>() : ""};
    const uint16_t listen_port{cmdline_vm["listen-port"].as<uint16_t>()};
    const std::vector<std::string> redis_server_connstrs{
      cmdline_vm["redis-server"].as<std::vector<std::string>>()};
 
    std::vector<HiredisAdapter> redis_adapters;
    redis_adapters.reserve(redis_server_connstrs.size());
    for (const auto& connstr : redis_server_connstrs) {
        const auto& [ip, port] = parse_ip_port_combo(connstr);
        if (port > 0) {
            redis_adapters.emplace_back(std::string{ip}, port);
        } else {
            redis_adapters.emplace_back(std::string{ip});
        }
    }
 
    HiredisMultiAdapter redis{redis_adapters};
    info() << "Connecting to redis servers\n";
    redis.connect();
 
    aai::ArpwatchRequestHandler request_handler{redis};
    aai::XmlRpcServer xmlrpc_server{create_xmlrpc_server(listen_ip, listen_port)};
    request_handler.register_method_handlers(xmlrpc_server);
 
    info() << "Starting XML-RPC server and request handler\n";
    xmlrpc_server.start();
 
    while (!wait_for_signals(signal_set, std::chrono::minutes(1))) {
        if (!redis.is_connected()) {
            warning() << "Lost connection to Redis server. Reconnecting\n";
            redis.disconnect();
            redis.connect();
        }
    }
 
    info() << "Stopping AdminDB ARPwatch interface\n";
    xmlrpc_server.stop();
    redis.disconnect();
 
    return 0;
}
 
namespace
{
std::pair<bool, bpo::variables_map> parse_cmdline(int argc, char** argv)
{
    bpo::options_description options_desc{"ARPwatch XML-RPC interface for Kea DHCP servers"};
    // clang-format off
    options_desc.add_options()
        ("help,h",
            "Print this help message and exit")
        ("listen-ip,i", bpo::value<std::string>(),
            "IP address to listen for XML-RPC requests on")
        ("listen-port,l", bpo::value<uint16_t>()->default_value(DEFAULT_XMLRPC_PORT),
            "Port to listen for XML-RPC reqeuests on")
        ("redis-server,r", bpo::value<std::vector<std::string>>(),
            "Redis server(s) to query")
    ;
    // clang-format on
 
    bpo::variables_map vm;
    bpo::store(bpo::parse_command_line(argc, argv, options_desc), vm);
    bpo::notify(vm);
 
    bool retval{true};
 
    if (vm.count("help") > 0) {
        std::clog << options_desc << '\n';
        // We are single-threaded at this point
        // NOLINTNEXTLINE(*-mt-unsafe)
        std::exit(0);
    }
 
    if (vm.count("redis-server") == 0) {
        std::clog << "Missing --redis-server!\n";
        retval = false;
    }
 
    return std::make_pair(retval, std::move(vm));
}
 
std::pair<std::string_view, int> parse_ip_port_combo(std::string_view ip_port_combo)
{
    const auto separator = ip_port_combo.find_last_of(':');
 
    if (separator == std::string_view::npos) {
        return std::make_pair(ip_port_combo, 0);
    }
 
    std::string_view ip = ip_port_combo.substr(0, separator);
    std::string_view port_str = ip_port_combo.substr(separator + 1);
 
    return std::make_pair(ip, boost::lexical_cast<int>(port_str));
}
 
aai::XmlRpcServer create_xmlrpc_server(const std::string& ip, uint16_t port)
{
    if (ip.empty()) {
        return aai::XmlRpcServer{port};
    }
 
    // sockaddr expects the port in network byte order
    port = htons(port);
 
    struct in6_addr in6_a
    {
    };
    int is_v6 = inet_pton(AF_INET6, ip.c_str(), &in6_a);
 
    if (is_v6 != 0) {
        const struct sockaddr_in6 sin6
        {
            .sin6_family = AF_INET6, .sin6_port = port, .sin6_flowinfo = 0, .sin6_addr = in6_a,
            .sin6_scope_id = 0
        };
        // NOLINTNEXTLINE(*-reinterpret-cast)
        return aai::XmlRpcServer{reinterpret_cast<const struct sockaddr*>(&sin6), sizeof(sin6)};
    }
 
    struct in_addr in4_a
    {
    };
    int is_v4 = inet_pton(AF_INET, ip.c_str(), &in4_a);
 
    if (is_v4 == 0) {
        throw std::invalid_argument{"Invalid listen IP address"};
    }
 
    const struct sockaddr_in sin4
    {
        .sin_family = AF_INET, .sin_port = port, .sin_addr = in4_a, .sin_zero = {
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0
        }
    };
    // NOLINTNEXTLINE(*-reinterpret-cast)
    return aai::XmlRpcServer{reinterpret_cast<const struct sockaddr*>(&sin4), sizeof(sin4)};
}
} // namespace