stellar-stellar/src/config/config.cpp

#include <errno.h>
#include <stdlib.h>
#include <string.h>

#include "config.h"
#include "toml.h"

// return  0: success
// retuun -1: failed
static int parse_system_section(struct config *cfg, toml_table_t *conf_file_handle)
{
    const char *ptr;
    toml_table_t *system_table;
    toml_array_t *mask_array;

    system_table = toml_table_in(conf_file_handle, "system");
    if (system_table == NULL)
    {
        CONFIG_LOG_ERROR("config file missing system section");
        return -1;
    }

    ptr = toml_raw_in(system_table, "app_symbol");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing system.app_symbol");
        return -1;
    }
    strncpy(cfg->sys_cfg.app_symbol, ptr, sizeof(cfg->sys_cfg.app_symbol) - 1);

    ptr = toml_raw_in(system_table, "dev_symbol");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing system.dev_symbol");
        return -1;
    }
    strncpy(cfg->sys_cfg.dev_symbol, ptr, sizeof(cfg->sys_cfg.dev_symbol) - 1);

    ptr = toml_raw_in(system_table, "nr_threads");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing system.nr_threads");
        return -1;
    }
    cfg->sys_cfg.nr_threads = atoi(ptr);

    mask_array = toml_array_in(system_table, "cpu_mask");
    if (mask_array == NULL)
    {
        CONFIG_LOG_ERROR("config file missing system.cpu_mask");
        return -1;
    }
    for (uint16_t i = 0; i < cfg->sys_cfg.nr_threads; i++)
    {
        ptr = toml_raw_at(mask_array, i);
        if (ptr == NULL)
        {
            CONFIG_LOG_ERROR("config file missing system.cpu_mask[%d]", i);
            return -1;
        }
        cfg->sys_cfg.cpu_mask[i] = atoi(ptr);
    }

    return 0;
}

// return  0: success
// retuun -1: failed
static int parse_session_manager_section(struct config *cfg, toml_table_t *conf_file_handle)
{
    const char *ptr;
    toml_table_t *sess_mgr_table;

    sess_mgr_table = toml_table_in(conf_file_handle, "session_manager");
    if (sess_mgr_table == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager section");
        return -1;
    }

    // max session number
    ptr = toml_raw_in(sess_mgr_table, "max_tcp_session_num");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.max_tcp_session_num");
        return -1;
    }
    cfg->sess_mgr_cfg.max_tcp_session_num = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "max_udp_session_num");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.max_udp_session_num");
        return -1;
    }
    cfg->sess_mgr_cfg.max_udp_session_num = atoll(ptr);

    // session overload (1: evict old session, 0: bypass new session)
    ptr = toml_raw_in(sess_mgr_table, "tcp_overload_evict_old_sess");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_overload_evict_old_sess");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_overload_evict_old_sess = atoi(ptr);

    ptr = toml_raw_in(sess_mgr_table, "udp_overload_evict_old_sess");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.udp_overload_evict_old_sess");
        return -1;
    }
    cfg->sess_mgr_cfg.udp_overload_evict_old_sess = atoi(ptr);

    // TCP timeout
    ptr = toml_raw_in(sess_mgr_table, "tcp_timeout_init");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_init");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_timeout_init = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "tcp_timeout_handshake");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_handshake");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_timeout_handshake = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "tcp_timeout_data");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_data");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_timeout_data = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "tcp_timeout_half_closed");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_half_closed");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_timeout_half_closed = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "tcp_timeout_time_wait");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_time_wait");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_timeout_time_wait = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "tcp_timeout_discard");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_timeout_discard");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_timeout_discard = atoll(ptr);

    // UDP timeout
    ptr = toml_raw_in(sess_mgr_table, "udp_timeout_data");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.udp_timeout_data");
        return -1;
    }
    cfg->sess_mgr_cfg.udp_timeout_data = atoll(ptr);

    // TCP duplicate packet filter
    ptr = toml_raw_in(sess_mgr_table, "tcp_dupkt_filter_enable");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_dupkt_filter_enable");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_dupkt_filter_enable = atoi(ptr);

    ptr = toml_raw_in(sess_mgr_table, "tcp_dupkt_filter_capacity");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_dupkt_filter_capacity");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_dupkt_filter_capacity = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "tcp_dupkt_filter_timeout");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_dupkt_filter_timeout");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_dupkt_filter_timeout = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "tcp_dupkt_filter_error_rate");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.tcp_dupkt_filter_error_rate");
        return -1;
    }
    cfg->sess_mgr_cfg.tcp_dupkt_filter_error_rate = atof(ptr);

    // UDP eviction filter
    ptr = toml_raw_in(sess_mgr_table, "udp_eviction_filter_enable");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.udp_eviction_filter_enable");
        return -1;
    }
    cfg->sess_mgr_cfg.udp_eviction_filter_enable = atoi(ptr);

    ptr = toml_raw_in(sess_mgr_table, "udp_eviction_filter_capacity");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.udp_eviction_filter_capacity");
        return -1;
    }
    cfg->sess_mgr_cfg.udp_eviction_filter_capacity = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "udp_eviction_filter_timeout");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.udp_eviction_filter_timeout");
        return -1;
    }
    cfg->sess_mgr_cfg.udp_eviction_filter_timeout = atoll(ptr);

    ptr = toml_raw_in(sess_mgr_table, "udp_eviction_filter_error_rate");
    if (ptr == NULL)
    {
        CONFIG_LOG_ERROR("config file missing session_manager.udp_eviction_filter_error_rate");
        return -1;
    }
    cfg->sess_mgr_cfg.udp_eviction_filter_error_rate = atof(ptr);

    return 0;
}

// return  0: success
// retuun -1: failed
int config_load(struct config *cfg, const char *cfg_file)
{
    int ret = -1;
    char errbuf[200];
    FILE *fp = NULL;
    toml_table_t *conf_file_handle = NULL;

    memset(cfg, 0, sizeof(*cfg));

    fp = fopen(cfg_file, "r");
    if (fp == NULL)
    {
        CONFIG_LOG_ERROR("open config file %s failed, %s", cfg_file, strerror(errno));
        goto error_out;
    }

    conf_file_handle = toml_parse_file(fp, errbuf, sizeof(errbuf));
    if (conf_file_handle == NULL)
    {
        CONFIG_LOG_ERROR("parse config file %s failed, %s", cfg_file, errbuf);
        goto error_out;
    }

    // system config
    if (parse_system_section(cfg, conf_file_handle) != 0)
    {
        goto error_out;
    }

    // session manager config
    if (parse_session_manager_section(cfg, conf_file_handle) != 0)
    {
        goto error_out;
    }

    ret = 0;

error_out:
    if (conf_file_handle)
    {
        toml_free(conf_file_handle);
    }

    if (fp)
    {
        fclose(fp);
    }

    return ret;
}

void config_dump(struct config *cfg)
{
    if (cfg == NULL)
    {
        return;
    }

    CONFIG_LOG_DEBUG("system.app_symbol       : %s", cfg->sys_cfg.app_symbol);
    CONFIG_LOG_DEBUG("system.dev_symbol       : %s", cfg->sys_cfg.dev_symbol);
    CONFIG_LOG_DEBUG("system.nr_threads       : %d", cfg->sys_cfg.nr_threads);
    for (uint16_t i = 0; i < cfg->sys_cfg.nr_threads; i++)
    {
        CONFIG_LOG_DEBUG("system.cpu_mask[%d]      : %d", i, cfg->sys_cfg.cpu_mask[i]);
    }

    CONFIG_LOG_DEBUG("session_manager.max_tcp_session_num            : %ld", cfg->sess_mgr_cfg.max_tcp_session_num);
    CONFIG_LOG_DEBUG("session_manager.max_udp_session_num            : %ld", cfg->sess_mgr_cfg.max_udp_session_num);

    CONFIG_LOG_DEBUG("session_manager.tcp_overload_evict_old_sess    : %d", cfg->sess_mgr_cfg.tcp_overload_evict_old_sess);
    CONFIG_LOG_DEBUG("session_manager.udp_overload_evict_old_sess    : %d", cfg->sess_mgr_cfg.udp_overload_evict_old_sess);

    CONFIG_LOG_DEBUG("session_manager.tcp_timeout_init               : %ld", cfg->sess_mgr_cfg.tcp_timeout_init);
    CONFIG_LOG_DEBUG("session_manager.tcp_timeout_handshake          : %ld", cfg->sess_mgr_cfg.tcp_timeout_handshake);
    CONFIG_LOG_DEBUG("session_manager.tcp_timeout_data               : %ld", cfg->sess_mgr_cfg.tcp_timeout_data);
    CONFIG_LOG_DEBUG("session_manager.tcp_timeout_half_closed        : %ld", cfg->sess_mgr_cfg.tcp_timeout_half_closed);
    CONFIG_LOG_DEBUG("session_manager.tcp_timeout_time_wait          : %ld", cfg->sess_mgr_cfg.tcp_timeout_time_wait);
    CONFIG_LOG_DEBUG("session_manager.tcp_timeout_discard            : %ld", cfg->sess_mgr_cfg.tcp_timeout_discard);

    CONFIG_LOG_DEBUG("session_manager.udp_timeout_data               : %ld", cfg->sess_mgr_cfg.udp_timeout_data);

    CONFIG_LOG_DEBUG("session_manager.tcp_dupkt_filter_enable        : %d", cfg->sess_mgr_cfg.tcp_dupkt_filter_enable);
    CONFIG_LOG_DEBUG("session_manager.tcp_dupkt_filter_capacity      : %ld", cfg->sess_mgr_cfg.tcp_dupkt_filter_capacity);
    CONFIG_LOG_DEBUG("session_manager.tcp_dupkt_filter_timeout       : %ld", cfg->sess_mgr_cfg.tcp_dupkt_filter_timeout);
    CONFIG_LOG_DEBUG("session_manager.tcp_dupkt_filter_error_rate    : %f", cfg->sess_mgr_cfg.tcp_dupkt_filter_error_rate);

    CONFIG_LOG_DEBUG("session_manager.udp_eviction_filter_enable     : %d", cfg->sess_mgr_cfg.udp_eviction_filter_enable);
    CONFIG_LOG_DEBUG("session_manager.udp_eviction_filter_capacity   : %ld", cfg->sess_mgr_cfg.udp_eviction_filter_capacity);
    CONFIG_LOG_DEBUG("session_manager.udp_eviction_filter_timeout    : %ld", cfg->sess_mgr_cfg.udp_eviction_filter_timeout);
    CONFIG_LOG_DEBUG("session_manager.udp_eviction_filter_error_rate : %f", cfg->sess_mgr_cfg.udp_eviction_filter_error_rate);
}