From b06dd5aaa0cf47b0b6f73ae858b2e2c267e60bbf Mon Sep 17 00:00:00 2001 From: Ben Longbons Date: Mon, 19 May 2014 21:05:38 -0700 Subject: make packets be non-type templates --- src/net/packets.hpp | 215 +++++++++++++++++++++++----------------------------- 1 file changed, 93 insertions(+), 122 deletions(-) (limited to 'src/net/packets.hpp') diff --git a/src/net/packets.hpp b/src/net/packets.hpp index 2e3d77c..c0f3ecb 100644 --- a/src/net/packets.hpp +++ b/src/net/packets.hpp @@ -25,7 +25,10 @@ # include "../ints/little.hpp" - #include "../io/fwd.hpp" +# include "../io/fwd.hpp" + +// ordering violation, should invert +# include "../proto2/fwd.hpp" # include "socket.hpp" @@ -66,55 +69,55 @@ bool packet_peek_id(Session *s, uint16_t *packet_id) return okay; } -template +template __attribute__((warn_unused_result)) -SendResult net_send_fpacket(Session *s, const F& fixed) +SendResult net_send_fpacket(Session *s, const NetPacket_Fixed& fixed) { - bool ok = packet_send(s, reinterpret_cast(&fixed), sizeof(F)); + bool ok = packet_send(s, reinterpret_cast(&fixed), sizeof(NetPacket_Fixed)); return ok ? SendResult::Success : SendResult::Fail; } -template +template __attribute__((warn_unused_result)) -SendResult net_send_vpacket(Session *s, const H& head, const std::vector& repeat) +SendResult net_send_vpacket(Session *s, const NetPacket_Head& head, const std::vector>& repeat) { - bool ok = packet_send(s, reinterpret_cast(&head), sizeof(H)); - ok &= packet_send(s, reinterpret_cast(repeat.data()), repeat.size() * sizeof(R)); + bool ok = packet_send(s, reinterpret_cast(&head), sizeof(NetPacket_Head)); + ok &= packet_send(s, reinterpret_cast(repeat.data()), repeat.size() * sizeof(NetPacket_Repeat)); return ok ? SendResult::Success : SendResult::Fail; } -template +template __attribute__((warn_unused_result)) -RecvResult net_recv_fpacket(Session *s, F& fixed) +RecvResult net_recv_fpacket(Session *s, NetPacket_Fixed& fixed) { - bool ok = packet_fetch(s, 0, reinterpret_cast(&fixed), sizeof(F)); + bool ok = packet_fetch(s, 0, reinterpret_cast(&fixed), sizeof(NetPacket_Fixed)); if (ok) { - packet_discard(s, sizeof(F)); + packet_discard(s, sizeof(NetPacket_Fixed)); return RecvResult::Complete; } return RecvResult::Incomplete; } -template +template __attribute__((warn_unused_result)) -RecvResult net_recv_vpacket(Session *s, H& head, std::vector& repeat) +RecvResult net_recv_vpacket(Session *s, NetPacket_Head& head, std::vector>& repeat) { - bool ok = packet_fetch(s, 0, reinterpret_cast(&head), sizeof(H)); + bool ok = packet_fetch(s, 0, reinterpret_cast(&head), sizeof(NetPacket_Head)); if (ok) { - HNat nat; + Packet_Head nat; if (!network_to_native(&nat, head)) return RecvResult::Error; if (packet_avail(s) < nat.magic_packet_length) return RecvResult::Incomplete; - if (nat.magic_packet_length < sizeof(H)) + if (nat.magic_packet_length < sizeof(NetPacket_Head)) return RecvResult::Error; - size_t bytes_repeat = nat.magic_packet_length - sizeof(H); - if (bytes_repeat % sizeof(R)) + size_t bytes_repeat = nat.magic_packet_length - sizeof(NetPacket_Head); + if (bytes_repeat % sizeof(NetPacket_Repeat)) return RecvResult::Error; - repeat.resize(bytes_repeat / sizeof(R)); - if (packet_fetch(s, sizeof(H), reinterpret_cast(repeat.data()), bytes_repeat)) + repeat.resize(bytes_repeat / sizeof(NetPacket_Repeat)); + if (packet_fetch(s, sizeof(NetPacket_Head), reinterpret_cast(repeat.data()), bytes_repeat)) { packet_discard(s, nat.magic_packet_length); return RecvResult::Complete; @@ -125,13 +128,13 @@ RecvResult net_recv_vpacket(Session *s, H& head, std::vector& repeat) } -template -void send_fpacket(Session *s, const F& fixed) +template +void send_fpacket(Session *s, const Packet_Fixed& fixed) { - static_assert(id == F::PACKET_ID, "F::PACKET_ID"); - static_assert(size == sizeof(typename F::NetType), "F::NetType"); + static_assert(id == Packet_Fixed::PACKET_ID, "Packet_Fixed::PACKET_ID"); + static_assert(size == sizeof(NetPacket_Fixed), "sizeof(NetPacket_Fixed)"); - typename F::NetType net_fixed; + NetPacket_Fixed net_fixed; if (!native_to_network(&net_fixed, fixed)) { s->set_eof(); @@ -142,17 +145,17 @@ void send_fpacket(Session *s, const F& fixed) s->set_eof(); } -template -void send_vpacket(Session *s, H& head, const std::vector& repeat) +template +void send_vpacket(Session *s, Packet_Head& head, const std::vector>& repeat) { - static_assert(id == H::PACKET_ID, "H::PACKET_ID"); - static_assert(headsize == sizeof(typename H::NetType), "H::NetType"); - static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == sizeof(typename R::NetType), "R::NetType"); + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "sizeof(NetPacket_Head)"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "sizeof(NetPacket_Repeat)"); - typename H::NetType net_head; + NetPacket_Head net_head; // since these are already allocated, can't overflow address space - size_t total_size = sizeof(typename H::NetType) + repeat.size() * sizeof(typename R::NetType); + size_t total_size = sizeof(NetPacket_Head) + repeat.size() * sizeof(NetPacket_Repeat); // truncates head.magic_packet_length = total_size; if (head.magic_packet_length != total_size) @@ -161,7 +164,7 @@ void send_vpacket(Session *s, H& head, const std::vector& repeat) return; } // TODO potentially avoid the allocation - std::vector net_repeat(repeat.size()); + std::vector> net_repeat(repeat.size()); if (!native_to_network(&net_head, head)) { s->set_eof(); @@ -180,16 +183,16 @@ void send_vpacket(Session *s, H& head, const std::vector& repeat) s->set_eof(); } -template +template __attribute__((warn_unused_result)) -RecvResult recv_fpacket(Session *s, F& fixed) +RecvResult recv_fpacket(Session *s, Packet_Fixed& fixed) { - static_assert(id == F::PACKET_ID, "F::PACKET_ID"); - static_assert(size == sizeof(typename F::NetType), "F::NetType"); + static_assert(id == Packet_Fixed::PACKET_ID, "Packet_Fixed::PACKET_ID"); + static_assert(size == sizeof(NetPacket_Fixed), "NetPacket_Fixed"); - typename F::NetType net_fixed; + NetPacket_Fixed net_fixed; RecvResult rv = net_recv_fpacket(s, net_fixed); - assert (fixed.magic_packet_id == F::PACKET_ID); + assert (fixed.magic_packet_id == Packet_Fixed::PACKET_ID); if (rv == RecvResult::Complete) { if (!network_to_native(&fixed, net_fixed)) @@ -198,19 +201,19 @@ RecvResult recv_fpacket(Session *s, F& fixed) return rv; } -template +template __attribute__((warn_unused_result)) -RecvResult recv_vpacket(Session *s, H& head, std::vector& repeat) +RecvResult recv_vpacket(Session *s, Packet_Head& head, std::vector>& repeat) { - static_assert(id == H::PACKET_ID, "H::PACKET_ID"); - static_assert(headsize == sizeof(typename H::NetType), "H::NetType"); - static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == sizeof(typename R::NetType), "R::NetType"); - - typename H::NetType net_head; - std::vector net_repeat; - RecvResult rv = net_recv_vpacket(s, net_head, net_repeat); - assert (head.magic_packet_id == H::PACKET_ID); + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "NetPacket_Head"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "NetPacket_Repeat"); + + NetPacket_Head net_head; + std::vector> net_repeat; + RecvResult rv = net_recv_vpacket(s, net_head, net_repeat); + assert (head.magic_packet_id == Packet_Head::PACKET_ID); if (rv == RecvResult::Complete) { if (!network_to_native(&head, net_head)) @@ -227,22 +230,18 @@ RecvResult recv_vpacket(Session *s, H& head, std::vector& repeat) // convenience for trailing strings -struct VarStringNetType +template +void send_vpacket(Session *s, Packet_Head& head, const XString& repeat) { - char c; -}; + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "NetPacket_Head"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "NetPacket_Repeat"); + static_assert(repeatsize == 1, "repeatsize"); -template -void send_vpacket(Session *s, H& head, const XString& repeat) -{ - static_assert(id == H::PACKET_ID, "H::PACKET_ID"); - static_assert(headsize == sizeof(typename H::NetType), "H::NetType"); - // static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == 1, "R::NetType"); - - typename H::NetType net_head; + NetPacket_Head net_head; // since it's already allocated, it can't overflow address space - size_t total_length = sizeof(typename H::NetType) + (repeat.size() + 1) * sizeof(VarStringNetType); + size_t total_length = sizeof(NetPacket_Head) + (repeat.size() + 1) * sizeof(NetPacket_Repeat); head.magic_packet_length = total_length; if (head.magic_packet_length != total_length) { @@ -250,7 +249,7 @@ void send_vpacket(Session *s, H& head, const XString& repeat) return; } // TODO potentially avoid the allocation - std::vector net_repeat(repeat.size() + 1); + std::vector> net_repeat(repeat.size() + 1); if (!native_to_network(&net_head, head)) { s->set_eof(); @@ -258,27 +257,28 @@ void send_vpacket(Session *s, H& head, const XString& repeat) } for (size_t i = 0; i < repeat.size(); ++i) { - net_repeat[i].c = repeat[i]; + net_repeat[i].c = Byte{static_cast(repeat[i])}; } - net_repeat[repeat.size()].c = '\0'; + net_repeat[repeat.size()].c = Byte{static_cast('\0')}; SendResult rv = net_send_vpacket(s, net_head, net_repeat); if (rv != SendResult::Success) s->set_eof(); } -template +template __attribute__((warn_unused_result)) -RecvResult recv_vpacket(Session *s, H& head, AString& repeat) +RecvResult recv_vpacket(Session *s, Packet_Head& head, AString& repeat) { - static_assert(id == H::PACKET_ID, "H::PACKET_ID"); - static_assert(headsize == sizeof(typename H::NetType), "H::NetType"); - //static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == 1, "R::NetType"); - - typename H::NetType net_head; - std::vector net_repeat; - RecvResult rv = net_recv_vpacket(s, net_head, net_repeat); - assert (head.magic_packet_id == H::PACKET_ID); + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "NetPacket_Head"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "NetPacket_Repeat"); + static_assert(repeatsize == 1, "repeatsize"); + + NetPacket_Head net_head; + std::vector> net_repeat; + RecvResult rv = net_recv_vpacket(s, net_head, net_repeat); + assert (head.magic_packet_id == Packet_Head::PACKET_ID); if (rv == RecvResult::Complete) { if (!network_to_native(&head, net_head)) @@ -295,59 +295,30 @@ RecvResult recv_vpacket(Session *s, H& head, AString& repeat) // if there is nothing in the head but the id and length, use the below -// TODO make this go away with template specialization - -template -struct NetCommonPacketHead -{ - Little16 magic_packet_id; - Little16 magic_packet_length; -}; - -template -struct CommonPacketHead -{ - using NetType = NetCommonPacketHead; - static const uint16_t PACKET_ID = PKT_ID; - - uint16_t magic_packet_id = PACKET_ID; - uint16_t magic_packet_length; -}; - -template -bool native_to_network(NetCommonPacketHead *net, CommonPacketHead nat) -{ - return native_to_network(&net->magic_packet_id, nat.magic_packet_id) - && native_to_network(&net->magic_packet_length, nat.magic_packet_length); -} - -template -bool network_to_native(CommonPacketHead *nat, NetCommonPacketHead net) -{ - return network_to_native(&nat->magic_packet_id, net.magic_packet_id) - && network_to_native(&nat->magic_packet_length, net.magic_packet_length); -} - -template -void send_packet_repeatonly(Session *s, const std::vector& v) +template +void send_packet_repeatonly(Session *s, const std::vector>& v) { + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "repeat headsize"); static_assert(headsize == 4, "repeat headsize"); - static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == sizeof(typename R::NetType), "R::NetType"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "sizeof(NetPacket_Repeat)"); - CommonPacketHead head; + Packet_Head head; send_vpacket(s, head, v); } -template +template __attribute__((warn_unused_result)) -RecvResult recv_packet_repeatonly(Session *s, std::vector& v) +RecvResult recv_packet_repeatonly(Session *s, std::vector>& v) { + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "repeat headsize"); static_assert(headsize == 4, "repeat headsize"); - static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == sizeof(typename R::NetType), "R::NetType"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "sizeof(NetPacket_Repeat)"); - CommonPacketHead head; + Packet_Head head; return recv_vpacket(s, head, v); } -- cgit v1.2.3-60-g2f50