]> git.stg.codes - stg.git/blobdiff - stargazer/traffcounter_impl.h
git.stg.codes / stg.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Non-virtual admin.
[stg.git] / stargazer / traffcounter_impl.h
diff --git a/stargazer/traffcounter_impl.h b/stargazer/traffcounter_impl.h
index 765724007c582a58c2f31c9d11452753be01439f..78027cb57d3d7d5eb8b08448b3b4e81843c9d65a 100644 (file)
--- a/stargazer/traffcounter_impl.h
+++ b/stargazer/traffcounter_impl.h
@@ -18,15 +18,7 @@
  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  */
 
  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  */
 
- /*
- $Revision: 1.23 $
- $Date: 2010/04/22 12:57:46 $
- $Author: faust $
- */
-
-
-#ifndef TRAFFCOUNTER_IMPL_H
-#define TRAFFCOUNTER_IMPL_H
+#pragma once
 
 #include "stg/traffcounter.h"
 #include "stg/logger.h"
 
 #include "stg/traffcounter.h"
 #include "stg/logger.h"
@@ -47,10 +39,13 @@
 
 #define PROTOMAX    (5)
 
 
 #define PROTOMAX    (5)
 
-class USERS_IMPL;
+namespace STG
+{
+
+class UsersImpl;
 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
-struct RULE {
+struct Rule {
 uint32_t    ip;             // IP
 uint32_t    mask;           // Network mask
 uint16_t    port1;          // Min port
 uint32_t    ip;             // IP
 uint32_t    mask;           // Network mask
 uint16_t    port1;          // Min port
@@ -59,186 +54,185 @@ uint8_t     proto;          // Protocol
 uint32_t    dir;            // Direction
 };
 //-----------------------------------------------------------------------------
 uint32_t    dir;            // Direction
 };
 //-----------------------------------------------------------------------------
-struct PACKET_EXTRA_DATA {
-PACKET_EXTRA_DATA()
-    : flushTime(0),
-      updateTime(0),
-      userU(NULL),
-      userUPresent(false),
-      userD(NULL),
-      userDPresent(false),
-      dirU(DIR_NUM),
-      dirD(DIR_NUM),
-      lenU(0),
-      lenD(0)
-{}
-
-time_t      flushTime;          // Last flush time
-time_t      updateTime;         // Last update time
-USER_IMPL * userU;              // Uploader
-bool        userUPresent;       // Uploader is registered user
-USER_IMPL * userD;              // Downloader
-bool        userDPresent;       // Downloader is registered user
-int         dirU;               // Upload direction
-int         dirD;               // Download direction
-uint32_t    lenU;               // Upload length
-uint32_t    lenD;               // Download length
+struct PacketExtraData {
+    PacketExtraData()
+        : flushTime(0),
+          updateTime(0),
+          userU(NULL),
+          userUPresent(false),
+          userD(NULL),
+          userDPresent(false),
+          dirU(DIR_NUM),
+          dirD(DIR_NUM),
+          lenU(0),
+          lenD(0)
+    {}
+
+    time_t      flushTime;          // Last flush time
+    time_t      updateTime;         // Last update time
+    UserImpl * userU;              // Uploader
+    bool        userUPresent;       // Uploader is registered user
+    UserImpl * userD;              // Downloader
+    bool        userDPresent;       // Downloader is registered user
+    int         dirU;               // Upload direction
+    int         dirD;               // Download direction
+    uint32_t    lenU;               // Upload length
+    uint32_t    lenD;               // Download length
 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------
-class TRAFFCOUNTER_IMPL;
+class TraffCounterImpl;
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
-class TRF_IP_BEFORE: public PROPERTY_NOTIFIER_BASE<uint32_t> {
+class TRF_IP_BEFORE: public PropertyNotifierBase<uint32_t> {
 public:
 public:
-                TRF_IP_BEFORE(TRAFFCOUNTER_IMPL & t, USER_IMPL * u)
-                    : PROPERTY_NOTIFIER_BASE<uint32_t>(),
+                TRF_IP_BEFORE(TraffCounterImpl & t, UserImpl * u)
+                    : PropertyNotifierBase<uint32_t>(),
                       traffCnt(t),
                       user(u)
                 {}
                 TRF_IP_BEFORE(const TRF_IP_BEFORE & rvalue)
                       traffCnt(t),
                       user(u)
                 {}
                 TRF_IP_BEFORE(const TRF_IP_BEFORE & rvalue)
-                    : PROPERTY_NOTIFIER_BASE<uint32_t>(),
+                    : PropertyNotifierBase<uint32_t>(),
                       traffCnt(rvalue.traffCnt),
                       user(rvalue.user)
                 {}
     void        Notify(const uint32_t & oldValue, const uint32_t & newValue);
                       traffCnt(rvalue.traffCnt),
                       user(rvalue.user)
                 {}
     void        Notify(const uint32_t & oldValue, const uint32_t & newValue);
-    void        SetUser(USER_IMPL * u) { user = u; }
-    USER_IMPL * GetUser() const { return user; }
+    void        SetUser(UserImpl * u) { user = u; }
+    UserImpl * GetUser() const { return user; }
 
 private:
     TRF_IP_BEFORE & operator=(const TRF_IP_BEFORE & rvalue);
 
 
 private:
     TRF_IP_BEFORE & operator=(const TRF_IP_BEFORE & rvalue);
 
-    TRAFFCOUNTER_IMPL & traffCnt;
-    USER_IMPL * user;
+    TraffCounterImpl & traffCnt;
+    UserImpl * user;
 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------
-class TRF_IP_AFTER: public PROPERTY_NOTIFIER_BASE<uint32_t> {
+class TRF_IP_AFTER: public PropertyNotifierBase<uint32_t> {
 public:
 public:
-                TRF_IP_AFTER(TRAFFCOUNTER_IMPL & t, USER_IMPL * u)
-                    : PROPERTY_NOTIFIER_BASE<uint32_t>(),
+                TRF_IP_AFTER(TraffCounterImpl & t, UserImpl * u)
+                    : PropertyNotifierBase<uint32_t>(),
                       traffCnt(t),
                       user(u)
                 {}
                 TRF_IP_AFTER(const TRF_IP_AFTER & rvalue)
                       traffCnt(t),
                       user(u)
                 {}
                 TRF_IP_AFTER(const TRF_IP_AFTER & rvalue)
-                    : PROPERTY_NOTIFIER_BASE<uint32_t>(),
+                    : PropertyNotifierBase<uint32_t>(),
                       traffCnt(rvalue.traffCnt),
                       user(rvalue.user)
                 {}
     void        Notify(const uint32_t & oldValue, const uint32_t & newValue);
                       traffCnt(rvalue.traffCnt),
                       user(rvalue.user)
                 {}
     void        Notify(const uint32_t & oldValue, const uint32_t & newValue);
-    void        SetUser(USER_IMPL * u) { user = u; }
-    USER_IMPL * GetUser() const { return user; }
+    void        SetUser(UserImpl * u) { user = u; }
+    UserImpl * GetUser() const { return user; }
 private:
     TRF_IP_AFTER & operator=(const TRF_IP_AFTER & rvalue);
 
 private:
     TRF_IP_AFTER & operator=(const TRF_IP_AFTER & rvalue);
 
-    TRAFFCOUNTER_IMPL & traffCnt;
-    USER_IMPL * user;
+    TraffCounterImpl & traffCnt;
+    UserImpl * user;
 };
 };
+
+using UserImplPtr = UserImpl*;
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
-class ADD_USER_NONIFIER: public NOTIFIER_BASE<USER_IMPL_PTR> {
+class ADD_USER_NONIFIER: public NotifierBase<UserImplPtr> {
 public:
 public:
-            explicit ADD_USER_NONIFIER(TRAFFCOUNTER_IMPL & t) :
-                NOTIFIER_BASE<USER_IMPL_PTR>(),
+            explicit ADD_USER_NONIFIER(TraffCounterImpl & t) :
+                NotifierBase<UserImplPtr>(),
                 traffCnt(t)
             {}
     virtual ~ADD_USER_NONIFIER() {}
                 traffCnt(t)
             {}
     virtual ~ADD_USER_NONIFIER() {}
-    void    Notify(const USER_IMPL_PTR & user);
+    void    Notify(const UserImplPtr & user);
 
 private:
     ADD_USER_NONIFIER(const ADD_USER_NONIFIER & rvalue);
     ADD_USER_NONIFIER & operator=(const ADD_USER_NONIFIER & rvalue);
 
 
 private:
     ADD_USER_NONIFIER(const ADD_USER_NONIFIER & rvalue);
     ADD_USER_NONIFIER & operator=(const ADD_USER_NONIFIER & rvalue);
 
-    TRAFFCOUNTER_IMPL & traffCnt;
+    TraffCounterImpl & traffCnt;
 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------
-class DEL_USER_NONIFIER: public NOTIFIER_BASE<USER_IMPL_PTR> {
+class DEL_USER_NONIFIER: public NotifierBase<UserImplPtr> {
 public:
 public:
-            explicit DEL_USER_NONIFIER(TRAFFCOUNTER_IMPL & t) :
-                NOTIFIER_BASE<USER_IMPL_PTR>(),
+            explicit DEL_USER_NONIFIER(TraffCounterImpl & t) :
+                NotifierBase<UserImplPtr>(),
                 traffCnt(t)
             {}
     virtual ~DEL_USER_NONIFIER() {}
                 traffCnt(t)
             {}
     virtual ~DEL_USER_NONIFIER() {}
-    void    Notify(const USER_IMPL_PTR & user);
+    void    Notify(const UserImplPtr & user);
 
 private:
     DEL_USER_NONIFIER(const DEL_USER_NONIFIER & rvalue);
     DEL_USER_NONIFIER & operator=(const DEL_USER_NONIFIER & rvalue);
 
 
 private:
     DEL_USER_NONIFIER(const DEL_USER_NONIFIER & rvalue);
     DEL_USER_NONIFIER & operator=(const DEL_USER_NONIFIER & rvalue);
 
-    TRAFFCOUNTER_IMPL & traffCnt;
+    TraffCounterImpl & traffCnt;
 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------
-class TRAFFCOUNTER_IMPL : public TRAFFCOUNTER, private NONCOPYABLE {
-friend class ADD_USER_NONIFIER;
-friend class DEL_USER_NONIFIER;
-friend class TRF_IP_BEFORE;
-friend class TRF_IP_AFTER;
-public:
-    TRAFFCOUNTER_IMPL(USERS_IMPL * users, const std::string & rulesFileName);
-    ~TRAFFCOUNTER_IMPL();
+class TraffCounterImpl : public TraffCounter {
+    friend class ADD_USER_NONIFIER;
+    friend class DEL_USER_NONIFIER;
+    friend class TRF_IP_BEFORE;
+    friend class TRF_IP_AFTER;
+    public:
+        TraffCounterImpl(UsersImpl * users, const std::string & rulesFileName);
+        ~TraffCounterImpl();
 
 
-    int         Reload();
-    int         Start();
-    int         Stop();
+        int         Reload();
+        int         Start();
+        int         Stop();
 
 
-    void        Process(const RAW_PACKET & rawPacket);
-    void        SetMonitorDir(const std::string & monitorDir);
+        void        process(const RawPacket & rawPacket) override;
+        void        SetMonitorDir(const std::string & monitorDir);
 
 
-    size_t      RulesCount() const { return rules.size(); }
+        size_t      rulesCount() const override { return rules.size(); }
 
 
-private:
-    TRAFFCOUNTER_IMPL(const TRAFFCOUNTER_IMPL &);
-    TRAFFCOUNTER_IMPL & operator=(const TRAFFCOUNTER_IMPL &);
+    private:
+        bool        ParseAddress(const char * ta, Rule * rule) const;
+        uint32_t    CalcMask(uint32_t msk) const;
+        void        FreeRules();
+        bool        ReadRules(bool test = false);
 
 
-    bool        ParseAddress(const char * ta, RULE * rule) const;
-    uint32_t    CalcMask(uint32_t msk) const;
-    void        FreeRules();
-    bool        ReadRules(bool test = false);
+        static void * Run(void * data);
 
 
-    static void * Run(void * data);
+        void        DeterminateDir(const RawPacket & packet,
+                                   int * dirU, // Direction for upload
+                                   int * dirD) const; // Direction for download
 
 
-    void        DeterminateDir(const RAW_PACKET & packet,
-                               int * dirU, // Direction for upload
-                               int * dirD) const; // Direction for download
+        void        FlushAndRemove();
 
 
-    void        FlushAndRemove();
+        void        AddUser(UserImpl * user);
+        void        DelUser(uint32_t uip);
+        void        SetUserNotifiers(UserImpl * user);
+        void        UnSetUserNotifiers(UserImpl * user);
 
 
-    void        AddUser(USER_IMPL * user);
-    void        DelUser(uint32_t uip);
-    void        SetUserNotifiers(USER_IMPL * user);
-    void        UnSetUserNotifiers(USER_IMPL * user);
+        typedef std::list<Rule>::iterator rule_iter;
 
 
-    typedef std::list<RULE>::iterator rule_iter;
+        std::list<Rule>          rules;
 
 
-    std::list<RULE>          rules;
+        typedef std::map<RawPacket, PacketExtraData> Packets;
+        typedef Packets::iterator pp_iter;
+        typedef std::multimap<uint32_t, pp_iter> Index;
+        typedef Index::iterator ip2p_iter;
+        typedef Index::const_iterator ip2p_citer;
 
 
-    typedef std::map<RAW_PACKET, PACKET_EXTRA_DATA> Packets;
-    typedef Packets::iterator pp_iter;
-    typedef std::multimap<uint32_t, pp_iter> Index;
-    typedef Index::iterator ip2p_iter;
-    typedef Index::const_iterator ip2p_citer;
+        Packets packets; // Packets tree
 
 
-    Packets packets; // Packets tree
+        Index ip2packets; // IP-to-Packet index
 
 
-    Index ip2packets; // IP-to-Packet index
+        std::string              dirName[DIR_NUM + 1];
 
 
-    std::string              dirName[DIR_NUM + 1];
+        Logger &             WriteServLog;
+        std::string              rulesFileName;
 
 
-    STG_LOGGER &             WriteServLog;
-    std::string              rulesFileName;
+        std::string              monitorDir;
+        bool                     monitoring;
+        time_t                   touchTimeP;
 
 
-    std::string              monitorDir;
-    bool                     monitoring;
-    time_t                   touchTimeP;
+        UsersImpl *             users;
 
 
-    USERS_IMPL *             users;
+        bool                     running;
+        bool                     stopped;
+        pthread_mutex_t          mutex;
+        pthread_t                thread;
 
 
-    bool                     running;
-    bool                     stopped;
-    pthread_mutex_t          mutex;
-    pthread_t                thread;
+        std::list<TRF_IP_BEFORE> ipBeforeNotifiers;
+        std::list<TRF_IP_AFTER>  ipAfterNotifiers;
 
 
-    std::list<TRF_IP_BEFORE> ipBeforeNotifiers;
-    std::list<TRF_IP_AFTER>  ipAfterNotifiers;
-
-    ADD_USER_NONIFIER        addUserNotifier;
-    DEL_USER_NONIFIER        delUserNotifier;
+        ADD_USER_NONIFIER        addUserNotifier;
+        DEL_USER_NONIFIER        delUserNotifier;
 };
 //-----------------------------------------------------------------------------
 inline
 };
 //-----------------------------------------------------------------------------
 inline
@@ -248,7 +242,7 @@ void TRF_IP_BEFORE::Notify(const uint32_t & oldValue, const uint32_t &)
 if (!oldValue)
     return;
 
 if (!oldValue)
     return;
 
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::DelUser, oldValue);
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, oldValue);
 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 inline
@@ -258,20 +252,20 @@ void TRF_IP_AFTER::Notify(const uint32_t &, const uint32_t & newValue)
 if (!newValue)
     return;
 
 if (!newValue)
     return;
 
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::AddUser, user);
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::AddUser, user);
 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 inline
-void ADD_USER_NONIFIER::Notify(const USER_IMPL_PTR & user)
+void ADD_USER_NONIFIER::Notify(const UserImplPtr & user)
 {
 {
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::SetUserNotifiers, user);
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::SetUserNotifiers, user);
 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 inline
-void DEL_USER_NONIFIER::Notify(const USER_IMPL_PTR & user)
+void DEL_USER_NONIFIER::Notify(const UserImplPtr & user)
 {
 {
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::UnSetUserNotifiers, user);
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::DelUser, user->GetCurrIP());
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::UnSetUserNotifiers, user);
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, user->GetCurrIP());
 }
 //-----------------------------------------------------------------------------
 }
 //-----------------------------------------------------------------------------
-#endif //TRAFFCOUNTER_H
+}
Stargazer Billing System