cNetAddrTracker.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cNetAddrTracker_H
#define _INC_cNetAddrTracker_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNetAddr.h"
#include "cNetHostRange.h"
#include "GrayCore/include/cTimeInt.h"
#include "GrayCore/include/cThreadLockRef.h"
#include "GrayCore/include/cThreadArray.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cNetAddrTracker);
 
        class cClientAddrObj;   // persisting def record. will be defined some time later.
 
        class GRAYLIB_LINK cNetAddrTracker : public cThreadLockableRef // cRefBase IUnknown
        {
 
                friend class cClientAddrObj;            
 
        public:
                static const TIMESECD_t k_PING_WINDOW_LEN = (5 * 60);   // seconds
                static const int k_PINGS_PER_WINDOW = 5 * 10;
                static const TIMESECD_t k_BLOCK_LEN = (60);     // seconds to block for some bad action.
 
                cNetAddress m_addr;                     
                cStringA m_sIPHost;                     
                cStringA m_sDescription;        
                bool m_bTrusted;                        
 
        protected:
                cTimeInt m_timeCreated;         
                cTimeInt m_timeDecay;           
                cTimeInt m_timeBlockTil;        
                cTimeInt m_timeWindowStart;     
                cTimeInt m_timeLastEvent;       
 
                // Track normal but excessive and anti social/hacking behaviors.
                int m_iPings;                   
                int m_iBadPasswords;    
 
                cRefBasePtr m_pAccount; 
 
        public:
                cNetAddrTracker(const cNetAddress& addr);
                virtual ~cNetAddrTracker();
 
                cString get_Name() const
                {
                        return cString(m_addr.get_HostStr());
                }
                HASHCODE_t get_HashCode() const noexcept
                {
                        return m_addr.get_HashCode();
                }
 
                cStringA get_DescString() const;
                bool LookupHostName();
 
                HRESULT DisposeThis();
 
                bool IsNeverDecay() const;
                void BumpDecayTimeSec(TIMESECD_t iSeconds);
 
                bool IsBlocked() const;
                bool SetBlocked(TIMESECD_t iTimeDecaySeconds, const char* pszReason);
 
                bool onTickAddr(int iRefCount);
 
                int get_Pings() const
                {
                        return m_iPings;
                }
 
                bool IncPingBlock(bool bPreAccept = false);
                bool IncBadPassword(const char* pszAttackedAccountName);
 
                void put_Account(cRefBase* pAccount)
                {
                        m_iPings = 0;
                        m_iBadPasswords = 0;
                        m_pAccount = pAccount;
                }
                cRefBasePtr get_Account() const
                {
                        return m_pAccount;      // associate this with a CAccount.
                }
        };
 
        typedef cRefPtr<cNetAddrTracker> cNetAddrTrackPtr;      
 
        class GRAYLIB_LINK cNetAddrMgr
                : public cSingleton<cNetAddrMgr>
                , public cThreadLockArrayHash<cNetAddrTracker>  // overload this so i can mess with protected stuff.
        {
 
                friend class cSingleton<cNetAddrMgr>;
                CHEAPOBJECT_IMPL;
 
        protected:
                cNetAddrMgr();
                ~cNetAddrMgr();
 
        public:
                ITERATE_t AddLogAddr(cNetAddrTracker* pClientAddr)
                {
                        return this->Add(pClientAddr);
                }
                bool RemoveLogAddr(cNetAddrTracker* pClientAddr)
                {
                        return this->RemoveArgKey(pClientAddr);
                }
 
                virtual cNetAddrTrackPtr CreateAddrTracker(const cNetAddress& addr);
                cNetAddrTrackPtr FindAddrTracker(const cNetAddress& addr, bool bCreate = true);
 
                void onTickAddrArray();
 
                UNITTEST_FRIEND(cNetAddrTracker);
        };
}
#endif // _INC_cNetAddrTracker_H