feat(clients): live: Gemini Live API over WebSocket, RFC 6455 client, session, relay, discovery check
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,132 @@
|
||||
#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<const char*>(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<WsFrame> FrameDecoder::next() {
|
||||
const std::size_t avail = buf_.size() - pos_;
|
||||
if (avail < 2) return std::nullopt;
|
||||
const auto* p = reinterpret_cast<const std::uint8_t*>(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<const char*>(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
|
||||
Reference in New Issue
Block a user