config.c

Go to the documentation of this file.

#include "safecomm/config/config.h"
 
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h> /* strcasecmp */

static char *trim(char *s)
{
    size_t len;
    size_t start = 0U;
 
    if (s == NULL)
    {
        return s;
    }
    while ((s[start] != '\0') && (isspace((unsigned char)s[start]) != 0))
    {
        start++;
    }
    if (start > 0U)
    {
        (void)memmove(s, &s[start], strlen(&s[start]) + 1U);
    }
    len = strlen(s);
    while ((len > 0U) && (isspace((unsigned char)s[len - 1U]) != 0))
    {
        s[len - 1U] = '\0';
        len--;
    }
    return s;
}

static void strip_inline_comment(char *s)
{
    size_t i;
 
    for (i = 0U; s[i] != '\0'; i++)
    {
        if ((s[i] == '#') && ((i == 0U) || (isspace((unsigned char)s[i - 1U]) != 0)))
        {
            s[i] = '\0';
            return;
        }
    }
}
 
static bool store_entry(safecomm_config_t *cfg, const char *key, const char *value)
{
    if (cfg->count >= SAFECOMM_CONFIG_MAX_ENTRIES)
    {
        return false;
    }
    if ((strlen(key) >= SAFECOMM_CONFIG_MAX_KEY_LEN) || (strlen(value) >= SAFECOMM_CONFIG_MAX_VALUE_LEN))
    {
        return false;
    }
    (void)strcpy(cfg->entries[cfg->count].key, key);
    (void)strcpy(cfg->entries[cfg->count].value, value);
    cfg->count++;
    return true;
}
 
safecomm_status_t safecomm_config_load(const char *path, safecomm_config_t *out)
{
    FILE *fp;
    char  line[SAFECOMM_CONFIG_MAX_LINE_LEN];
 
    if ((path == NULL) || (out == NULL))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    (void)memset(out, 0, sizeof(*out));
 
    fp = fopen(path, "re");
    if (fp == NULL)
    {
        return SAFECOMM_STATUS_TRANSPORT;
    }
 
    while (fgets(line, (int)sizeof(line), fp) != NULL)
    {
        char  *eq;
        char  *key;
        char  *value;
        size_t line_len = strlen(line);
 
        if ((line_len + 1U) == sizeof(line) && (line[line_len - 1U] != '\n'))
        {
            (void)fclose(fp);
            return SAFECOMM_STATUS_BUFFER_TOO_SMALL; /* line longer than the buffer */
        }
 
        (void)trim(line);
        if ((line[0] == '\0') || (line[0] == '#'))
        {
            continue;
        }
 
        eq = strchr(line, '=');
        if (eq == NULL)
        {
            continue; /* not a key=value line — ignored, not an error */
        }
        *eq  = '\0';
        key  = trim(line);
        value = eq + 1;
        strip_inline_comment(value);
        value = trim(value);
 
        if (key[0] == '\0')
        {
            continue;
        }
        if (!store_entry(out, key, value))
        {
            (void)fclose(fp);
            return SAFECOMM_STATUS_BUFFER_TOO_SMALL;
        }
    }
 
    if (ferror(fp) != 0)
    {
        (void)fclose(fp);
        return SAFECOMM_STATUS_TRANSPORT;
    }
    (void)fclose(fp);
    return SAFECOMM_STATUS_OK;
}
 
const char *safecomm_config_get_str(const safecomm_config_t *cfg, const char *key)
{
    uint32_t i;
 
    if ((cfg == NULL) || (key == NULL))
    {
        return NULL;
    }
    for (i = 0U; i < cfg->count; i++)
    {
        if (strcmp(cfg->entries[i].key, key) == 0)
        {
            return cfg->entries[i].value;
        }
    }
    return NULL;
}
 
safecomm_status_t safecomm_config_get_u32(const safecomm_config_t *cfg, const char *key, uint32_t *out)
{
    const char   *s = safecomm_config_get_str(cfg, key);
    unsigned long parsed;
    char         *end = NULL;
 
    if ((out == NULL) || (s == NULL) || (s[0] == '\0'))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    parsed = strtoul(s, &end, 10);
    if ((end == s) || (*end != '\0') || (parsed > 0xFFFFFFFFUL))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    *out = (uint32_t)parsed;
    return SAFECOMM_STATUS_OK;
}
 
safecomm_status_t safecomm_config_get_bool(const safecomm_config_t *cfg, const char *key, bool *out)
{
    const char *s = safecomm_config_get_str(cfg, key);
 
    if ((out == NULL) || (s == NULL))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    if ((strcasecmp(s, "true") == 0) || (strcmp(s, "1") == 0))
    {
        *out = true;
        return SAFECOMM_STATUS_OK;
    }
    if ((strcasecmp(s, "false") == 0) || (strcmp(s, "0") == 0))
    {
        *out = false;
        return SAFECOMM_STATUS_OK;
    }
    return SAFECOMM_STATUS_INVALID_PARAM;
}