CodeServer.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 _CODESERVER_H_
#define _CODESERVER_H_
#include "RNPlatform/Inc/SysTime.h"
#include "RNPlatform/Inc/RegistryManagerMap.h"
#include "RNPlatform/Inc/Encryption.h"
#include "RNPlatform/Inc/ThreadClass.h"
#include "RNPlatform/Inc/Thread.h"
#include "RNXPSockets/Inc/XPSockets.h"
#include <string.h>

namespace RNReplicaNet
{

namespace RNLobby
{

class CodeServer : private ThreadClass , private Thread
{
public:
    class CodeEntry
    {
    public:
        struct ThisLess
        {
            bool operator()(const std::string &s1, const std::string &s2) const;
        };
        CodeEntry();

        // ctor variables
        XPAddress mLastAddress;
        SysTimeType mLastTime;
        int mUserSuppliedReply;
        int mLastNOnce1,mLastNOnce2;

        // ctor body variables
        std::string mTheCode;
    };

    enum Reply
    {
        kReply_ValidKey = 0,
        kReply_UnspecifiedError,
        kReply_InvalidKey,
        kReply_KeyInUse,
        kReply_Timeout,
        kReply_CorruptReply
    };
    enum
    {
        kDefaultPort = 4003
    };


    CodeServer();
    virtual ~CodeServer();

    bool ReadCodeFile(const char *filename, const bool duplicateCodeCheck = false);

    bool AddCode(const char *code, const bool duplicateCodeCheck = false,const int userSuppliedReply = 0);

    bool RemoveCode(const char *code = 0);

    bool Start(const XPAddress &address = XPAddress(kDefaultPort));

    bool Stop(bool hardware = false);

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

    void SetCodeTimeout(const float time = (60.0f * 30.0f));

    float GetCodeTimeout(void) const;

    virtual void CallbackDataReceived(void *data,int &length,const int maxLength,XPAddress &address) {}

    virtual void CallbackVersion(const int version) {}

    virtual void CallbackKeyData(char *keyData,const int maxLength,int &nOnce1,int &nOnce2,bool &updateDatabase) {}

    virtual void CallbackQueryReply(Reply &reply,int &userSuppliedReply,int &nOnce1,int &nOnce2) {}

    virtual void CallbackDataSend(void *data,int &length,const int maxLength,XPAddress &address) {}

    virtual void CallbackQueryReplyTime(const float seconds) {}

    int GetNumRequests(void) const;

    int GetNumFailed(void) const;

private:
    int ThreadEntry(void);

protected:
    RegistryManagerMap<std::string,CodeEntry,CodeEntry::ThisLess> mCodes;
    MutexClass mCodesMutex;
private:
    XPSocketUrgent *mListen;

    Encryption::Key mCryptoKey;
    float mCodeTimeout;
    int mNumRequests;
    int mNumFailed;
};

} // namespace RNLobby

} // namespace RNReplicaNet

#endif