Router2.h

Go to the documentation of this file.

/*
 *  Original work: Copyright (c) 2014, Oculus VR, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  RakNet License.txt file in the licenses directory of this source tree. An additional grant 
 *  of patent rights can be found in the RakNet Patents.txt file in the same directory.
 *
 *
 *  Modified work: Copyright (c) 2017, SLikeSoft UG (haftungsbeschränkt)
 *
 *  This source code was modified by SLikeSoft. Modifications are licensed under the MIT-style
 *  license found in the license.txt file in the root directory of this source tree.
 */



#include "NativeFeatureIncludes.h"
#if _RAKNET_SUPPORT_Router2==1 && _RAKNET_SUPPORT_UDPForwarder==1

#ifndef __ROUTER_2_PLUGIN_H
#define __ROUTER_2_PLUGIN_H

#include "types.h"
#include "PluginInterface2.h"
#include "PacketPriority.h"
#include "Export.h"
#include "UDPForwarder.h"
#include "MessageIdentifiers.h"
#include "DS_List.h"
#include "SimpleMutex.h"

namespace SLNet
{
class RakPeerInterface;

struct Router2DebugInterface
{
    Router2DebugInterface() {}
    virtual ~Router2DebugInterface() {}
    virtual void ShowFailure(const char *message);
    virtual void ShowDiagnostic(const char *message);
};


class RAK_DLL_EXPORT Router2 : public PluginInterface2
{
public:
    // GetInstance() and DestroyInstance(instance*)
    STATIC_FACTORY_DECLARATIONS(Router2)

    Router2();
    virtual ~Router2();

    void SetSocketFamily(unsigned short _socketFamily);

    void EstablishRouting(RakNetGUID endpointGuid);

    void SetMaximumForwardingRequests(int max);

    void SetDebugInterface(Router2DebugInterface *_debugInterface);

    Router2DebugInterface *GetDebugInterface(void) const;

    // --------------------------------------------------------------------------------------------
    // Packet handling functions
    // --------------------------------------------------------------------------------------------
    virtual PluginReceiveResult OnReceive(Packet *packet);
    virtual void Update(void);
    virtual void OnClosedConnection(const SystemAddress &systemAddress, RakNetGUID rakNetGUID, PI2_LostConnectionReason lostConnectionReason );
    virtual void OnFailedConnectionAttempt(Packet *packet, PI2_FailedConnectionAttemptReason failedConnectionAttemptReason);
    virtual void OnRakPeerShutdown(void);


    enum Router2RequestStates
    {
        R2RS_REQUEST_STATE_QUERY_FORWARDING,
        REQUEST_STATE_REQUEST_FORWARDING,
    };

    struct ConnectionRequestSystem
    {
        RakNetGUID guid;
        int pingToEndpoint;
        unsigned short usedForwardingEntries;
    };

    struct ConnnectRequest
    {
        ConnnectRequest();
        ~ConnnectRequest();

        DataStructures::List<ConnectionRequestSystem> connectionRequestSystems;
        SimpleMutex connectionRequestSystemsMutex;
        Router2RequestStates requestState;
        SLNet::TimeMS pingTimeout;
        RakNetGUID endpointGuid;
        RakNetGUID lastRequestedForwardingSystem;
        bool returnConnectionLostOnFailure;
        unsigned int GetGuidIndex(RakNetGUID guid);
    };

    unsigned int GetConnectionRequestIndex(RakNetGUID endpointGuid);

    struct MiniPunchRequest
    {
        RakNetGUID endpointGuid;
        SystemAddress endpointAddress;
        bool gotReplyFromEndpoint;
        RakNetGUID sourceGuid;
        SystemAddress sourceAddress;
        bool gotReplyFromSource;
        SLNet::TimeMS timeout;
        SLNet::TimeMS nextAction;
        unsigned short forwardingPort;
        __UDPSOCKET__ forwardingSocket;
    };

    struct ForwardedConnection
    {
        RakNetGUID endpointGuid;
        RakNetGUID intermediaryGuid;
        SystemAddress intermediaryAddress;
        bool returnConnectionLostOnFailure;
        bool weInitiatedForwarding;
    };

protected:

    bool UpdateForwarding(ConnnectRequest* connectionRequest);
    void RemoveConnectionRequest(unsigned int connectionRequestIndex);
    void RequestForwarding(ConnnectRequest* connectionRequest);
    void OnQueryForwarding(Packet *packet);
    void OnQueryForwardingReply(Packet *packet);
    void OnRequestForwarding(Packet *packet);
    void OnRerouted(Packet *packet);
    void OnMiniPunchReply(Packet *packet);
    void OnMiniPunchReplyBounce(Packet *packet);
    bool OnForwardingSuccess(Packet *packet);
    int GetLargestPingAmongConnectedSystems(void) const;
    void ReturnToUser(MessageID messageId, RakNetGUID endpointGuid, const SystemAddress &systemAddress, bool wasGeneratedLocally);
    bool ConnectInternal(RakNetGUID endpointGuid, bool returnConnectionLostOnFailure);

    UDPForwarder *udpForwarder;
    int maximumForwardingRequests;
    SimpleMutex connectionRequestsMutex, miniPunchesInProgressMutex, forwardedConnectionListMutex;
    DataStructures::List<ConnnectRequest*> connectionRequests;
    DataStructures::List<MiniPunchRequest> miniPunchesInProgress;
    // Forwarding we have initiated
    DataStructures::List<ForwardedConnection> forwardedConnectionList;

    void ClearConnectionRequests(void);
    void ClearMinipunches(void);
    void ClearForwardedConnections(void);
    void ClearAll(void);
    int ReturnFailureOnCannotForward(RakNetGUID sourceGuid, RakNetGUID endpointGuid);
    void SendFailureOnCannotForward(RakNetGUID sourceGuid, RakNetGUID endpointGuid);
    void SendForwardingSuccess(MessageID messageId, RakNetGUID sourceGuid, RakNetGUID endpointGuid, unsigned short sourceToDstPort);
    void SendOOBFromRakNetPort(OutOfBandIdentifiers oob, BitStream *extraData, SystemAddress sa);
    void SendOOBFromSpecifiedSocket(OutOfBandIdentifiers oob, SystemAddress sa, __UDPSOCKET__ socket);
    void SendOOBMessages(MiniPunchRequest *mpr);

    Router2DebugInterface *debugInterface;
    unsigned short socketFamily;
};

}

#endif

#endif // _RAKNET_SUPPORT_*