TCPInterface.h

Go to the documentation of this file.

#include "NativeFeatureIncludes.h"
#if _RAKNET_SUPPORT_TCPInterface==1

#ifndef __SIMPLE_TCP_SERVER
#define __SIMPLE_TCP_SERVER

#include "RakMemoryOverride.h"
#include "DS_List.h"
#include "RakNetTypes.h"
#include "Export.h"
#include "RakThread.h"
#include "DS_Queue.h"
#include "SimpleMutex.h"
#include "RakNetDefines.h"
#include "SocketIncludes.h"
#include "DS_ByteQueue.h"
#include "DS_ThreadsafeAllocatingQueue.h"

struct RemoteClient;

#if defined(OPEN_SSL_CLIENT_SUPPORT)
#include <openssl/crypto.h>
#include <openssl/x509.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#endif

class RAK_DLL_EXPORT TCPInterface
{
public:
        TCPInterface();
        virtual ~TCPInterface();

        bool Start(unsigned short port, unsigned short maxIncomingConnections, unsigned short maxConnections=0, int _threadPriority=-99999);

        void Stop(void);

        SystemAddress Connect(const char* host, unsigned short remotePort, bool block=true);

#if defined(OPEN_SSL_CLIENT_SUPPORT)

        void StartSSLClient(SystemAddress systemAddress);

        bool IsSSLActive(SystemAddress systemAddress);
#endif

        void Send( const char *data, unsigned int length, SystemAddress systemAddress, bool broadcast );

        // Sends a concatenated list of byte streams
        bool SendList( const char **data, const unsigned int  *lengths, const int numParameters, SystemAddress systemAddress, bool broadcast );

        // Get how many bytes are waiting to be sent. If too many, you may want to skip sending
        unsigned int GetOutgoingDataBufferSize(SystemAddress systemAddress) const;

        bool ReceiveHasPackets( void );

        Packet* Receive( void );

        void CloseConnection( SystemAddress systemAddress );

        void DeallocatePacket( Packet *packet );

        void GetConnectionList( SystemAddress *remoteSystems, unsigned short *numberOfSystems ) const;

        unsigned short GetConnectionCount(void) const;

        SystemAddress HasCompletedConnectionAttempt(void);

        SystemAddress HasFailedConnectionAttempt(void);

        SystemAddress HasNewIncomingConnection(void);

        SystemAddress HasLostConnection(void);

        Packet* AllocatePacket(unsigned dataSize);

        // Push a packet back to the queue
        virtual void PushBackPacket( Packet *packet, bool pushAtHead );
protected:

        bool isStarted, threadRunning;
        SOCKET listenSocket;

        DataStructures::Queue<Packet*> headPush, tailPush;
        RemoteClient* remoteClients;
        int remoteClientsLength;

        // Assuming remoteClients is only used by one thread!
        // DataStructures::List<RemoteClient*> remoteClients;
        // Use this thread-safe queue to add to remoteClients
        // DataStructures::Queue<RemoteClient*> remoteClientsInsertionQueue;
        // SimpleMutex remoteClientsInsertionQueueMutex;

        /*
        struct OutgoingMessage
        {
                unsigned char* data;
                SystemAddress systemAddress;
                bool broadcast;
                unsigned int length;
        };
        */
//      DataStructures::SingleProducerConsumer<OutgoingMessage> outgoingMessages;
//      DataStructures::SingleProducerConsumer<Packet> incomingMessages;
//      DataStructures::SingleProducerConsumer<SystemAddress> newIncomingConnections, lostConnections, requestedCloseConnections;
//      DataStructures::SingleProducerConsumer<RemoteClient*> newRemoteClients;
//      DataStructures::ThreadsafeAllocatingQueue<OutgoingMessage> outgoingMessages;
        DataStructures::ThreadsafeAllocatingQueue<Packet> incomingMessages;
        DataStructures::ThreadsafeAllocatingQueue<SystemAddress> newIncomingConnections, lostConnections, requestedCloseConnections;
        DataStructures::ThreadsafeAllocatingQueue<RemoteClient*> newRemoteClients;
        SimpleMutex completedConnectionAttemptMutex, failedConnectionAttemptMutex;
        DataStructures::Queue<SystemAddress> completedConnectionAttempts, failedConnectionAttempts;

        int threadPriority;

        DataStructures::List<SOCKET> blockingSocketList;
        SimpleMutex blockingSocketListMutex;

        friend RAK_THREAD_DECLARATION(UpdateTCPInterfaceLoop);
        friend RAK_THREAD_DECLARATION(ConnectionAttemptLoop);

//      void DeleteRemoteClient(RemoteClient *remoteClient, fd_set *exceptionFD);
//      void InsertRemoteClient(RemoteClient* remoteClient);
        SOCKET SocketConnect(const char* host, unsigned short remotePort);

        struct ThisPtrPlusSysAddr
        {
                TCPInterface *tcpInterface;
                SystemAddress systemAddress;
                bool useSSL;
        };

#if defined(OPEN_SSL_CLIENT_SUPPORT)
        SSL_CTX* ctx;
        SSL_METHOD *meth;
        DataStructures::ThreadsafeAllocatingQueue<SystemAddress> startSSL;
        DataStructures::List<SystemAddress> activeSSLConnections;
#endif
};

struct RemoteClient
{
        RemoteClient() {
#if defined(OPEN_SSL_CLIENT_SUPPORT)
                ssl=0;
#endif
                isActive=false;
                socket=INVALID_SOCKET;
        }
        SOCKET socket;
        SystemAddress systemAddress;
        DataStructures::ByteQueue outgoingData;
        bool isActive;
        SimpleMutex outgoingDataMutex;
        SimpleMutex isActiveMutex;

#if defined(OPEN_SSL_CLIENT_SUPPORT)
        SSL*     ssl;
        void InitSSL(SSL_CTX* ctx, SSL_METHOD *meth);
        void DisconnectSSL(void);
        void FreeSSL(void);
        int Send(const char *data, unsigned int length);
        int Recv(char *data, const int dataSize);
#else
        int Send(const char *data, unsigned int length);
        int Recv(char *data, const int dataSize);
#endif
        void Reset(void)
        {
                outgoingDataMutex.Lock();
                outgoingData.Clear(__FILE__,__LINE__);
                outgoingDataMutex.Unlock();
        }
        void SetActive(bool a);
        void SendOrBuffer(const char **data, const unsigned int *lengths, const int numParameters);
};

#endif

#endif // _RAKNET_SUPPORT_*