AdvertiseClient.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 _ADVERTISECLIENT_H_
#define _ADVERTISECLIENT_H_
#include "RNPlatform/Inc/DLLExportAPI.h"
#include "RNLobby/Inc/BaseTransportServer.h"
#include "RNXPSockets/Inc/XPSocket.h"
#include "RNLobby/Inc/UserClient.h"
#include <list>

namespace RNReplicaNet
{

namespace RNLobby
{

class AdvertiseClient : public BaseTransportServer
{
public:
    AdvertiseClient();
    virtual ~AdvertiseClient();

    bool Start(void);

    bool StartLAN(void);

    void SetServer(const XPAddress &address);

    bool AdvertiseSession(const char *url,const char *userData = "");

    bool RulesChanged(void);

    bool PlayersChanged(void);

    bool StopAdvertiseSession(void);

    bool GetListings(const size_t maxResults = 10,const size_t offset = 0,const char *filter = 0);

    bool StopListings(void);

    bool RequestRules(const int serverIndex);

    bool RequestPlayers(const int serverIndex);

    bool RequestLatency(const int serverIndex);

    bool GetAnyActivePings(void) const;

    bool AddRule(const char *rule,const char *userData = "");

    bool AddPlayer(const char *name,const char *userData = "",const int loginID = UserInfo::kAnyLoginID);

    bool SendReliableMessage(const int serverIndex,const void *data,const int length);

protected:


    virtual void CallbackConnectionEstablished(Transport *transport) {}

    virtual void CallbackWantRules(void) {}

    virtual void CallbackWantPlayers(void) {}

    virtual void CallbackGotServerIndex(const int serverIndex) {}

    virtual void CallbackListingsBegin(void) {}

    virtual void CallbackListingsEntry(const int serverIndex,const int hostLoginID,const char *url, const char *userData, const float age, const XPAddress &address) {}

    virtual void CallbackListingsComplete(void) {}

    virtual void CallbackRulesBegin(const int serverIndex) {}

    virtual void CallbackRule(const int serverIndex,const char *rule, const char *userData) {}

    virtual void CallbackRulesComplete(const int serverIndex) {}

    virtual void CallbackPlayersBegin(const int serverIndex) {}

    virtual void CallbackPlayer(const int serverIndex,const char *name, const char *userData, const int loginID) {}

    virtual void CallbackPlayersComplete(const int serverIndex) {}

    virtual void CallbackLatencyTo(const int serverIndex,const float latency,const float packetLossPercent) {}

    virtual void CallbackMessageReceived(const int sourceLoginID,const void *data,const int length) {}

protected:
    // These callbacks from BaseTransportServer are implemented by this class. If they are implemented by the user this implementation must be called.
    void CallbackTidy(void);

    bool CallbackPoll(void);

    bool CallbackParseValidMessage(Transport *transport,DynamicMessageHelper &message,const size_t length);

    XPAddress mServerAddress;

    bool mIsAdvertising;

    std::string mCurrentURL;
    std::string mCurrentUserData;

    bool mDoingListing;

    bool mWantRules;
    bool mDoingRules;

    bool mWantPlayers;
    bool mDoingPlayers;

    XPSocketUrgent *mBroadcast;
//  int mSerial;
    std::string mBroadcastURL;                      // Protected by the mutex
    std::string mBroadcastData;                     // Protected by the mutex
    std::map<int,XPAddress> mGotReplyFrom;          // Protected by the mutex
    int mBroadcastServerID;
    XPAddress mCurrentReply;
    int mCurrentNOnce;
    float mRequestListingTime;
    std::list<std::pair<float,int> > mRequestRulesTimes;    // Protected by the mutex
    std::list<std::pair<float,int> > mRequestPlayersTimes;  // Protected by the mutex

    struct ServerInfo
    {
        ServerInfo();

        void StartLatencyCalculate(void);

        // If the latency has not been calculated then it returns a value less than 0.0f
        float GetLatency(void);

        float GetPacketLoss(void);

        std::string mURL;
        std::string mData;
        int mLoginID;
        XPAddress mExternalIP;
        bool mWantPing;
        size_t mPingTries;
        float mLastPingSentTime;
        size_t mPacketsLost;
        size_t mReplies;
        float mTotalRoundTripTime;
        bool mPingAcked;
    };

    class PingServer : public ThreadClass , public Thread
    {
    public:
        PingServer();
        ~PingServer();

        std::map<int,ServerInfo> mLocalServerInfo;      // Protected by the mutex
        std::multimap<XPAddress,int> mServerIndexByAddress; // Protected by the mutex
        std::list<int> mServerIDsPingFinished;          // Protected by the mutex
        bool mAnyActivePings;

        int ThreadEntry(void);

    private:
        void ThreadExiting(const int returnCode);

        t_XPSocket *mPingSocket;
    };

    PingServer mPingServer;

    bool mServerAddressSet;
};

} // namespace RNLobby

} // namespace RNReplicaNet

#endif

---