transport.c

Go to the documentation of this file.

#include "safecomm/transport/transport.h"
 
#ifdef SAFECOMM_HAVE_FRAMEWORK
#include "rte/redundancy/channel_service/rte_channel_service.h"
 
static safecomm_status_t map_status(rte_status_t status)
{
    switch (status)
    {
        case RTE_STATUS_OK:
            return SAFECOMM_STATUS_OK;
        case RTE_STATUS_TIMEOUT:
            return SAFECOMM_STATUS_TIMEOUT;
        default:
            return SAFECOMM_STATUS_TRANSPORT;
    }
}
 
static safecomm_status_t channel_send(void *user, const uint8_t *buf, size_t len)
{
    safecomm_transport_channel_ctx_t *ctx = (safecomm_transport_channel_ctx_t *)user;
    rte_status_t status;
 
    if ((ctx == NULL) || (buf == NULL) || (len == 0U))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    status = rte_channel_service_send((rte_channel_service_t *)ctx->channel, buf, len,
                                       (rte_duration_ms_t)ctx->recv_timeout_ms);
    return map_status(status);
}
 
static safecomm_status_t channel_recv(void *user, uint8_t *buf, size_t cap, size_t *out_len)
{
    safecomm_transport_channel_ctx_t *ctx = (safecomm_transport_channel_ctx_t *)user;
    rte_status_t status;
 
    if ((ctx == NULL) || (buf == NULL) || (cap == 0U) || (out_len == NULL))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    status = rte_channel_service_read_ex((rte_channel_service_t *)ctx->channel, buf, cap,
                                          (rte_duration_ms_t)ctx->recv_timeout_ms, out_len);
    return map_status(status);
}
 
static void channel_close(void *user)
{
    /* Deliberate no-op: the caller owns and closes the underlying channel - see this
     * function's own header doc comment. */
    (void)user;
}
 
safecomm_status_t safecomm_transport_from_channel_service(safecomm_transport_t *out,
                                                            safecomm_transport_channel_ctx_t *ctx,
                                                            void *channel,
                                                            uint32_t recv_timeout_ms)
{
    if ((out == NULL) || (ctx == NULL) || (channel == NULL))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    ctx->channel = channel;
    ctx->recv_timeout_ms = recv_timeout_ms;
    out->send = channel_send;
    out->recv = channel_recv;
    out->close = channel_close;
    out->user = ctx;
    return SAFECOMM_STATUS_OK;
}
 
#else /* !SAFECOMM_HAVE_FRAMEWORK */
 
safecomm_status_t safecomm_transport_from_channel_service(safecomm_transport_t *out,
                                                            safecomm_transport_channel_ctx_t *ctx,
                                                            void *channel,
                                                            uint32_t recv_timeout_ms)
{
    (void)recv_timeout_ms;
    if ((out == NULL) || (ctx == NULL) || (channel == NULL))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    return SAFECOMM_STATUS_NOT_IMPLEMENTED;
}
 
#endif /* SAFECOMM_HAVE_FRAMEWORK */
 
safecomm_status_t safecomm_transport_oal_tcp(safecomm_transport_t *out,
                                             const char *host, uint16_t port,
                                             uint32_t recv_timeout_ms)
{
    (void)port;
    (void)recv_timeout_ms;
    if ((out == NULL) || (host == NULL))
    {
        return SAFECOMM_STATUS_INVALID_PARAM;
    }
    /* TODO(REQ-SC-TRANSPORT-004): open a safeAPIFreamwork channel and wire
     * send/recv/close/user to it. Genuinely different from
     * safecomm_transport_from_channel_service() above: this one opens its own bearer from a
     * host/port, for a peer this library dials itself (e.g. a direct Subset-098 fixed-IP link)
     * rather than wrapping a channel the caller already manages. */
    return SAFECOMM_STATUS_NOT_IMPLEMENTED;
}