src/connection.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #ifndef CONNECTION_HEADER
  21 #define CONNECTION_HEADER
  22
  23 #include <iostream>
  24 #include <fstream>
  25 #include "debug.h"
  26 #include "common_irrlicht.h"
  27 #include "socket.h"
  28 #include "utility.h"
  29 #include "exceptions.h"
  30 #include "constants.h"
  31
  32 namespace con
  33 {
  34
  35 /*
  36         Exceptions
  37 */
  38 class NotFoundException : public BaseException
  39 {
  40 public:
  41         NotFoundException(const char *s):
  42                 BaseException(s)
  43         {}
  44 };
  45
  46 class PeerNotFoundException : public BaseException
  47 {
  48 public:
  49         PeerNotFoundException(const char *s):
  50                 BaseException(s)
  51         {}
  52 };
  53
  54 class ConnectionException : public BaseException
  55 {
  56 public:
  57         ConnectionException(const char *s):
  58                 BaseException(s)
  59         {}
  60 };
  61
  62 /*class ThrottlingException : public BaseException
  63 {
  64 public:
  65         ThrottlingException(const char *s):
  66                 BaseException(s)
  67         {}
  68 };*/
  69
  70 class InvalidIncomingDataException : public BaseException
  71 {
  72 public:
  73         InvalidIncomingDataException(const char *s):
  74                 BaseException(s)
  75         {}
  76 };
  77
  78 class InvalidOutgoingDataException : public BaseException
  79 {
  80 public:
  81         InvalidOutgoingDataException(const char *s):
  82                 BaseException(s)
  83         {}
  84 };
  85
  86 class NoIncomingDataException : public BaseException
  87 {
  88 public:
  89         NoIncomingDataException(const char *s):
  90                 BaseException(s)
  91         {}
  92 };
  93
  94 class ProcessedSilentlyException : public BaseException
  95 {
  96 public:
  97         ProcessedSilentlyException(const char *s):
  98                 BaseException(s)
  99         {}
 100 };
 101
 102 inline u16 readPeerId(u8 *packetdata)
 103 {
 104         return readU16(&packetdata[4]);
 105 }
 106 inline u8 readChannel(u8 *packetdata)
 107 {
 108         return readU8(&packetdata[6]);
 109 }
 110
 111 #define SEQNUM_MAX 65535
 112 inline bool seqnum_higher(u16 higher, u16 lower)
 113 {
 114         if(lower > higher && lower - higher > SEQNUM_MAX/2){
 115                 return true;
 116         }
 117         return (higher > lower);
 118 }
 119
 120 struct BufferedPacket
 121 {
 122         BufferedPacket(u8 *a_data, u32 a_size):
 123                 data(a_data, a_size), time(0.0), totaltime(0.0)
 124         {}
 125         BufferedPacket(u32 a_size):
 126                 data(a_size), time(0.0), totaltime(0.0)
 127         {}
 128         SharedBuffer<u8> data; // Data of the packet, including headers
 129         float time; // Seconds from buffering the packet or re-sending
 130         float totaltime; // Seconds from buffering the packet
 131         Address address; // Sender or destination
 132 };
 133
 134 // This adds the base headers to the data and makes a packet out of it
 135 BufferedPacket makePacket(Address &address, u8 *data, u32 datasize,
 136                 u32 protocol_id, u16 sender_peer_id, u8 channel);
 137 BufferedPacket makePacket(Address &address, SharedBuffer<u8> &data,
 138                 u32 protocol_id, u16 sender_peer_id, u8 channel);
 139
 140 // Add the TYPE_ORIGINAL header to the data
 141 SharedBuffer<u8> makeOriginalPacket(
 142                 SharedBuffer<u8> data);
 143
 144 // Split data in chunks and add TYPE_SPLIT headers to them
 145 core::list<SharedBuffer<u8> > makeSplitPacket(
 146                 SharedBuffer<u8> data,
 147                 u32 chunksize_max,
 148                 u16 seqnum);
 149
 150 // Depending on size, make a TYPE_ORIGINAL or TYPE_SPLIT packet
 151 // Increments split_seqnum if a split packet is made
 152 core::list<SharedBuffer<u8> > makeAutoSplitPacket(
 153                 SharedBuffer<u8> data,
 154                 u32 chunksize_max,
 155                 u16 &split_seqnum);
 156
 157 // Add the TYPE_RELIABLE header to the data
 158 SharedBuffer<u8> makeReliablePacket(
 159                 SharedBuffer<u8> data,
 160                 u16 seqnum);
 161
 162 struct IncomingSplitPacket
 163 {
 164         IncomingSplitPacket()
 165         {
 166                 time = 0.0;
 167                 reliable = false;
 168         }
 169         // Key is chunk number, value is data without headers
 170         core::map<u16, SharedBuffer<u8> > chunks;
 171         u32 chunk_count;
 172         float time; // Seconds from adding
 173         bool reliable; // If true, isn't deleted on timeout
 174
 175         bool allReceived()
 176         {
 177                 return (chunks.size() == chunk_count);
 178         }
 179 };
 180
 181 /*
 182 === NOTES ===
 183
 184 A packet is sent through a channel to a peer with a basic header:
 185 TODO: Should we have a receiver_peer_id also?
 186         Header (7 bytes):
 187         [0] u32 protocol_id
 188         [4] u16 sender_peer_id
 189         [6] u8 channel
 190 sender_peer_id:
 191         Unique to each peer.
 192         value 0 is reserved for making new connections
 193         value 1 is reserved for server
 194 channel:
 195         The lower the number, the higher the priority is.
 196         Only channels 0, 1 and 2 exist.
 197 */
 198 #define BASE_HEADER_SIZE 7
 199 #define PEER_ID_INEXISTENT 0
 200 #define PEER_ID_SERVER 1
 201 #define CHANNEL_COUNT 3
 202 /*
 203 Packet types:
 204
 205 CONTROL: This is a packet used by the protocol.
 206 - When this is processed, nothing is handed to the user.
 207         Header (2 byte):
 208         [0] u8 type
 209         [1] u8 controltype
 210 controltype and data description:
 211         CONTROLTYPE_ACK
 212                 [2] u16 seqnum
 213         CONTROLTYPE_SET_PEER_ID
 214                 [2] u16 peer_id_new
 215         CONTROLTYPE_PING
 216         - There is no actual reply, but this can be sent in a reliable
 217           packet to get a reply
 218         CONTROLTYPE_DISCO
 219 */
 220 #define TYPE_CONTROL 0
 221 #define CONTROLTYPE_ACK 0
 222 #define CONTROLTYPE_SET_PEER_ID 1
 223 #define CONTROLTYPE_PING 2
 224 #define CONTROLTYPE_DISCO 3
 225 /*
 226 ORIGINAL: This is a plain packet with no control and no error
 227 checking at all.
 228 - When this is processed, it is directly handed to the user.
 229         Header (1 byte):
 230         [0] u8 type
 231 */
 232 #define TYPE_ORIGINAL 1
 233 #define ORIGINAL_HEADER_SIZE 1
 234 /*
 235 SPLIT: These are sequences of packets forming one bigger piece of
 236 data.
 237 - When processed and all the packet_nums 0...packet_count-1 are
 238   present (this should be buffered), the resulting data shall be
 239   directly handed to the user.
 240 - If the data fails to come up in a reasonable time, the buffer shall
 241   be silently discarded.
 242 - These can be sent as-is or atop of a RELIABLE packet stream.
 243         Header (7 bytes):
 244         [0] u8 type
 245         [1] u16 seqnum
 246         [3] u16 chunk_count
 247         [5] u16 chunk_num
 248 */
 249 #define TYPE_SPLIT 2
 250 /*
 251 RELIABLE: Delivery of all RELIABLE packets shall be forced by ACKs,
 252 and they shall be delivered in the same order as sent. This is done
 253 with a buffer in the receiving and transmitting end.
 254 - When this is processed, the contents of each packet is recursively
 255   processed as packets.
 256         Header (3 bytes):
 257         [0] u8 type
 258         [1] u16 seqnum
 259
 260 */
 261 #define TYPE_RELIABLE 3
 262 #define RELIABLE_HEADER_SIZE 3
 263 //#define SEQNUM_INITIAL 0x10
 264 #define SEQNUM_INITIAL 65500
 265
 266 /*
 267         A buffer which stores reliable packets and sorts them internally
 268         for fast access to the smallest one.
 269 */
 270
 271 typedef core::list<BufferedPacket>::Iterator RPBSearchResult;
 272
 273 class ReliablePacketBuffer
 274 {
 275 public:
 276
 277         void print();
 278         bool empty();
 279         u32 size();
 280         RPBSearchResult findPacket(u16 seqnum);
 281         RPBSearchResult notFound();
 282         u16 getFirstSeqnum();
 283         BufferedPacket popFirst();
 284         BufferedPacket popSeqnum(u16 seqnum);
 285         void insert(BufferedPacket &p);
 286         void incrementTimeouts(float dtime);
 287         void resetTimedOuts(float timeout);
 288         bool anyTotaltimeReached(float timeout);
 289         core::list<BufferedPacket> getTimedOuts(float timeout);
 290
 291 private:
 292         core::list<BufferedPacket> m_list;
 293 };
 294
 295 /*
 296         A buffer for reconstructing split packets
 297 */
 298
 299 class IncomingSplitBuffer
 300 {
 301 public:
 302         ~IncomingSplitBuffer();
 303         /*
 304                 Returns a reference counted buffer of length != 0 when a full split
 305                 packet is constructed. If not, returns one of length 0.
 306         */
 307         SharedBuffer<u8> insert(BufferedPacket &p, bool reliable);
 308
 309         void removeUnreliableTimedOuts(float dtime, float timeout);
 310
 311 private:
 312         // Key is seqnum
 313         core::map<u16, IncomingSplitPacket*> m_buf;
 314 };
 315
 316 class Connection;
 317
 318 struct Channel
 319 {
 320         Channel();
 321         ~Channel();
 322
 323         u16 next_outgoing_seqnum;
 324         u16 next_incoming_seqnum;
 325         u16 next_outgoing_split_seqnum;
 326
 327         // This is for buffering the incoming packets that are coming in
 328         // the wrong order
 329         ReliablePacketBuffer incoming_reliables;
 330         // This is for buffering the sent packets so that the sender can
 331         // re-send them if no ACK is received
 332         ReliablePacketBuffer outgoing_reliables;
 333
 334         IncomingSplitBuffer incoming_splits;
 335 };
 336
 337 class Peer;
 338
 339 class PeerHandler
 340 {
 341 public:
 342         PeerHandler()
 343         {
 344         }
 345         virtual ~PeerHandler()
 346         {
 347         }
 348
 349         /*
 350                 This is called after the Peer has been inserted into the
 351                 Connection's peer container.
 352         */
 353         virtual void peerAdded(Peer *peer) = 0;
 354         /*
 355                 This is called before the Peer has been removed from the
 356                 Connection's peer container.
 357         */
 358         virtual void deletingPeer(Peer *peer, bool timeout) = 0;
 359 };
 360
 361 class Peer
 362 {
 363 public:
 364
 365         Peer(u16 a_id, Address a_address);
 366         virtual ~Peer();
 367
 368         /*
 369                 Calculates avg_rtt and resend_timeout.
 370
 371                 rtt=-1 only recalculates resend_timeout
 372         */
 373         void reportRTT(float rtt);
 374
 375         Channel channels[CHANNEL_COUNT];
 376
 377         // Address of the peer
 378         Address address;
 379         // Unique id of the peer
 380         u16 id;
 381         // Seconds from last receive
 382         float timeout_counter;
 383         // Ping timer
 384         float ping_timer;
 385         // This is changed dynamically
 386         float resend_timeout;
 387         // Updated when an ACK is received
 388         float avg_rtt;
 389         // This is set to true when the peer has actually sent something
 390         // with the id we have given to it
 391         bool has_sent_with_id;
 392
 393         float m_sendtime_accu;
 394         float m_max_packets_per_second;
 395         int m_num_sent;
 396         int m_max_num_sent;
 397
 398 private:
 399 };
 400
 401 /*
 402         Connection
 403 */
 404
 405 struct OutgoingPacket
 406 {
 407         u16 peer_id;
 408         u8 channelnum;
 409         SharedBuffer<u8> data;
 410         bool reliable;
 411
 412         OutgoingPacket(u16 peer_id_, u8 channelnum_, SharedBuffer<u8> data_,
 413                         bool reliable_):
 414                 peer_id(peer_id_),
 415                 channelnum(channelnum_),
 416                 data(data_),
 417                 reliable(reliable_)
 418         {
 419         }
 420 };
 421
 422 enum ConnectionEventType{
 423         CONNEVENT_NONE,
 424         CONNEVENT_DATA_RECEIVED,
 425         CONNEVENT_PEER_ADDED,
 426         CONNEVENT_PEER_REMOVED,
 427 };
 428
 429 struct ConnectionEvent
 430 {
 431         enum ConnectionEventType type;
 432         u16 peer_id;
 433         Buffer<u8> data;
 434         bool timeout;
 435         Address address;
 436
 437         ConnectionEvent(): type(CONNEVENT_NONE) {}
 438
 439         std::string describe()
 440         {
 441                 switch(type){
 442                 case CONNEVENT_NONE:
 443                         return "CONNEVENT_NONE";
 444                 case CONNEVENT_DATA_RECEIVED:
 445                         return "CONNEVENT_DATA_RECEIVED";
 446                 case CONNEVENT_PEER_ADDED:
 447                         return "CONNEVENT_PEER_ADDED";
 448                 case CONNEVENT_PEER_REMOVED:
 449                         return "CONNEVENT_PEER_REMOVED";
 450                 }
 451                 return "Invalid ConnectionEvent";
 452         }
 453
 454         void dataReceived(u16 peer_id_, SharedBuffer<u8> data_)
 455         {
 456                 type = CONNEVENT_DATA_RECEIVED;
 457                 peer_id = peer_id_;
 458                 data = data_;
 459         }
 460         void peerAdded(u16 peer_id_, Address address_)
 461         {
 462                 type = CONNEVENT_PEER_ADDED;
 463                 peer_id = peer_id_;
 464                 address = address_;
 465         }
 466         void peerRemoved(u16 peer_id_, bool timeout_, Address address_)
 467         {
 468                 type = CONNEVENT_PEER_REMOVED;
 469                 peer_id = peer_id_;
 470                 timeout = timeout_;
 471                 address = address_;
 472         }
 473 };
 474
 475 enum ConnectionCommandType{
 476         CONNCMD_NONE,
 477         CONNCMD_SERVE,
 478         CONNCMD_CONNECT,
 479         CONNCMD_DISCONNECT,
 480         CONNCMD_SEND,
 481         CONNCMD_SEND_TO_ALL,
 482         CONNCMD_DELETE_PEER,
 483 };
 484
 485 struct ConnectionCommand
 486 {
 487         enum ConnectionCommandType type;
 488         u16 port;
 489         Address address;
 490         u16 peer_id;
 491         u8 channelnum;
 492         Buffer<u8> data;
 493         bool reliable;
 494
 495         ConnectionCommand(): type(CONNCMD_NONE) {}
 496
 497         void serve(u16 port_)
 498         {
 499                 type = CONNCMD_SERVE;
 500                 port = port_;
 501         }
 502         void connect(Address address_)
 503         {
 504                 type = CONNCMD_CONNECT;
 505                 address = address_;
 506         }
 507         void disconnect()
 508         {
 509                 type = CONNCMD_DISCONNECT;
 510         }
 511         void send(u16 peer_id_, u8 channelnum_,
 512                         SharedBuffer<u8> data_, bool reliable_)
 513         {
 514                 type = CONNCMD_SEND;
 515                 peer_id = peer_id_;
 516                 channelnum = channelnum_;
 517                 data = data_;
 518                 reliable = reliable_;
 519         }
 520         void sendToAll(u8 channelnum_, SharedBuffer<u8> data_, bool reliable_)
 521         {
 522                 type = CONNCMD_SEND_TO_ALL;
 523                 channelnum = channelnum_;
 524                 data = data_;
 525                 reliable = reliable_;
 526         }
 527         void deletePeer(u16 peer_id_)
 528         {
 529                 type = CONNCMD_DELETE_PEER;
 530                 peer_id = peer_id_;
 531         }
 532 };
 533
 534 class Connection: public SimpleThread
 535 {
 536 public:
 537         Connection(u32 protocol_id, u32 max_packet_size, float timeout);
 538         Connection(u32 protocol_id, u32 max_packet_size, float timeout,
 539                         PeerHandler *peerhandler);
 540         ~Connection();
 541         void * Thread();
 542
 543         /* Interface */
 544
 545         ConnectionEvent getEvent();
 546         ConnectionEvent waitEvent(u32 timeout_ms);
 547         void putCommand(ConnectionCommand &c);
 548
 549         void SetTimeoutMs(int timeout){ m_bc_receive_timeout = timeout; }
 550         void Serve(unsigned short port);
 551         void Connect(Address address);
 552         bool Connected();
 553         void Disconnect();
 554         u32 Receive(u16 &peer_id, u8 *data, u32 datasize);
 555         void SendToAll(u8 channelnum, SharedBuffer<u8> data, bool reliable);
 556         void Send(u16 peer_id, u8 channelnum, SharedBuffer<u8> data, bool reliable);
 557         void RunTimeouts(float dtime); // dummy
 558         u16 GetPeerID(){ return m_peer_id; }
 559         Address GetPeerAddress(u16 peer_id);
 560         float GetPeerAvgRTT(u16 peer_id);
 561         void DeletePeer(u16 peer_id);
 562
 563 private:
 564         void putEvent(ConnectionEvent &e);
 565         void processCommand(ConnectionCommand &c);
 566         void send(float dtime);
 567         void receive();
 568         void runTimeouts(float dtime);
 569         void serve(u16 port);
 570         void connect(Address address);
 571         void disconnect();
 572         void sendToAll(u8 channelnum, SharedBuffer<u8> data, bool reliable);
 573         void send(u16 peer_id, u8 channelnum, SharedBuffer<u8> data, bool reliable);
 574         void sendAsPacket(u16 peer_id, u8 channelnum,
 575                         SharedBuffer<u8> data, bool reliable);
 576         void rawSendAsPacket(u16 peer_id, u8 channelnum,
 577                         SharedBuffer<u8> data, bool reliable);
 578         void rawSend(const BufferedPacket &packet);
 579         Peer* getPeer(u16 peer_id);
 580         Peer* getPeerNoEx(u16 peer_id);
 581         core::list<Peer*> getPeers();
 582         bool getFromBuffers(u16 &peer_id, SharedBuffer<u8> &dst);
 583         // Returns next data from a buffer if possible
 584         // If found, returns true; if not, false.
 585         // If found, sets peer_id and dst
 586         bool checkIncomingBuffers(Channel *channel, u16 &peer_id,
 587                         SharedBuffer<u8> &dst);
 588         /*
 589                 Processes a packet with the basic header stripped out.
 590                 Parameters:
 591                         packetdata: Data in packet (with no base headers)
 592                         peer_id: peer id of the sender of the packet in question
 593                         channelnum: channel on which the packet was sent
 594                         reliable: true if recursing into a reliable packet
 595         */
 596         SharedBuffer<u8> processPacket(Channel *channel,
 597                         SharedBuffer<u8> packetdata, u16 peer_id,
 598                         u8 channelnum, bool reliable);
 599         bool deletePeer(u16 peer_id, bool timeout);
 600
 601         Queue<OutgoingPacket> m_outgoing_queue;
 602         MutexedQueue<ConnectionEvent> m_event_queue;
 603         MutexedQueue<ConnectionCommand> m_command_queue;
 604
 605         u32 m_protocol_id;
 606         u32 m_max_packet_size;
 607         float m_timeout;
 608         UDPSocket m_socket;
 609         u16 m_peer_id;
 610
 611         core::map<u16, Peer*> m_peers;
 612         JMutex m_peers_mutex;
 613
 614         // Backwards compatibility
 615         PeerHandler *m_bc_peerhandler;
 616         int m_bc_receive_timeout;
 617
 618         void SetPeerID(u16 id){ m_peer_id = id; }
 619         u32 GetProtocolID(){ return m_protocol_id; }
 620         void PrintInfo(std::ostream &out);
 621         void PrintInfo();
 622         std::string getDesc();
 623         u16 m_indentation;
 624 };
 625
 626 } // namespace
 627
 628 #endif
 629