Fix build on Darwin.

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

diff --git a/projects/stargazer/traffcounter_impl.h b/projects/stargazer/traffcounter_impl.h
index 27e7c03c637ee48fc5a03c9b9d57c810e050833b..03c118dfb94a1c1c6bb9965a6b99c84f18e31761 100644 (file)
--- a/projects/stargazer/traffcounter_impl.h
+++ b/projects/stargazer/traffcounter_impl.h
@@ -18,38 +18,36 @@
  *    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 <pthread.h>
+#include "stg/traffcounter.h"
+#include "stg/logger.h"
+#include "stg/raw_ip_packet.h"
+#include "stg/subscriptions.h"
+#include "user_impl.h"

 
 

-#include <ctime>

 #include <list>
 #include <list>

+#include <vector>
+#include <tuple>

 #include <map>
 #include <string>
 #include <map>
 #include <string>

-
-#include "stg/traffcounter.h"
-#include "stg/os_int.h"
-#include "stg/stg_logger.h"
-#include "stg/raw_ip_packet.h"
-#include "stg/users.h"
-#include "stg/noncopyable.h"
-#include "actions.h"
-#include "eventloop.h"
+#include <mutex>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop
+#include <cstdint>
+#include <ctime>

 
 #define PROTOMAX    (5)
 
 
 #define PROTOMAX    (5)
 

-class TARIFFS;
+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


@@ -58,204 +56,102 @@ uint8_t     proto;          // Protocol
 uint32_t    dir;            // Direction
 };
 //-----------------------------------------------------------------------------
 uint32_t    dir;            // Direction
 };
 //-----------------------------------------------------------------------------

-struct PACKET_EXTRA_DATA {
-PACKET_EXTRA_DATA()
-    : flushTime(0),
-      updateTime(0),
-      userU(),
-      userUPresent(false),
-      userD(),
-      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_PTR    userU;              // Uploader
-bool        userUPresent;       // Uploader is registered user
-USER_PTR    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 TRF_IP_BEFORE: public PROPERTY_NOTIFIER_BASE<uint32_t> {
-public:
-                    TRF_IP_BEFORE(TRAFFCOUNTER_IMPL & t, USER_PTR u)
-                        : PROPERTY_NOTIFIER_BASE<uint32_t>(),
-                          traffCnt(t),
-                          user(u)
-                    {}
-    void            Notify(const uint32_t & oldValue, const uint32_t & newValue);
-    void            SetUser(USER_PTR u) { user = u; }
-    USER_PTR        GetUser() const { return user; }
+class TraffCounterImpl : public TraffCounter {
+    public:
+        TraffCounterImpl(UsersImpl * users, const std::string & rulesFileName);
+        ~TraffCounterImpl();

 
 

-private:
-    TRAFFCOUNTER_IMPL & traffCnt;
-    USER_PTR            user;
-};
-//-----------------------------------------------------------------------------
-class TRF_IP_AFTER: public PROPERTY_NOTIFIER_BASE<uint32_t> {
-public:
-                    TRF_IP_AFTER(TRAFFCOUNTER_IMPL & t, USER_PTR u)
-                        : PROPERTY_NOTIFIER_BASE<uint32_t>(),
-                          traffCnt(t),
-                          user(u)
-                    {}
-    void            Notify(const uint32_t & oldValue, const uint32_t & newValue);
-    void            SetUser(USER_PTR u) { user = u; }
-    USER_PTR        GetUser() const { return user; }
-private:
-    TRAFFCOUNTER_IMPL & traffCnt;
-    USER_PTR            user;
-};
-//-----------------------------------------------------------------------------
-class ADD_USER_NONIFIER: public NOTIFIER_BASE<USER_PTR> {
-public:
-            ADD_USER_NONIFIER(TRAFFCOUNTER_IMPL & t) :
-                NOTIFIER_BASE<USER_PTR>(),
-                traffCnt(t)
-            {}
-    virtual ~ADD_USER_NONIFIER() {}
-    void    Notify(const USER_PTR & user);
-private:
-    TRAFFCOUNTER_IMPL & traffCnt;
-};
-//-----------------------------------------------------------------------------
-class DEL_USER_NONIFIER: public NOTIFIER_BASE<USER_PTR> {
-public:
-            DEL_USER_NONIFIER(TRAFFCOUNTER_IMPL & t) :
-                NOTIFIER_BASE<USER_PTR>(),
-                traffCnt(t)
-            {}
-    virtual ~DEL_USER_NONIFIER() {}
-    void    Notify(const USER_PTR & user);
-private:
-    TRAFFCOUNTER_IMPL & 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 * users, const TARIFFS * tariffs, const std::string & rulesFileName);
-    ~TRAFFCOUNTER_IMPL();
+        int         Reload();
+        int         Start();
+        int         Stop();

 
 

-    void        SetRulesFile(const std::string & rulesFileName);
+        void        process(const RawPacket & rawPacket) override;
+        void        SetMonitorDir(const std::string & monitorDir);

 
 

-    int         Reload();
-    int         Start();
-    int         Stop();
+        size_t      rulesCount() const override { return rules.size(); }

 
 

-    void        Process(const RAW_PACKET & rawPacket);
-    void        SetMonitorDir(const std::string & monitorDir);
+    private:
+        bool        ParseAddress(const char * ta, Rule * rule) const;
+        uint32_t    CalcMask(uint32_t msk) const;
+        void        FreeRules();
+        bool        ReadRules(bool test = false);

 
 

-private:
-    bool        ParseAddress(const char * ta, RULE * rule) const;
-    uint32_t    CalcMask(uint32_t msk) const;
-    void        FreeRules();
-    void        PrintRule(RULE rule) const;
-    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_PTR user);
-    void        DelUser(uint32_t uip);
-    void        SetUserNotifiers(USER_PTR user);
-    void        UnSetUserNotifiers(USER_PTR user);
+        typedef std::list<Rule>::iterator rule_iter;

 
 

-    typedef std::list<RULE>::iterator rule_iter;
-    typedef std::map<RAW_PACKET, PACKET_EXTRA_DATA>::iterator pp_iter;
-    typedef std::multimap<uint32_t, pp_iter>::iterator ip2p_iter;
-    typedef std::multimap<uint32_t, pp_iter>::const_iterator ip2p_citer;
+        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;

 
 

-    std::map<RAW_PACKET, PACKET_EXTRA_DATA> packets; // Packets tree
+        Packets packets; // Packets tree

 
 

-    std::multimap<uint32_t, pp_iter> ip2packets; // IP-to-Packet index
+        Index ip2packets; // IP-to-Packet index

 
 

-    std::string              dirName[DIR_NUM + 1];
+        std::string              dirName[DIR_NUM + 1];

 
 

-    STG_LOGGER &             WriteServLog;
-    std::string              rulesFileName;
+        Logger &             WriteServLog;
+        std::string              rulesFileName;

 
 

-    std::string              monitorDir;
-    bool                     monitoring;
+        std::string              monitorDir;
+        bool                     monitoring;
+        time_t                   touchTimeP;

 
 

-    USERS *                  users;
+        UsersImpl *             users;

 
 

-    bool                     running;
-    bool                     stopped;
-    pthread_mutex_t          mutex;
-    pthread_t                thread;
+        bool                     stopped;
+        std::mutex               m_mutex;
+        std::jthread             m_thread;

 
 

-    std::list<TRF_IP_BEFORE> ipBeforeNotifiers;
-    std::list<TRF_IP_AFTER>  ipAfterNotifiers;
+        ScopedConnection m_onAddUserConn;
+        ScopedConnection m_onDelUserConn;

 
 

-    ADD_USER_NONIFIER        addUserNotifier;
-    DEL_USER_NONIFIER        delUserNotifier;
+        using OnIPConns = std::tuple<int, ScopedConnection, ScopedConnection>;
+        std::vector<OnIPConns> m_onIPConns;
+        void beforeIPChange(uint32_t oldVal);
+        void afterIPChange(UserImpl* user, uint32_t newVal);

 };
 };

-//-----------------------------------------------------------------------------
-inline
-void TRF_IP_BEFORE::Notify(const uint32_t & oldValue, const uint32_t &)
-{
-// User changes his address. Remove old IP
-if (!oldValue)
-    return;

 
 

-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::DelUser, oldValue);
-}
-//-----------------------------------------------------------------------------
-inline
-void TRF_IP_AFTER::Notify(const uint32_t &, const uint32_t & newValue)
-{
-// User changes his address. Add new IP
-if (!newValue)
-    return;
-
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::AddUser, user);
-}
-//-----------------------------------------------------------------------------
-inline
-void ADD_USER_NONIFIER::Notify(const USER_PTR & user)
-{
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::SetUserNotifiers, user);
-}
-//-----------------------------------------------------------------------------
-inline
-void DEL_USER_NONIFIER::Notify(const USER_PTR & user)
-{
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::UnSetUserNotifiers, user);
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::DelUser, user->GetCurrIP());

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

-#endif //TRAFFCOUNTER_H