#include "ProtocolCodec.h"
|
#include <cstring> // std::memcpy
|
#include <cstdio> // std::snprintf (ÈçÐèÈÕÖ¾)
|
#include <vector>
|
|
namespace Proto {
|
|
// ---------------------------
|
// Big-endian »ù´¡±à½âÂ빤¾ß
|
// ---------------------------
|
void put_u16(std::vector<uint8_t>& v, uint16_t x) {
|
v.push_back(static_cast<uint8_t>((x >> 8) & 0xFF));
|
v.push_back(static_cast<uint8_t>(x & 0xFF));
|
}
|
void put_u32(std::vector<uint8_t>& v, uint32_t x) {
|
v.push_back(static_cast<uint8_t>((x >> 24) & 0xFF));
|
v.push_back(static_cast<uint8_t>((x >> 16) & 0xFF));
|
v.push_back(static_cast<uint8_t>((x >> 8) & 0xFF));
|
v.push_back(static_cast<uint8_t>(x & 0xFF));
|
}
|
void put_u64(std::vector<uint8_t>& v, uint64_t x) {
|
for (int i = 7; i >= 0; --i) v.push_back(static_cast<uint8_t>((x >> (i * 8)) & 0xFF));
|
}
|
uint16_t get_u16(const uint8_t* p) {
|
return static_cast<uint16_t>((uint16_t(p[0]) << 8) | uint16_t(p[1]));
|
}
|
uint32_t get_u32(const uint8_t* p) {
|
return (uint32_t(p[0]) << 24) | (uint32_t(p[1]) << 16) | (uint32_t(p[2]) << 8) | uint32_t(p[3]);
|
}
|
uint64_t get_u64(const uint8_t* p) {
|
uint64_t x = 0;
|
for (int i = 0; i < 8; ++i) { x = (x << 8) | p[i]; }
|
return x;
|
}
|
void put_f64_be(std::vector<uint8_t>& v, double d) {
|
static_assert(sizeof(double) == 8, "double must be 8 bytes");
|
uint64_t u;
|
std::memcpy(&u, &d, 8);
|
for (int i = 7; i >= 0; --i) v.push_back(static_cast<uint8_t>((u >> (i * 8)) & 0xFF));
|
}
|
double get_f64_be(const uint8_t* p) {
|
uint64_t u = 0;
|
for (int i = 0; i < 8; ++i) { u = (u << 8) | p[i]; }
|
double d;
|
std::memcpy(&d, &u, 8);
|
return d;
|
}
|
|
// ¿ìËÙ¿ú̽ÕýÎÄ cmd£¨²»×öÍêÕû³¤¶ÈºË¶Ô£¬±£ÁôÄãÔ±¾·ç¸ñ£©
|
uint16_t peek_cmd(const std::vector<uint8_t>& f) {
|
if (f.size() < 12) return 0;
|
if (!(f[0] == kHead[0] && f[1] == kHead[1] && f[2] == kHead[2] && f[3] == kHead[3])) return 0;
|
return (uint16_t(f[10]) << 8) | f[11];
|
}
|
|
// °ü×°Ö¡£º4BÍ· + 4B dataId + 2B bodyLen + body + 1Bβ
|
static inline void frame_wrap(uint32_t dataId, const std::vector<uint8_t>& body, std::vector<uint8_t>& out) {
|
out.clear();
|
out.reserve(4 + 4 + 2 + body.size() + 1);
|
out.push_back(kHead[0]); out.push_back(kHead[1]); out.push_back(kHead[2]); out.push_back(kHead[3]);
|
put_u32(out, dataId);
|
put_u16(out, static_cast<uint16_t>(body.size()));
|
out.insert(out.end(), body.begin(), body.end());
|
out.push_back(kTail);
|
}
|
|
// ---------------------------
|
// 0x0104 / 0xF104 Machines
|
// ---------------------------
|
std::vector<uint8_t> encodeRequestMachines(const ReqMachines& req) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_REQ_MACHINES);
|
|
std::vector<uint8_t> out;
|
frame_wrap(req.dataId, body, out);
|
return out;
|
}
|
|
std::vector<uint8_t> encodeResponseMachines(const RspMachines& rsp) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_RSP_MACHINES);
|
put_u16(body, static_cast<uint16_t>(rsp.machines.size()));
|
for (auto& m : rsp.machines) {
|
put_u32(body, m.id);
|
const uint16_t n = static_cast<uint16_t>(m.name.size());
|
put_u16(body, n);
|
body.insert(body.end(), m.name.begin(), m.name.end());
|
}
|
|
std::vector<uint8_t> out;
|
frame_wrap(rsp.dataId, body, out);
|
return out;
|
}
|
|
bool decodeRequestMachines(const std::vector<uint8_t>& f, ReqMachines& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
return (get_u16(b) == CMD_REQ_MACHINES);
|
}
|
|
bool decodeResponseMachines(const std::vector<uint8_t>& f, RspMachines& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 + 2 > e) return false;
|
if (get_u16(b) != CMD_RSP_MACHINES) return false;
|
b += 2;
|
const uint16_t cnt = get_u16(b); b += 2;
|
|
out.machines.clear();
|
out.machines.reserve(cnt);
|
for (uint16_t i = 0; i < cnt; ++i) {
|
if (b + 4 + 2 > e) return false;
|
const uint32_t id = get_u32(b); b += 4;
|
const uint16_t n = get_u16(b); b += 2;
|
if (b + n > e) return false;
|
out.machines.push_back({ id, std::string(reinterpret_cast<const char*>(b), n) });
|
b += n;
|
}
|
return (b == e);
|
}
|
|
// ---------------------------
|
// 0x0001 / 0xF001 Version
|
// ---------------------------
|
std::vector<uint8_t> encodeRequestVersion(const ReqVersion& req) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_REQ_VERSION);
|
|
std::vector<uint8_t> out;
|
frame_wrap(req.dataId, body, out);
|
return out;
|
}
|
|
std::vector<uint8_t> encodeResponseVersion(const RspVersion& rsp) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_RSP_VERSION);
|
const uint16_t n = static_cast<uint16_t>(rsp.version.size());
|
put_u16(body, n);
|
body.insert(body.end(), rsp.version.begin(), rsp.version.end()); // UTF-8
|
|
std::vector<uint8_t> out;
|
frame_wrap(rsp.dataId, body, out);
|
return out;
|
}
|
|
bool decodeRequestVersion(const std::vector<uint8_t>& f, ReqVersion& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
const uint8_t* b = p + 10;
|
return (get_u16(b) == CMD_REQ_VERSION);
|
}
|
|
bool decodeResponseVersion(const std::vector<uint8_t>& f, RspVersion& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 + 2 > e) return false;
|
if (get_u16(b) != CMD_RSP_VERSION) return false;
|
b += 2;
|
|
const uint16_t n = get_u16(b); b += 2;
|
if (b + n > e) return false;
|
out.version.assign(reinterpret_cast<const char*>(b), n);
|
b += n;
|
|
return (b == e);
|
}
|
|
// ---------------------------
|
// 0x0103 / 0xF103 Stats
|
// ---------------------------
|
std::vector<uint8_t> encodeRequestStats(const ReqStats& req) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_REQ_STATS);
|
put_u32(body, req.machineId);
|
put_u16(body, req.flags);
|
|
std::vector<uint8_t> out;
|
frame_wrap(req.dataId, body, out);
|
return out;
|
}
|
|
std::vector<uint8_t> encodeResponseStats(const RspStats& rsp) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_RSP_STATS);
|
put_u32(body, rsp.machineId);
|
put_u16(body, static_cast<uint16_t>(rsp.channels.size()));
|
|
for (auto& c : rsp.channels) {
|
put_u32(body, c.channelId);
|
put_u64(body, c.earliestTs);
|
put_u64(body, c.latestTs);
|
put_u32(body, c.size);
|
const uint16_t n = static_cast<uint16_t>(c.name.size());
|
put_u16(body, n);
|
body.insert(body.end(), c.name.begin(), c.name.end());
|
}
|
|
std::vector<uint8_t> out;
|
frame_wrap(rsp.dataId, body, out);
|
return out;
|
}
|
|
bool decodeRequestStats(const std::vector<uint8_t>& f, ReqStats& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
if (b + 2 + 4 + 2 > e) return false;
|
if (get_u16(b) != CMD_REQ_STATS) return false;
|
b += 2;
|
|
out.machineId = get_u32(b); b += 4;
|
out.flags = get_u16(b); b += 2;
|
|
return (b == e);
|
}
|
|
bool decodeResponseStats(const std::vector<uint8_t>& f, RspStats& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 + 4 + 2 > e) return false;
|
if (get_u16(b) != CMD_RSP_STATS) return false;
|
b += 2;
|
|
out.machineId = get_u32(b); b += 4;
|
const uint16_t cnt = get_u16(b); b += 2;
|
|
out.channels.clear();
|
out.channels.reserve(cnt);
|
for (uint16_t i = 0; i < cnt; ++i) {
|
if (b + 4 + 8 + 8 + 4 + 2 > e) return false;
|
ChannelStatInfo ci{};
|
ci.channelId = get_u32(b); b += 4;
|
ci.earliestTs = get_u64(b); b += 8;
|
ci.latestTs = get_u64(b); b += 8;
|
ci.size = get_u32(b); b += 4;
|
|
const uint16_t n = get_u16(b); b += 2;
|
if (b + n > e) return false;
|
ci.name.assign(reinterpret_cast<const char*>(b), n);
|
b += n;
|
|
out.channels.push_back(std::move(ci));
|
}
|
return (b == e);
|
}
|
|
// ---------------------------------------
|
// 0x0101 / 0xF101 Since£¨Ö§³Ö¿ÉÑ¡ batchId£©
|
// ---------------------------------------
|
std::vector<uint8_t> encodeRequestSince(const ReqSince& req) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_REQ_SINCE);
|
put_u32(body, req.machineId);
|
put_u32(body, req.channelId);
|
put_u64(body, req.sinceTsExclusive);
|
put_u16(body, req.maxCount);
|
put_u16(body, req.flags);
|
if (req.flags & SINCE_FLAG_HAS_BATCH) {
|
const uint16_t L = static_cast<uint16_t>(req.batchId.size());
|
put_u16(body, L);
|
body.insert(body.end(), req.batchId.begin(), req.batchId.end());
|
}
|
|
std::vector<uint8_t> out;
|
frame_wrap(req.dataId, body, out);
|
return out;
|
}
|
|
std::vector<uint8_t> encodeResponseSince(const RspSince& rsp) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_RSP_SINCE);
|
put_u32(body, rsp.machineId);
|
put_u32(body, rsp.channelId);
|
put_u64(body, rsp.lastTsSent);
|
body.push_back(rsp.more ? 1u : 0u);
|
put_u16(body, static_cast<uint16_t>(rsp.samples.size()));
|
for (auto& s : rsp.samples) {
|
put_u64(body, s.ts_ms);
|
put_f64_be(body, s.value);
|
}
|
|
std::vector<uint8_t> out;
|
frame_wrap(rsp.dataId, body, out);
|
return out;
|
}
|
|
bool decodeRequestSince(const std::vector<uint8_t>& f, ReqSince& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 > e) return false;
|
if (get_u16(b) != CMD_REQ_SINCE) return false;
|
b += 2;
|
|
if (b + 4 + 4 + 8 + 2 + 2 > e) return false;
|
out.machineId = get_u32(b); b += 4;
|
out.channelId = get_u32(b); b += 4;
|
out.sinceTsExclusive = get_u64(b); b += 8;
|
out.maxCount = get_u16(b); b += 2;
|
out.flags = get_u16(b); b += 2;
|
|
out.batchId.clear();
|
if (out.flags & SINCE_FLAG_HAS_BATCH) {
|
if (b + 2 > e) return false;
|
const uint16_t L = get_u16(b); b += 2;
|
if (b + L > e) return false;
|
out.batchId.assign(reinterpret_cast<const char*>(b), L);
|
b += L;
|
}
|
|
return (b == e);
|
}
|
|
bool decodeResponseSince(const std::vector<uint8_t>& f, RspSince& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 > e) return false;
|
if (get_u16(b) != CMD_RSP_SINCE) return false;
|
b += 2;
|
|
if (b + 4 + 4 + 8 + 1 + 2 > e) return false;
|
out.machineId = get_u32(b); b += 4;
|
out.channelId = get_u32(b); b += 4;
|
out.lastTsSent = get_u64(b); b += 8;
|
out.more = *b++; // u8
|
const uint16_t cnt = get_u16(b); b += 2;
|
|
out.samples.clear();
|
out.samples.reserve(cnt);
|
for (uint16_t i = 0; i < cnt; ++i) {
|
if (b + 8 + 8 > e) return false;
|
const uint64_t ts = get_u64(b); b += 8;
|
const double v = get_f64_be(b); b += 8;
|
out.samples.push_back({ ts, v });
|
}
|
return (b == e);
|
}
|
|
// ---------------------------------------
|
// 0x0105 / 0xF105 SinceAll£¨Õû»ú¶àͨµÀÔöÁ¿£©
|
// ---------------------------------------
|
std::vector<uint8_t> encodeRequestSinceAll(const ReqSinceAll& req) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_REQ_SINCE_ALL);
|
put_u32(body, req.machineId);
|
put_u64(body, req.sinceTsExclusive);
|
put_u16(body, req.maxPerChannel);
|
put_u16(body, req.flags);
|
if (req.flags & SINCE_FLAG_HAS_BATCH) {
|
const uint16_t L = static_cast<uint16_t>(req.batchId.size());
|
put_u16(body, L);
|
body.insert(body.end(), req.batchId.begin(), req.batchId.end());
|
}
|
|
std::vector<uint8_t> out;
|
frame_wrap(req.dataId, body, out);
|
return out;
|
}
|
|
std::vector<uint8_t> encodeResponseSinceAll(const RspSinceAll& rsp) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_RSP_SINCE_ALL);
|
put_u32(body, rsp.machineId);
|
body.push_back(rsp.moreAny ? 1u : 0u);
|
put_u16(body, static_cast<uint16_t>(rsp.blocks.size()));
|
|
for (const auto& b : rsp.blocks) {
|
put_u32(body, b.channelId);
|
put_u64(body, b.lastTsSent);
|
body.push_back(b.more ? 1u : 0u);
|
put_u16(body, static_cast<uint16_t>(b.samples.size()));
|
for (const auto& sp : b.samples) {
|
put_u64(body, sp.ts_ms);
|
put_f64_be(body, sp.value);
|
}
|
}
|
|
std::vector<uint8_t> out;
|
frame_wrap(rsp.dataId, body, out);
|
return out;
|
}
|
|
bool decodeRequestSinceAll(const std::vector<uint8_t>& f, ReqSinceAll& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 > e) return false;
|
if (get_u16(b) != CMD_REQ_SINCE_ALL) return false;
|
b += 2;
|
|
if (b + 4 + 8 + 2 + 2 > e) return false;
|
out.machineId = get_u32(b); b += 4;
|
out.sinceTsExclusive = get_u64(b); b += 8;
|
out.maxPerChannel = get_u16(b); b += 2;
|
out.flags = get_u16(b); b += 2;
|
|
out.batchId.clear();
|
if (out.flags & SINCE_FLAG_HAS_BATCH) {
|
if (b + 2 > e) return false;
|
const uint16_t L = get_u16(b); b += 2;
|
if (b + L > e) return false;
|
out.batchId.assign(reinterpret_cast<const char*>(b), L);
|
b += L;
|
}
|
return (b == e);
|
}
|
|
bool decodeResponseSinceAll(const std::vector<uint8_t>& f, RspSinceAll& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 > e) return false;
|
if (get_u16(b) != CMD_RSP_SINCE_ALL) return false;
|
b += 2;
|
|
if (b + 4 + 1 + 2 > e) return false;
|
out.machineId = get_u32(b); b += 4;
|
out.moreAny = *b++; // u8
|
const uint16_t N = get_u16(b); b += 2;
|
|
out.blocks.clear();
|
out.blocks.reserve(N);
|
for (uint16_t i = 0; i < N; ++i) {
|
if (b + 4 + 8 + 1 + 2 > e) return false;
|
ChannelBlock blk;
|
blk.channelId = get_u32(b); b += 4;
|
blk.lastTsSent = get_u64(b); b += 8;
|
blk.more = *b++; // u8
|
const uint16_t M = get_u16(b); b += 2;
|
|
blk.samples.clear();
|
blk.samples.reserve(M);
|
for (uint16_t j = 0; j < M; ++j) {
|
if (b + 8 + 8 > e) return false;
|
SamplePair sp;
|
sp.ts_ms = get_u64(b); b += 8;
|
sp.value = get_f64_be(b); b += 8;
|
blk.samples.push_back(sp);
|
}
|
out.blocks.push_back(std::move(blk));
|
}
|
return (b == e);
|
}
|
|
// ---------------------------
|
// 0x0120 / 0xF120 BatchInfo
|
// ---------------------------
|
std::vector<uint8_t> encodeRequestBatchInfo(const ReqBatchInfo& req) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_REQ_BATCH_INFO);
|
put_u32(body, req.machineId);
|
|
std::vector<uint8_t> out;
|
frame_wrap(req.dataId, body, out);
|
return out;
|
}
|
|
bool decodeRequestBatchInfo(const std::vector<uint8_t>& f, ReqBatchInfo& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 + 4 > e) return false;
|
if (get_u16(b) != CMD_REQ_BATCH_INFO) return false;
|
b += 2;
|
|
out.machineId = get_u32(b); b += 4;
|
return (b == e);
|
}
|
|
std::vector<uint8_t> encodeResponseBatchInfo(const RspBatchInfo& rsp) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_RSP_BATCH_INFO);
|
put_u32(body, rsp.machineId);
|
body.push_back(static_cast<uint8_t>(rsp.state));
|
|
const uint16_t L = static_cast<uint16_t>(rsp.activeBatchId.size());
|
put_u16(body, L);
|
body.insert(body.end(), rsp.activeBatchId.begin(), rsp.activeBatchId.end());
|
|
put_u64(body, rsp.activeStartTs);
|
put_u64(body, rsp.expectedEndTs);
|
|
std::vector<uint8_t> out;
|
frame_wrap(rsp.dataId, body, out);
|
return out;
|
}
|
|
bool decodeResponseBatchInfo(const std::vector<uint8_t>& f, RspBatchInfo& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 + 4 + 1 + 2 > e) return false;
|
if (get_u16(b) != CMD_RSP_BATCH_INFO) return false;
|
b += 2;
|
|
out.machineId = get_u32(b); b += 4;
|
out.state = static_cast<BatchState>(*b++);
|
|
const uint16_t L = get_u16(b); b += 2;
|
if (b + L > e) return false;
|
out.activeBatchId.assign(reinterpret_cast<const char*>(b), L); b += L;
|
|
if (b + 8 + 8 > e) return false;
|
out.activeStartTs = get_u64(b); b += 8;
|
out.expectedEndTs = get_u64(b); b += 8;
|
|
return (b == e);
|
}
|
|
// ---------------------------
|
// 0xE100 Error
|
// ---------------------------
|
std::vector<uint8_t> encodeResponseError(const RspError& rsp) {
|
std::vector<uint8_t> body;
|
put_u16(body, CMD_RSP_ERROR);
|
put_u16(body, rsp.refCmd);
|
put_u32(body, rsp.machineId);
|
put_u16(body, static_cast<uint16_t>(rsp.code));
|
const uint16_t L = static_cast<uint16_t>(rsp.message.size());
|
put_u16(body, L);
|
body.insert(body.end(), rsp.message.begin(), rsp.message.end());
|
|
std::vector<uint8_t> out;
|
frame_wrap(rsp.dataId, body, out);
|
return out;
|
}
|
|
bool decodeResponseError(const std::vector<uint8_t>& f, RspError& out) {
|
if (f.size() < 11) return false;
|
const uint8_t* p = f.data();
|
if (p[0] != kHead[0] || p[1] != kHead[1] || p[2] != kHead[2] || p[3] != kHead[3]) return false;
|
if (f.back() != kTail) return false;
|
|
out.dataId = get_u32(p + 4);
|
const uint16_t bodyLen = get_u16(p + 8);
|
if (10u + bodyLen + 1u != f.size()) return false;
|
|
const uint8_t* b = p + 10;
|
const uint8_t* e = b + bodyLen;
|
|
if (b + 2 + 2 + 4 + 2 + 2 > e) return false;
|
if (get_u16(b) != CMD_RSP_ERROR) return false;
|
b += 2;
|
|
out.refCmd = get_u16(b); b += 2;
|
out.machineId = get_u32(b); b += 4;
|
out.code = static_cast<ErrCode>(get_u16(b)); b += 2;
|
|
const uint16_t L = get_u16(b); b += 2;
|
if (b + L > e) return false;
|
out.message.assign(reinterpret_cast<const char*>(b), L); b += L;
|
|
return (b == e);
|
}
|
|
} // namespace Proto
|
