BaseTransportServer.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
#ifndef _BASETRANSPORTSERVER_H_
#define _BASETRANSPORTSERVER_H_
#include "RNPlatform/Inc/DLLExportAPI.h"
#include <map>
#include "RNPlatform/Inc/Encryption.h"
#include "RNPlatform/Inc/ThreadClass.h"
#include "RNPlatform/Inc/Thread.h"
#include "RNXPURL/Inc/Transport.h"
#include "RNPlatform/Inc/MessageHelper.h"
#include "RNLobby/Inc/CommonServer.h"

namespace RNReplicaNet
{

namespace RNLobby
{

// This pragma disables a warning in the Microsoft compiler. This can be safely ignored. See bug ref: C4786
#ifdef _WIN32
#pragma warning(disable : 4786)
#endif

class BaseTransportServer : private CommonServer , public ThreadClass , public Thread
{
public:
    BaseTransportServer();
    virtual ~BaseTransportServer();

    void SetEncryptionKey(const void *data,const int length);

    virtual bool Start(Transport *transport,const bool allowDelete = true,const bool isListen = true);

    virtual bool Stop(void);

    static float FloatTime(void);

    size_t GetNumConnections(void) const;

    bool SetAsDisconnecting(Transport *transport);

protected:
    virtual bool CallbackParseValidMessage(Transport *transport,DynamicMessageHelper &message,const size_t length) { return true; }

    virtual bool PackageAndSendData(Transport *transport,const DynamicMessageHelper &message);

    virtual bool CallbackParsePacketData(Transport *transport,void *data,size_t &length,DynamicMessageHelper &result);

    virtual void CallbackAccepted(Transport *transport) {}

    virtual void CallbackDisconnected(Transport *transport) {}

    virtual void CallbackDataReceived(DynamicMessageHelper &message) {}

    virtual void CallbackDataSend(DynamicMessageHelper &message) {}

    virtual void CallbackQueryReplyTime(const float seconds) {}

    virtual bool CallbackPoll(void) { return true; }

    virtual void CallbackTidy(void) {}

    int ThreadEntry(void);

    void GenerateNewNonce(void);

private:

    struct Entry
    {
        Entry() : mLastPacketTime(0.0f) , mLastPacketsSent(0) , mWaitingForDisconnect(-1.0f) , mError(false) {}
        float mLastPacketTime;
        int mLastPacketsSent;
        float mWaitingForDisconnect;
        bool mError;
    };

    void ThreadExiting(const int returnCode);
    void Tidy(void);

    int RunThink(Transport *transport,Entry &entry);

protected:
    Transport *mTransport;
    bool mAllowDelete;

    int mNOnce;
    std::map<Transport*,Entry> mConnected;

    bool mIsListen;
    bool mClientIsStable;

    Entry mClientEntry;

    size_t mNumConnections;
};

} // namespace RNLobby

} // namespace RNReplicaNet

#endif

---