Files
@ r14843:47401053c1ce
Branch filter:
Location: cpp/openttd-patchpack/source/src/network/core/tcp.h
r14843:47401053c1ce
3.2 KiB
text/x-c
(svn r19449) -Codechange: pay for every airport tile build, not for every tile in the rectangle where the airport is build
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | /* $Id$ */
/*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD 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 General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file tcp.h Basic functions to receive and send TCP packets.
*/
#ifndef NETWORK_CORE_TCP_H
#define NETWORK_CORE_TCP_H
#include "address.h"
#include "packet.h"
#ifdef ENABLE_NETWORK
/** Base socket handler for all TCP sockets */
class NetworkTCPSocketHandler : public NetworkSocketHandler {
private:
Packet *packet_queue; ///< Packets that are awaiting delivery
Packet *packet_recv; ///< Partially received packet
public:
SOCKET sock; ///< The socket currently connected to
bool writable; ///< Can we write to this socket?
/**
* Whether this socket is currently bound to a socket.
* @return true when the socket is bound, false otherwise
*/
bool IsConnected() const { return this->sock != INVALID_SOCKET; }
virtual NetworkRecvStatus CloseConnection(bool error = true);
void Send_Packet(Packet *packet);
bool Send_Packets(bool closing_down = false);
bool IsPacketQueueEmpty();
Packet *Recv_Packet();
NetworkTCPSocketHandler(SOCKET s = INVALID_SOCKET);
~NetworkTCPSocketHandler();
};
/**
* "Helper" class for creating TCP connections in a non-blocking manner
*/
class TCPConnecter {
private:
class ThreadObject *thread; ///< Thread used to create the TCP connection
bool connected; ///< Whether we succeeded in making the connection
bool aborted; ///< Whether we bailed out (i.e. connection making failed)
bool killed; ///< Whether we got killed
SOCKET sock; ///< The socket we're connecting with
/** The actual connection function */
void Connect();
/**
* Entry point for the new threads.
* @param param the TCPConnecter instance to call Connect on.
*/
static void ThreadEntry(void *param);
protected:
/** Address we're connecting to */
NetworkAddress address;
public:
/**
* Create a new connecter for the given address
* @param address the (un)resolved address to connect to
*/
TCPConnecter(const NetworkAddress &address);
/** Silence the warnings */
virtual ~TCPConnecter() {}
/**
* Callback when the connection succeeded.
* @param s the socket that we opened
*/
virtual void OnConnect(SOCKET s) {}
/**
* Callback for when the connection attempt failed.
*/
virtual void OnFailure() {}
/**
* Check whether we need to call the callback, i.e. whether we
* have connected or aborted and call the appropriate callback
* for that. It's done this way to ease on the locking that
* would otherwise be needed everywhere.
*/
static void CheckCallbacks();
/** Kill all connection attempts. */
static void KillAll();
};
#endif /* ENABLE_NETWORK */
#endif /* NETWORK_CORE_TCP_H */
|