Added note about waiting rscriptd until message queue becomes empty

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

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

-
-#include "user.h"
-#include "common.h"
-#include "settings.h"
-#include "script_executer.h"
-#include "tariff.h"
-#include "tariffs.h"
-#include "admin.h"
-
-USER::USER(const SETTINGS * s,
-           const BASE_STORE * st,
+#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"
+
+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),


@@ -105,7 +108,6 @@ USER::USER(const SETTINGS * s,
       ipNotifier(this)
 {
 settings = s;
       ipNotifier(this)
 {
 settings = s;

-ipIndex = ipIdx;

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


@@ -114,7 +116,7 @@ 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.tariffName.AddBeforeNotifier(&tariffNotifier);
 property.passive.AddBeforeNotifier(&passiveNotifier);


@@ -129,8 +131,9 @@ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 pthread_mutex_init(&mutex, &attr);
 }
 //-----------------------------------------------------------------------------
 pthread_mutex_init(&mutex, &attr);
 }
 //-----------------------------------------------------------------------------

-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,12 +191,10 @@ 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;
 
 
 settings = u.settings;
 


@@ -212,14 +213,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 +228,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 +273,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 +292,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,7 +311,7 @@ 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());


@@ -331,7 +332,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 +352,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__);
 /*


@@ -383,12 +384,12 @@ if (authorizedBy.size())
         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";
             return -1;
             {
             errorStr = "IP address " + inet_ntostring(ip) + " alredy in use";
             return -1;


@@ -397,7 +398,7 @@ if (authorizedBy.size())
     }
 else
     {
     }
 else
     {

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

         {
         //  Address is already present in IP-index
         errorStr = "IP address " + inet_ntostring(ip) + " alredy in use";
         {
         //  Address is already present in IP-index
         errorStr = "IP address " + inet_ntostring(ip) + " alredy in use";


@@ -424,7 +425,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 +442,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 +459,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 +500,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 +516,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 +562,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 +599,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__);
 


@@ -659,7 +660,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 +670,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__);
 


@@ -690,7 +691,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,9 +702,9 @@ 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__);


@@ -756,8 +757,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,9 +794,9 @@ 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__);


@@ -847,8 +848,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 +884,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 +954,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 +978,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 +1005,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 +1015,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 +1051,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 +1064,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 +1075,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


@@ -1090,7 +1115,7 @@ if (nextTariff.ConstData() != "")
     }
 }
 //-----------------------------------------------------------------------------
     }
 }
 //-----------------------------------------------------------------------------

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

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


@@ -1107,7 +1132,7 @@ property.cash.Set(c - f, sysAdmin, login, store, "Subscriber fee charge");
 ResetPassiveTime();
 }
 //-----------------------------------------------------------------------------
 ResetPassiveTime();
 }
 //-----------------------------------------------------------------------------

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

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


@@ -1140,14 +1165,14 @@ printfd(__FILE__, "login: %8s   Fee=%f PassiveTimePart=%f fee=%f\n",
 property.cash.Set(c - f, sysAdmin, login, store, "Subscriber fee charge");
 }
 //-----------------------------------------------------------------------------
 property.cash.Set(c - f, sysAdmin, login, store, "Subscriber fee charge");
 }
 //-----------------------------------------------------------------------------

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

 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 property.freeMb.Set(tariff->GetFree(), sysAdmin, login, store, "Prepaid traffic");
 }
 //-----------------------------------------------------------------------------
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 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 +1211,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 +1234,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