gateway_c_il_handler.c

Go to the documentation of this file.

#include "gateway_c_il_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_il_handler_state_t g_il;
 
static const char *peer_name(gateway_c_peer_t peer)
{
    return (peer == GATEWAY_C_PEER_A) ? "A" : "B";
}
 
static void broadcast_one(gateway_c_peer_t peer, const uint8_t bytes[RBC_ENVELOPE_WIRE_SIZE])
{
    sapi_status_t status = sapi_channel_service_send(&g_il.relay_channel[peer], bytes,
                                                     RBC_ENVELOPE_WIRE_SIZE, 0U);
 
    if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
    {
        sapi_log_write_event(SAPI_LOG_LEVEL_WARNING, "-", 0U, "GW", peer_name(peer), "LOG_LEVEL",
                              sapi_status_to_string(status), NULL);
    }
}
 
void gateway_c_il_handler_broadcast_to_ab(const uint8_t bytes[RBC_ENVELOPE_WIRE_SIZE])
{
    broadcast_one(GATEWAY_C_PEER_A, bytes);
    broadcast_one(GATEWAY_C_PEER_B, bytes);
}
 
sapi_status_t gateway_c_il_handler_init(gateway_c_context_t *ctx)
{
    sapi_status_t status;
 
    g_il.last_known_tag = "SUPPRESSED";
    g_il.relay_consecutive_timeout = 0U;
    g_il.relay_down_since_ms[GATEWAY_C_PEER_A] = 0U;
    g_il.relay_down_since_ms[GATEWAY_C_PEER_B] = 0U;
    g_il.a_seen_this_cycle = 0U;
    g_il.a_stale_cycles = 0U;
 
    status = sapi_channel_service_setup(&g_il.relay_channel[GATEWAY_C_PEER_A], "c-relay-il-a");
    if (status != SAPI_STATUS_OK)
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] ILHandler: 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_il.relay_channel[GATEWAY_C_PEER_B], "c-relay-il-b");
    if (status != SAPI_STATUS_OK)
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] ILHandler: relay B channel setup failed (%s)\n",
                             site_config_name(ctx->site), sapi_status_to_string(status));
        return status;
    }
    status = sapi_channel_service_setup(&g_il.sim_channel, "c-sim-il");
    if (status != SAPI_STATUS_OK)
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] ILHandler: 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_il.relay_channel[peer],
                                                     bytes, RBC_ENVELOPE_WIRE_SIZE, 0U);
    if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] ILHandler: forward 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_il.sim_channel,
                                                     bytes, RBC_ENVELOPE_WIRE_SIZE, 0U);
    if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
    {
        SAFEAPI_EXAMPLE_LOG("[GW %s] ILHandler: forward to ILSim 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", "IL", "ENVELOPE",
                              sapi_status_to_string(status), NULL);
    }
}
 
void gateway_c_il_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;
    bool          forwarded_this_cycle = false;
    (void)cycle;
 
    /* ILSim -> Gateway -> A and B (verbatim) */
    while (sapi_channel_service_read(&g_il.sim_channel, bytes, sizeof(bytes), 0U) == SAPI_STATUS_OK)
    {
        /* ADR-038: the IL sim's own-perspective status frame - republish to
         * the C status broker, never forward to A/B (they never see this
         * kind). Not counted as relay traffic (idle-cycle keepalive below
         * still fires if this was the only frame). */
        if (rbc_envelope_is_sim_status(bytes, sim_status, (uint16_t)sizeof(sim_status)))
        {
            gateway_c_selfstatus_publish((uint8_t)RBC_UTIL_SRC_SIM_IL, sim_status);
            continue;
        }
        send_to_relay(ctx, GATEWAY_C_PEER_A, bytes);
        send_to_relay(ctx, GATEWAY_C_PEER_B, bytes);
        forwarded_this_cycle = true;
    }
 
    /* Keepalive the C->A/B relay every idle cycle - the IL sim is
     * command-driven (long silent stretches), and with one multiplexed
     * link that silence would trip A/B's relay-RX staleness detector.
     * Same rationale as gateway_c_train_handler.c's own keepalive; A/B
     * drop it before any IL decode (pre_execute.c). */
    if (!forwarded_this_cycle)
    {
        uint8_t keepalive[RBC_ENVELOPE_WIRE_SIZE];
 
        rbc_envelope_write_keepalive(keepalive);
        send_to_relay(ctx, GATEWAY_C_PEER_A, keepalive);
        send_to_relay(ctx, GATEWAY_C_PEER_B, keepalive);
    }
 
    /* A/B -> Gateway -> ILSim (A primary, B drained always, forwarded
     * only in fallback). */
    {
        uint32_t a_count = 0U;
        bool     use_b_fallback;
 
        while ((status = sapi_channel_service_read(&g_il.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_il.relay_down_since_ms[GATEWAY_C_PEER_A] == 0U)
            {
                (void)sapi_timer_now(&g_il.relay_down_since_ms[GATEWAY_C_PEER_A]);
            }
        }
        else if (a_count > 0U)
        {
            g_il.relay_down_since_ms[GATEWAY_C_PEER_A] = 0U;
            g_il.relay_consecutive_timeout = 0U;
            g_il.a_stale_cycles = 0U;
        }
        else
        {
            g_il.a_stale_cycles++;
        }
        g_il.a_seen_this_cycle = a_count;
 
        use_b_fallback = (g_il.a_stale_cycles >= (unsigned int)SAFEAPI_EXAMPLE_C_A_STALE_CYCLE_LIMIT);
        {
            uint32_t b_count = 0U;
 
            while ((status = sapi_channel_service_read(&g_il.relay_channel[GATEWAY_C_PEER_B],
                                                      bytes, sizeof(bytes), 0U)) == SAPI_STATUS_OK)
            {
                if (use_b_fallback)
                {
                    send_to_sim(ctx, bytes);
                }
                b_count++;
            }
            if ((status != SAPI_STATUS_OK) && (status != SAPI_STATUS_TIMEOUT))
            {
                if (g_il.relay_down_since_ms[GATEWAY_C_PEER_B] == 0U)
                {
                    (void)sapi_timer_now(&g_il.relay_down_since_ms[GATEWAY_C_PEER_B]);
                }
            }
            else if (b_count > 0U)
            {
                g_il.relay_down_since_ms[GATEWAY_C_PEER_B] = 0U;
            }
            if (use_b_fallback)
            {
                g_il.last_known_tag = (b_count > 0U) ? "ACTIVE" : "SUPPRESSED";
            }
            else
            {
                g_il.last_known_tag = (a_count > 0U) ? "ACTIVE" : "SUPPRESSED";
            }
        }
    }
}
 
void gateway_c_il_handler_shutdown(void)
{
    (void)sapi_channel_service_close(&g_il.sim_channel);
    (void)sapi_channel_service_close(&g_il.relay_channel[GATEWAY_C_PEER_A]);
    (void)sapi_channel_service_close(&g_il.relay_channel[GATEWAY_C_PEER_B]);
}
 
bool gateway_c_il_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_il.relay_down_since_ms[peer];
 
        if ((down_since != 0U) && ((now_ms - down_since) >= threshold_ms))
        {
            (void)snprintf(out_which, which_size, "IL relay link to %s", peer_name(peer));
            return true;
        }
    }
    return false;
}