ale.c

Go to the documentation of this file.

#include "safecomm/ale/ale.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static bool parse_peer_line(const char *line, safecomm_ale_peer_t *out)
{
    unsigned long peer_id;
    unsigned long port;
    char          a_host[64];
    char          b_host[64];
    int           consumed;
 
    consumed = sscanf(line, " %lu %63s %63s %lu", &peer_id, a_host, b_host, &port);
    if (consumed != 4)
    {
        return false;
    }
    if ((peer_id > 0xFFFFFFFFUL) || (port == 0UL) || (port > 65535UL))
    {
        return false;
    }
    (void)memset(out, 0, sizeof(*out));
    out->peer_id = (uint32_t)peer_id;
    (void)snprintf(out->ab_a_host, sizeof(out->ab_a_host), "%s", a_host);
    (void)snprintf(out->ab_b_host, sizeof(out->ab_b_host), "%s", b_host);
    out->ab_port = (uint16_t)port;
    out->in_use  = true;
    return true;
}
 
static safecomm_status_t load_peer_map(const char *path, safecomm_ale_t *ale)
{
    FILE *fp = fopen(path, "re");
    char  line[256];
 
    if (fp == NULL)
    {
        return SAFECOMM_STATUS_TRANSPORT;
    }
    while ((fgets(line, (int)sizeof(line), fp) != NULL) && (ale->peer_count < SAFECOMM_ALE_MAX_PEERS))
    {
        size_t i = 0U;
 
        while ((line[i] == ' ') || (line[i] == '\t'))
        {
            i++;
        }
        if ((line[i] == '#') || (line[i] == '\n') || (line[i] == '\0') || (line[i] == '\r'))
        {
            continue;
        }
        if (parse_peer_line(&line[i], &ale->peers[ale->peer_count]))
        {
            ale->peer_count++;
        }
    }
    (void)fclose(fp);
    return SAFECOMM_STATUS_OK;
}
 
safecomm_status_t safecomm_ale_from_config(const safecomm_config_t *cfg, safecomm_ale_t *out)
{
    const char       *host;
    const char       *peer_map;
    uint32_t          u;
    safecomm_status_t st;
 
    if ((cfg == NULL) || (out == NULL))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    (void)memset(out, 0, sizeof(*out));
 
    host = safecomm_config_get_str(cfg, "ale.listen_host");
    if ((host != NULL) && (strlen(host) < sizeof(out->listen_host)))
    {
        (void)strcpy(out->listen_host, host);
    }
    st = safecomm_config_get_u32(cfg, "ale.listen_port", &u);
    if ((st == SAFECOMM_STATUS_OK) && (u <= 0xFFFFU))
    {
        out->listen_port = (uint16_t)u;
    }
 
    peer_map = safecomm_config_get_str(cfg, "ale.peer_map_file");
    if (peer_map != NULL)
    {
        return load_peer_map(peer_map, out);
    }
    return SAFECOMM_STATUS_OK; /* no peer map configured — an empty table is valid */
}
 
const safecomm_ale_peer_t *safecomm_ale_lookup(const safecomm_ale_t *ale, uint32_t peer_id)
{
    uint32_t i;
 
    if (ale == NULL)
    {
        return NULL;
    }
    for (i = 0U; i < ale->peer_count; i++)
    {
        if (ale->peers[i].in_use && (ale->peers[i].peer_id == peer_id))
        {
            return &ale->peers[i];
        }
    }
    return NULL;
}