gateway_c_config.c

Go to the documentation of this file.

 
#include "gateway_c_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"
#include "common/rbc_wire_types.h"
 
#define MAX_CONFIG_FILE_SIZE 8192U
 
static const char *skip_whitespace(const char *p)
{
    if (p == NULL)
    {
        return NULL;
    }
    while ((*p != '\0') && (isspace((unsigned char)*p) != 0))
    {
        p++;
    }
    return p;
}
 
static const char *extract_string(const char *p, char *out, size_t out_size)
{
    size_t idx = 0U;
 
    p = skip_whitespace(p);
    if (*p != '"')
    {
        return NULL;
    }
    p++;
 
    while ((*p != '\0') && (*p != '"'))
    {
        if (idx + 1U < out_size)
        {
            out[idx++] = *p;
        }
        p++;
    }
 
    if (*p != '"')
    {
        return NULL;
    }
    out[idx] = '\0';
    return p + 1;
}
 
static const char *extract_uint32(const char *p, uint32_t *out_val)
{
    char *endptr = NULL;
    unsigned long val;
 
    p = skip_whitespace(p);
    val = strtoul(p, &endptr, 10);
    if (endptr == p)
    {
        return NULL;
    }
    *out_val = (uint32_t)val;
    return endptr;
}

static const char *extract_uint32_checked(const char *p, uint32_t *out_val)
{
    const char *q = skip_whitespace(p);
    const char *start = q;
    const char *result = NULL;
    uint32_t value = 0U;
    bool overflow = false;
 
    while ((!overflow) && (*q >= '0') && (*q <= '9'))
    {
        const uint32_t digit = (uint32_t)((uint8_t)*q) - (uint32_t)((uint8_t)'0');
 
        if (value > ((UINT32_MAX - digit) / 10U))
        {
            overflow = true;
        }
        else
        {
            value = (value * 10U) + digit;
            q++;
        }
    }
    if ((!overflow) && (q != start))
    {
        const char *after = skip_whitespace(q);
 
        if ((*after == ',') || (*after == '}'))
        {
            *out_val = value;
            result = q;
        }
    }
    return result;
}
 
rte_status_t gateway_c_config_init_defaults(rte_example_site_t site, gateway_c_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->timers.report_period_ms = (uint32_t)RTE_EXAMPLE_C_REPORT_PERIOD_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;
 
    return RTE_STATUS_OK;
}

static const char *skip_separator(const char *p)
{
    p = skip_whitespace(p);
    if ((p != NULL) && (*p == ','))
    {
        p++;
    }
    return p;
}

static const char *extract_into(const char *p, char *dest, size_t dest_size)
{
    char text[64];
    const char *next = extract_string(p, text, sizeof(text));
 
    if ((next != NULL) && (dest != NULL))
    {
        (void)snprintf(dest, dest_size, "%.*s", (int)(dest_size - 1U), text); /* explicit truncation */
    }
    return next;
}

static const char *extract_number_into(const char *p, uint32_t *field)
{
    uint32_t value = 0U;
    const char *next = extract_uint32(p, &value);
 
    if ((next != NULL) && (field != NULL))
    {
        *field = value;
    }
    return next;
}

static const char *extract_buffer_size_into(const char *p, uint32_t *field)
{
    uint32_t value = 0U;
    const char *next = extract_uint32_checked(p, &value);
 
    if ((next != NULL) && (field != NULL))
    {
        *field = value;
    }
    return next;
}

static const char *parse_channel_prop(const char *p, const char *key, gateway_c_config_channel_t *ch,
                                      bool allow_identity)
{
    uint32_t number = 0U;
    char text[64];
 
    if (allow_identity && (strcmp(key, "id") == 0))
    {
        return extract_number_into(p, (ch != NULL) ? &ch->id : NULL);
    }
    if (allow_identity && (strcmp(key, "name") == 0))
    {
        return extract_into(p, (ch != NULL) ? ch->name : NULL, sizeof(ch->name));
    }
    if (strcmp(key, "role") == 0)
    {
        const char *next = extract_string(p, text, 16U);
 
        if ((next != NULL) && (ch != NULL))
        {
            ch->role = ((strcmp(text, "CONNECT") == 0) || (strcmp(text, "connect") == 0))
                           ? RTE_NETLINK_ROLE_CONNECT
                           : RTE_NETLINK_ROLE_LISTEN;
        }
        return next;
    }
    if (strcmp(key, "port") == 0)
    {
        const char *next = extract_uint32(p, &number);
 
        if ((next != NULL) && (ch != NULL))
        {
            ch->port = (uint16_t)number;
        }
        return next;
    }
    if (strcmp(key, "host") == 0)
    {
        return extract_into(p, (ch != NULL) ? ch->host : NULL, sizeof(ch->host));
    }
    if (strcmp(key, "message_size") == 0)
    {
        return extract_number_into(p, (ch != NULL) ? &ch->message_size : NULL);
    }
    if (strcmp(key, "connect_timeout_ms") == 0)
    {
        return extract_number_into(p, (ch != NULL) ? &ch->connect_timeout_ms : NULL);
    }
    /* REQ-OAL-NETLINK-015: optional socket buffer sizes, 0 = OS default. A rejected value fails the load. */
    if (strcmp(key, "rcvbuf_bytes") == 0)
    {
        return extract_buffer_size_into(p, (ch != NULL) ? &ch->rcvbuf_bytes : NULL);
    }
    if (strcmp(key, "sndbuf_bytes") == 0)
    {
        return extract_buffer_size_into(p, (ch != NULL) ? &ch->sndbuf_bytes : NULL);
    }
 
    /* Unknown property: consume a string or a number, ignore it. */
    if (*p == '"')
    {
        return extract_string(p, text, sizeof(text));
    }
    return extract_uint32(p, &number);
}

static const char *parse_channel_object(const char *p, gateway_c_config_t *cfg, const char *fixed_name)
{
    gateway_c_config_channel_t *ch = NULL;
 
    if (cfg->channel_count < GATEWAY_C_MAX_CHANNELS)
    {
        ch = &cfg->channels[cfg->channel_count++];
        rte_mem_set(ch, 0, sizeof(*ch));
        if (fixed_name != NULL)
        {
            (void)snprintf(ch->name, sizeof(ch->name), "%.*s", (int)(sizeof(ch->name) - 1U), fixed_name);
        }
        ch->is_configured = true;
        ch->message_size = RBC_ENVELOPE_WIRE_SIZE;
    }
 
    p++; /* Skip '{' */
    while ((*p != '\0') && (*p != '}'))
    {
        char prop_key[32];
 
        p = skip_whitespace(p);
        if (*p == '}')
        {
            break;
        }
        p = extract_string(p, prop_key, sizeof(prop_key));
        if (p == NULL)
        {
            return NULL;
        }
        p = skip_whitespace(p);
        if (*p == ':')
        {
            p++;
        }
        p = skip_whitespace(p);
        p = parse_channel_prop(p, prop_key, ch, fixed_name == NULL);
        if (p == NULL)
        {
            return NULL;
        }
        p = skip_separator(p);
    }
    if (*p == '}')
    {
        p++;
    }
    return p;
}

static const char *parse_channels_array(const char *p, gateway_c_config_t *cfg)
{
    p++; /* Skip '[' */
    while ((*p != '\0') && (*p != ']'))
    {
        p = skip_whitespace(p);
        if (*p == ']')
        {
            break;
        }
        if (*p == '{')
        {
            p = parse_channel_object(p, cfg, NULL);
            if (p == NULL)
            {
                return NULL;
            }
        }
        else
        {
            p++; /* Stray character: skip so the scan always advances */
        }
        p = skip_separator(p);
    }
    if (*p == ']')
    {
        p++;
    }
    return p;
}

static const char *parse_channels_object(const char *p, gateway_c_config_t *cfg)
{
    p++; /* Skip '{' */
    while ((*p != '\0') && (*p != '}'))
    {
        char ch_name[64];
 
        p = skip_whitespace(p);
        if (*p == '}')
        {
            break;
        }
        p = extract_string(p, ch_name, sizeof(ch_name));
        if (p == NULL)
        {
            return NULL;
        }
        p = skip_whitespace(p);
        if (*p == ':')
        {
            p++;
        }
        p = skip_whitespace(p);
        if (*p == '{')
        {
            p = parse_channel_object(p, cfg, ch_name);
            if (p == NULL)
            {
                return NULL;
            }
        }
        p = skip_separator(p);
    }
    if (*p == '}')
    {
        p++;
    }
    return p;
}

static const char *parse_top_level_value(const char *p, const char *key, gateway_c_config_t *cfg)
{
    if (strcmp(key, "site") == 0)
    {
        char site_str[32];
        const char *next = extract_string(p, site_str, sizeof(site_str));
 
        if (next != NULL)
        {
            (void)site_config_parse(site_str, &cfg->site);
        }
        return next;
    }
    if (strcmp(key, "report_period_ms") == 0)
    {
        return extract_uint32(p, &cfg->timers.report_period_ms);
    }
    if (strcmp(key, "link_timeout_ms") == 0)
    {
        return extract_uint32(p, &cfg->timers.link_timeout_ms);
    }
    if (strcmp(key, "connect_timeout_ms") == 0)
    {
        return extract_uint32(p, &cfg->timers.connect_timeout_ms);
    }
    if (strcmp(key, "reconnect_attempt_timeout_ms") == 0)
    {
        return extract_uint32(p, &cfg->timers.reconnect_attempt_timeout_ms);
    }
    if (strcmp(key, "channels") == 0)
    {
        if (*p == '[')
        {
            return parse_channels_array(p, cfg);
        }
        if (*p == '{')
        {
            return parse_channels_object(p, cfg);
        }
    }
    return p; /* Unknown key or container: the scan below walks into it */
}
 
rte_status_t gateway_c_config_load_file(const char *filepath, gateway_c_config_t *out_cfg)
{
    FILE *fp;
    char buffer[MAX_CONFIG_FILE_SIZE];
    size_t bytes_read;
    const char *p;
 
    if ((filepath == NULL) || (out_cfg == NULL))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    fp = fopen(filepath, "r");
    if (fp == NULL)
    {
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
 
    bytes_read = fread(buffer, 1, sizeof(buffer) - 1U, fp);
    (void)fclose(fp);
    buffer[bytes_read] = '\0';
 
    /* Flat scan: any "key": value pair is dispatched wherever it appears, so the nested "timers" object
     * needs no handling of its own. A malformed value for a known key is an error, never a crash. */
    p = buffer;
    while (*p != '\0')
    {
        char key[64];
 
        if (*p != '"')
        {
            p++;
            continue;
        }
        p = extract_string(p, key, sizeof(key));
        if (p == NULL)
        {
            break; /* Unterminated string: truncated file, keep what was parsed */
        }
        p = skip_whitespace(p);
        if (*p != ':')
        {
            continue;
        }
        p++; /* Skip ':' */
        p = skip_whitespace(p);
        p = parse_top_level_value(p, key, out_cfg);
        if (p == NULL)
        {
            return RTE_STATUS_INVALID_PARAM;
        }
    }
 
    return RTE_STATUS_OK;
}
 
rte_status_t gateway_c_config_find_channel(const gateway_c_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 gateway_c_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 > 0U) ? ch->message_size : RBC_ENVELOPE_WIRE_SIZE;
            out_netlink_cfg->connect_timeout_ms = (ch->connect_timeout_ms > 0U) ? ch->connect_timeout_ms
                                                                                 : cfg->timers.connect_timeout_ms;
            out_netlink_cfg->rcvbuf_bytes = ch->rcvbuf_bytes;
            out_netlink_cfg->sndbuf_bytes = ch->sndbuf_bytes;
            return RTE_STATUS_OK;
        }
    }
 
    return RTE_STATUS_RESOURCE_EXHAUSTED;
}
 
rte_status_t gateway_c_config_find_channel_by_id(const gateway_c_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 gateway_c_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 > 0U) ? ch->message_size : RBC_ENVELOPE_WIRE_SIZE;
            out_netlink_cfg->connect_timeout_ms = (ch->connect_timeout_ms > 0U) ? ch->connect_timeout_ms
                                                                                 : cfg->timers.connect_timeout_ms;
            out_netlink_cfg->rcvbuf_bytes = ch->rcvbuf_bytes;
            out_netlink_cfg->sndbuf_bytes = ch->sndbuf_bytes;
            return RTE_STATUS_OK;
        }
    }
 
    return RTE_STATUS_RESOURCE_EXHAUSTED;
}