Home /Modules/http-3.0/station_backend.c

station_backend.c

http-3.0/station/station_backend.c · 178 line(s) · c

/* ==========================================================================
 * station_backend.c -- userland Station backend: simulation + device.
 * ========================================================================== */
#include "station_backend.h"

#include <string.h>
#include <stddef.h>
#include <fcntl.h>
#include <unistd.h>

int sl_station_init(sl_station_t *st, sl_backend_kind_t kind, const char *device_path)
{
    if (st == NULL) {
        return -1;
    }
    memset(st, 0, sizeof(*st));
    st->kind = kind;
    st->fd = -1;
    st->next_session_id = 1u;
    st->clock_ns = 1u; /* simulated monotonic clock starts at 1ns */

    if (kind == SL_BACKEND_DEVICE) {
        const char *path = device_path ? device_path : SLEELA_STATION_DEVPATH;
        st->fd = open(path, O_RDWR);
        if (st->fd < 0) {
            return -1;
        }
    }
    return 0;
}

static sl_session_t *sim_find(sl_station_t *st, uint64_t id)
{
    size_t i;
    for (i = 0; i < st->session_count; ++i) {
        if (st->sessions[i].session_id == id) {
            return &st->sessions[i];
        }
    }
    return NULL;
}

int sl_station_open(sl_station_t *st, uint64_t *session_id)
{
    if (st == NULL || session_id == NULL) {
        return -1;
    }
    if (st->kind == SL_BACKEND_DEVICE) {
        sl_session_view_t view;
        memset(&view, 0, sizeof(view));
        if (ioctl(st->fd, SL_IOC_OPEN, &view) != 0) {
            return -1;
        }
        *session_id = view.session_id;
        return 0;
    }
    /* simulation */
    if (st->session_count >= SL_BACKEND_MAX_SESSIONS) {
        return -1;
    }
    {
        sl_session_t *s = &st->sessions[st->session_count++];
        uint64_t id = st->next_session_id++;
        sl_session_open(s, id, st->clock_ns);
        *session_id = id;
    }
    return 0;
}

int sl_station_signal(sl_station_t *st, const sl_signal_t *sig, sl_record_t *out)
{
    if (st == NULL || sig == NULL) {
        return -1;
    }
    if (st->kind == SL_BACKEND_DEVICE) {
        sl_signal_t local = *sig;
        if (ioctl(st->fd, SL_IOC_SIGNAL, &local) != 0) {
            return -1;
        }
        /* Record is read back via query in the device path; out is best-effort. */
        if (out != NULL) {
            memset(out, 0, sizeof(*out));
        }
        return 0;
    }
    /* simulation */
    {
        sl_session_t *s = sim_find(st, sig->session_id);
        if (s == NULL) {
            return -1;
        }
        return sl_session_signal(s, sig, out);
    }
}

int sl_station_query(sl_station_t *st, uint64_t session_id, sl_session_view_t *view)
{
    if (st == NULL || view == NULL) {
        return -1;
    }
    if (st->kind == SL_BACKEND_DEVICE) {
        memset(view, 0, sizeof(*view));
        view->session_id = session_id;
        return ioctl(st->fd, SL_IOC_QUERY, view) == 0 ? 0 : -1;
    }
    {
        sl_session_t *s = sim_find(st, session_id);
        if (s == NULL) {
            return -1;
        }
        sl_session_view(s, view);
        return 0;
    }
}

int sl_station_close_session(sl_station_t *st, uint64_t session_id)
{
    if (st == NULL) {
        return -1;
    }
    if (st->kind == SL_BACKEND_DEVICE) {
        uint64_t id = session_id;
        return ioctl(st->fd, SL_IOC_CLOSE, &id) == 0 ? 0 : -1;
    }
    {
        sl_session_t *s = sim_find(st, session_id);
        if (s == NULL) {
            return -1;
        }
        sl_session_close(s, st->clock_ns);
        return 0;
    }
}

const sl_session_t *sl_station_peek(const sl_station_t *st, uint64_t session_id)
{
    size_t i;
    if (st == NULL || st->kind != SL_BACKEND_SIMULATION) {
        return NULL;
    }
    for (i = 0; i < st->session_count; ++i) {
        if (st->sessions[i].session_id == session_id) {
            return &st->sessions[i];
        }
    }
    return NULL;
}

void sl_station_shutdown(sl_station_t *st)
{
    if (st == NULL) {
        return;
    }
    if (st->kind == SL_BACKEND_DEVICE && st->fd >= 0) {
        close(st->fd);
        st->fd = -1;
    }
}

sl_signal_t sl_make_signal(uint64_t session_id, sl_party_t party,
                           uint8_t urg_units, int hop_delta,
                           uint8_t flags_extra, uint64_t timestamp_ns)
{
    sl_signal_t sig;
    memset(&sig, 0, sizeof(sig));
    sig.abi_version = SLEELA_STATION_ABI_VERSION;
    sig.session_id = session_id;
    sig.party = (uint8_t)party;
    sig.urg_units = urg_units;
    sig.hop_delta = (int8_t)hop_delta;
    sig.tcp_flags = flags_extra;
    if (urg_units > 0u) {
        sig.tcp_flags |= SL_TCP_URG; /* a premise-bearing signal carries URG */
    }
    sig.timestamp_ns = timestamp_ns;
    return sig;
}