Home /Modules/http-3.0/station_session.c

station_session.c

http-3.0/station/station_session.c · 228 line(s) · c

/* ==========================================================================
 * station_session.c -- Station witnessed session + state machine.
 * Pure logic; no libc/kernel-only calls beyond memset via a tiny local zero.
 * ========================================================================== */
#include "station_session.h"

#ifdef __KERNEL__
#include <linux/string.h>   /* memset */
#include <linux/stddef.h>   /* NULL   */
#else
#include <string.h>
#include <stddef.h>
#endif

void sl_session_open(sl_session_t *s, uint64_t session_id, uint64_t now_ns)
{
    if (s == NULL) {
        return;
    }
    memset(s, 0, sizeof(*s));
    s->session_id = session_id;
    s->state = SL_STATE_OPEN;
    s->party[0].open_premise = -1;
    s->party[1].open_premise = -1;
    s->opened_ns = now_ns;
    s->updated_ns = now_ns;
}

static int append_record(sl_session_t *s, const sl_signal_t *sig,
                         const sl_classification_t *cls)
{
    sl_record_t *r;
    if (s->record_count >= SL_SESSION_MAX_RECORDS) {
        return -1; /* store full; caller keeps state but stops recording */
    }
    r = &s->records[s->record_count];
    r->session_id = s->session_id;
    r->party = sig->party;
    r->condition = (uint8_t)cls->condition;
    r->premise = (uint8_t)cls->premise;
    r->hop_verb = (int8_t)cls->hop_verb;
    r->timestamp_ns = sig->timestamp_ns;
    r->sequence = s->sequence++;
    ++s->record_count;
    return 0;
}

/* Both parties agreed: each opened INTERMEDIARY and each ACKed the peer. */
static int both_agreed(const sl_session_t *s)
{
    return s->party[0].open_premise == (int)SL_PREMISE_INTERMEDIARY &&
           s->party[1].open_premise == (int)SL_PREMISE_INTERMEDIARY &&
           s->party[0].acked_peer && s->party[1].acked_peer;
}

int sl_session_signal(sl_session_t *s, const sl_signal_t *sig, sl_record_t *out_record)
{
    sl_classification_t cls;
    sl_party_state_t *ps;
    if (s == NULL || sig == NULL || s->sealed) {
        return -1;
    }
    if (sig->party > (uint8_t)SL_PARTY_B) {
        return -1;
    }
    if (s->state == SL_STATE_CLEAR || s->state == SL_STATE_DISASTROUS) {
        return -1; /* terminal; no further folding */
    }
    ps = &s->party[sig->party];

    /* A hard abort ends the negotiation disastrously, regardless of URG. */
    if (sig->tcp_flags & SL_TCP_RST) {
        cls.condition = SL_COND_WARNING;
        cls.premise = SL_PREMISE_CANCELLING;
        cls.hop_verb = SL_HOP_CANCEL;
        cls.valid = 1;
        (void)append_record(s, sig, &cls);
        s->state = SL_STATE_DISASTROUS;
        s->updated_ns = sig->timestamp_ns;
        if (out_record != NULL) {
            *out_record = s->records[s->record_count ? s->record_count - 1u : 0u];
        }
        return 0;
    }

    /* An orderly FIN marks this party finished. */
    if (sig->tcp_flags & SL_TCP_FIN) {
        ps->finished = 1;
    }

    /* An ACK (without URG premise) records acknowledgement of the peer. */
    if ((sig->tcp_flags & SL_TCP_ACK) && (sig->tcp_flags & SL_TCP_URG) == 0u) {
        ps->acked_peer = 1;
    }

    cls = sl_classify_signal(sig, ps->open_premise);
    ++ps->signal_count;
    s->updated_ns = sig->timestamp_ns;

    if (cls.valid) {
        (void)append_record(s, sig, &cls);
        if (cls.condition == SL_COND_LEGAL) {
            s->legal_asserted = 1;
        }
        /* A premise that both is CANCELLING while a LEGAL premise stands, or a
         * LEGAL premise arriving after a CANCELLING from the same party, is a
         * contradiction the Station flags as DISASTROUS. */
        if (s->legal_asserted && cls.premise == SL_PREMISE_CANCELLING &&
            cls.condition == SL_COND_LEGAL) {
            s->state = SL_STATE_DISASTROUS;
            if (out_record != NULL && s->record_count) {
                *out_record = s->records[s->record_count - 1u];
            }
            return 0;
        }
        ps->open_premise = (int)cls.premise;
        /* A premise signal that also carries ACK acknowledges the peer. */
        if (sig->tcp_flags & SL_TCP_ACK) {
            ps->acked_peer = 1;
        }
    }

    /* Recompute joint state. */
    if (both_agreed(s)) {
        s->state = SL_STATE_CLEAR;
    } else if (s->party[0].finished || s->party[1].finished) {
        s->state = SL_STATE_HUNG_UP;
    } else if ((s->party[0].open_premise == (int)SL_PREMISE_CANCELLING ||
                s->party[1].open_premise == (int)SL_PREMISE_CANCELLING)) {
        /* A standing cancellation with no re-advance leaves things UNCLEAR,
         * but the negotiation may still continue, so this is not terminal. */
        s->state = SL_STATE_UNCLEAR;
    } else {
        s->state = SL_STATE_OPEN;
    }

    if (out_record != NULL && s->record_count) {
        *out_record = s->records[s->record_count - 1u];
    }
    return 0;
}

void sl_session_timeout(sl_session_t *s, sl_party_t party, uint64_t now_ns)
{
    if (s == NULL || s->sealed || party > SL_PARTY_B) {
        return;
    }
    if (s->state == SL_STATE_CLEAR || s->state == SL_STATE_DISASTROUS) {
        return;
    }
    s->party[party].finished = 1;
    s->state = SL_STATE_HUNG_UP;
    s->updated_ns = now_ns;
}

void sl_session_close(sl_session_t *s, uint64_t now_ns)
{
    if (s == NULL || s->sealed) {
        return;
    }
    /* If still merely OPEN at close, the outcome was never made definite. */
    if (s->state == SL_STATE_OPEN) {
        s->state = SL_STATE_UNCLEAR;
    }
    s->sealed = 1;
    s->updated_ns = now_ns;
}

void sl_session_view(const sl_session_t *s, sl_session_view_t *view)
{
    if (s == NULL || view == NULL) {
        return;
    }
    memset(view, 0, sizeof(*view));
    view->session_id = s->session_id;
    view->state = (uint8_t)s->state;
    view->last_premise_a = (uint8_t)(s->party[0].open_premise < 0 ? 0 : s->party[0].open_premise);
    view->last_premise_b = (uint8_t)(s->party[1].open_premise < 0 ? 0 : s->party[1].open_premise);
    view->record_count = s->record_count;
    view->opened_ns = s->opened_ns;
    view->updated_ns = s->updated_ns;
}

const char *sl_state_name(sl_state_t st)
{
    switch (st) {
        case SL_STATE_IDLE:       return "IDLE";
        case SL_STATE_OPEN:       return "OPEN";
        case SL_STATE_CLEAR:      return "CLEAR";
        case SL_STATE_UNCLEAR:    return "UNCLEAR";
        case SL_STATE_HUNG_UP:    return "HUNG-UP";
        case SL_STATE_DISASTROUS: return "DISASTROUS";
        default:                  return "?";
    }
}

const char *sl_condition_name(sl_condition_t c)
{
    switch (c) {
        case SL_COND_NONE:        return "NONE";
        case SL_COND_INTENTIONAL: return "INTENTIONAL";
        case SL_COND_LEGAL:       return "LEGAL";
        case SL_COND_WARNING:     return "WARNING";
        case SL_COND_EMERGENCY:   return "EMERGENCY";
        default:                  return "?";
    }
}

const char *sl_premise_name(sl_premise_t p)
{
    switch (p) {
        case SL_PREMISE_START:        return "START";
        case SL_PREMISE_INTERMEDIARY: return "INTERMEDIARY";
        case SL_PREMISE_CANCELLING:   return "CANCELLING";
        default:                      return "?";
    }
}

const char *sl_hop_verb_name(sl_hop_verb_t v)
{
    switch (v) {
        case SL_HOP_CANCEL:  return "CANCEL(DIST-1)";
        case SL_HOP_HOLD:    return "HOLD(DIST+0)";
        case SL_HOP_ADVANCE: return "ADVANCE(DIST+1)";
        default:             return "?";
    }
}