TransportNATUDP.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 __TRANSPORTNATUDP_H__
#define __TRANSPORTNATUDP_H__
#include "RNXPURL/Inc/Transport.h"
#include "RNXPSockets/Inc/XPSocket.h"

namespace RNReplicaNet
{

namespace RNLobby
{

class TransportNATUDP : public Transport
{
public:
    TransportNATUDP();

    virtual ~TransportNATUDP();

    // Optional implementation of Transport virtual functions.
    int GetPacketsSent(const bool reset);

    int GetPacketsSentMerged(const bool reset);

    int GetPacketsSentSize(const bool reset);

    int GetPacketsReceived(const bool reset);

    int GetPacketsReceivedMerged(const bool reset);

    int GetPacketsReceivedSize(const bool reset);

    int GetPacketsLost(const bool reset);

    void SetBandwidthLimit(const Bandwidth enable);

    Bandwidth GetBandwidthLimit();

    void SetMaximumOutputBandwidth(const int bytesPerSecond);

    int GetMaximumOutputBandwidth(void);

    void SetMaximumInputBandwidth(const int bytesPerSecond);

    int GetMaximumInputBandwidth(void);

    std::string GetPeerURL(void);

    bool GetTransportClosed(void);

    void SetEnableLANDiscovery(const bool enable);

    bool GetEnableLANDiscovery(void);

    // These pure virtual functions are the minimum feature set the transport has to support.

    std::string CanAccept(void);

    std::string CanRoute(void);

    std::string ExportURL(void);

    Transport *Allocate(void);

    Error Listen(const int channel);

    Error Listen(const std::string &address);

    void CommonListen(void);

    Error Connect(const std::string address);

    Transport *Accept(void);

    Error Send(const char *data,const int len);

    Error SendOrdered(const char *data,const int len,const unsigned int band = 0);

    Error SendReliable(const char *data,const int len,const unsigned int band = 0);

    Error SendCertain(const char *data,const int len);

    int Recv(char *const data,const int maxlen);

    int GetMaxPacketSize(void);

    std::string HandleDiscovery(void);

    void HandleDiscoveryReply(const std::string reply);

    void BeginDiscovery(void);

    std::string GetNextDiscovery(void);

    Error GetStatus(void);

    void SetBaseTransport(Transport *baseTransport);

    // Extension API for this transport type. Normally this wouldn't need to be used.
    bool SetNATValues(const bool isAdvertised,const int globalID,const int sessionID);
    void GetNATValues(bool &isAdvertised,int &globalID,int &sessionID);

    static void SetServer(const XPAddress &address);
    static void ClearServer(void);


private:
friend class MyNATResolver;
    void SetError(void);

    bool mAllocated;
    Transport *mBaseTransport;
    bool mIsResolved;
    int mMyNOnceUsed;
    bool mKnowExternalAddress;
    XPAddress mExternalAddress;
    bool mIsListen;
    bool mIsUsed;

    bool mStateIsAdvertised;
    int mStateGlobalID;
    int mStateSessionID;
//  bool mBeginResolveCalled;
//  SysTime mBeginResolveCalledTime;
};

} // namespace RNLobby

} // namespace RNReplicaNet

#endif