projects/stargazer/traffcounter.h

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  19  */
  20
  21  /*
  22  $Revision: 1.23 $
  23  $Date: 2010/04/22 12:57:46 $
  24  $Author: faust $
  25  */
  26
  27
  28 #ifndef TRAFFCOUNTER_H
  29 #define TRAFFCOUNTER_H
  30
  31 #include <pthread.h>
  32 #include <ctime>
  33 #include <list>
  34 #include <map>
  35 #include <string>
  36
  37 #include "os_int.h"
  38 #include "stg_logger.h"
  39 #include "raw_ip_packet.h"
  40 #include "users.h"
  41 #include "actions.h"
  42 #include "noncopyable.h"
  43 #include "eventloop.h"
  44
  45 #define PROTOMAX    (5)
  46
  47 //-----------------------------------------------------------------------------
  48 struct RULE
  49 {
  50 uint32_t    ip;             // IP
  51 uint32_t    mask;           // Network mask
  52 uint16_t    port1;          // Min port
  53 uint16_t    port2;          // Max port
  54 uint8_t     proto;          // Protocol
  55 uint32_t    dir;            // Direction
  56 };
  57 //-----------------------------------------------------------------------------
  58 struct PACKET_EXTRA_DATA
  59 {
  60 PACKET_EXTRA_DATA()
  61     : flushTime(0),
  62       updateTime(0),
  63       userU(),
  64       userUPresent(false),
  65       userD(),
  66       userDPresent(false),
  67       dirU(DIR_NUM),
  68       dirD(DIR_NUM),
  69       lenU(0),
  70       lenD(0)
  71 {};
  72
  73 PACKET_EXTRA_DATA(const PACKET_EXTRA_DATA & pp)
  74     : flushTime(pp.flushTime),
  75       updateTime(pp.updateTime),
  76       userU(pp.userU),
  77       userUPresent(pp.userUPresent),
  78       userD(pp.userD),
  79       userDPresent(pp.userDPresent),
  80       dirU(pp.dirU),
  81       dirD(pp.dirD),
  82       lenU(pp.lenU),
  83       lenD(pp.lenD)
  84 {};
  85
  86 time_t      flushTime;          // Last flush time
  87 time_t      updateTime;         // Last update time
  88 user_iter   userU;              // Uploader
  89 bool        userUPresent;       // Uploader is registered user
  90 user_iter   userD;              // Downloader
  91 bool        userDPresent;       // Downloader is registered user
  92 int         dirU;               // Upload direction
  93 int         dirD;               // Download direction
  94 uint32_t    lenU;               // Upload length
  95 uint32_t    lenD;               // Download length
  96 };
  97 //-----------------------------------------------------------------------------
  98 class TRAFFCOUNTER;
  99 //-----------------------------------------------------------------------------
 100 class TRF_IP_BEFORE: public PROPERTY_NOTIFIER_BASE<uint32_t>
 101 {
 102 public:
 103                     TRF_IP_BEFORE(TRAFFCOUNTER & t, user_iter u)
 104                         : PROPERTY_NOTIFIER_BASE<uint32_t>(),
 105                           traffCnt(t),
 106                           user(u)
 107                     {};
 108     void            Notify(const uint32_t & oldValue, const uint32_t & newValue);
 109     void            SetUser(user_iter u) { user = u; }
 110     user_iter       GetUser() { return user; }
 111
 112 private:
 113     TRAFFCOUNTER &  traffCnt;
 114     user_iter       user;
 115 };
 116 //-----------------------------------------------------------------------------
 117 class TRF_IP_AFTER: public PROPERTY_NOTIFIER_BASE<uint32_t>
 118 {
 119 public:
 120                     TRF_IP_AFTER(TRAFFCOUNTER & t, user_iter u)
 121                         : PROPERTY_NOTIFIER_BASE<uint32_t>(),
 122                           traffCnt(t),
 123                           user(u)
 124                     {};
 125     void            Notify(const uint32_t & oldValue, const uint32_t & newValue);
 126     void            SetUser(user_iter u) { user = u; }
 127     user_iter       GetUser() { return user; }
 128 private:
 129     TRAFFCOUNTER &  traffCnt;
 130     user_iter       user;
 131 };
 132 //-----------------------------------------------------------------------------
 133 class ADD_USER_NONIFIER: public NOTIFIER_BASE<user_iter>
 134 {
 135 public:
 136             ADD_USER_NONIFIER(TRAFFCOUNTER & t) :
 137                 NOTIFIER_BASE<user_iter>(),
 138                 traffCnt(t) {};
 139     virtual ~ADD_USER_NONIFIER(){};
 140     void    Notify(const user_iter & user);
 141 private:
 142     TRAFFCOUNTER & traffCnt;
 143 };
 144 //-----------------------------------------------------------------------------
 145 class DEL_USER_NONIFIER: public NOTIFIER_BASE<user_iter>
 146 {
 147 public:
 148             DEL_USER_NONIFIER(TRAFFCOUNTER & t) :
 149                 NOTIFIER_BASE<user_iter>(),
 150                 traffCnt(t) {};
 151     virtual ~DEL_USER_NONIFIER(){};
 152     void    Notify(const user_iter & user);
 153 private:
 154     TRAFFCOUNTER & traffCnt;
 155 };
 156 //-----------------------------------------------------------------------------
 157 class TRAFFCOUNTER : private NONCOPYABLE
 158 {
 159 friend class ADD_USER_NONIFIER;
 160 friend class DEL_USER_NONIFIER;
 161 friend class TRF_IP_BEFORE;
 162 friend class TRF_IP_AFTER;
 163 public:
 164     TRAFFCOUNTER(USERS * users, const TARIFFS * tariffs, const std::string & rulesFileName);
 165     ~TRAFFCOUNTER();
 166
 167     void        SetRulesFile(const std::string & rulesFileName);
 168
 169     int         Reload();
 170     int         Start();
 171     int         Stop();
 172
 173     void        Process(const RAW_PACKET & rawPacket);
 174     void        SetMonitorDir(const std::string & monitorDir);
 175
 176 private:
 177     bool        ParseAddress(const char * ta, RULE * rule) const;
 178     uint32_t    CalcMask(uint32_t msk) const;
 179     void        FreeRules();
 180     void        PrintRule(RULE rule) const;
 181     bool        ReadRules(bool test = false);
 182
 183     static void * Run(void * data);
 184
 185     void        DeterminateDir(const RAW_PACKET & packet,
 186                                int * dirU, // Direction for upload
 187                                int * dirD) const; // Direction for download
 188
 189     void        FlushAndRemove();
 190
 191     void        AddUser(user_iter user);
 192     void        DelUser(uint32_t uip);
 193     void        SetUserNotifiers(user_iter user);
 194     void        UnSetUserNotifiers(user_iter user);
 195
 196     std::list<RULE>  rules;
 197     typedef std::list<RULE>::iterator rule_iter;
 198
 199     std::map<RAW_PACKET, PACKET_EXTRA_DATA> packets; // Packets tree
 200     typedef std::map<RAW_PACKET, PACKET_EXTRA_DATA>::iterator pp_iter;
 201
 202     std::multimap<uint32_t, pp_iter> ip2packets; // IP-to-Packet index
 203
 204     typedef std::multimap<uint32_t, pp_iter>::iterator ip2p_iter;
 205     typedef std::multimap<uint32_t, pp_iter>::const_iterator ip2p_citer;
 206
 207     std::string dirName[DIR_NUM + 1];
 208
 209     STG_LOGGER & WriteServLog;
 210     std::string rulesFileName;
 211
 212     std::string monitorDir;
 213     bool        monitoring;
 214
 215     USERS *     users;
 216
 217     bool        running;
 218     bool        stopped;
 219     pthread_mutex_t         mutex;
 220     pthread_t               thread;
 221
 222     std::list<TRF_IP_BEFORE>     ipBeforeNotifiers;
 223     std::list<TRF_IP_AFTER>      ipAfterNotifiers;
 224
 225     ADD_USER_NONIFIER       addUserNotifier;
 226     DEL_USER_NONIFIER       delUserNotifier;
 227 };
 228 //-----------------------------------------------------------------------------
 229 inline
 230 void TRF_IP_BEFORE::Notify(const uint32_t & oldValue, const uint32_t &)
 231 {
 232 // User changes his address. Remove old IP
 233 if (!oldValue)
 234     return;
 235
 236 EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::DelUser, oldValue);
 237 }
 238 //-----------------------------------------------------------------------------
 239 inline
 240 void TRF_IP_AFTER::Notify(const uint32_t &, const uint32_t & newValue)
 241 {
 242 // User changes his address. Add new IP
 243 if (!newValue)
 244     return;
 245
 246 EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::AddUser, user);
 247 }
 248 //-----------------------------------------------------------------------------
 249 inline
 250 void ADD_USER_NONIFIER::Notify(const user_iter & user)
 251 {
 252 EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::SetUserNotifiers, user);
 253 }
 254 //-----------------------------------------------------------------------------
 255 inline
 256 void DEL_USER_NONIFIER::Notify(const user_iter & user)
 257 {
 258 EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::UnSetUserNotifiers, user);
 259 EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TRAFFCOUNTER::DelUser, user->GetCurrIP());
 260 }
 261 //-----------------------------------------------------------------------------
 262 #endif //TRAFFCOUNTER_H