src/net/net.cpp

   1 #include "Client.hpp"
   2 #include "ClientConnection.hpp"
   3 #include "Connection.hpp"
   4 #include "ConnectionHandler.hpp"
   5 #include "io.hpp"
   6 #include "Packet.hpp"
   7 #include "Server.hpp"
   8
   9 #include "../app/init.hpp"
  10 #include "../world/World.hpp"
  11
  12 #include <cstring>
  13 #include <iostream>
  14 #include <glm/gtx/io.hpp>
  15
  16 using namespace std;
  17
  18
  19 namespace blank {
  20
  21 constexpr size_t Packet::Ping::MAX_LEN;
  22 constexpr size_t Packet::Login::MAX_LEN;
  23 constexpr size_t Packet::Join::MAX_LEN;
  24 constexpr size_t Packet::Part::MAX_LEN;
  25 constexpr size_t Packet::PlayerUpdate::MAX_LEN;
  26
  27 namespace {
  28
  29 UDPsocket client_bind(Uint16 port) {
  30         UDPsocket sock = SDLNet_UDP_Open(port);
  31         if (!sock) {
  32                 throw NetError("SDLNet_UDP_Open");
  33         }
  34         return sock;
  35 }
  36
  37 IPaddress client_resolve(const char *host, Uint16 port) {
  38         IPaddress addr;
  39         if (SDLNet_ResolveHost(&addr, host, port) != 0) {
  40                 throw NetError("SDLNet_ResolveHost");
  41         }
  42         return addr;
  43 }
  44
  45 }
  46
  47 Client::Client(const Config &conf)
  48 : conn(client_resolve(conf.host.c_str(), conf.port))
  49 , client_sock(client_bind(0))
  50 , client_pack{ -1, nullptr, 0 } {
  51         client_pack.data = new Uint8[sizeof(Packet)];
  52         client_pack.maxlen = sizeof(Packet);
  53         // establish connection
  54         SendPing();
  55 }
  56
  57 Client::~Client() {
  58         delete[] client_pack.data;
  59         SDLNet_UDP_Close(client_sock);
  60 }
  61
  62
  63 void Client::Handle() {
  64         int result = SDLNet_UDP_Recv(client_sock, &client_pack);
  65         while (result > 0) {
  66                 HandlePacket(client_pack);
  67                 result = SDLNet_UDP_Recv(client_sock, &client_pack);
  68         }
  69         if (result == -1) {
  70                 // a boo boo happened
  71                 throw NetError("SDLNet_UDP_Recv");
  72         }
  73 }
  74
  75 void Client::HandlePacket(const UDPpacket &udp_pack) {
  76         if (!conn.Matches(udp_pack.address)) {
  77                 // packet came from somewhere else, drop
  78                 return;
  79         }
  80         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
  81         if (pack.header.tag != Packet::TAG) {
  82                 // mistagged packet, drop
  83                 return;
  84         }
  85
  86         conn.Received(udp_pack);
  87 }
  88
  89 void Client::Update(int dt) {
  90         conn.Update(dt);
  91         if (conn.ShouldPing()) {
  92                 SendPing();
  93         }
  94 }
  95
  96 uint16_t Client::SendPing() {
  97         return conn.SendPing(client_pack, client_sock);
  98 }
  99
 100 uint16_t Client::SendLogin(const string &name) {
 101         auto pack = Packet::Make<Packet::Login>(client_pack);
 102         pack.WritePlayerName(name);
 103         return conn.Send(client_pack, client_sock);
 104 }
 105
 106 uint16_t Client::SendPlayerUpdate(const Entity &player) {
 107         auto pack = Packet::Make<Packet::PlayerUpdate>(client_pack);
 108         pack.WritePlayer(player);
 109         return conn.Send(client_pack, client_sock);
 110 }
 111
 112
 113 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
 114 : server(server)
 115 , conn(addr)
 116 , player(nullptr) {
 117         conn.SetHandler(this);
 118 }
 119
 120 ClientConnection::~ClientConnection() {
 121         DetachPlayer();
 122 }
 123
 124 void ClientConnection::Update(int dt) {
 125         conn.Update(dt);
 126         if (Disconnected()) {
 127                 cout << "disconnect from " << conn.Address() << endl;
 128         } else if (conn.ShouldPing()) {
 129                 conn.SendPing(server.GetPacket(), server.GetSocket());
 130         }
 131 }
 132
 133 void ClientConnection::AttachPlayer(Entity &new_player) {
 134         DetachPlayer();
 135         player = &new_player;
 136         player->Ref();
 137 }
 138
 139 void ClientConnection::DetachPlayer() {
 140         if (!player) return;
 141         player->Kill();
 142         player->UnRef();
 143         player = nullptr;
 144 }
 145
 146 void ClientConnection::On(const Packet::Login &pack) {
 147         string name;
 148         pack.ReadPlayerName(name);
 149
 150         Entity *new_player = server.GetWorld().AddPlayer(name);
 151
 152         if (new_player) {
 153                 // success!
 154                 AttachPlayer(*new_player);
 155                 cout << "accepted login from player \"" << name << '"' << endl;
 156                 auto response = Packet::Make<Packet::Join>(server.GetPacket());
 157                 response.WritePlayer(*new_player);
 158                 response.WriteWorldName(server.GetWorld().Name());
 159                 conn.Send(server.GetPacket(), server.GetSocket());
 160         } else {
 161                 // aw no :(
 162                 cout << "rejected login from player \"" << name << '"' << endl;
 163                 Packet::Make<Packet::Part>(server.GetPacket());
 164                 conn.Send(server.GetPacket(), server.GetSocket());
 165                 conn.Close();
 166         }
 167 }
 168
 169 void ClientConnection::On(const Packet::Part &) {
 170         conn.Close();
 171 }
 172
 173 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
 174         if (!HasPlayer()) return;
 175         pack.ReadPlayer(Player());
 176 }
 177
 178
 179 Connection::Connection(const IPaddress &addr)
 180 : handler(nullptr)
 181 , addr(addr)
 182 , send_timer(500)
 183 , recv_timer(10000)
 184 , ctrl_out{ 0, 0xFFFF, 0xFFFFFFFF }
 185 , ctrl_in{ 0, 0xFFFF, 0xFFFFFFFF }
 186 , closed(false) {
 187         send_timer.Start();
 188         recv_timer.Start();
 189 }
 190
 191 bool Connection::Matches(const IPaddress &remote) const noexcept {
 192         return memcmp(&addr, &remote, sizeof(IPaddress)) == 0;
 193 }
 194
 195 void Connection::FlagSend() noexcept {
 196         send_timer.Reset();
 197 }
 198
 199 void Connection::FlagRecv() noexcept {
 200         recv_timer.Reset();
 201 }
 202
 203 bool Connection::ShouldPing() const noexcept {
 204         return !closed && send_timer.HitOnce();
 205 }
 206
 207 bool Connection::TimedOut() const noexcept {
 208         return recv_timer.HitOnce();
 209 }
 210
 211 void Connection::Update(int dt) {
 212         send_timer.Update(dt);
 213         recv_timer.Update(dt);
 214         if (TimedOut()) {
 215                 Close();
 216                 if (HasHandler()) {
 217                         Handler().OnTimeout();
 218                 }
 219         }
 220 }
 221
 222
 223 uint16_t Connection::Send(UDPpacket &udp_pack, UDPsocket sock) {
 224         Packet &pack = *reinterpret_cast<Packet *>(udp_pack.data);
 225         pack.header.ctrl = ctrl_out;
 226         uint16_t seq = ctrl_out.seq++;
 227
 228         udp_pack.address = addr;
 229         if (SDLNet_UDP_Send(sock, -1, &udp_pack) == 0) {
 230                 throw NetError("SDLNet_UDP_Send");
 231         }
 232
 233         FlagSend();
 234         return seq;
 235 }
 236
 237 void Connection::Received(const UDPpacket &udp_pack) {
 238         Packet &pack = *reinterpret_cast<Packet *>(udp_pack.data);
 239
 240         // ack to the remote
 241         int16_t diff = int16_t(pack.header.ctrl.seq) - int16_t(ctrl_out.ack);
 242         if (diff > 0) {
 243                 if (diff >= 32) {
 244                         ctrl_out.hist = 0;
 245                 } else {
 246                         ctrl_out.hist <<= diff;
 247                         ctrl_out.hist |= 1 << (diff - 1);
 248                 }
 249         } else if (diff < 0 && diff >= -32) {
 250                 ctrl_out.hist |= 1 << (-diff - 1);
 251         }
 252         ctrl_out.ack = pack.header.ctrl.seq;
 253         FlagRecv();
 254
 255         if (!HasHandler()) {
 256                 return;
 257         }
 258
 259         Packet::TControl ctrl_new = pack.header.ctrl;
 260         Handler().Handle(udp_pack);
 261
 262         if (diff > 0) {
 263                 // if the packet holds more recent information
 264                 // check if remote failed to ack one of our packets
 265                 diff = int16_t(ctrl_new.ack) - int16_t(ctrl_in.ack);
 266                 // should always be true, but you never know…
 267                 if (diff > 0) {
 268                         for (int i = 0; i < diff; ++i) {
 269                                 if (i > 32 || (i < 32 && (ctrl_in.hist & (1 << (31 - i))) == 0)) {
 270                                         Handler().OnPacketLost(ctrl_in.ack - 32 + i);
 271                                 }
 272                         }
 273                 }
 274                 // check for newly ack'd packets
 275                 for (uint16_t s = ctrl_new.AckBegin(); s != ctrl_new.AckEnd(); ++s) {
 276                         if (ctrl_new.Acks(s) && !ctrl_in.Acks(s)) {
 277                                 Handler().OnPacketReceived(s);
 278                         }
 279                 }
 280                 ctrl_in = ctrl_new;
 281         }
 282 }
 283
 284 bool Packet::TControl::Acks(uint16_t s) const noexcept {
 285         int16_t diff = int16_t(ack) - int16_t(s);
 286         if (diff == 0) return true;
 287         if (diff < 0 || diff > 32) return false;
 288         return (hist & (1 << (diff - 1))) != 0;
 289 }
 290
 291 uint16_t Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) {
 292         Packet::Make<Packet::Ping>(udp_pack);
 293         return Send(udp_pack, sock);
 294 }
 295
 296
 297 ostream &operator <<(ostream &out, const IPaddress &addr) {
 298         const unsigned char *host = reinterpret_cast<const unsigned char *>(&addr.host);
 299         out << int(host[0])
 300                 << '.' << int(host[1])
 301                 << '.' << int(host[2])
 302                 << '.' << int(host[3]);
 303         if (addr.port) {
 304                 out << ':' << SDLNet_Read16(&addr.port);
 305         }
 306         return out;
 307 }
 308
 309
 310 const char *Packet::Type2String(uint8_t t) noexcept {
 311         switch (t) {
 312                 case Ping::TYPE:
 313                         return "Ping";
 314                 case Login::TYPE:
 315                         return "Login";
 316                 case Join::TYPE:
 317                         return "Join";
 318                 case Part::TYPE:
 319                         return "Part";
 320                 case PlayerUpdate::TYPE:
 321                         return "PlayerUpdate";
 322                 default:
 323                         return "Unknown";
 324         }
 325 }
 326
 327 template<class T>
 328 void Packet::Payload::Write(const T &src, size_t off) noexcept {
 329         if ((length - off) < sizeof(T)) {
 330                 // dismiss out of bounds write
 331                 return;
 332         }
 333         *reinterpret_cast<T *>(&data[off]) = src;
 334 }
 335
 336 template<class T>
 337 void Packet::Payload::Read(T &dst, size_t off) const noexcept {
 338         if ((length - off) < sizeof(T)) {
 339                 // dismiss out of bounds read
 340                 return;
 341         }
 342         dst = *reinterpret_cast<T *>(&data[off]);
 343 }
 344
 345 void Packet::Payload::WriteString(const string &src, size_t off, size_t maxlen) noexcept {
 346         uint8_t *dst = &data[off];
 347         size_t len = min(maxlen, length - off);
 348         if (src.size() < len) {
 349                 memset(dst, '\0', len);
 350                 memcpy(dst, src.c_str(), src.size());
 351         } else {
 352                 memcpy(dst, src.c_str(), len);
 353         }
 354 }
 355
 356 void Packet::Payload::ReadString(string &dst, size_t off, size_t maxlen) const noexcept {
 357         size_t len = min(maxlen, length - off);
 358         dst.clear();
 359         dst.reserve(len);
 360         for (size_t i = 0; i < len && data[off + i] != '\0'; ++i) {
 361                 dst.push_back(data[off + i]);
 362         }
 363 }
 364
 365
 366 void Packet::Login::WritePlayerName(const string &name) noexcept {
 367         WriteString(name, 0, 32);
 368 }
 369
 370 void Packet::Login::ReadPlayerName(string &name) const noexcept {
 371         ReadString(name, 0, 32);
 372 }
 373
 374 void Packet::Join::WritePlayer(const Entity &player) noexcept {
 375         Write(player.ID(), 0);
 376         Write(player.ChunkCoords(), 4);
 377         Write(player.Position(), 16);
 378         Write(player.Velocity(), 28);
 379         Write(player.Orientation(), 40);
 380         Write(player.AngularVelocity(), 56);
 381 }
 382
 383 void Packet::Join::ReadPlayerID(uint32_t &id) const noexcept {
 384         Read(id, 0);
 385 }
 386
 387 void Packet::Join::ReadPlayer(Entity &player) const noexcept {
 388         glm::ivec3 chunk_coords(0);
 389         glm::vec3 pos;
 390         glm::vec3 vel;
 391         glm::quat rot;
 392         glm::vec3 ang;
 393
 394         Read(chunk_coords, 4);
 395         Read(pos, 16);
 396         Read(vel, 28);
 397         Read(rot, 40);
 398         Read(ang, 56);
 399
 400         player.Position(chunk_coords, pos);
 401         player.Velocity(vel);
 402         player.Orientation(rot);
 403         player.AngularVelocity(ang);
 404 }
 405
 406 void Packet::Join::WriteWorldName(const string &name) noexcept {
 407         WriteString(name, 68, 32);
 408 }
 409
 410 void Packet::Join::ReadWorldName(string &name) const noexcept {
 411         ReadString(name, 68, 32);
 412 }
 413
 414 void Packet::PlayerUpdate::WritePlayer(const Entity &player) noexcept {
 415         Write(player.ChunkCoords(), 0);
 416         Write(player.Position(), 12);
 417         Write(player.Velocity(), 24);
 418         Write(player.Orientation(), 36);
 419         Write(player.AngularVelocity(), 52);
 420 }
 421
 422 void Packet::PlayerUpdate::ReadPlayer(Entity &player) const noexcept {
 423         glm::ivec3 chunk_coords(0);
 424         glm::vec3 pos;
 425         glm::vec3 vel;
 426         glm::quat rot;
 427         glm::vec3 ang;
 428
 429         Read(chunk_coords, 0);
 430         Read(pos, 12);
 431         Read(vel, 24);
 432         Read(rot, 36);
 433         Read(ang, 52);
 434
 435         player.Position(chunk_coords, pos);
 436         player.Velocity(vel);
 437         player.Orientation(rot);
 438         player.AngularVelocity(ang);
 439 }
 440
 441
 442 void ConnectionHandler::Handle(const UDPpacket &udp_pack) {
 443         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
 444         switch (pack.Type()) {
 445                 case Packet::Ping::TYPE:
 446                         On(Packet::As<Packet::Ping>(udp_pack));
 447                         break;
 448                 case Packet::Login::TYPE:
 449                         On(Packet::As<Packet::Login>(udp_pack));
 450                         break;
 451                 case Packet::Join::TYPE:
 452                         On(Packet::As<Packet::Join>(udp_pack));
 453                         break;
 454                 case Packet::Part::TYPE:
 455                         On(Packet::As<Packet::Part>(udp_pack));
 456                         break;
 457                 case Packet::PlayerUpdate::TYPE:
 458                         On(Packet::As<Packet::PlayerUpdate>(udp_pack));
 459                         break;
 460                 default:
 461                         // drop unknown or unhandled packets
 462                         break;
 463         }
 464 }
 465
 466
 467 Server::Server(const Config &conf, World &world)
 468 : serv_sock(nullptr)
 469 , serv_pack{ -1, nullptr, 0 }
 470 , clients()
 471 , world(world) {
 472         serv_sock = SDLNet_UDP_Open(conf.port);
 473         if (!serv_sock) {
 474                 throw NetError("SDLNet_UDP_Open");
 475         }
 476
 477         serv_pack.data = new Uint8[sizeof(Packet)];
 478         serv_pack.maxlen = sizeof(Packet);
 479 }
 480
 481 Server::~Server() {
 482         delete[] serv_pack.data;
 483         SDLNet_UDP_Close(serv_sock);
 484 }
 485
 486
 487 void Server::Handle() {
 488         int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 489         while (result > 0) {
 490                 HandlePacket(serv_pack);
 491                 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 492         }
 493         if (result == -1) {
 494                 // a boo boo happened
 495                 throw NetError("SDLNet_UDP_Recv");
 496         }
 497 }
 498
 499 void Server::HandlePacket(const UDPpacket &udp_pack) {
 500         if (udp_pack.len < int(sizeof(Packet::Header))) {
 501                 // packet too small, drop
 502                 return;
 503         }
 504         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
 505         if (pack.header.tag != Packet::TAG) {
 506                 // mistagged packet, drop
 507                 return;
 508         }
 509
 510         ClientConnection &client = GetClient(udp_pack.address);
 511         client.GetConnection().Received(udp_pack);
 512 }
 513
 514 ClientConnection &Server::GetClient(const IPaddress &addr) {
 515         for (ClientConnection &client : clients) {
 516                 if (client.Matches(addr)) {
 517                         return client;
 518                 }
 519         }
 520         clients.emplace_back(*this, addr);
 521         return clients.back();
 522 }
 523
 524 void Server::Update(int dt) {
 525         for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
 526                 client->Update(dt);
 527                 if (client->Disconnected()) {
 528                         client = clients.erase(client);
 529                 } else {
 530                         ++client;
 531                 }
 532         }
 533 }
 534
 535 }