NatPunchthroughClient.h

Go to the documentation of this file.

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

#ifndef __NAT_PUNCHTHROUGH_CLIENT_H
#define __NAT_PUNCHTHROUGH_CLIENT_H

#include "RakNetTypes.h"
#include "Export.h"
#include "PluginInterface2.h"
#include "PacketPriority.h"
#include "SocketIncludes.h"
#include "DS_List.h"
#include "RakString.h"

// Trendnet TEW-632BRP sometimes starts at port 1024 and increments sequentially.
// Zonnet zsr1134we. Replies go out on the net, but are always absorbed by the remote router??
// Dlink ebr2310 to Trendnet ok
// Trendnet TEW-652BRP to Trendnet 632BRP OK
// Trendnet TEW-632BRP to Trendnet 632BRP OK
// Buffalo WHR-HP-G54 OK
// Netgear WGR614 ok

class RakPeerInterface;
struct Packet;
#if _RAKNET_SUPPORT_PacketLogger==1
class PacketLogger;
#endif

struct RAK_DLL_EXPORT PunchthroughConfiguration
{
        PunchthroughConfiguration() {
                TIME_BETWEEN_PUNCH_ATTEMPTS_INTERNAL=15;
                TIME_BETWEEN_PUNCH_ATTEMPTS_EXTERNAL=50;
                UDP_SENDS_PER_PORT_INTERNAL=2;
                UDP_SENDS_PER_PORT_EXTERNAL=8;
                INTERNAL_IP_WAIT_AFTER_ATTEMPTS=30;
                MAXIMUM_NUMBER_OF_INTERNAL_IDS_TO_CHECK=5; 
                MAX_PREDICTIVE_PORT_RANGE=2;
                EXTERNAL_IP_WAIT_BETWEEN_PORTS=100;
                EXTERNAL_IP_WAIT_AFTER_ALL_ATTEMPTS=EXTERNAL_IP_WAIT_BETWEEN_PORTS;
                retryOnFailure=false;
        }

        RakNetTimeMS TIME_BETWEEN_PUNCH_ATTEMPTS_INTERNAL;
        RakNetTimeMS TIME_BETWEEN_PUNCH_ATTEMPTS_EXTERNAL;

        int UDP_SENDS_PER_PORT_INTERNAL;
        int UDP_SENDS_PER_PORT_EXTERNAL;

        int INTERNAL_IP_WAIT_AFTER_ATTEMPTS;

        int MAX_PREDICTIVE_PORT_RANGE;

        int EXTERNAL_IP_WAIT_BETWEEN_PORTS;

        int EXTERNAL_IP_WAIT_AFTER_ALL_ATTEMPTS;

        int MAXIMUM_NUMBER_OF_INTERNAL_IDS_TO_CHECK;

        bool retryOnFailure;
};

struct NatPunchthroughDebugInterface
{
        NatPunchthroughDebugInterface() {}
        virtual ~NatPunchthroughDebugInterface() {}
        virtual void OnClientMessage(const char *msg)=0;
};

struct NatPunchthroughDebugInterface_Printf : public NatPunchthroughDebugInterface
{
        virtual void OnClientMessage(const char *msg);
};

#if _RAKNET_SUPPORT_PacketLogger==1

struct NatPunchthroughDebugInterface_PacketLogger : public NatPunchthroughDebugInterface
{
        // Set to non-zero to write to the packetlogger!
        PacketLogger *pl;

        NatPunchthroughDebugInterface_PacketLogger() {pl=0;}
        ~NatPunchthroughDebugInterface_PacketLogger() {}
        virtual void OnClientMessage(const char *msg);
};
#endif

class RAK_DLL_EXPORT NatPunchthroughClient : public PluginInterface2
{
public:
        NatPunchthroughClient();
        ~NatPunchthroughClient();

        bool OpenNAT(RakNetGUID destination, SystemAddress facilitator);

        PunchthroughConfiguration* GetPunchthroughConfiguration(void);

        void SetDebugInterface(NatPunchthroughDebugInterface *i);

        unsigned short GetUPNPExternalPort(void) const;

        unsigned short GetUPNPInternalPort(void) const;

        RakNet::RakString GetUPNPInternalAddress(void) const;

        virtual void Update(void);

        virtual PluginReceiveResult OnReceive(Packet *packet);

        virtual void OnNewConnection(SystemAddress systemAddress, RakNetGUID rakNetGUID, bool isIncoming);

        virtual void OnClosedConnection(SystemAddress systemAddress, RakNetGUID rakNetGUID, PI2_LostConnectionReason lostConnectionReason );

        virtual void OnAttach(void);
        virtual void OnDetach(void);
        virtual void OnRakPeerShutdown(void);
        void Clear(void);

protected:
        unsigned short mostRecentNewExternalPort;
        void OnGetMostRecentPort(Packet *packet);
        void OnConnectAtTime(Packet *packet);
        unsigned int GetPendingOpenNATIndex(RakNetGUID destination, SystemAddress facilitator);
        void SendPunchthrough(RakNetGUID destination, SystemAddress facilitator);
        void SendTTL(SystemAddress sa);
        void SendOutOfBand(SystemAddress sa, MessageID oobId);
        void OnPunchthroughFailure(void);
        void OnReadyForNextPunchthrough(void);
        void PushFailure(void);
        bool RemoveFromFailureQueue(void);
        void PushSuccess(void);
        //void ProcessNextPunchthroughQueue(void);

        /*
        struct PendingOpenNAT
        {
                RakNetGUID destination;
                SystemAddress facilitator;
        };
        DataStructures::List<PendingOpenNAT> pendingOpenNAT;
        */

        struct SendPing
        {
                RakNetTime nextActionTime;
                SystemAddress targetAddress;
                SystemAddress facilitator;
                SystemAddress internalIds[MAXIMUM_NUMBER_OF_INTERNAL_IDS];
                RakNetGUID targetGuid;
                bool weAreSender;
                int attemptCount;
                int retryCount;
                int punchingFixedPortAttempts; // only used for TestMode::PUNCHING_FIXED_PORT
                uint16_t sessionId;
                // Give priority to internal IP addresses because if we are on a LAN, we don't want to try to connect through the internet
                enum TestMode
                {
                        TESTING_INTERNAL_IPS,
                        WAITING_FOR_INTERNAL_IPS_RESPONSE,
                        TESTING_EXTERNAL_IPS_FROM_FACILITATOR_PORT,
                        TESTING_EXTERNAL_IPS_FROM_1024,
                        WAITING_AFTER_ALL_ATTEMPTS,

                        // The trendnet remaps the remote port to 1024.
                        // If you continue punching on a different port for the same IP it bans you and the communication becomes unidirectioal
                        PUNCHING_FIXED_PORT,

                        // try port 1024-1028
                } testMode;
        } sp;

        PunchthroughConfiguration pc;
        NatPunchthroughDebugInterface *natPunchthroughDebugInterface;

        // The first time we fail a NAT attempt, we add it to failedAttemptList and try again, since sometimes trying again later fixes the problem
        // The second time we fail, we return ID_NAT_PUNCHTHROUGH_FAILED
        struct AddrAndGuid
        {
                SystemAddress addr;
                RakNetGUID guid;
        };
        DataStructures::List<AddrAndGuid> failedAttemptList;
};

#endif

#endif // _RAKNET_SUPPORT_*