Add missing include to conffiles.h.

[stg.git] / projects / stargazer / traffcounter_impl.h

diff --git a/projects/stargazer/traffcounter_impl.h b/projects/stargazer/traffcounter_impl.h
index a1dfa74303aa8a4844fcf443550a53b712b4b359..ed639f5c3ddcffb2fc1db1d669678a41a673add6 100644 (file)
--- a/projects/stargazer/traffcounter_impl.h
+++ b/projects/stargazer/traffcounter_impl.h
@@ -18,18 +18,9 @@
  *    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/traffcounter.h"

-#include "stg/os_int.h"

 #include "stg/logger.h"
 #include "stg/raw_ip_packet.h"
 #include "stg/noncopyable.h"
 #include "stg/logger.h"
 #include "stg/raw_ip_packet.h"
 #include "stg/noncopyable.h"


@@ -42,15 +33,22 @@
 #include <list>
 #include <map>
 #include <string>
 #include <list>
 #include <map>
 #include <string>

-
-#include <pthread.h>
+#include <mutex>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop
+#include <cstdint>

 
 #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,199 +57,184 @@ 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)
-{}
-
-PACKET_EXTRA_DATA(const PACKET_EXTRA_DATA & pp)
-    : flushTime(pp.flushTime),
-      updateTime(pp.updateTime),
-      userU(pp.userU),
-      userUPresent(pp.userUPresent),
-      userD(pp.userD),
-      userDPresent(pp.userDPresent),
-      dirU(pp.dirU),
-      dirD(pp.dirD),
-      lenU(pp.lenU),
-      lenD(pp.lenD)
-{}
-
-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 & rvalue);
-    TRAFFCOUNTER_IMPL & operator=(const TRAFFCOUNTER_IMPL & rvalue);
+    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);
+        void        Run(std::stop_token token);

 
 

-    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                     stopped;
+        std::mutex               m_mutex;
+        std::jthread             m_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


@@ -261,7 +244,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::instance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, oldValue);

 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 inline


@@ -271,20 +254,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::instance().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::instance().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::instance().Enqueue(traffCnt, &TraffCounterImpl::UnSetUserNotifiers, user);
+EVENT_LOOP::instance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, user->GetCurrIP());

 }
 //-----------------------------------------------------------------------------
 }
 //-----------------------------------------------------------------------------

-#endif //TRAFFCOUNTER_H
+}