XPSession.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 */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef __XPSESSION_H__
#define __XPSESSION_H__

#define _XPSESSION_VERSION 7200

#include <string>
#include <vector>
#include <list>
#include <map>
#include "RNXPSession/Inc/XPSession.h"
#include "RNXPURL/Inc/XPURL.h"
#include "RNXPURL/Inc/Transport.h"
#include "RNPlatform/Inc/MessageHelper.h"
#include "RNPlatform/Inc/ThreadClass.h"
#include "RNPlatform/Inc/SysTime.h"

namespace RNReplicaNet
{

const int kPingHistorySize = 5;

class Thread;

struct SessionPacket_Header
{
    short mDestinationSession;              
    short mSourceSession;                   
    unsigned char mPacketTypeAndChecksum;   
                                            /*  The top 4 bits are a checksum produced from the data in the packet */
};

class XPSessionInternalBufferedPacket
{
public:
    XPSessionInternalBufferedPacket(const int sessionid,const char *data,const int length,const bool reliable,const bool certain,const bool ordered,const unsigned int band);
    ~XPSessionInternalBufferedPacket();

    int mSessionID;
    char *mData;
    int mLength;
    bool mReliable;
    bool mCertain;
    bool mOrdered;
    unsigned int mBand;
};

const int kXPSessionUnknownID = -1;
const int kXPSessionBroadcastID = -2;

/* These are the internal message types for session messages */
const unsigned char kXPSessionPacketType_Unreliable             = 0;
const unsigned char kXPSessionPacketType_Reliable               = 1;
const unsigned char kXPSessionPacketType_Certain                = 2;
const unsigned char kXPSessionPacketType_Ordered                = 3;

class XPSession : public XPURL , public MessageHelper, public ThreadClass , private SysTime
{
public:

    enum Error
    {
        kXPSession_EOK = 0,                     
        kXPSession_EERROR = -1,                 
        kXPSession_ETRANSPORT_CLOSED = -2,
        kXPSession_ETRANSPORT_ERROR = -3
    };

    XPSession();

    virtual ~XPSession();

    static XPSession *Allocate(void);

    void Create(const std::string name);

    void Create(const std::string name,const std::string protocols);

    std::string ExportURL(const bool shortAddress = true);

    void Join(const std::string url);

    void Find(void);

    void Find(const std::string protocols);

    std::string EnumerateFound(void);

    int GetGameChannel(void);

    void SetGameChannel(const int channel = TransportAnyGameChannel);

    int GetSessionID(void);

    bool IsStable(void);

    Error GetStatus(void);

    Error GetSessionErrorReason(void);

    void DataSendToSession(const int sessionid,const char *data,const int length,const bool reliable = true,const bool certain = false,const bool ordered = false,const unsigned int band = 0);

    void DataSendToSessionUnreliable(const int sessionid,const char *data,const int length);

    void DataSendToSessionOrdered(const int sessionid,const char *data,const int length,const unsigned int band = 0);

    void DataSendToSessionReliable(const int sessionid,const char *data,const int length,const unsigned int band = 0);

    void DataSendToSessionCertain(const int sessionid,const char *data,const int length);

    bool DataReceivePeek(int *const fromsessionid,int *const length,unsigned char *const type = 0);

    bool DataReceive(int *const fromsessionid,char *const data,int *const length,unsigned char *const type = 0);

    bool IsMaster(void);

    int GetJoiner(void);

    int GetLeaver(void);

    SysTimeType GetTime(void);

    SysTimeType GetLocalTime(void);

    float GetNetworkSendRate(void);

    float GetNetworkReceiveRate(void);

    int GetNetworkPacketsLost(void);

    int GetNetworkPacketsRejected(void);

    void Poll(void);

    void SetPollLayerBelow(bool enable = true);

    bool GetPollLayerBelow(void);

    void SetManualPoll(void);

    void SetAutomaticPoll(void);

    void SetManualPollXPURL(void);

    void SetAutomaticPollXPURL(void);


    void SetCanSpider(const bool canSpider = true);

    bool GetCanSpider(void);

    void SetCanBecomeMaster(const bool canBeMaster = true);

    bool GetCanBecomeMaster(void);

    float GetLatencyToMasterSession(void);

    float GetLatencyToSessionID(const int sessionID);

    void SetLatencyRecalculationDelay(const float seconds = 1.0f);

    void SetEncryption(const bool enable = false);

    bool GetEncryption(void);


    void Disconnect(const int sessionID = kXPSessionUnknownID);

    bool GetPreConnectStatus(void);

    void SetPreConnect(const bool enable = false);

    bool GetPreConnect(void);

    void PreConnectHasFinished(void);

    void SetAutomaticPacketCompression(const bool enable = false);

    bool GetAutomaticPacketCompression(void);

    void GetCompressionStatistics(int *const before=0,int *const after=0,const bool reset = false);

    void GetMergedStatistics(int *const sent=0,int *const received=0,const bool reset = false);

    int GetMasterSessionID(void);

    std::string GetURLFromSessionID(const int sessionID);

    void SetClientOnly(const bool isClient = false);

    bool GetClientOnly(void);

    bool GetBandwidthFromSessionID(const int sessionID,Transport::Bandwidth *const bandwidth,int *const output,int *const input);

    void SetAllowConnections(const bool allow = true);

    bool GetAllowConnections(void);

    void SetNodeBuffers(const bool enable = false);

    bool GetNodeBuffers(void);

    typedef int GetSessionIDCallback(void *context);

    void RegisterSessionIDCallback(GetSessionIDCallback *callback = 0,void *context=0);


    void SetProxyMode(const bool enable = false);

    bool GetProxyMode(void);

    void SetMaximumDataSize(const int bytes = 64*1024);
    int GetMaximumDataSize(void) const;

    void SetPacketCompressionLevel(const int level = 10);
    void SetLargePacketCompressionLevel(const int level = 5);

    int GetPacketCompressionLevel(void) const;
    int GetLargePacketCompressionLevel(void) const;

    void SetTransparentPacketCompression(const int level = 0);

    int GetTransparentPacketCompression(void);

private:
struct Route;
friend struct Route;
// Variables in initialiser
    int mGameChannel;
    int mSessionID;
    Error mStatus;
    bool mIsMaster;
    int mMasterSessionID;       
    Thread *mThread;
    int mBufferLen;
    char *mMessageBufferIn;
    char *mMessageBufferOut;
    float mCurrentSendRate;
    float mCurrentRecvRate;
    SysTimeType mLastRateCalcTime;
    bool mCanSpider;
    bool mCanBeMaster;
    bool mCompletelyStable;
    bool mTryingJoin;
    SysTimeType startPollTime;
    SysTimeType mLocalTimeStartPollTime;
    int mPotentialMasterSessionID;  
    int mNoticedHighestSessionID;
    bool mManualPoll;
    bool mEncryptionOn;
    bool mPollLayerBelow;
    bool mEnablePreConnect;


// End of initialiser variables
    std::vector<Transport *> mMasterListens;    
    std::vector<Transport *> mListens;          
    std::list<Route *> mConnections;            
    std::multimap<int,Route *> mConnectionsBySessionID; 
    std::vector<Transport *> mFindTransports;   
    std::string mSessionName;

    int mNextSessionID;                         
    struct WaitingPacket
    {
        WaitingPacket()
        {
            mFromSession = kXPSessionUnknownID;
            mPacket = 0;
            mSize = 0;
            mPacketType = kXPSessionPacketType_Unreliable;
        }

        virtual ~WaitingPacket()
        {
            if (mPacket)
            {
                free (mPacket);
                mPacket = 0;
            }
        }

        int mFromSession;
        int mSize;
        char *mPacket;
        unsigned char mPacketType;
    };

    std::list<WaitingPacket *> mWaitingPackets;

    std::list<int> mJoiners;
    std::list<int> mLeavers;

    // When the session master disconnects then any routes that have errors are pushed on to the potential leaver list
    std::list<int> mPotentialLeavers;


    SysTimeType mZeroTime;
    float mZeroTimeDelta;
    SysTimeType mLastTimeCorrectionTime;
    SysTimeType mTargetZeroTime;


    bool mBreakoutDone;
    bool mDontDoBreakOut;

    float mLatencyRecalculationDelay;

    bool mInPreConnect;
    bool mPreConnectSignalDone;
    int mPreConnectSendToID;

    bool mCreateOrJoinDone;

    bool mEnableAutomaticCompression;
    int mCompressionBefore;
    int mCompressionAfter;

    bool mIsClientOnly;
    bool mTransportDisconnected;
    bool mTransportError;

    bool mAllowConnections;

    int mNetworkPacketsLost;
    int mNetworkPacketsRejected;

    bool mEnableExtraBuffering;
    void HandleWaitingToSendPackets(void);
    MutexClass mMutexSentPackets;
    int mNumWaitingToSend;
    std::list<XPSessionInternalBufferedPacket*> mWaitingToSend;
    MutexClass mMutexRecvPackets;
    MutexClass mMutexJoinerList;
    MutexClass mMutexLeaverList;
    // A mutex for locking misc values that are buffered below
    MutexClass mMutexMiscValues;

    // Return values that are locked against mMutexMiscValues
    std::string mReturnExportURLTrue;
    std::string mReturnExportURLFalse;
    std::map<int,std::string> mBufferedURLsBySessionID;
    std::map<int,float> mBufferedLatencyBySessionID;

    XPSession::GetSessionIDCallback *mGetSessionIDCallback;
    void *mGetSessionIDCallbackContext;

    bool mProxyMode;
    bool mMasterIsProxyMode;

    // Private functions that mutex lock the main class
    std::string BufferedExportURL(const bool shortAddress);
    int BufferedGetNetworkPacketsLost(void);

    void MutateToMaster(const int nextsessionid,const Route *route);

    // This just exports the transport URLs and not the session name. Used by the spider to code.
    std::string ExportURLInternal(const bool ShortAddress = true);

    std::string GetSessionString(void);

    Route *FindRouteForSessionIDFromMap(const int sessionID);

    bool Initialise(void);


    void DataSendToSessionPrivate(const int sessionid,const char *data,const int length,const bool reliable = true,const bool certain = false,const bool ordered = false,const unsigned int band = 0);
    void DataPacketSendPrivate(const int finalDestID,const char *data,const int length,const bool reliable,const bool certain,const bool ordered,const unsigned int band,Route *route);

    void InternalSendMessage(Route *routed, const SessionPacket_Header &message,const int length);
    bool ParsePacket(Route *const route,int length);

    std::string AppendSessionInfo(std::string instr);


    void HandleTransportDiscovery(Transport *const trans);
    int ThreadEntry(void);

    // Compress and encrypt session packets are two very similar functions.
    // They both act on the current message buffer only and modify the message header.
    void CompressSessionPacket(SessionPacket_Header &message);
    void EncryptSessionPacket(SessionPacket_Header &message);

    void AddJoiner(const int sessionid);
    void AddLeaver(const int sessionid);

    void CreateBufferedURL(void);

    int mMaximumDataSize;
    int mPacketCompressionLevel;
    int mLargePacketCompressionLevel;

    int mTransparentPacketCompression;
};

} // namespace RNReplicaNet

#endif