* 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
-
-#include <pthread.h>
-
-#include <ctime>
-#include <list>
-#include <map>
-#include <string>
+#pragma once
#include "stg/traffcounter.h"
-#include "stg/os_int.h"
#include "stg/logger.h"
#include "stg/raw_ip_packet.h"
#include "stg/noncopyable.h"
#include "eventloop.h"
#include "user_impl.h"
+#include <ctime>
+#include <list>
+#include <map>
+#include <string>
+#include <mutex>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop
+#include <cstdint>
+
#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 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:
- 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)
- : PROPERTY_NOTIFIER_BASE<uint32_t>(),
+ : PropertyNotifierBase<uint32_t>(),
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);
- 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:
- 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)
- : PROPERTY_NOTIFIER_BASE<uint32_t>(),
+ : PropertyNotifierBase<uint32_t>(),
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);
- 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:
- 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() {}
- 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);
- TRAFFCOUNTER_IMPL & traffCnt;
+ TraffCounterImpl & traffCnt;
};
//-----------------------------------------------------------------------------
-class DEL_USER_NONIFIER: public NOTIFIER_BASE<USER_IMPL_PTR> {
+class DEL_USER_NONIFIER: public NotifierBase<UserImplPtr> {
public:
- 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() {}
- 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);
- 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();
- void SetRulesFile(const std::string & rulesFileName);
+ int Reload();
+ int Start();
+ int Stop();
- int Reload();
- int Start();
- int Stop();
+ void process(const RawPacket & rawPacket) override;
+ void SetMonitorDir(const std::string & monitorDir);
- void Process(const RAW_PACKET & rawPacket);
- void SetMonitorDir(const std::string & monitorDir);
+ size_t rulesCount() const override { return rules.size(); }
- size_t RulesCount() const { return rules.size(); }
+ private:
+ bool ParseAddress(const char * ta, Rule * rule) const;
+ uint32_t CalcMask(uint32_t msk) const;
+ void FreeRules();
+ bool ReadRules(bool test = false);
-private:
- TRAFFCOUNTER_IMPL(const TRAFFCOUNTER_IMPL & rvalue);
- TRAFFCOUNTER_IMPL & operator=(const TRAFFCOUNTER_IMPL & rvalue);
+ void Run(std::stop_token token);
- 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 DeterminateDir(const RawPacket & packet,
+ int * dirU, // Direction for upload
+ int * dirD) const; // Direction for download
- static void * Run(void * data);
+ void FlushAndRemove();
- void DeterminateDir(const RAW_PACKET & packet,
- int * dirU, // Direction for upload
- int * dirD) const; // Direction for download
+ void AddUser(UserImpl * user);
+ void DelUser(uint32_t uip);
+ void SetUserNotifiers(UserImpl * user);
+ void UnSetUserNotifiers(UserImpl * user);
- void FlushAndRemove();
+ typedef std::list<Rule>::iterator rule_iter;
- void AddUser(USER_IMPL * user);
- void DelUser(uint32_t uip);
- void SetUserNotifiers(USER_IMPL * user);
- void UnSetUserNotifiers(USER_IMPL * user);
+ std::list<Rule> rules;
- 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;
+ 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::list<RULE> rules;
+ Packets packets; // Packets tree
- std::map<RAW_PACKET, PACKET_EXTRA_DATA> packets; // Packets tree
+ Index ip2packets; // IP-to-Packet index
- std::multimap<uint32_t, pp_iter> 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;
+ 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
if (!oldValue)
return;
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::DelUser, oldValue);
+EVENT_LOOP::instance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, oldValue);
}
//-----------------------------------------------------------------------------
inline
if (!newValue)
return;
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::AddUser, user);
+EVENT_LOOP::instance().Enqueue(traffCnt, &TraffCounterImpl::AddUser, user);
}
//-----------------------------------------------------------------------------
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
-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
+}
git.stg.codes / stg.git / blobdiff