main.cpp

Go to the documentation of this file.

#include "bsc/config/Config.hpp"
#include "bsc/logging/Logger.hpp"
#include "bsc/service/DaemonService.hpp"
 
#include <csignal>
#include <iostream>
#include <memory>
#include <string>
 
static std::unique_ptr<bsc::service::DaemonService> g_service;
 
static void on_signal(int) {
    if (g_service) g_service->stop();
}
 
namespace {
 
bool is_flag(const std::string& arg, const std::string& long_name, const std::string& short_name = {}) {
    return arg == long_name || (!short_name.empty() && arg == short_name);
}
 
int clamp_log_level(int lvl) {
    if (lvl <= 0) return 0;
    if (lvl >= 3) return 3;
    return lvl;
}
 
} // namespace
 
int main(int argc, char** argv) {
    std::string config_file = "/etc/bastionguard-secure-connectiond/default-config.json";
    std::string rules_path_override;
    std::string socket_override;
    std::string log_file_override;
    std::string fw_config_override;
    std::string proc_monitor_method_override;
    std::uint16_t queue_num_override = 0;
    bool set_queue_num_override = false;
    bool intercept_unknown_override = false;
    bool set_intercept_override = false;
    bool log_utc_override = true;
    bool set_log_utc_override = false;
    bool log_micro_override = false;
    bool set_log_micro_override = false;
    int log_level_override = -1;
 
    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if ((is_flag(arg, "--config-file", "-config-file")) && i + 1 < argc) config_file = argv[++i];
        else if ((is_flag(arg, "--rules-path", "-rules-path")) && i + 1 < argc) rules_path_override = argv[++i];
        else if ((is_flag(arg, "--ui-socket", "-ui-socket")) && i + 1 < argc) socket_override = argv[++i];
        else if ((is_flag(arg, "--log-file", "-log-file")) && i + 1 < argc) log_file_override = argv[++i];
        else if ((is_flag(arg, "--fw-config-file", "-fw-config-file")) && i + 1 < argc) fw_config_override = argv[++i];
        else if ((is_flag(arg, "--process-monitor-method", "-process-monitor-method")) && i + 1 < argc) proc_monitor_method_override = argv[++i];
        else if ((is_flag(arg, "--queue-num", "-queue-num")) && i + 1 < argc) {
            queue_num_override = static_cast<std::uint16_t>(std::stoul(argv[++i]));
            set_queue_num_override = true;
        }
        else if (is_flag(arg, "--intercept-unknown", "-intercept-unknown")) { intercept_unknown_override = true; set_intercept_override = true; }
        else if (is_flag(arg, "--no-intercept-unknown", "-no-intercept-unknown")) { intercept_unknown_override = false; set_intercept_override = true; }
        else if (is_flag(arg, "--log-utc", "-log-utc")) { log_utc_override = true; set_log_utc_override = true; }
        else if (is_flag(arg, "--no-log-utc", "-no-log-utc")) { log_utc_override = false; set_log_utc_override = true; }
        else if (is_flag(arg, "--log-micro", "-log-micro")) { log_micro_override = true; set_log_micro_override = true; }
        else if (is_flag(arg, "--debug", "-debug")) log_level_override = 0;
        else if (is_flag(arg, "--warning", "-warning")) log_level_override = 1;
        else if (is_flag(arg, "--important", "-important")) log_level_override = 2;
        else if (is_flag(arg, "--error", "-error")) log_level_override = 3;
        else if (arg == "--version" || arg == "-version") { std::cout << "bsc-daemon-cpp 0.6\n"; return 0; }
        else if (arg == "--help" || arg == "-help") {
            std::cout
                << "Usage: bsc-daemon [--config-file PATH] [--rules-path DIR] [--ui-socket URI] [--log-file PATH]\n"
                << "                  [--fw-config-file PATH] [--process-monitor-method proc|netlink|audit|ebpf]\n"
                << "                  [--queue-num N] [--intercept-unknown|--no-intercept-unknown]\n";
            return 0;
        }
    }
 
    auto cfg = bsc::config::load_file(config_file);
    cfg.source_path = config_file;
    if (!rules_path_override.empty()) cfg.rules.path = rules_path_override;
    if (!socket_override.empty()) cfg.server.address = socket_override;
    if (!log_file_override.empty()) cfg.server.log_file = log_file_override;
    if (!fw_config_override.empty()) cfg.fw_options.config_path = fw_config_override;
    if (!proc_monitor_method_override.empty()) cfg.proc_monitor_method = proc_monitor_method_override;
    if (set_queue_num_override) cfg.fw_options.queue_num = queue_num_override;
    if (set_intercept_override) cfg.intercept_unknown = intercept_unknown_override;
    if (set_log_utc_override) cfg.log_utc = log_utc_override;
    if (set_log_micro_override) cfg.log_micro = log_micro_override;
    if (log_level_override >= 0) cfg.log_level = clamp_log_level(log_level_override);
 
    auto& log = bsc::logging::Logger::instance();
    log.set_level(static_cast<bsc::logging::Level>(clamp_log_level(cfg.log_level)));
    log.set_utc(cfg.log_utc);
    log.set_microseconds(cfg.log_micro);
    log.set_log_file(cfg.server.log_file);
 
    std::signal(SIGINT, on_signal);
    std::signal(SIGTERM, on_signal);
    g_service = std::make_unique<bsc::service::DaemonService>(cfg);
    g_service->run();
    g_service.reset();
    return 0;
}