#include "google/live/ws_frame.h" #include "google/live/caps.h" #include "google/live/ws_error.h" namespace molo::google::live { using K = WsError::Kind; std::string encode_frame(bool fin, WsOpcode opcode, const std::string& payload, const std::uint8_t* mask_key) { std::string out; out.push_back((char)((fin ? 0x80 : 0x00) | (std::uint8_t)opcode)); std::uint8_t mask_bit = mask_key ? 0x80 : 0x00; std::size_t n = payload.size(); if (n < 126) { out.push_back((char)(mask_bit | n)); } else if (n <= 0xFFFF) { out.push_back((char)(mask_bit | 126)); out.push_back((char)(n >> 8)); out.push_back((char)(n & 0xFF)); } else { out.push_back((char)(mask_bit | 127)); for (int shift = 56; shift >= 0; shift -= 8) out.push_back((char)(((std::uint64_t)n >> shift) & 0xFF)); } if (mask_key) { out.append(reinterpret_cast(mask_key), 4); for (std::size_t i = 0; i < n; ++i) out.push_back((char)((std::uint8_t)payload[i] ^ mask_key[i & 3])); } else { out += payload; } return out; } bool valid_utf8(const std::string& s) { std::size_t i = 0, n = s.size(); while (i < n) { std::uint8_t c = (std::uint8_t)s[i]; std::size_t len; std::uint32_t cp; if (c < 0x80) { ++i; continue; } else if (c >= 0xC2 && c <= 0xDF) { len = 2; cp = c & 0x1F; } else if (c >= 0xE0 && c <= 0xEF) { len = 3; cp = c & 0x0F; } else if (c >= 0xF0 && c <= 0xF4) { len = 4; cp = c & 0x07; } else { return false; } if (i + len > n) return false; for (std::size_t k = 1; k < len; ++k) { std::uint8_t cc = (std::uint8_t)s[i + k]; if ((cc & 0xC0) != 0x80) return false; cp = (cp << 6) | (cc & 0x3F); } if (len == 3 && (cp < 0x800 || (cp >= 0xD800 && cp <= 0xDFFF))) return false; if (len == 4 && (cp < 0x10000 || cp > 0x10FFFF)) return false; i += len; } return true; } void FrameDecoder::feed(const char* data, std::size_t size) { if (pos_ > 0 && pos_ == buf_.size()) { buf_.clear(); pos_ = 0; } else if (pos_ > LiveCaps::kReadChunk) { buf_.erase(0, pos_); pos_ = 0; } buf_.append(data, size); } std::optional FrameDecoder::next() { const std::size_t avail = buf_.size() - pos_; if (avail < 2) return std::nullopt; const auto* p = reinterpret_cast(buf_.data()) + pos_; bool fin = p[0] & 0x80; if (p[0] & 0x70) throw WsError(K::Protocol, "reserved bits set"); std::uint8_t op = p[0] & 0x0F; bool known = op == 0 || op == 1 || op == 2 || (op >= 8 && op <= 10); if (!known) throw WsError(K::Protocol, "unknown opcode"); bool masked = p[1] & 0x80; if (masked != expect_masked_) throw WsError(K::Protocol, expect_masked_ ? "unmasked client frame" : "masked server frame"); std::uint64_t len = p[1] & 0x7F; std::size_t header = 2; if (len == 126) { if (avail < 4) return std::nullopt; len = ((std::uint64_t)p[2] << 8) | p[3]; header = 4; if (len < 126) throw WsError(K::Protocol, "non-minimal length"); } else if (len == 127) { if (avail < 10) return std::nullopt; len = 0; for (int i = 0; i < 8; ++i) len = (len << 8) | p[2 + i]; header = 10; if (len >> 63) throw WsError(K::Protocol, "length high bit set"); if (len <= 0xFFFF) throw WsError(K::Protocol, "non-minimal length"); } bool control = op >= 8; if (control) { if (!fin) throw WsError(K::Protocol, "fragmented control frame"); if (len > LiveCaps::kMaxControlPayload) throw WsError(K::Protocol, "control payload over 125 bytes"); } if (len > max_payload_) throw WsError(K::TooBig, "frame payload over cap"); std::size_t mask_len = masked ? 4 : 0; if (avail < header + mask_len + len) return std::nullopt; WsFrame f; f.fin = fin; f.opcode = op; const std::uint8_t* key = p + header; const std::uint8_t* body = p + header + mask_len; f.payload.assign(reinterpret_cast(body), (std::size_t)len); if (masked) for (std::size_t i = 0; i < f.payload.size(); ++i) f.payload[i] = (char)((std::uint8_t)f.payload[i] ^ key[i & 3]); pos_ += header + mask_len + (std::size_t)len; return f; } } // namespace molo::google::live