From 3cea7a349ac55df93b3eac1bf40365e00e472480 Mon Sep 17 00:00:00 2001 From: Loïc Blot Date: Fri, 25 Aug 2017 15:53:56 +0200 Subject: Network cleanup (#6310) * Move Connection threads to dedicated files + various cleanups * ConnectionReceiveThread::processPacket now uses function pointer table to route MT packet types * Various code style fixes * Code style with clang-format * Various SharedBuffer copy removal * SharedBuffer cannot be copied anymore using Buffer * Fix many SharedBuffer copy (thanks to delete operator) --- src/network/connectionthreads.h | 148 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 src/network/connectionthreads.h (limited to 'src/network/connectionthreads.h') diff --git a/src/network/connectionthreads.h b/src/network/connectionthreads.h new file mode 100644 index 000000000..11bec0c6c --- /dev/null +++ b/src/network/connectionthreads.h @@ -0,0 +1,148 @@ +/* +Minetest +Copyright (C) 2013-2017 celeron55, Perttu Ahola +Copyright (C) 2017 celeron55, Loic Blot + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#pragma once + +#include +#include "../threading/thread.h" +#include "connection.h" + +namespace con +{ + +class Connection; + +class ConnectionSendThread : public Thread +{ + +public: + friend class UDPPeer; + + ConnectionSendThread(unsigned int max_packet_size, float timeout); + + void *run(); + + void Trigger(); + + void setParent(Connection *parent) + { + assert(parent != NULL); // Pre-condition + m_connection = parent; + } + + void setPeerTimeout(float peer_timeout) { m_timeout = peer_timeout; } + +private: + void runTimeouts(float dtime); + void rawSend(const BufferedPacket &packet); + bool rawSendAsPacket(u16 peer_id, u8 channelnum, const SharedBuffer &data, + bool reliable); + + void processReliableCommand(ConnectionCommand &c); + void processNonReliableCommand(ConnectionCommand &c); + void serve(Address bind_address); + void connect(Address address); + void disconnect(); + void disconnect_peer(u16 peer_id); + void send(u16 peer_id, u8 channelnum, SharedBuffer data); + void sendReliable(ConnectionCommand &c); + void sendToAll(u8 channelnum, SharedBuffer data); + void sendToAllReliable(ConnectionCommand &c); + + void sendPackets(float dtime); + + void sendAsPacket(u16 peer_id, u8 channelnum, SharedBuffer data, + bool ack = false); + + void sendAsPacketReliable(BufferedPacket &p, Channel *channel); + + bool packetsQueued(); + + Connection *m_connection = nullptr; + unsigned int m_max_packet_size; + float m_timeout; + std::queue m_outgoing_queue; + Semaphore m_send_sleep_semaphore; + + unsigned int m_iteration_packets_avaialble; + unsigned int m_max_commands_per_iteration = 1; + unsigned int m_max_data_packets_per_iteration; + unsigned int m_max_packets_requeued = 256; +}; + +class ConnectionReceiveThread : public Thread +{ +public: + ConnectionReceiveThread(unsigned int max_packet_size); + + void *run(); + + void setParent(Connection *parent) + { + assert(parent); // Pre-condition + m_connection = parent; + } + +private: + void receive(); + + // Returns next data from a buffer if possible + // If found, returns true; if not, false. + // If found, sets peer_id and dst + bool getFromBuffers(u16 &peer_id, SharedBuffer &dst); + + bool checkIncomingBuffers(Channel *channel, u16 &peer_id, SharedBuffer &dst); + + /* + Processes a packet with the basic header stripped out. + Parameters: + packetdata: Data in packet (with no base headers) + peer_id: peer id of the sender of the packet in question + channelnum: channel on which the packet was sent + reliable: true if recursing into a reliable packet + */ + SharedBuffer processPacket(Channel *channel, SharedBuffer &packetdata, + u16 peer_id, u8 channelnum, bool reliable); + + SharedBuffer handlePacketType_Control(Channel *channel, + SharedBuffer &packetdata, Peer *peer, u8 channelnum, + bool reliable); + SharedBuffer handlePacketType_Original(Channel *channel, + SharedBuffer &packetdata, Peer *peer, u8 channelnum, + bool reliable); + SharedBuffer handlePacketType_Split(Channel *channel, + SharedBuffer &packetdata, Peer *peer, u8 channelnum, + bool reliable); + SharedBuffer handlePacketType_Reliable(Channel *channel, + SharedBuffer &packetdata, Peer *peer, u8 channelnum, + bool reliable); + + struct PacketTypeHandler + { + SharedBuffer (ConnectionReceiveThread::*handler)(Channel *channel, + SharedBuffer &packet, Peer *peer, u8 channelnum, + bool reliable); + }; + + static const PacketTypeHandler packetTypeRouter[PACKET_TYPE_MAX]; + + Connection *m_connection = nullptr; +}; +} -- cgit v1.2.3