ab_gp_config.c

Go to the documentation of this file.

 
#include "ab_gp_config.h"
 
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "rte/oal/memory/rte_mem_util.h"
#include "../../common/common_config.h"
 
#define MAX_LINE_LEN 256U
 
static void trim_whitespace(char *str)
{
    char *end;
    char *start = str;
 
    if (str == NULL)
    {
        return;
    }
 
    while ((*start != '\0') && (isspace((unsigned char)*start) != 0))
    {
        start++;
    }
 
    if (start != str)
    {
        (void)memmove(str, start, strlen(start) + 1U);
    }
 
    if (*str == '\0')
    {
        return;
    }
 
    end = str + strlen(str) - 1U;
    while ((end >= str) && (isspace((unsigned char)*end) != 0))
    {
        *end = '\0';
        end--;
    }
}
 
static ab_gp_config_channel_t *get_or_create_channel(ab_gp_config_t *cfg, const char *name)
{
    uint8_t i;
 
    for (i = 0U; i < cfg->channel_count; i++)
    {
        if (strcmp(cfg->channels[i].name, name) == 0)
        {
            return &cfg->channels[i];
        }
    }
 
    if (cfg->channel_count < AB_GP_CONFIG_MAX_CHANNELS)
    {
        ab_gp_config_channel_t *ch = &cfg->channels[cfg->channel_count];
        cfg->channel_count++;
        rte_mem_set(ch, 0, sizeof(*ch));
        (void)snprintf(ch->name, sizeof(ch->name), "%.*s", (int)(sizeof(ch->name) - 1U), name);
        ch->is_configured = true;
        return ch;
    }
 
    return NULL;
}
 
rte_status_t ab_gp_config_init_defaults(rte_example_site_t site, bool is_role_a, ab_gp_config_t *out_cfg)
{
    if (out_cfg == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    rte_mem_set(out_cfg, 0, sizeof(*out_cfg));
    out_cfg->site = site;
    out_cfg->is_role_a = is_role_a;
 
    /* Default timer configurations */
    out_cfg->timers.cycle_period_ms = (uint32_t)RTE_EXAMPLE_AB_CYCLE_PERIOD_MS;
    out_cfg->timers.watchdog_timeout_ms = (uint32_t)RTE_EXAMPLE_AB_WATCHDOG_TIMEOUT_MS;
    out_cfg->timers.checkpoint_max_delay_ms = (uint32_t)RTE_EXAMPLE_AB_CHECKPOINT_MAX_DELAY_MS;
    out_cfg->timers.checkpoint_relaxed_max_delay_ms = (uint32_t)RTE_EXAMPLE_AB_CHECKPOINT_RELAXED_MAX_DELAY_MS;
    out_cfg->timers.checkpoint_relax_duration_ms = (uint32_t)RTE_EXAMPLE_CHECKPOINT_RELAX_DURATION_MS;
    out_cfg->timers.checkpoint_reenable_grace_ms = (uint32_t)RTE_EXAMPLE_CHECKPOINT_REENABLE_GRACE_MS;
    out_cfg->timers.dual_transfer_timeout_ms = (uint32_t)RTE_EXAMPLE_AB_DUAL_TRANSFER_TIMEOUT_MS;
    out_cfg->timers.channel_down_reboot_ms = (uint32_t)RTE_EXAMPLE_CHANNEL_DOWN_REBOOT_MS;
    out_cfg->timers.link_timeout_ms = (uint32_t)RTE_EXAMPLE_LINK_TIMEOUT_MS;
    out_cfg->timers.connect_timeout_ms = (uint32_t)RTE_EXAMPLE_CONNECT_TIMEOUT_MS;
    out_cfg->timers.reconnect_attempt_timeout_ms = (uint32_t)RTE_EXAMPLE_RECONNECT_ATTEMPT_TIMEOUT_MS;
    out_cfg->timers.neg_ack_timeout_ms = (uint32_t)RTE_EXAMPLE_NEG_ACK_TIMEOUT_MS;
 
    return RTE_STATUS_OK;
}
 
/* One `[timers]` section key=value pair, extracted from ab_gp_config_load_file()'s own former
 * inline dispatch. Unknown keys are silently ignored - unchanged from before this extraction. */
static void apply_timer_setting(ab_gp_config_timers_t *timers, const char *key, const char *val)
{
    uint32_t num_val = (uint32_t)strtoul(val, NULL, 10);
 
    if (strcmp(key, "cycle_period_ms") == 0)
    {
        timers->cycle_period_ms = num_val;
    }
    else if (strcmp(key, "watchdog_timeout_ms") == 0)
    {
        timers->watchdog_timeout_ms = num_val;
    }
    else if (strcmp(key, "checkpoint_max_delay_ms") == 0)
    {
        timers->checkpoint_max_delay_ms = num_val;
    }
    else if (strcmp(key, "checkpoint_relaxed_max_delay_ms") == 0)
    {
        timers->checkpoint_relaxed_max_delay_ms = num_val;
    }
    else if (strcmp(key, "checkpoint_relax_duration_ms") == 0)
    {
        timers->checkpoint_relax_duration_ms = num_val;
    }
    else if (strcmp(key, "checkpoint_reenable_grace_ms") == 0)
    {
        timers->checkpoint_reenable_grace_ms = num_val;
    }
    else if (strcmp(key, "dual_transfer_timeout_ms") == 0)
    {
        timers->dual_transfer_timeout_ms = num_val;
    }
    else if (strcmp(key, "channel_down_reboot_ms") == 0)
    {
        timers->channel_down_reboot_ms = num_val;
    }
    else if (strcmp(key, "link_timeout_ms") == 0)
    {
        timers->link_timeout_ms = num_val;
    }
    else if (strcmp(key, "connect_timeout_ms") == 0)
    {
        timers->connect_timeout_ms = num_val;
    }
    else if (strcmp(key, "reconnect_attempt_timeout_ms") == 0)
    {
        timers->reconnect_attempt_timeout_ms = num_val;
    }
    else if (strcmp(key, "neg_ack_timeout_ms") == 0)
    {
        timers->neg_ack_timeout_ms = num_val;
    }
    else
    {
        /* Ignore unknown timer key */
    }
}
 
/* One `[channel.<name>]` section key=value pair, extracted the same way as
 * apply_timer_setting() above. Unknown keys are silently ignored - unchanged from before this
 * extraction. */
static void apply_channel_setting(ab_gp_config_channel_t *ch, const char *key, const char *val)
{
    if (strcmp(key, "id") == 0)
    {
        ch->id = (uint32_t)strtoul(val, NULL, 10);
    }
    else if (strcmp(key, "role") == 0)
    {
        if ((strcmp(val, "LISTEN") == 0) || (strcmp(val, "listen") == 0))
        {
            ch->role = RTE_NETLINK_ROLE_LISTEN;
        }
        else
        {
            ch->role = RTE_NETLINK_ROLE_CONNECT;
        }
    }
    else if (strcmp(key, "host") == 0)
    {
        (void)snprintf(ch->host, sizeof(ch->host), "%.*s", (int)(sizeof(ch->host) - 1U), val);
    }
    else if (strcmp(key, "port") == 0)
    {
        ch->port = (uint16_t)strtoul(val, NULL, 10);
    }
    else if (strcmp(key, "message_size") == 0)
    {
        ch->message_size = (uint32_t)strtoul(val, NULL, 10);
    }
    else if (strcmp(key, "connect_timeout_ms") == 0)
    {
        ch->connect_timeout_ms = (uint32_t)strtoul(val, NULL, 10);
    }
    else
    {
        /* Ignore unknown channel key */
    }
}
 
/* A top-level (no `[section]` yet open, and not inside a `[channel.*]` section) key=value pair,
 * extracted the same way as apply_timer_setting() above. Unknown keys are silently ignored -
 * unchanged from before this extraction. */
static void apply_global_setting(ab_gp_config_t *cfg, const char *key, const char *val)
{
    if (strcmp(key, "site") == 0)
    {
        (void)site_config_parse(val, &cfg->site);
    }
    else if (strcmp(key, "role") == 0)
    {
        cfg->is_role_a = ((strcmp(val, "A") == 0) || (strcmp(val, "a") == 0));
    }
    else
    {
        /* Ignore other top-level keys */
    }
}
 
rte_status_t ab_gp_config_load_file(const char *filepath, ab_gp_config_t *out_cfg)
{
    FILE *fp;
    char line[MAX_LINE_LEN];
    char current_section[64] = "";
    ab_gp_config_channel_t *current_ch = NULL;
 
    if ((filepath == NULL) || (out_cfg == NULL))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    fp = fopen(filepath, "r");
    if (fp == NULL)
    {
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
 
    while (fgets(line, (int)sizeof(line), fp) != NULL)
    {
        char *comment;
        char *eq;
        char *key;
        char *val;
 
        /* Strip comments starting with '#' or ';' */
        comment = strpbrk(line, "#;");
        if (comment != NULL)
        {
            *comment = '\0';
        }
 
        trim_whitespace(line);
        if (line[0] == '\0')
        {
            continue;
        }
 
        /* Section header: [section] */
        if ((line[0] == '[') && (line[strlen(line) - 1U] == ']'))
        {
            line[strlen(line) - 1U] = '\0';
            /* Over-long section names are cut to the buffer on purpose (they match no known section). */
            (void)snprintf(current_section, sizeof(current_section), "%.*s", (int)(sizeof(current_section) - 1U), &line[1]);
            trim_whitespace(current_section);
 
            if (strncmp(current_section, "channel.", 8) == 0)
            {
                current_ch = get_or_create_channel(out_cfg, &current_section[8]);
            }
            else
            {
                current_ch = NULL;
            }
            continue;
        }
 
        /* Key = Value */
        eq = strchr(line, '=');
        if (eq == NULL)
        {
            continue;
        }
 
        *eq = '\0';
        key = line;
        val = eq + 1;
        trim_whitespace(key);
        trim_whitespace(val);
 
        if (strcmp(current_section, "timers") == 0)
        {
            apply_timer_setting(&out_cfg->timers, key, val);
        }
        else if (current_ch != NULL)
        {
            apply_channel_setting(current_ch, key, val);
        }
        else
        {
            apply_global_setting(out_cfg, key, val);
        }
    }
 
    (void)fclose(fp);
    return RTE_STATUS_OK;
}
 
rte_status_t ab_gp_config_find_channel(const ab_gp_config_t *cfg, const char *channel_name,
                                         rte_netlink_config_t *out_netlink_cfg)
{
    uint8_t i;
 
    if ((cfg == NULL) || (channel_name == NULL) || (out_netlink_cfg == NULL))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    for (i = 0U; i < cfg->channel_count; i++)
    {
        const ab_gp_config_channel_t *ch = &cfg->channels[i];
        if (ch->is_configured && (strcmp(ch->name, channel_name) == 0))
        {
            rte_mem_set(out_netlink_cfg, 0, sizeof(*out_netlink_cfg));
            out_netlink_cfg->role = ch->role;
            out_netlink_cfg->host = (ch->role == RTE_NETLINK_ROLE_CONNECT && ch->host[0] != '\0') ? ch->host : NULL;
            out_netlink_cfg->port = ch->port;
            out_netlink_cfg->message_size = ch->message_size;
            out_netlink_cfg->connect_timeout_ms = (ch->connect_timeout_ms > 0U) ? ch->connect_timeout_ms
                                                                                 : cfg->timers.connect_timeout_ms;
            return RTE_STATUS_OK;
        }
    }
 
    return RTE_STATUS_RESOURCE_EXHAUSTED;
}
 
rte_status_t ab_gp_config_find_channel_by_id(const ab_gp_config_t *cfg, uint32_t channel_id,
                                              rte_netlink_config_t *out_netlink_cfg)
{
    uint8_t i;
 
    if ((cfg == NULL) || (channel_id == 0U) || (out_netlink_cfg == NULL))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    for (i = 0U; i < cfg->channel_count; i++)
    {
        const ab_gp_config_channel_t *ch = &cfg->channels[i];
        if (ch->is_configured && (ch->id == channel_id))
        {
            rte_mem_set(out_netlink_cfg, 0, sizeof(*out_netlink_cfg));
            out_netlink_cfg->role = ch->role;
            out_netlink_cfg->host = (ch->role == RTE_NETLINK_ROLE_CONNECT && ch->host[0] != '\0') ? ch->host : NULL;
            out_netlink_cfg->port = ch->port;
            out_netlink_cfg->message_size = ch->message_size;
            out_netlink_cfg->connect_timeout_ms = (ch->connect_timeout_ms > 0U) ? ch->connect_timeout_ms
                                                                                 : cfg->timers.connect_timeout_ms;
            return RTE_STATUS_OK;
        }
    }
 
    return RTE_STATUS_RESOURCE_EXHAUSTED;
}