bool native_to_network(NetPacket_Head<0x0063> *network, Packet_Head<0x0063> native)
{
bool rv = true;
rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
return rv;
}
bool native_to_network(NetPacket_Fixed<0x006a> *network, Packet_Fixed<0x006a> native)
{
bool rv = true;
rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
rv &= native_to_network(&network->error_code, native.error_code);
rv &= native_to_network(&network->error_message, native.error_message);
return rv;
}
bool native_to_network(NetPacket_Fixed<0x0064> *network, Packet_Fixed<0x0064> native)
{
bool rv = true;
rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
rv &= native_to_network(&network->unknown, native.unknown);
rv &= native_to_network(&network->account_name, native.account_name);
rv &= native_to_network(&network->account_pass, native.account_pass);
rv &= native_to_network(&network->version_2_flags, native.version_2_flags);
return rv;
}
bool native_to_network(NetPacket_Head<0x0069> *network, Packet_Head<0x0069> native)
{
bool rv = true;
rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
rv &= native_to_network(&network->login_id1, native.login_id1);
rv &= native_to_network(&network->account_id, native.account_id);
rv &= native_to_network(&network->login_id2, native.login_id2);
rv &= native_to_network(&network->unused, native.unused);
rv &= native_to_network(&network->last_login_string, native.last_login_string);
rv &= native_to_network(&network->unused2, native.unused2);
rv &= native_to_network(&network->sex, native.sex);
return rv;
}
Buffer create_opacket(Packet_Head<id>& head, bool has_opt, const Packet_Option<id>& opt)
{
static_assert(id == Packet_Head<id>::PACKET_ID, "Packet_Head<id>::PACKET_ID");
static_assert(headsize == sizeof(NetPacket_Head<id>), "sizeof(NetPacket_Head<id>)");
static_assert(id == Packet_Option<id>::PACKET_ID, "Packet_Option<id>::PACKET_ID");
static_assert(optsize == sizeof(NetPacket_Option<id>), "sizeof(NetPacket_Option<id>)");
// since these are already allocated, can't overflow address space
size_t total_size = sizeof(NetPacket_Head<id>) + has_opt * sizeof(NetPacket_Option<id>);
// truncates
head.magic_packet_length = total_size;
if (head.magic_packet_length != total_size)
{
return Buffer();
}
Buffer buf;
buf.bytes.resize(total_size);
auto& net_head = reinterpret_cast<NetPacket_Head<id>&>(
*(buf.bytes.begin() + 0));
if (!native_to_network(&net_head, head))
{
return Buffer();
}
if (has_opt)
{
auto& net_opt = reinterpret_cast<NetPacket_Option<id>&>(
*(buf.bytes.begin()
+ sizeof(NetPacket_Head<id>)));
if (!native_to_network(&net_opt, opt))
{
return Buffer();
}
}
return buf;
}
Buffer create_vpacket(Packet_Head<id>& head, const std::vector<Packet_Repeat<id>>& repeat)
{
static_assert(id == Packet_Head<id>::PACKET_ID, "Packet_Head<id>::PACKET_ID");
static_assert(headsize == sizeof(NetPacket_Head<id>), "sizeof(NetPacket_Head<id>)");
static_assert(id == Packet_Repeat<id>::PACKET_ID, "Packet_Repeat<id>::PACKET_ID");
static_assert(repeatsize == sizeof(NetPacket_Repeat<id>), "sizeof(NetPacket_Repeat<id>)");
// since these are already allocated, can't overflow address space
size_t total_size = sizeof(NetPacket_Head<id>) + repeat.size() * sizeof(NetPacket_Repeat<id>);
// truncates
head.magic_packet_length = total_size;
if (head.magic_packet_length != total_size)
{
return Buffer();
}
Buffer buf;
buf.bytes.resize(total_size);
auto& net_head = reinterpret_cast<NetPacket_Head<id>&>(
*(buf.bytes.begin() + 0));
if (!native_to_network(&net_head, head))
{
return Buffer();
}
for (size_t i = 0; i < repeat.size(); ++i)
{
auto& net_repeat_i = reinterpret_cast<NetPacket_Repeat<id>&>(
*(buf.bytes.begin()
+ sizeof(NetPacket_Head<id>)
+ i * sizeof(NetPacket_Repeat<id>)));
if (!native_to_network(&net_repeat_i, repeat[i]))
{
return Buffer();
}
}
return buf;
}
Buffer create_fpacket(const Packet_Fixed<id>& fixed)
{
static_assert(id == Packet_Fixed<id>::PACKET_ID, "Packet_Fixed<id>::PACKET_ID");
static_assert(size == sizeof(NetPacket_Fixed<id>), "sizeof(NetPacket_Fixed<id>)");
Buffer buf;
buf.bytes.resize(sizeof(NetPacket_Fixed<id>));
auto& net_fixed = reinterpret_cast<NetPacket_Fixed<id>&>(
*(buf.bytes.begin() + 0));
if (!native_to_network(&net_fixed, fixed))
{
return Buffer();
}
return buf;
}
bool native_to_network(NetPacket_Repeat<0x0069> *network, Packet_Repeat<0x0069> native)
{
bool rv = true;
rv &= native_to_network(&network->ip, native.ip);
rv &= native_to_network(&network->port, native.port);
rv &= native_to_network(&network->server_name, native.server_name);
rv &= native_to_network(&network->users, native.users);
rv &= native_to_network(&network->maintenance, native.maintenance);
rv &= native_to_network(&network->is_new, native.is_new);
return rv;
}
Buffer create_ppacket(Packet_Payload<id>& payload)
{
static_assert(id == Packet_Payload<id>::PACKET_ID, "Packet_Payload<id>::PACKET_ID");
if (id != 0x8000)
payload.magic_packet_length = sizeof(NetPacket_Payload<id>);
Buffer buf;
buf.bytes.resize(sizeof(NetPacket_Payload<id>));
auto& net_payload = reinterpret_cast<NetPacket_Payload<id>&>(
*(buf.bytes.begin() + 0));
if (!native_to_network(&net_payload, payload))
{
return Buffer();
}
return buf;
}
Buffer create_vpacket(Packet_Head<id>& head, const XString& repeat)
{
static_assert(id == Packet_Head<id>::PACKET_ID, "Packet_Head<id>::PACKET_ID");
static_assert(headsize == sizeof(NetPacket_Head<id>), "NetPacket_Head<id>");
static_assert(id == Packet_Repeat<id>::PACKET_ID, "Packet_Repeat<id>::PACKET_ID");
static_assert(repeatsize == sizeof(NetPacket_Repeat<id>), "NetPacket_Repeat<id>");
static_assert(repeatsize == 1, "repeatsize");
// since it's already allocated, it can't overflow address space
size_t total_length = sizeof(NetPacket_Head<id>) + (repeat.size() + 1) * sizeof(NetPacket_Repeat<id>);
head.magic_packet_length = total_length;
if (head.magic_packet_length != total_length)
{
return Buffer();
}
Buffer buf;
buf.bytes.resize(total_length);
auto& net_head = reinterpret_cast<NetPacket_Head<id>&>(
*(buf.bytes.begin() + 0));
std::vector<NetPacket_Repeat<id>> net_repeat(repeat.size() + 1);
if (!native_to_network(&net_head, head))
{
return Buffer();
}
for (size_t i = 0; i < repeat.size(); ++i)
{
auto& net_repeat_i = reinterpret_cast<NetPacket_Repeat<id>&>(
*(buf.bytes.begin()
+ sizeof(NetPacket_Head<id>)
+ i));
net_repeat_i.c = Byte{static_cast<uint8_t>(repeat[i])};
}
auto& net_repeat_repeat_size = reinterpret_cast<NetPacket_Repeat<id>&>(
*(buf.bytes.begin()
+ sizeof(NetPacket_Head<id>)
+ repeat.size()));
net_repeat_repeat_size.c = Byte{static_cast<uint8_t>('\0')};
return buf;
}
friend
bool native_to_network(Little32 *network, GmLevel native)
{
return native_to_network(network, native.bits);
}
// TODO kill this code too
friend
bool native_to_network(Little16 *network, GmLevel native)
{
uint16_t tmp = native.bits;
return native_to_network(network, tmp);
}
bool native_to_network(NetPacket_Repeat<0x0063> *network, Packet_Repeat<0x0063> native)
{
bool rv = true;
rv &= native_to_network(&network->c, native.c);
return rv;
}
