NATResolver.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 _NATSERVER_H_
#define _NATSERVER_H_
#include "RNPlatform/Inc/DLLExportAPI.h"
#include "RNPlatform/Inc/MessageHelper.h"
#include "RNPlatform/Inc/Encryption.h"
#include "RNPlatform/Inc/ThreadClass.h"
#include "RNPlatform/Inc/Thread.h"
#include "RNXPSockets/Inc/XPSocket.h"
#include "RNPlatform/Inc/SysTime.h"
#include <set>
#include <list>

namespace RNReplicaNet
{

namespace RNLobby
{

class NATResolver : private ThreadClass , private Thread , private SysTime
{
public:
    NATResolver();
    virtual ~NATResolver();

    enum
    {
        kDefaultPort = 3001
    };

    bool Start(void);

    bool Stop(void);

    void SetAutomaticThreadStop(const bool allow = true);

    void SetAutomaticHostSocketReads(const bool allow = false);

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

    bool BeginHosting(t_XPSocket *socket);

    bool BeginAdvertise(t_XPSocket *socket,void *userPointer,const bool isAdvertised,const int globalID,const int sessionID,const int nonceID,const bool externalHost = true,const XPAddress *optionalHost=0,const bool persistant = false);

    bool BeginResolve(t_XPSocket *socket,void *userPointer,const bool isAdvertised,const int globalID,const int sessionID,const int nonceID,const bool tryExternalHost = true,const XPAddress *optionalHost=0,const XPAddress *optionalFirstTargetTry=0);

    void ForgetSocket(const t_XPSocket *socket);

    void ForgetUserPointer(const void *userPointer);

    void ForgetResolve(t_XPSocket *socket,const bool isAdvertised,const int globalID,const int sessionID,const int nonceID);

    bool CallbackParsePacketData(t_XPSocket *socket,const XPAddress &addr,void *data,size_t length);

    void SetServer(const XPAddress &address);

    virtual void CallbackResolveResult(t_XPSocket *socket,void *userPointer,const XPAddress &targetAddress,const int titleID,const bool isAdvertised,const int globalID,const int sessionID,const int nonceID);

    virtual void CallbackExternalAddressKnown(t_XPSocket *socket,void *userPointer,const XPAddress &externalAddress,const int titleID,const bool isAdvertised,const int globalID,const int sessionID,const int nonceID);

private:
    int ThreadEntry(void);

protected:

private:
    class NATState;
    class PerHostState;

    bool InsertState(NATState *state);
    void DeleteState(NATState * &state);
    bool PackageAndSendData(t_XPSocket *socket,const DynamicMessageHelper &message,const XPAddress &address);

    Encryption::Key mCryptoKey;
    t_XPSocket *mHost;

    // Compare funcs
    struct ltSocket
    {
        bool operator()(const NATState *a,const NATState *b) const;
    };

    struct ltIDs
    {
        bool operator()(const NATState *a,const NATState *b) const;
    };

    struct ltIDsWithSocket
    {
        bool operator()(const NATState *a,const NATState *b) const;
    };

    struct ltUserPointer
    {
        bool operator()(const NATState *a,const NATState *b) const;
    };

    std::multiset<NATState *,ltSocket> mSetBySocket;
    std::set<NATState *,ltIDs> mSetByIDs;               // There must be only one for each ID setting. Used mostly for advertised resolves.
    std::set<NATState *,ltIDsWithSocket> mSetByIDsWithSocket;               // There must be only one for each ID setting.
    std::multiset<NATState *,ltUserPointer> mSetByUserPointer;
    std::list<NATState *> mListByOrder;

    bool BuildAndSendAdvertisePacket(DynamicMessageHelper &message,NATState *state,PerHostState &hostState);

    bool mIsEmpty;
    float mBecameEmptyAt;
    bool mAllowAutoThreadStop;
    bool mAllowAutoHostSocketReads;

    XPAddress mServerAddress;
    bool mServerAddressSet;
};

} // namespace RNLobby

} // namespace RNReplicaNet

#endif

---