42. 기능 플래그(capability) 협상: 교집합 부재와 협상 결과의 잘못된 캐시 범위 (C#)

// [시나리오]
// 게임 클라이언트와 C++ 서버가 접속 시 핸드셰이크로 "기능 플래그(capability bits)"를 교환한다.
// 클라가 지원 기능 비트를 보내면 서버는 그 세션에서 쓸 인코딩·기능을 결정한다.
//
// 기능 비트:
//   0x01 DeltaSnapshot  - 델타 스냅샷 전송
//   0x02 Lz4Compress    - LZ4 압축 페이로드
//   0x04 BatchedEvents  - 이벤트 배치 전송
//   0x08 VoiceRelay     - 음성 릴레이 (서버 v3.2 부터 지원)
//   0x10 Reserved       - 미사용(향후 확장)
//
// [요구사항]
// - 서버는 자신이 실제로 지원하는 기능만 활성화한다.
// - 협상 결과는 해당 연결에만 적용되고, 재접속 시 다시 협상한다.
// - 클라가 보낸 바이트열은 신뢰할 수 없는 입력이다.
//
// [과제]
// (A), (B) 지점을 중심으로 요구사항이 깨지는 조건을 찾고, 재현 시나리오와 수정안을 제시하시오.

#include <cstdint>
#include <cstring>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>

namespace gs {

enum Capability : std::uint32_t {
    CAP_NONE = 0,
    CAP_DELTA_SNAPSHOT = 0x01,
    CAP_LZ4 = 0x02,
    CAP_BATCHED_EVENTS = 0x04,
    CAP_VOICE_RELAY = 0x08,
};

constexpr std::uint32_t kServerSupported =
    CAP_DELTA_SNAPSHOT | CAP_LZ4 | CAP_BATCHED_EVENTS;

struct Session {
    std::int64_t accountId = 0;
    std::uint32_t caps = CAP_NONE;
    std::uint16_t clientProtocolVersion = 0;
};

std::vector<std::uint8_t> lz4Compress(const std::vector<std::uint8_t>& b) { return b; }
std::vector<std::uint8_t> voiceRelayWrap(const std::vector<std::uint8_t>& b) { return b; }

class CapabilityNegotiator {
public:
    void onHandshake(Session& session, const std::uint8_t* payload, std::size_t len) {
        std::uint16_t version = 0;
        std::uint32_t clientCaps = 0;
        std::memcpy(&version, payload, sizeof(version));
        std::memcpy(&clientCaps, payload + 2, sizeof(clientCaps));

        session.clientProtocolVersion = version;

        // (A)
        {
            std::lock_guard<std::mutex> lk(mutex_);
            auto it = cache_.find(session.accountId);
            if (it != cache_.end()) {
                session.caps = it->second;
                sendHandshakeAck(session, session.caps);
                return;
            }
        }

        // (B)
        session.caps = clientCaps;
        {
            std::lock_guard<std::mutex> lk(mutex_);
            cache_[session.accountId] = session.caps;
        }
        sendHandshakeAck(session, session.caps);
    }

    std::vector<std::uint8_t> encode(const Session& session,
                                     std::vector<std::uint8_t> body) {
        if (session.caps & CAP_LZ4) body = lz4Compress(body);
        if (session.caps & CAP_VOICE_RELAY) body = voiceRelayWrap(body);
        return body;
    }

private:
    void sendHandshakeAck(const Session&, std::uint32_t) {}

    std::mutex mutex_;
    std::unordered_map<std::int64_t, std::uint32_t> cache_;
};

} // namespace gs

int main() { return 0; }