Implement ReconnectOnTariffChange logic

[stg.git] / projects / stargazer / user_impl.cpp

diff --git a/projects/stargazer/user_impl.cpp b/projects/stargazer/user_impl.cpp
index d8368c4d41b1885821af69c158b4da0afe4dc417..4cb4467ee70c7c70abfe370ec15a8cae5c81af79 100644 (file)
--- a/projects/stargazer/user_impl.cpp
+++ b/projects/stargazer/user_impl.cpp
@@ -36,21 +36,108 @@
 #include <unistd.h> // access
 
 #include <cassert>
 #include <unistd.h> // access
 
 #include <cassert>

+#include <cstdlib>
+
+#include "stg/users.h"
+#include "stg/common.h"
+#include "stg/scriptexecuter.h"
+#include "stg/tariff.h"
+#include "stg/tariffs.h"
+#include "stg/admin.h"
+#include "user_impl.h"
+#include "settings_impl.h"
+
+#ifdef USE_ABSTRACT_SETTINGS
+USER_IMPL::USER_IMPL(const SETTINGS * s,
+           const STORE * st,
+           const TARIFFS * t,
+           const ADMIN * a,
+           const USERS * u)
+    : users(u),
+      property(s->GetScriptsDir()),
+      WriteServLog(GetStgLogger()),
+      login(),
+      id(0),
+      __connected(0),
+      connected(__connected),
+      userIDGenerator(),
+      __currIP(0),
+      currIP(__currIP),
+      lastIPForDisconnect(0),
+      pingTime(0),
+      sysAdmin(a),
+      store(st),
+      tariffs(t),
+      tariff(NULL),
+      cash(property.cash),
+      up(property.up),
+      down(property.down),
+      lastCashAdd(property.lastCashAdd),
+      passiveTime(property.passiveTime),
+      lastCashAddTime(property.lastCashAddTime),
+      freeMb(property.freeMb),
+      lastActivityTime(property.lastActivityTime),
+      password(property.password),
+      passive(property.passive),
+      disabled(property.disabled),
+      disabledDetailStat(property.disabledDetailStat),
+      alwaysOnline(property.alwaysOnline),
+      tariffName(property.tariffName),
+      nextTariff(property.nextTariff),
+      address(property.address),
+      note(property.note),
+      group(property.group),
+      email(property.email),
+      phone(property.phone),
+      realName(property.realName),
+      credit(property.credit),
+      creditExpire(property.creditExpire),
+      ips(property.ips),
+      userdata0(property.userdata0),
+      userdata1(property.userdata1),
+      userdata2(property.userdata2),
+      userdata3(property.userdata3),
+      userdata4(property.userdata4),
+      userdata5(property.userdata5),
+      userdata6(property.userdata6),
+      userdata7(property.userdata7),
+      userdata8(property.userdata8),
+      userdata9(property.userdata9),
+      passiveNotifier(this),
+      tariffNotifier(this),
+      cashNotifier(this),
+      ipNotifier(this)
+{
+settings = s;

 
 

-#include "user.h"
-#include "common.h"
-#include "settings.h"
-#include "script_executer.h"
-#include "tariff.h"
-#include "tariffs.h"
-#include "admin.h"
+password = "*_EMPTY_PASSWORD_*";
+tariffName = NO_TARIFF_NAME;
+connected = 0;
+ips = StrToIPS("*");
+deleted = false;
+lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();
+lastWriteDetailedStat = stgTime;
+
+property.tariffName.AddBeforeNotifier(&tariffNotifier);
+property.passive.AddBeforeNotifier(&passiveNotifier);
+property.cash.AddBeforeNotifier(&cashNotifier);
+ips.AddAfterNotifier(&ipNotifier);
+
+lastScanMessages = 0;

 
 

-USER::USER(const SETTINGS * s,
-           const BASE_STORE * st,
+pthread_mutexattr_t attr;
+pthread_mutexattr_init(&attr);
+pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+pthread_mutex_init(&mutex, &attr);
+}
+#else
+USER_IMPL::USER_IMPL(const SETTINGS_IMPL * s,
+           const STORE * st,

            const TARIFFS * t,
            const TARIFFS * t,

-           const ADMIN & a,
-           const map<uint32_t, user_iter> * ipIdx)
-    : property(s),
+           const ADMIN * a,
+           const USERS * u)
+    : users(u),
+      property(s->GetScriptsDir()),

       WriteServLog(GetStgLogger()),
       login(),
       id(0),
       WriteServLog(GetStgLogger()),
       login(),
       id(0),


@@ -64,7 +151,7 @@ USER::USER(const SETTINGS * s,
       sysAdmin(a),
       store(st),
       tariffs(t),
       sysAdmin(a),
       store(st),
       tariffs(t),

-      tariff(tariffs->GetNoTariff()),
+      tariff(NULL),

       cash(property.cash),
       up(property.up),
       down(property.down),
       cash(property.cash),
       up(property.up),
       down(property.down),


@@ -105,21 +192,19 @@ USER::USER(const SETTINGS * s,
       ipNotifier(this)
 {
 settings = s;
       ipNotifier(this)
 {
 settings = s;

-ipIndex = ipIdx;

 
 password = "*_EMPTY_PASSWORD_*";
 tariffName = NO_TARIFF_NAME;
 connected = 0;
 
 password = "*_EMPTY_PASSWORD_*";
 tariffName = NO_TARIFF_NAME;
 connected = 0;

-tariff = tariffs->GetNoTariff();

 ips = StrToIPS("*");
 deleted = false;
 lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();
 ips = StrToIPS("*");
 deleted = false;
 lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();

-lastWriteDeatiledStat = stgTime;
+lastWriteDetailedStat = stgTime;

 
 property.tariffName.AddBeforeNotifier(&tariffNotifier);
 property.passive.AddBeforeNotifier(&passiveNotifier);
 property.cash.AddBeforeNotifier(&cashNotifier);
 
 property.tariffName.AddBeforeNotifier(&tariffNotifier);
 property.passive.AddBeforeNotifier(&passiveNotifier);
 property.cash.AddBeforeNotifier(&cashNotifier);

-currIP.AddAfterNotifier(&ipNotifier);
+ips.AddAfterNotifier(&ipNotifier);

 
 lastScanMessages = 0;
 
 
 lastScanMessages = 0;
 


@@ -128,9 +213,11 @@ pthread_mutexattr_init(&attr);
 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 pthread_mutex_init(&mutex, &attr);
 }
 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 pthread_mutex_init(&mutex, &attr);
 }

+#endif

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-USER::USER(const USER & u)
-    : property(u.settings),
+USER_IMPL::USER_IMPL(const USER_IMPL & u)
+    : users(u.users),
+      property(u.settings->GetScriptsDir()),

       WriteServLog(GetStgLogger()),
       login(u.login),
       id(u.id),
       WriteServLog(GetStgLogger()),
       login(u.login),
       id(u.id),


@@ -188,19 +275,17 @@ if (&u == this)
 
 connected = 0;
 
 
 connected = 0;
 

-ipIndex = u.ipIndex;
-

 deleted = u.deleted;
 
 lastWriteStat = u.lastWriteStat;
 deleted = u.deleted;
 
 lastWriteStat = u.lastWriteStat;

-lastWriteDeatiledStat = u.lastWriteDeatiledStat;
+lastWriteDetailedStat = u.lastWriteDetailedStat;

 
 settings = u.settings;
 
 property.tariffName.AddBeforeNotifier(&tariffNotifier);
 property.passive.AddBeforeNotifier(&passiveNotifier);
 property.cash.AddBeforeNotifier(&cashNotifier);
 
 settings = u.settings;
 
 property.tariffName.AddBeforeNotifier(&tariffNotifier);
 property.passive.AddBeforeNotifier(&passiveNotifier);
 property.cash.AddBeforeNotifier(&cashNotifier);

-currIP.AddAfterNotifier(&ipNotifier);
+ips.AddAfterNotifier(&ipNotifier);

 
 lastScanMessages = 0;
 
 
 lastScanMessages = 0;
 


@@ -212,14 +297,14 @@ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 pthread_mutex_init(&mutex, &attr);
 }
 //-----------------------------------------------------------------------------
 pthread_mutex_init(&mutex, &attr);
 }
 //-----------------------------------------------------------------------------

-USER::~USER()
+USER_IMPL::~USER_IMPL()

 {
 property.passive.DelBeforeNotifier(&passiveNotifier);
 property.tariffName.DelBeforeNotifier(&tariffNotifier);
 pthread_mutex_destroy(&mutex);
 }
 //-----------------------------------------------------------------------------
 {
 property.passive.DelBeforeNotifier(&passiveNotifier);
 property.tariffName.DelBeforeNotifier(&tariffNotifier);
 pthread_mutex_destroy(&mutex);
 }
 //-----------------------------------------------------------------------------

-void USER::SetLogin(string const & l)
+void USER_IMPL::SetLogin(string const & l)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 assert(login.empty() && "Login is already set");
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 assert(login.empty() && "Login is already set");


@@ -227,7 +312,7 @@ login = l;
 id = userIDGenerator.GetNextID();
 }
 //-----------------------------------------------------------------------------
 id = userIDGenerator.GetNextID();
 }
 //-----------------------------------------------------------------------------

-int USER::ReadConf()
+int USER_IMPL::ReadConf()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_CONF conf;
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_CONF conf;


@@ -272,7 +357,7 @@ for (it = hdrsList.begin(); it != hdrsList.end(); ++it)
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-int USER::ReadStat()
+int USER_IMPL::ReadStat()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_STAT stat;
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_STAT stat;


@@ -291,7 +376,7 @@ property.SetStat(stat);
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-int USER::WriteConf()
+int USER_IMPL::WriteConf()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_CONF conf(property.GetConf());
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_CONF conf(property.GetConf());


@@ -310,13 +395,11 @@ if (store->SaveUserConf(conf, login))
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-int USER::WriteStat()
+int USER_IMPL::WriteStat()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_STAT stat(property.GetStat());
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_STAT stat(property.GetStat());
 

-printfd(__FILE__, "USER::WriteStat()\n");
-

 if (store->SaveUserStat(stat, login))
     {
     WriteServLog("Cannot write stat for user %s.", login.c_str());
 if (store->SaveUserStat(stat, login))
     {
     WriteServLog("Cannot write stat for user %s.", login.c_str());


@@ -331,7 +414,7 @@ lastWriteStat = stgTime;
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-int USER::WriteMonthStat()
+int USER_IMPL::WriteMonthStat()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 time_t tt = stgTime - 3600;
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 time_t tt = stgTime - 3600;


@@ -351,7 +434,7 @@ if (store->SaveMonthStat(stat, t1.tm_mon, t1.tm_year, login))
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-int USER::Authorize(uint32_t ip, const string &, uint32_t dirs, const BASE_AUTH * auth)
+int USER_IMPL::Authorize(uint32_t ip, uint32_t dirs, const AUTH * auth)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 /*
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 /*


@@ -379,28 +462,28 @@ if (authorizedBy.size())
     if (currIP != ip)
         {
         //  We are already authorized, but with different IP address
     if (currIP != ip)
         {
         //  We are already authorized, but with different IP address

-        errorStr = "User " + login + " alredy authorized with IP address " + inet_ntostring(ip);
+        errorStr = "User " + login + " already authorized with IP address " + inet_ntostring(ip);

         return -1;
         }
 
         return -1;
         }
 

-    map<uint32_t, user_iter>::const_iterator ci = ipIndex->find(ip);
-    if (ci != ipIndex->end())
+    USER * u = NULL;
+    if (!users->FindByIPIdx(ip, &u))

         {
         //  Address is already present in IP-index
         //  If it's not our IP - throw an error
         {
         //  Address is already present in IP-index
         //  If it's not our IP - throw an error

-        if (&(*ci->second) != this)
+        if (u != this)

             {
             {

-            errorStr = "IP address " + inet_ntostring(ip) + " alredy in use";
+            errorStr = "IP address " + inet_ntostring(ip) + " already in use";

             return -1;
             }
         }
     }
 else
     {
             return -1;
             }
         }
     }
 else
     {

-    if (ipIndex->find(ip) != ipIndex->end())
+    if (users->IsIPInIndex(ip))

         {
         //  Address is already present in IP-index
         {
         //  Address is already present in IP-index

-        errorStr = "IP address " + inet_ntostring(ip) + " alredy in use";
+        errorStr = "IP address " + inet_ntostring(ip) + " already in use";

         return -1;
         }
 
         return -1;
         }
 


@@ -424,7 +507,7 @@ ScanMessage();
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-void USER::Unauthorize(const BASE_AUTH * auth)
+void USER_IMPL::Unauthorize(const AUTH * auth)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 /*
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 /*


@@ -441,14 +524,14 @@ if (authorizedBy.empty())
     }
 }
 //-----------------------------------------------------------------------------
     }
 }
 //-----------------------------------------------------------------------------

-bool USER::IsAuthorizedBy(const BASE_AUTH * auth) const
+bool USER_IMPL::IsAuthorizedBy(const AUTH * auth) const

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 //  Is this user authorized by specified authorizer?
 return authorizedBy.find(auth) != authorizedBy.end();
 }
 //-----------------------------------------------------------------------------
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 //  Is this user authorized by specified authorizer?
 return authorizedBy.find(auth) != authorizedBy.end();
 }
 //-----------------------------------------------------------------------------

-void USER::Connect(bool fakeConnect)
+void USER_IMPL::Connect(bool fakeConnect)

 {
 /*
  *  Connect user to Internet. This function is differ from Authorize() !!!
 {
 /*
  *  Connect user to Internet. This function is differ from Authorize() !!!


@@ -458,7 +541,7 @@ STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 if (!fakeConnect)
     {
 
 if (!fakeConnect)
     {

-    string scriptOnConnect = settings->GetScriptDir() + "/OnConnect";
+    string scriptOnConnect = settings->GetScriptsDir() + "/OnConnect";

 
     if (access(scriptOnConnect.c_str(), X_OK) == 0)
         {
 
     if (access(scriptOnConnect.c_str(), X_OK) == 0)
         {


@@ -499,7 +582,7 @@ if (!fakeConnect)
     lastIPForDisconnect = currIP;
 }
 //-----------------------------------------------------------------------------
     lastIPForDisconnect = currIP;
 }
 //-----------------------------------------------------------------------------

-void USER::Disconnect(bool fakeDisconnect, const std::string & reason)
+void USER_IMPL::Disconnect(bool fakeDisconnect, const std::string & reason)

 {
 /*
  *  Disconnect user from Internet. This function is differ from UnAuthorize() !!!
 {
 /*
  *  Disconnect user from Internet. This function is differ from UnAuthorize() !!!


@@ -515,7 +598,7 @@ if (!lastIPForDisconnect)
 
 if (!fakeDisconnect)
     {
 
 if (!fakeDisconnect)
     {

-    string scriptOnDisonnect = settings->GetScriptDir() + "/OnDisconnect";
+    string scriptOnDisonnect = settings->GetScriptsDir() + "/OnDisconnect";

 
     if (access(scriptOnDisonnect.c_str(), X_OK) == 0)
         {
 
     if (access(scriptOnDisonnect.c_str(), X_OK) == 0)
         {


@@ -561,7 +644,7 @@ sessionUpload = zeroSesssion;
 sessionDownload = zeroSesssion;
 }
 //-----------------------------------------------------------------------------
 sessionDownload = zeroSesssion;
 }
 //-----------------------------------------------------------------------------

-void USER::PrintUser() const
+void USER_IMPL::PrintUser() const

 {
 //return;
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 {
 //return;
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);


@@ -598,7 +681,7 @@ cout << "lastActivityTime=" << lastActivityTime << endl;
 cout << "============================================================" << endl;
 }
 //-----------------------------------------------------------------------------
 cout << "============================================================" << endl;
 }
 //-----------------------------------------------------------------------------

-void USER::Run()
+void USER_IMPL::Run()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 


@@ -627,7 +710,7 @@ if (!authorizedBy.empty())
     {
     if (connected)
         {
     {
     if (connected)
         {

-        lastActivityTime = *const_cast<time_t *>(&stgTime);
+        property.Stat().lastActivityTime = stgTime;

         }
     if (!connected && IsInetable())
         {
         }
     if (!connected && IsInetable())
         {


@@ -659,7 +742,7 @@ else
 
 }
 //-----------------------------------------------------------------------------
 
 }
 //-----------------------------------------------------------------------------

-void USER::UpdatePingTime(time_t t)
+void USER_IMPL::UpdatePingTime(time_t t)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 //printfd(__FILE__, "UpdatePingTime(%d) %s\n", t, login.c_str());
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 //printfd(__FILE__, "UpdatePingTime(%d) %s\n", t, login.c_str());


@@ -669,7 +752,7 @@ else
     pingTime = stgTime;
 }
 //-----------------------------------------------------------------------------
     pingTime = stgTime;
 }
 //-----------------------------------------------------------------------------

-bool USER::IsInetable()
+bool USER_IMPL::IsInetable()

 {
 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 


@@ -682,7 +765,7 @@ if (settings->GetFreeMbAllowInet())
         return true;
     }
 
         return true;
     }
 

-if (settings->GetShowFeeInCash())
+if (settings->GetShowFeeInCash() || tariff == NULL)

     {
     return (cash >= -credit);
     }
     {
     return (cash >= -credit);
     }


@@ -690,7 +773,7 @@ if (settings->GetShowFeeInCash())
 return (cash - tariff->GetFee() >= -credit);
 }
 //-----------------------------------------------------------------------------
 return (cash - tariff->GetFee() >= -credit);
 }
 //-----------------------------------------------------------------------------

-string USER::GetEnabledDirs()
+string USER_IMPL::GetEnabledDirs()

 {
 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 


@@ -701,14 +784,14 @@ return dirs;
 }
 //-----------------------------------------------------------------------------
 #ifdef TRAFF_STAT_WITH_PORTS
 }
 //-----------------------------------------------------------------------------
 #ifdef TRAFF_STAT_WITH_PORTS

-void USER::AddTraffStatU(int dir, uint32_t ip, uint16_t port, uint32_t len)
+void USER_IMPL::AddTraffStatU(int dir, uint32_t ip, uint16_t port, uint32_t len)

 #else
 #else

-void USER::AddTraffStatU(int dir, uint32_t ip, uint32_t len)
+void USER_IMPL::AddTraffStatU(int dir, uint32_t ip, uint32_t len)

 #endif
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 #endif
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 

-if (!connected)
+if (!connected || tariff == NULL)

     return;
 
 double cost = 0;
     return;
 
 double cost = 0;


@@ -756,8 +839,8 @@ if (tt == TRAFF_UP ||
         cost = dc - freeMb.ConstData();
 
     // Direct access to internal data structures via friend-specifier
         cost = dc - freeMb.ConstData();
 
     // Direct access to internal data structures via friend-specifier

-    property.stat.freeMb -= dc;
-    property.stat.cash -= cost;
+    property.Stat().freeMb -= dc;
+    property.Stat().cash -= cost;

     cash.ModifyTime();
     freeMb.ModifyTime();
     }
     cash.ModifyTime();
     freeMb.ModifyTime();
     }


@@ -793,14 +876,14 @@ else
 }
 //-----------------------------------------------------------------------------
 #ifdef TRAFF_STAT_WITH_PORTS
 }
 //-----------------------------------------------------------------------------
 #ifdef TRAFF_STAT_WITH_PORTS

-void USER::AddTraffStatD(int dir, uint32_t ip, uint16_t port, uint32_t len)
+void USER_IMPL::AddTraffStatD(int dir, uint32_t ip, uint16_t port, uint32_t len)

 #else
 #else

-void USER::AddTraffStatD(int dir, uint32_t ip, uint32_t len)
+void USER_IMPL::AddTraffStatD(int dir, uint32_t ip, uint32_t len)

 #endif
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 #endif
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 

-if (!connected)
+if (!connected || tariff == NULL)

     return;
 
 double cost = 0;
     return;
 
 double cost = 0;


@@ -847,8 +930,8 @@ if (tt == TRAFF_DOWN ||
     else if (freeMb.ConstData() < dc) // FreeMb is partially exhausted
         cost = dc - freeMb.ConstData();
 
     else if (freeMb.ConstData() < dc) // FreeMb is partially exhausted
         cost = dc - freeMb.ConstData();
 

-    property.stat.freeMb -= dc;
-    property.stat.cash -= cost;
+    property.Stat().freeMb -= dc;
+    property.Stat().cash -= cost;

     cash.ModifyTime();
     freeMb.ModifyTime();
     }
     cash.ModifyTime();
     freeMb.ModifyTime();
     }


@@ -883,35 +966,59 @@ else
     }
 }
 //-----------------------------------------------------------------------------
     }
 }
 //-----------------------------------------------------------------------------

-void USER::AddCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::AddCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 currIP.AddBeforeNotifier(n);
 }
 //-----------------------------------------------------------------------------
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 currIP.AddBeforeNotifier(n);
 }
 //-----------------------------------------------------------------------------

-void USER::DelCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::DelCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 currIP.DelBeforeNotifier(n);
 }
 //-----------------------------------------------------------------------------
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 currIP.DelBeforeNotifier(n);
 }
 //-----------------------------------------------------------------------------

-void USER::AddCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::AddCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 currIP.AddAfterNotifier(n);
 }
 //-----------------------------------------------------------------------------
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 currIP.AddAfterNotifier(n);
 }
 //-----------------------------------------------------------------------------

-void USER::DelCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::DelCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 currIP.DelAfterNotifier(n);
 }
 //-----------------------------------------------------------------------------
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 currIP.DelAfterNotifier(n);
 }
 //-----------------------------------------------------------------------------

-void USER::OnAdd()
+void USER_IMPL::AddConnectedBeforeNotifier(PROPERTY_NOTIFIER_BASE<bool> * n)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+connected.AddBeforeNotifier(n);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::DelConnectedBeforeNotifier(PROPERTY_NOTIFIER_BASE<bool> * n)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+connected.DelBeforeNotifier(n);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::AddConnectedAfterNotifier(PROPERTY_NOTIFIER_BASE<bool> * n)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+connected.AddAfterNotifier(n);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::DelConnectedAfterNotifier(PROPERTY_NOTIFIER_BASE<bool> * n)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+connected.DelAfterNotifier(n);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::OnAdd()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 

-string scriptOnAdd = settings->GetScriptDir() + "/OnUserAdd";
+string scriptOnAdd = settings->GetScriptsDir() + "/OnUserAdd";

 
 if (access(scriptOnAdd.c_str(), X_OK) == 0)
     {
 
 if (access(scriptOnAdd.c_str(), X_OK) == 0)
     {


@@ -929,11 +1036,11 @@ else
     }
 }
 //-----------------------------------------------------------------------------
     }
 }
 //-----------------------------------------------------------------------------

-void USER::OnDelete()
+void USER_IMPL::OnDelete()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 

-string scriptOnDel = settings->GetScriptDir() + "/OnUserDel";
+string scriptOnDel = settings->GetScriptsDir() + "/OnUserDel";

 
 if (access(scriptOnDel.c_str(), X_OK) == 0)
     {
 
 if (access(scriptOnDel.c_str(), X_OK) == 0)
     {


@@ -953,7 +1060,7 @@ else
 Run();
 }
 //-----------------------------------------------------------------------------
 Run();
 }
 //-----------------------------------------------------------------------------

-int USER::WriteDetailStat(bool hard)
+int USER_IMPL::WriteDetailStat(bool hard)

 {
 printfd(__FILE__, "USER::WriteDetailedStat() - saved size = %d\n", traffStatSaved.second.size());
 
 {
 printfd(__FILE__, "USER::WriteDetailedStat() - saved size = %d\n", traffStatSaved.second.size());
 


@@ -980,7 +1087,7 @@ printfd(__FILE__, "USER::WriteDetailedStat() - size = %d\n", ts.size());
 
 if (ts.size() && !disabledDetailStat)
     {
 
 if (ts.size() && !disabledDetailStat)
     {

-    if (store->WriteDetailedStat(ts, lastWriteDeatiledStat, login))
+    if (store->WriteDetailedStat(ts, lastWriteDetailedStat, login))

         {
         printfd(__FILE__, "USER::WriteDetailStat() - failed to write current detail stat\n");
         WriteServLog("Cannot write detail stat for user %s.", login.c_str());
         {
         printfd(__FILE__, "USER::WriteDetailStat() - failed to write current detail stat\n");
         WriteServLog("Cannot write detail stat for user %s.", login.c_str());


@@ -990,16 +1097,16 @@ if (ts.size() && !disabledDetailStat)
             printfd(__FILE__, "USER::WriteDetailStat() - pushing detail stat to queue\n");
             STG_LOCKER lock(&mutex, __FILE__, __LINE__);
             traffStatSaved.second.swap(ts);
             printfd(__FILE__, "USER::WriteDetailStat() - pushing detail stat to queue\n");
             STG_LOCKER lock(&mutex, __FILE__, __LINE__);
             traffStatSaved.second.swap(ts);

-            traffStatSaved.first = lastWriteDeatiledStat;
+            traffStatSaved.first = lastWriteDetailedStat;

             }
         return -1;
         }
     }
             }
         return -1;
         }
     }

-lastWriteDeatiledStat = stgTime;
+lastWriteDetailedStat = stgTime;

 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-double USER::GetPassiveTimePart() const
+double USER_IMPL::GetPassiveTimePart() const

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 


@@ -1026,7 +1133,7 @@ if (dt < 0)
 return double(dt) / (secMonth);
 }
 //-----------------------------------------------------------------------------
 return double(dt) / (secMonth);
 }
 //-----------------------------------------------------------------------------

-void USER::SetPassiveTimeAsNewUser()
+void USER_IMPL::SetPassiveTimeAsNewUser()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 


@@ -1039,7 +1146,7 @@ double pt = (tm.tm_mday - 1) / (double)daysCurrMon;
 passiveTime = (time_t)(pt * 24 * 3600 * daysCurrMon);
 }
 //-----------------------------------------------------------------------------
 passiveTime = (time_t)(pt * 24 * 3600 * daysCurrMon);
 }
 //-----------------------------------------------------------------------------

-void USER::MidnightResetSessionStat()
+void USER_IMPL::MidnightResetSessionStat()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 


@@ -1050,7 +1157,7 @@ if (connected)
     }
 }
 //-----------------------------------------------------------------------------
     }
 }
 //-----------------------------------------------------------------------------

-void USER::ProcessNewMonth()
+void USER_IMPL::ProcessNewMonth()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 //  Reset traff
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 //  Reset traff


@@ -1083,34 +1190,50 @@ if (nextTariff.ConstData() != "")
     else
         {
         property.tariffName.Set(nextTariff, sysAdmin, login, store);
     else
         {
         property.tariffName.Set(nextTariff, sysAdmin, login, store);

-        tariff = nt;
+        //tariff = nt;

         }
     ResetNextTariff();
     WriteConf();
     }
 }
 //-----------------------------------------------------------------------------
         }
     ResetNextTariff();
     WriteConf();
     }
 }
 //-----------------------------------------------------------------------------

-void USER::ProcessDayFeeSpread()
+void USER_IMPL::ProcessDayFeeSpread()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 

-if (passive.ConstData())
+if (passive.ConstData() || tariff == NULL)

     return;
 
     return;
 

-double f = tariff->GetFee() / DaysInCurrentMonth();
+double fee = tariff->GetFee() / DaysInCurrentMonth();

 
 

-if (f == 0.0)
+if (fee == 0.0)

     return;
 
 double c = cash;
     return;
 
 double c = cash;

-property.cash.Set(c - f, sysAdmin, login, store, "Subscriber fee charge");
+switch (settings->GetFeeChargeType())
+    {
+    case 0:
+        property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+        break;
+    case 1:
+        if (c > 0)
+            property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+        break;
+    case 2:
+        if (c > fee)
+            property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+        break;
+    }

 ResetPassiveTime();
 }
 //-----------------------------------------------------------------------------
 ResetPassiveTime();
 }
 //-----------------------------------------------------------------------------

-void USER::ProcessDayFee()
+void USER_IMPL::ProcessDayFee()

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 

+if (tariff == NULL)
+    return;
+

 double passiveTimePart = 1.0;
 if (!settings->GetFullFee())
     {
 double passiveTimePart = 1.0;
 if (!settings->GetFullFee())
     {


@@ -1124,30 +1247,52 @@ else
         return;
         }
     }
         return;
         }
     }

-double f = tariff->GetFee() * passiveTimePart;
+double fee = tariff->GetFee() * passiveTimePart;

 
 ResetPassiveTime();
 
 
 ResetPassiveTime();
 

-if (f == 0.0)
+if (fee == 0.0)
+    {
+    SetPrepaidTraff();

     return;
     return;

+    }

 
 double c = cash;
 printfd(__FILE__, "login: %8s   Fee=%f PassiveTimePart=%f fee=%f\n",
         login.c_str(),
         tariff->GetFee(),
         passiveTimePart,
 
 double c = cash;
 printfd(__FILE__, "login: %8s   Fee=%f PassiveTimePart=%f fee=%f\n",
         login.c_str(),
         tariff->GetFee(),
         passiveTimePart,

-        f);
-property.cash.Set(c - f, sysAdmin, login, store, "Subscriber fee charge");
+        fee);
+switch (settings->GetFeeChargeType())
+    {
+    case 0:
+        property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+        SetPrepaidTraff();
+        break;
+    case 1:
+        if (c > 0)
+            {
+            property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+            SetPrepaidTraff();
+            }
+        break;
+    case 2:
+        if (c > fee)
+            {
+            property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+            SetPrepaidTraff();
+            }
+        break;
+    }

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

-void USER::SetPrepaidTraff()
+void USER_IMPL::SetPrepaidTraff()

 {
 {

-STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-
-property.freeMb.Set(tariff->GetFree(), sysAdmin, login, store, "Prepaid traffic");
+if (tariff != NULL)
+    property.freeMb.Set(tariff->GetFree(), sysAdmin, login, store, "Prepaid traffic");

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

-int USER::AddMessage(STG_MSG * msg)
+int USER_IMPL::AddMessage(STG_MSG * msg)

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 


@@ -1186,11 +1331,11 @@ else
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-int USER::SendMessage(STG_MSG & msg) const
+int USER_IMPL::SendMessage(STG_MSG & msg) const

 {
 // No lock `cause we are already locked from caller
 int ret = -1;
 {
 // No lock `cause we are already locked from caller
 int ret = -1;

-set<const BASE_AUTH*>::iterator it(authorizedBy.begin());
+set<const AUTH*>::iterator it(authorizedBy.begin());

 while (it != authorizedBy.end())
     {
     if (!(*it++)->SendMessage(msg, currIP))
 while (it != authorizedBy.end())
     {
     if (!(*it++)->SendMessage(msg, currIP))


@@ -1209,7 +1354,7 @@ if (!ret)
 return ret;
 }
 //-----------------------------------------------------------------------------
 return ret;
 }
 //-----------------------------------------------------------------------------

-void USER::ScanMessage()
+void USER_IMPL::ScanMessage()

 {
 // No lock `cause we are already locked from caller
 // We need not check for the authorizedBy `cause it has already checked by caller
 {
 // No lock `cause we are already locked from caller
 // We need not check for the authorizedBy `cause it has already checked by caller


@@ -1256,6 +1401,10 @@ while (it != messages.end())
             ++it;
             }
         }
             ++it;
             }
         }

+    else
+        {
+        ++it;
+        }

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


@@ -1263,7 +1412,7 @@ while (it != messages.end())
 //-----------------------------------------------------------------------------
 void CHG_PASSIVE_NOTIFIER::Notify(const int & oldPassive, const int & newPassive)
 {
 //-----------------------------------------------------------------------------
 void CHG_PASSIVE_NOTIFIER::Notify(const int & oldPassive, const int & newPassive)
 {

-if (newPassive && !oldPassive)
+if (newPassive && !oldPassive && user->tariff != NULL)

     user->property.cash.Set(user->cash - user->tariff->GetPassiveCost(),
                             user->sysAdmin,
                             user->login,
     user->property.cash.Set(user->cash - user->tariff->GetPassiveCost(),
                             user->sysAdmin,
                             user->login,


@@ -1273,7 +1422,11 @@ if (newPassive && !oldPassive)
 //-----------------------------------------------------------------------------
 void CHG_TARIFF_NOTIFIER::Notify(const string &, const string & newTariff)
 {
 //-----------------------------------------------------------------------------
 void CHG_TARIFF_NOTIFIER::Notify(const string &, const string & newTariff)
 {

+if (user->settings->GetReconnectOnTariffChange() && user->connected)
+    user->Disconnect(true, "Change tariff");

 user->tariff = user->tariffs->FindByName(newTariff);
 user->tariff = user->tariffs->FindByName(newTariff);

+if (user->settings->GetReconnectOnTariffChange() && user->IsInetable())
+    user->Connect(true);

 }
 //-----------------------------------------------------------------------------
 void CHG_CASH_NOTIFIER::Notify(const double & oldCash, const double & newCash)
 }
 //-----------------------------------------------------------------------------
 void CHG_CASH_NOTIFIER::Notify(const double & oldCash, const double & newCash)


@@ -1282,14 +1435,12 @@ user->lastCashAddTime = *const_cast<time_t *>(&stgTime);
 user->lastCashAdd = newCash - oldCash;
 }
 //-----------------------------------------------------------------------------
 user->lastCashAdd = newCash - oldCash;
 }
 //-----------------------------------------------------------------------------

-void CHG_IP_NOTIFIER::Notify(const uint32_t & from, const uint32_t & to)
+void CHG_IPS_NOTIFIER::Notify(const USER_IPS & from, const USER_IPS & to)

 {
 {

-    printfd(__FILE__, "Change IP from %s to %s\n", inet_ntostring(from).c_str(), inet_ntostring(to).c_str());
-    if (from != 0)
-        if (user->connected)
-            user->Disconnect(false, "Change IP");
-    if (to != 0)
-        if (user->IsInetable())
-            user->Connect(false);
+    printfd(__FILE__, "Change IP from '%s' to '%s'\n", from.GetIpStr().c_str(), to.GetIpStr().c_str());
+    if (user->connected)
+        user->Disconnect(true, "Change IP");
+    if (user->IsInetable())
+        user->Connect(true);

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