#ifndef TRAFFCOUNTER_IMPL_H
#define TRAFFCOUNTER_IMPL_H
-#include <pthread.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/notifer.h"
+#include "actions.h"
+#include "eventloop.h"
+#include "user_impl.h"
#include <ctime>
#include <list>
#include <map>
#include <string>
-#include "traffcounter.h"
-#include "os_int.h"
-#include "stg_logger.h"
-#include "raw_ip_packet.h"
-#include "users.h"
-#include "actions.h"
-#include "noncopyable.h"
-#include "eventloop.h"
+#include <pthread.h>
#define PROTOMAX (5)
-class TARIFFS;
+class USERS_IMPL;
//-----------------------------------------------------------------------------
struct RULE {
PACKET_EXTRA_DATA()
: flushTime(0),
updateTime(0),
- userU(),
+ userU(NULL),
userUPresent(false),
- userD(),
+ userD(NULL),
userDPresent(false),
dirU(DIR_NUM),
dirD(DIR_NUM),
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
+USER_IMPL * userU; // Uploader
bool userUPresent; // Uploader is registered user
-USER_PTR userD; // Downloader
+USER_IMPL * userD; // Downloader
bool userDPresent; // Downloader is registered user
int dirU; // Upload direction
int dirD; // Download direction
//-----------------------------------------------------------------------------
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; }
+ TRF_IP_BEFORE(TRAFFCOUNTER_IMPL & t, USER_IMPL * u)
+ : PROPERTY_NOTIFIER_BASE<uint32_t>(),
+ traffCnt(t),
+ user(u)
+ {}
+ TRF_IP_BEFORE(const TRF_IP_BEFORE & rvalue)
+ : PROPERTY_NOTIFIER_BASE<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; }
private:
+ TRF_IP_BEFORE & operator=(const TRF_IP_BEFORE & rvalue);
+
TRAFFCOUNTER_IMPL & traffCnt;
- USER_PTR user;
+ USER_IMPL * 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; }
+ TRF_IP_AFTER(TRAFFCOUNTER_IMPL & t, USER_IMPL * u)
+ : PROPERTY_NOTIFIER_BASE<uint32_t>(),
+ traffCnt(t),
+ user(u)
+ {}
+ TRF_IP_AFTER(const TRF_IP_AFTER & rvalue)
+ : PROPERTY_NOTIFIER_BASE<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; }
private:
+ TRF_IP_AFTER & operator=(const TRF_IP_AFTER & rvalue);
+
TRAFFCOUNTER_IMPL & traffCnt;
- USER_PTR user;
+ USER_IMPL * user;
};
//-----------------------------------------------------------------------------
-class ADD_USER_NONIFIER: public NOTIFIER_BASE<USER_PTR> {
+class ADD_USER_NONIFIER: public NOTIFIER_BASE<USER_IMPL_PTR> {
public:
- ADD_USER_NONIFIER(TRAFFCOUNTER_IMPL & t) :
- NOTIFIER_BASE<USER_PTR>(),
+ explicit ADD_USER_NONIFIER(TRAFFCOUNTER_IMPL & t) :
+ NOTIFIER_BASE<USER_IMPL_PTR>(),
traffCnt(t)
{}
virtual ~ADD_USER_NONIFIER() {}
- void Notify(const USER_PTR & user);
+ void Notify(const USER_IMPL_PTR & user);
+
private:
+ ADD_USER_NONIFIER(const ADD_USER_NONIFIER & rvalue);
+ ADD_USER_NONIFIER & operator=(const ADD_USER_NONIFIER & rvalue);
+
TRAFFCOUNTER_IMPL & traffCnt;
};
//-----------------------------------------------------------------------------
-class DEL_USER_NONIFIER: public NOTIFIER_BASE<USER_PTR> {
+class DEL_USER_NONIFIER: public NOTIFIER_BASE<USER_IMPL_PTR> {
public:
- DEL_USER_NONIFIER(TRAFFCOUNTER_IMPL & t) :
- NOTIFIER_BASE<USER_PTR>(),
+ explicit DEL_USER_NONIFIER(TRAFFCOUNTER_IMPL & t) :
+ NOTIFIER_BASE<USER_IMPL_PTR>(),
traffCnt(t)
{}
virtual ~DEL_USER_NONIFIER() {}
- void Notify(const USER_PTR & user);
+ void Notify(const USER_IMPL_PTR & user);
+
private:
+ DEL_USER_NONIFIER(const DEL_USER_NONIFIER & rvalue);
+ DEL_USER_NONIFIER & operator=(const DEL_USER_NONIFIER & rvalue);
+
TRAFFCOUNTER_IMPL & traffCnt;
};
//-----------------------------------------------------------------------------
-class TRAFFCOUNTER : public TRAFFCOUNTER, private NONCOPYABLE {
+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(USERS_IMPL * users, const std::string & rulesFileName);
~TRAFFCOUNTER_IMPL();
- void SetRulesFile(const std::string & rulesFileName);
-
int Reload();
int Start();
int Stop();
void Process(const RAW_PACKET & rawPacket);
void SetMonitorDir(const std::string & monitorDir);
+ size_t RulesCount() const { return rules.size(); }
+
private:
+ TRAFFCOUNTER_IMPL(const TRAFFCOUNTER_IMPL &);
+ TRAFFCOUNTER_IMPL & operator=(const TRAFFCOUNTER_IMPL &);
+
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);
static void * Run(void * data);
void FlushAndRemove();
- void AddUser(USER_PTR user);
+ void AddUser(USER_IMPL * user);
void DelUser(uint32_t uip);
- void SetUserNotifiers(USER_PTR user);
- void UnSetUserNotifiers(USER_PTR user);
+ void SetUserNotifiers(USER_IMPL * user);
+ void UnSetUserNotifiers(USER_IMPL * user);
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::map<RAW_PACKET, PACKET_EXTRA_DATA> packets; // Packets tree
+ 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
- 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 monitorDir;
bool monitoring;
+ time_t touchTimeP;
- USERS * users;
+ USERS_IMPL * users;
bool running;
bool stopped;
if (!oldValue)
return;
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::DelUser, oldValue);
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::DelUser, oldValue);
}
//-----------------------------------------------------------------------------
inline
if (!newValue)
return;
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::AddUser, user);
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::AddUser, user);
}
//-----------------------------------------------------------------------------
inline
-void ADD_USER_NONIFIER::Notify(const USER_PTR & user)
+void ADD_USER_NONIFIER::Notify(const USER_IMPL_PTR & user)
{
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::SetUserNotifiers, user);
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::SetUserNotifiers, user);
}
//-----------------------------------------------------------------------------
inline
-void DEL_USER_NONIFIER::Notify(const USER_PTR & user)
+void DEL_USER_NONIFIER::Notify(const USER_IMPL_PTR & user)
{
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::UnSetUserNotifiers, user);
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::DelUser, user->GetCurrIP());
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::UnSetUserNotifiers, user);
+EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER_IMPL::DelUser, user->GetCurrIP());
}
//-----------------------------------------------------------------------------
#endif //TRAFFCOUNTER_H
git.stg.codes / stg.git / blobdiff