gateway_c_ctc_handler.c

Go to the documentation of this file.

#include "gateway_c_ctc_handler.h"
 
#include <stdio.h>
#include "safeapi/oal/memory/sapi_mem_util.h"
#include "safeapi/oal/log/sapi_log.h"
#include "common/common_config.h"
#include "common/rbc_util_frame.h"
#include "gateway_c_selfstatus.h"
 
static gateway_c_ctc_handler_state_t g_ctc;
 
static const char *peer_name(gateway_c_peer_t peer)
{
    return (peer == GATEWAY_C_PEER_A) ? "A" : "B";
}
 
sapi_status_t gateway_c_ctc_handler_init(gateway_c_context_t *ctx)
{
    sapi_status_t status;
 
    g_ctc.last_known_tag = "SUPPRESSED";
    g_ctc.relay_consecutive_timeout = 0U;
    g_ctc.relay_down_since_ms[GATEWAY_C_PEER_A] = 0U;
    g_ctc.relay_down_since_ms[GATEWAY_C_PEER_B] = 0U;
    g_ctc.a_seen_this_cycle = 0U;
    g_ctc.a_stale_cycles = 0U;
 
    /* Relay links to/from A and B */
    status = sapi_channel_service_setup(&g_ctc.relay_channel[GATEWAY_C_PEER_A], "c-relay-ctc-a");
    if (status != SAPI_STATUS_OK)
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] CTCHandler: relay A channel setup failed (%s)\n",
                             site_config_name(ctx->site), sapi_status_to_string(status));
        return status;
    }
 
    status = sapi_channel_service_setup(&g_ctc.relay_channel[GATEWAY_C_PEER_B], "c-relay-ctc-b");
    if (status != SAPI_STATUS_OK)
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] CTCHandler: relay B channel setup failed (%s)\n",
                             site_config_name(ctx->site), sapi_status_to_string(status));
        return status;
    }
 
    /* CTCSim-facing link */
    status = sapi_channel_service_setup(&g_ctc.sim_channel, "c-sim-ctc");
    if (status != SAPI_STATUS_OK)
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] CTCHandler: sim channel setup failed (%s)\n",
                             site_config_name(ctx->site), sapi_status_to_string(status));
        return status;
    }
 
    return SAPI_STATUS_OK;
}
 
static void send_to_relay(gateway_c_context_t *ctx, gateway_c_peer_t peer, const uint8_t bytes[RBC_ENVELOPE_WIRE_SIZE])
{
    sapi_status_t status = sapi_channel_service_send(&g_ctc.relay_channel[peer],
                                                     bytes, RBC_ENVELOPE_WIRE_SIZE, 0U);
    if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] CTCHandler: keepalive to %s failed (%s)\n", site_config_name(ctx->site),
                             peer_name(peer), sapi_status_to_string(status));
        sapi_log_write_event(SAPI_LOG_LEVEL_ERROR, site_config_name(ctx->site), 0U, "GW", peer_name(peer),
                              "ENVELOPE", sapi_status_to_string(status), NULL);
    }
}
 
static void send_to_sim(gateway_c_context_t *ctx, const uint8_t bytes[RBC_ENVELOPE_WIRE_SIZE])
{
    sapi_status_t status = sapi_channel_service_send(&g_ctc.sim_channel,
                                                     bytes, RBC_ENVELOPE_WIRE_SIZE, 0U);
    if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] CTCHandler: forward to CTCSim failed (%s)\n",
                             site_config_name(ctx->site), sapi_status_to_string(status));
        sapi_log_write_event(SAPI_LOG_LEVEL_ERROR, site_config_name(ctx->site), 0U, "GW", "CTC", "ENVELOPE",
                              sapi_status_to_string(status), NULL);
    }
}
 
void gateway_c_ctc_handler_execute(gateway_c_context_t *ctx, uint32_t cycle)
{
    uint8_t       bytes[RBC_ENVELOPE_WIRE_SIZE];
    char          sim_status[RBC_UTIL_PAYLOAD_MAX + 1];
    sapi_status_t status;
    (void)cycle;
 
    /* CTCSim -> Gateway -> A/B */
    while (sapi_channel_service_read(&g_ctc.sim_channel, bytes, sizeof(bytes), 0U) == SAPI_STATUS_OK)
    {
        /* ADR-038: the CTC sim's own-perspective status frame - republish to
         * the C status broker, never forward to A/B (they never see this
         * kind). */
        if (rbc_envelope_is_sim_status(bytes, sim_status, (uint16_t)sizeof(sim_status)))
        {
            gateway_c_selfstatus_publish((uint8_t)RBC_UTIL_SRC_SIM_CTC, sim_status);
            continue;
        }
        send_to_relay(ctx, GATEWAY_C_PEER_A, bytes);
        send_to_relay(ctx, GATEWAY_C_PEER_B, bytes);
    }
 
    /* A/B -> Gateway -> CTCSim */
    {
        uint32_t a_count = 0U;
        bool     use_b_fallback;
 
        while ((status = sapi_channel_service_read(&g_ctc.relay_channel[GATEWAY_C_PEER_A],
                                                  bytes, sizeof(bytes), 0U)) == SAPI_STATUS_OK)
        {
            send_to_sim(ctx, bytes);
            a_count++;
        }
        if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
        {
            if (g_ctc.relay_down_since_ms[GATEWAY_C_PEER_A] == 0U)
            {
                (void)sapi_timer_now(&g_ctc.relay_down_since_ms[GATEWAY_C_PEER_A]);
            }
        }
        else if (a_count > 0U)
        {
            g_ctc.relay_down_since_ms[GATEWAY_C_PEER_A] = 0U;
            g_ctc.relay_consecutive_timeout = 0U;
            g_ctc.a_stale_cycles = 0U;
        }
        else
        {
            g_ctc.a_stale_cycles++;
        }
        g_ctc.a_seen_this_cycle = a_count;
 
        use_b_fallback = (g_ctc.a_stale_cycles >= (unsigned int)SAFEAPI_EXAMPLE_C_A_STALE_CYCLE_LIMIT);
        if (use_b_fallback)
        {
            uint32_t b_count = 0U;
 
            while ((status = sapi_channel_service_read(&g_ctc.relay_channel[GATEWAY_C_PEER_B],
                                                      bytes, sizeof(bytes), 0U)) == SAPI_STATUS_OK)
            {
                send_to_sim(ctx, bytes);
                b_count++;
            }
            if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
            {
                if (g_ctc.relay_down_since_ms[GATEWAY_C_PEER_B] == 0U)
                {
                    (void)sapi_timer_now(&g_ctc.relay_down_since_ms[GATEWAY_C_PEER_B]);
                }
            }
            else if (b_count > 0U)
            {
                g_ctc.relay_down_since_ms[GATEWAY_C_PEER_B] = 0U;
            }
            g_ctc.last_known_tag = (b_count > 0U) ? "ACTIVE" : "SUPPRESSED";
        }
        else
        {
            uint32_t b_count = 0U;
 
            while ((status = sapi_channel_service_read(&g_ctc.relay_channel[GATEWAY_C_PEER_B],
                                                      bytes, sizeof(bytes), 0U)) == SAPI_STATUS_OK)
            {
                b_count++;
            }
            if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
            {
                if (g_ctc.relay_down_since_ms[GATEWAY_C_PEER_B] == 0U)
                {
                    (void)sapi_timer_now(&g_ctc.relay_down_since_ms[GATEWAY_C_PEER_B]);
                }
            }
            else if (b_count > 0U)
            {
                g_ctc.relay_down_since_ms[GATEWAY_C_PEER_B] = 0U;
            }
            g_ctc.last_known_tag = (a_count > 0U) ? "ACTIVE" : "SUPPRESSED";
        }
    }
}
 
void gateway_c_ctc_handler_shutdown(void)
{
    (void)sapi_channel_service_close(&g_ctc.sim_channel);
    (void)sapi_channel_service_close(&g_ctc.relay_channel[GATEWAY_C_PEER_A]);
    (void)sapi_channel_service_close(&g_ctc.relay_channel[GATEWAY_C_PEER_B]);
}
 
bool gateway_c_ctc_handler_check_link_down(sapi_timestamp_ms_t threshold_ms, sapi_timestamp_ms_t now_ms,
                                           char *out_which, size_t which_size)
{
    gateway_c_peer_t peer;
 
    for (peer = GATEWAY_C_PEER_A; peer <= GATEWAY_C_PEER_B; peer = (gateway_c_peer_t)((int)peer + 1))
    {
        sapi_timestamp_ms_t down_since = g_ctc.relay_down_since_ms[peer];
 
        if ((down_since != 0U) && ((now_ms - down_since) >= threshold_ms))
        {
            (void)snprintf(out_which, which_size, "CTC relay link to %s", peer_name(peer));
            return true;
        }
    }
    return false;
}