ab_gp_km114_relay.c

Go to the documentation of this file.

#include "ab_gp_km114_relay.h"
 
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
 
#include "rte/oal/log/rte_log.h"
 
#include "../../common/rbc_util_km114_relay.h"
#include "ab_gp_km114_client.h"



static uint8_t  s_buf[RBC_UTIL_KM114_RELAY_FILE_MAX];
static uint16_t s_total_len;
static uint8_t  s_frag_count;
static bool     s_frag_seen[RBC_UTIL_KM114_RELAY_MAX_FRAGS];
static uint8_t  s_frags_seen_count;

void ab_gp_km114_relay_on_frame(const rbc_util_frame_t *frame, const char *role_tag, rte_example_site_t site,
                                 ab_gp_channel_handle_t handle)
{
    uint16_t       total_len;
    uint8_t        frag_index;
    uint8_t        frag_count;
    const uint8_t *chunk;
    uint8_t        chunk_len;
    size_t         offset;
 
    if (frame == NULL)
    {
        return;
    }
    if (!rbc_util_km114_relay_decode_chunk((const uint8_t *)frame->payload_z, frame->payload_len, &total_len,
                                           &frag_index, &frag_count, &chunk, &chunk_len))
    {
        return;
    }
    if ((frag_count == 0U) || (frag_count > (uint8_t)RBC_UTIL_KM114_RELAY_MAX_FRAGS) ||
        (frag_index >= frag_count) || (total_len > (uint16_t)RBC_UTIL_KM114_RELAY_FILE_MAX))
    {
        rte_log_write_event(RTE_LOG_LEVEL_WARNING, site_config_name(site), 0U, role_tag, "-", "KM114_RELAY",
                              "malformed chunk header", NULL);
        return;
    }
 
    /* A frag_count that differs from an in-progress transfer's own means a NEW transfer
     * started (the off-line KMC drop is one-file-at-a-time in this workspace's design, so
     * overlapping transfers are not expected) - reset and start over rather than mix bytes
     * from two different files. */
    if ((s_frag_count != frag_count) || (s_total_len != total_len))
    {
        s_total_len = total_len;
        s_frag_count = frag_count;
        s_frags_seen_count = 0U;
        for (offset = 0U; offset < (size_t)RBC_UTIL_KM114_RELAY_MAX_FRAGS; offset++)
        {
            s_frag_seen[offset] = false;
        }
    }
 
    offset = (size_t)frag_index * (size_t)RBC_UTIL_KM114_RELAY_CHUNK_MAX;
    if ((offset + (size_t)chunk_len) > (size_t)RBC_UTIL_KM114_RELAY_FILE_MAX)
    {
        return; /* Defensive - cannot happen given the range checks above. */
    }
    if (chunk_len > 0U)
    {
        (void)memcpy(&s_buf[offset], chunk, chunk_len);
    }
    if (!s_frag_seen[frag_index])
    {
        s_frag_seen[frag_index] = true;
        s_frags_seen_count++;
    }
 
    if (s_frags_seen_count == s_frag_count)
    {
        char msg[64];
 
        (void)snprintf(msg, sizeof(msg), "bytes=%u frags=%u", (unsigned int)s_total_len,
                       (unsigned int)s_frag_count);
        rte_log_write_event(RTE_LOG_LEVEL_INFO, site_config_name(site), 0U, role_tag, "-", "KM114_RELAY",
                              "file reassembled", msg);
        /* Hand off to the actual decoder - see ab_gp_km114_client.h. Gateway (which sent these
         * bytes) never does this itself; only A/B, each independently. */
        ab_gp_km114_client_on_message(s_buf, (size_t)s_total_len, role_tag, site, handle);
        s_frag_count = 0U;
        s_frags_seen_count = 0U;
    }
}