X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fnet%2Fnet.cpp;h=4d364124253d9e5d5e5668e77a6ec52ef29eb9b0;hb=1812e1a29378526a59a346caa2348df3e7522049;hp=314410ebbdb66fee6bb053f43a7dac6d02762dd6;hpb=09b734344f31e18d0fa31c39acba6d012aa2cc56;p=blank.git diff --git a/src/net/net.cpp b/src/net/net.cpp index 314410e..4d36412 100644 --- a/src/net/net.cpp +++ b/src/net/net.cpp @@ -1,5 +1,6 @@ #include "Client.hpp" #include "Connection.hpp" +#include "ConnectionHandler.hpp" #include "io.hpp" #include "Packet.hpp" #include "Server.hpp" @@ -15,6 +16,11 @@ using namespace std; namespace blank { +constexpr size_t Packet::Ping::MAX_LEN; +constexpr size_t Packet::Login::MAX_LEN; +constexpr size_t Packet::Join::MAX_LEN; +constexpr size_t Packet::Part::MAX_LEN; + namespace { UDPsocket client_bind(Uint16 port) { @@ -35,9 +41,8 @@ IPaddress client_resolve(const char *host, Uint16 port) { } -Client::Client(const Config &conf, World &world) -: world(world) -, conn(client_resolve(conf.host.c_str(), conf.port)) +Client::Client(const Config &conf) +: conn(client_resolve(conf.host.c_str(), conf.port)) , client_sock(client_bind(0)) , client_pack{ -1, nullptr, 0 } { client_pack.data = new Uint8[sizeof(Packet)]; @@ -76,34 +81,34 @@ void Client::HandlePacket(const UDPpacket &udp_pack) { } conn.Received(udp_pack); - cout << "I got something!" << endl; } void Client::Update(int dt) { conn.Update(dt); - if (conn.TimedOut()) { - cout << "connection timed out :(" << endl; - } else if (conn.ShouldPing()) { + if (conn.ShouldPing()) { SendPing(); } } -void Client::SendPing() { - conn.SendPing(client_pack, client_sock); +uint16_t Client::SendPing() { + return conn.SendPing(client_pack, client_sock); } -void Client::SendLogin(const string &name) { - Packet &pack = *reinterpret_cast(client_pack.data); - client_pack.len = pack.Login(name); - conn.Send(client_pack, client_sock); +uint16_t Client::SendLogin(const string &name) { + auto pack = Packet::Make(client_pack); + pack.WritePlayerName(name); + return conn.Send(client_pack, client_sock); } Connection::Connection(const IPaddress &addr) -: addr(addr) -, send_timer(5000) +: handler(nullptr) +, addr(addr) +, send_timer(500) , recv_timer(10000) -, ctrl{ 0, 0xFFFF, 0xFFFF } { +, ctrl_out{ 0, 0xFFFF, 0xFFFFFFFF } +, ctrl_in{ 0, 0xFFFF, 0xFFFFFFFF } +, closed(false) { send_timer.Start(); recv_timer.Start(); } @@ -121,7 +126,7 @@ void Connection::FlagRecv() noexcept { } bool Connection::ShouldPing() const noexcept { - return send_timer.HitOnce(); + return !closed && send_timer.HitOnce(); } bool Connection::TimedOut() const noexcept { @@ -131,12 +136,19 @@ bool Connection::TimedOut() const noexcept { void Connection::Update(int dt) { send_timer.Update(dt); recv_timer.Update(dt); + if (TimedOut()) { + Close(); + if (HasHandler()) { + Handler().OnTimeout(); + } + } } -void Connection::Send(UDPpacket &udp_pack, UDPsocket sock) { +uint16_t Connection::Send(UDPpacket &udp_pack, UDPsocket sock) { Packet &pack = *reinterpret_cast(udp_pack.data); - pack.header.ctrl = ctrl; + pack.header.ctrl = ctrl_out; + uint16_t seq = ctrl_out.seq++; udp_pack.address = addr; if (SDLNet_UDP_Send(sock, -1, &udp_pack) == 0) { @@ -144,47 +156,53 @@ void Connection::Send(UDPpacket &udp_pack, UDPsocket sock) { } FlagSend(); + return seq; } void Connection::Received(const UDPpacket &udp_pack) { Packet &pack = *reinterpret_cast(udp_pack.data); - int diff = std::int16_t(pack.header.ctrl.seq) - std::int16_t(ctrl.ack); - + // ack to the remote + int16_t diff = int16_t(pack.header.ctrl.seq) - int16_t(ctrl_out.ack); if (diff > 0) { - // incoming more recent than last acked - - // TODO: packets considered lost are detected here - // this should have ones for all of them: - // ~hist & ((1 << dist) - 1) if dist is < 32 - if (diff >= 32) { - // missed more than the last 32 oO - ctrl.hist = 0; - } else { - ctrl.hist >>= diff; - ctrl.hist |= 1 << (32 - diff); - } - } else if (diff < 0) { - // incoming older than acked - if (diff > -32) { - // too late :/ + ctrl_out.hist = 0; } else { - ctrl.hist |= 1 << (32 + diff); + ctrl_out.hist <<= diff; + ctrl_out.hist |= 1 << (diff - 1); } - } else { - // incoming the same as last acked oO + } else if (diff < 0 && diff >= -32) { + ctrl_out.hist |= 1 << (-diff - 1); } + ctrl_out.ack = pack.header.ctrl.seq; + FlagRecv(); - ctrl.ack = pack.header.ctrl.seq; + if (!HasHandler()) { + return; + } - FlagRecv(); + Packet::TControl ctrl_new = pack.header.ctrl; + Handler().Handle(udp_pack); + + if (diff > 0) { + // if the packet holds more recent information + // check if remote failed to ack one of our packets + diff = int16_t(ctrl_new.ack) - int16_t(ctrl_in.ack); + // should always be true, but you never know… + if (diff > 0) { + for (int i = 0; i < diff; ++i) { + if (i > 32 || (i < 32 && (ctrl_in.hist & (1 << (31 - i))) == 0)) { + Handler().OnPacketLost(ctrl_in.ack - 32 + i); + } + } + } + ctrl_in = ctrl_new; + } } -void Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) { - Packet &pack = *reinterpret_cast(udp_pack.data); - udp_pack.len = pack.Ping(); - Send(udp_pack, sock); +uint16_t Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) { + Packet::Make(udp_pack); + return Send(udp_pack, sock); } @@ -201,28 +219,128 @@ ostream &operator <<(ostream &out, const IPaddress &addr) { } -void Packet::Tag() noexcept { - header.tag = TAG; +const char *Packet::Type2String(uint8_t t) noexcept { + switch (t) { + case Ping::TYPE: + return "Ping"; + case Login::TYPE: + return "Login"; + case Join::TYPE: + return "Join"; + case Part::TYPE: + return "Part"; + default: + return "Unknown"; + } } -size_t Packet::Ping() noexcept { - Tag(); - header.type = PING; - return sizeof(Header); +template +void Packet::Payload::Write(const T &src, size_t off) noexcept { + if ((length - off) < sizeof(T)) { + // dismiss out of bounds write + return; + } + *reinterpret_cast(&data[off]) = src; } -size_t Packet::Login(const string &name) noexcept { - constexpr size_t maxname = 32; +template +void Packet::Payload::Read(T &dst, size_t off) const noexcept { + if ((length - off) < sizeof(T)) { + // dismiss out of bounds read + return; + } + dst = *reinterpret_cast(&data[off]); +} - Tag(); - header.type = LOGIN; - if (name.size() < maxname) { - memset(payload, '\0', maxname); - memcpy(payload, name.c_str(), name.size()); +void Packet::Payload::WriteString(const string &src, size_t off, size_t maxlen) noexcept { + uint8_t *dst = &data[off]; + size_t len = min(maxlen, length - off); + if (src.size() < len) { + memset(dst, '\0', len); + memcpy(dst, src.c_str(), src.size()); } else { - memcpy(payload, name.c_str(), maxname); + memcpy(dst, src.c_str(), len); + } +} + +void Packet::Payload::ReadString(string &dst, size_t off, size_t maxlen) const noexcept { + size_t len = min(maxlen, length - off); + dst.clear(); + dst.reserve(len); + for (size_t i = 0; i < len && data[off + i] != '\0'; ++i) { + dst.push_back(data[off + i]); + } +} + + +void Packet::Login::WritePlayerName(const string &name) noexcept { + WriteString(name, 0, 32); +} + +void Packet::Login::ReadPlayerName(string &name) const noexcept { + ReadString(name, 0, 32); +} + +void Packet::Join::WritePlayer(const Entity &player) noexcept { + Write(player.ID(), 0); + Write(player.ChunkCoords(), 4); + Write(player.Position(), 16); + Write(player.Velocity(), 28); + Write(player.Orientation(), 40); + Write(player.AngularVelocity(), 56); +} + +void Packet::Join::ReadPlayerID(uint32_t &id) const noexcept { + Read(id, 0); +} + +void Packet::Join::ReadPlayer(Entity &player) const noexcept { + glm::ivec3 chunk_coords(0); + glm::vec3 pos; + glm::vec3 vel; + glm::quat rot; + glm::vec3 ang; + + Read(chunk_coords, 4); + Read(pos, 16); + Read(vel, 28); + Read(rot, 40); + Read(ang, 56); + + player.Position(chunk_coords, pos); + player.Velocity(vel); + player.Orientation(rot); + player.AngularVelocity(ang); +} + +void Packet::Join::WriteWorldName(const string &name) noexcept { + WriteString(name, 68, 32); +} + +void Packet::Join::ReadWorldName(string &name) const noexcept { + ReadString(name, 68, 32); +} + + +void ConnectionHandler::Handle(const UDPpacket &udp_pack) { + const Packet &pack = *reinterpret_cast(udp_pack.data); + switch (pack.Type()) { + case Packet::Ping::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::Login::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::Join::TYPE: + On(Packet::As(udp_pack)); + break; + case Packet::Part::TYPE: + On(Packet::As(udp_pack)); + break; + default: + // drop unknown or unhandled packets + break; } - return sizeof(Header) + maxname; } @@ -273,14 +391,14 @@ void Server::HandlePacket(const UDPpacket &udp_pack) { client.Received(udp_pack); switch (pack.header.type) { - case Packet::PING: - // already done all that's supposed to do - break; - case Packet::LOGIN: + case Packet::Login::TYPE: HandleLogin(client, udp_pack); break; + case Packet::Part::TYPE: + HandlePart(client, udp_pack); + break; default: - // just drop packets of unknown type + // just drop packets of unknown or unhandled type break; } } @@ -305,7 +423,7 @@ void Server::OnConnect(Connection &client) { void Server::Update(int dt) { for (list::iterator client(clients.begin()), end(clients.end()); client != end;) { client->Update(dt); - if (client->TimedOut()) { + if (client->Closed()) { OnDisconnect(*client); client = clients.erase(client); } else { @@ -323,23 +441,31 @@ void Server::OnDisconnect(Connection &client) { void Server::HandleLogin(Connection &client, const UDPpacket &udp_pack) { - const Packet &pack = *reinterpret_cast(udp_pack.data); - size_t maxlen = min(udp_pack.len - int(sizeof(Packet::Header)), 32); + auto pack = Packet::As(udp_pack); + string name; - name.reserve(maxlen); - for (size_t i = 0; i < maxlen && pack.payload[i] != '\0'; ++i) { - name.push_back(pack.payload[i]); - } - cout << "got login request from player \"" << name << '"' << endl; + pack.ReadPlayerName(name); Entity *player = world.AddPlayer(name); + if (player) { // success! - cout << "\taccepted" << endl; + cout << "accepted login from player \"" << name << '"' << endl; + auto response = Packet::Make(serv_pack); + response.WritePlayer(*player); + response.WriteWorldName(world.Name()); + client.Send(serv_pack, serv_sock); } else { // aw no :( - cout << "\trejected" << endl; + cout << "rejected login from player \"" << name << '"' << endl; + Packet::Make(serv_pack); + client.Send(serv_pack, serv_sock); + client.Close(); } } +void Server::HandlePart(Connection &client, const UDPpacket &udp_pack) { + client.Close(); +} + }