FragmentReassembler.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "PacketHeader.hpp"
 
#include <SDL3/SDL_stdinc.h>
 
#include <cstdint>
#include <vector>
 
namespace net
{
 
class FragmentReassembler
{
public:
    static constexpr int k_maxFragments = 256;

    enum class Result
    {
        InProgress,
        Complete,
        Stale,
        Malformed,
    };

    Result addFragment(const PacketHeader& hdr, const uint8_t* payload, int payloadLen, std::vector<uint8_t>& assembled)
    {
        const uint8_t fragIdx = static_cast<uint8_t>(hdr.fragmentInfo >> 8);
        const uint8_t fragCount = static_cast<uint8_t>(hdr.fragmentInfo & 0xFF);
 
        if (fragCount == 0 || fragIdx >= fragCount)
            return Result::Malformed;
 
        // Older sequence than what we're currently reassembling? Drop.
        // Glenn-Fiedler "more recent" comparison handles 16-bit wrap.
        //
        // PR-17 (BUG FIX): pre-PR-17 the args were swapped — the call
        // was `seqMoreRecent(active->sequence, hdr.sequence)` which
        // asks "is hdr more recent than active" (per the docstring on
        // `seqMoreRecent` below).  That made the receiver drop NEWER
        // fragments and stay stuck on the OLDEST in-progress
        // sequence forever — the moment a single fragment of the
        // first multi-fragment snapshot was lost, all subsequent
        // snapshot fragments returned Stale, freezing the client's
        // ECS registry at whichever FULL last completed cleanly.
        //
        // Pre-PR-15 the bug was masked because each snapshot's
        // fragments arrived back-to-back with no loss, completed
        // cleanly, `active_.reset()` cleared state, and the next
        // sequence started fresh in the `if (!active_)` path below.
        // PR-15's per-fragment redundancy then exposed it: the
        // duplicate copy of the LAST fragment arriving after Complete
        // re-creates an active set at the just-finished sequence with
        // 1/N fragments, locking out every newer sequence.
        //
        // Correct argument order: "is `active->sequence` more recent
        // than `hdr.sequence`?" → if yes, hdr is older, drop.
        if (active_ && seqMoreRecent(hdr.sequence, active_->sequence))
            return Result::Stale;
 
        // Newer sequence (or first fragment ever)? Reset the in-progress set.
        if (!active_ || hdr.sequence != active_->sequence) {
            active_.emplace();
            active_->sequence = hdr.sequence;
            active_->fragmentCount = fragCount;
            active_->received.assign(fragCount, std::vector<uint8_t>{});
            active_->haveCount = 0;
        }
 
        // Set must be self-consistent. If a fragment claims a different
        // count than the in-progress set, the sender's sequence/count
        // got mismatched somewhere. Reset and try again with this new
        // count.
        if (active_->fragmentCount != fragCount) {
            active_.emplace();
            active_->sequence = hdr.sequence;
            active_->fragmentCount = fragCount;
            active_->received.assign(fragCount, std::vector<uint8_t>{});
            active_->haveCount = 0;
        }
 
        auto& slot = active_->received[fragIdx];
        if (!slot.empty())
            return Result::InProgress; // duplicate; ignore
 
        slot.assign(payload, payload + payloadLen);
        ++active_->haveCount;
 
        if (active_->haveCount < active_->fragmentCount)
            return Result::InProgress;
 
        // Complete. Concatenate fragments in index order and hand back.
        size_t total = 0;
        for (const auto& s : active_->received)
            total += s.size();
        assembled.clear();
        assembled.reserve(total);
        for (const auto& s : active_->received)
            assembled.insert(assembled.end(), s.begin(), s.end());
 
        active_.reset();
        return Result::Complete;
    }

    void reset() noexcept { active_.reset(); }
 
private:
    static bool seqMoreRecent(uint16_t s1, uint16_t s2) noexcept
    {
        constexpr uint16_t k_half = 32768u;
        return ((s1 > s2) && (s1 - s2 > k_half)) || ((s2 > s1) && (s2 - s1 < k_half));
    }
 
    struct ActiveSet
    {
        uint16_t sequence = 0;
        uint8_t fragmentCount = 0;
        uint8_t haveCount = 0;
        std::vector<std::vector<uint8_t>> received;
    };
 
    // Single in-progress set per reassembler. Multi-channel reassembly
    // would need a small map; not needed at current scope.
    struct OptionalSet
    {
        bool hasValue = false;
        ActiveSet value;
 
        OptionalSet& emplace()
        {
            value = ActiveSet{};
            hasValue = true;
            return *this;
        }
        void reset() noexcept { hasValue = false; }
        ActiveSet* operator->() { return &value; }
        const ActiveSet* operator->() const { return &value; }
        ActiveSet& operator*() { return value; }
        const ActiveSet& operator*() const { return value; }
        explicit operator bool() const noexcept { return hasValue; }
    };
    OptionalSet active_;
};
 
} // namespace net