Replace change_tariff link to chg_tariff

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

diff --git a/projects/stargazer/user_impl.cpp b/projects/stargazer/user_impl.cpp
index d8368c4d41b1885821af69c158b4da0afe4dc417..e1bb4baefb2c40955661ede5717167adc28ff7dc 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 <cstdlib>
 
-#include "user.h"
+#include "user_impl.h"
+#include "users.h"
 #include "common.h"
-#include "settings.h"
+#include "settings_impl.h"
 #include "script_executer.h"
 #include "tariff.h"
 #include "tariffs.h"
 #include "admin.h"
 
-USER::USER(const SETTINGS * s,
-           const BASE_STORE * st,
+USER_IMPL::USER_IMPL(const SETTINGS_IMPL * s,
+           const STORE * st,
            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),
@@ -105,7 +108,6 @@ USER::USER(const SETTINGS * s,
       ipNotifier(this)
 {
 settings = s;
-ipIndex = ipIdx;
 
 password = "*_EMPTY_PASSWORD_*";
 tariffName = NO_TARIFF_NAME;
@@ -114,7 +116,7 @@ tariff = tariffs->GetNoTariff();
 ips = StrToIPS("*");
 deleted = false;
 lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();
-lastWriteDeatiledStat = stgTime;
+lastWriteDetailedStat = stgTime;
 
 property.tariffName.AddBeforeNotifier(&tariffNotifier);
 property.passive.AddBeforeNotifier(&passiveNotifier);
@@ -129,8 +131,9 @@ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 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),
@@ -188,12 +191,10 @@ if (&u == this)
 
 connected = 0;
 
-ipIndex = u.ipIndex;
-
 deleted = u.deleted;
 
 lastWriteStat = u.lastWriteStat;
-lastWriteDeatiledStat = u.lastWriteDeatiledStat;
+lastWriteDetailedStat = u.lastWriteDetailedStat;
 
 settings = u.settings;
 
@@ -212,14 +213,14 @@ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 pthread_mutex_init(&mutex, &attr);
 }
 //-----------------------------------------------------------------------------
-USER::~USER()
+USER_IMPL::~USER_IMPL()
 {
 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");
@@ -227,7 +228,7 @@ login = l;
 id = userIDGenerator.GetNextID();
 }
 //-----------------------------------------------------------------------------
-int USER::ReadConf()
+int USER_IMPL::ReadConf()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_CONF conf;
@@ -272,7 +273,7 @@ for (it = hdrsList.begin(); it != hdrsList.end(); ++it)
 return 0;
 }
 //-----------------------------------------------------------------------------
-int USER::ReadStat()
+int USER_IMPL::ReadStat()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_STAT stat;
@@ -291,7 +292,7 @@ property.SetStat(stat);
 return 0;
 }
 //-----------------------------------------------------------------------------
-int USER::WriteConf()
+int USER_IMPL::WriteConf()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_CONF conf(property.GetConf());
@@ -310,7 +311,7 @@ if (store->SaveUserConf(conf, login))
 return 0;
 }
 //-----------------------------------------------------------------------------
-int USER::WriteStat()
+int USER_IMPL::WriteStat()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 USER_STAT stat(property.GetStat());
@@ -331,7 +332,7 @@ lastWriteStat = stgTime;
 return 0;
 }
 //-----------------------------------------------------------------------------
-int USER::WriteMonthStat()
+int USER_IMPL::WriteMonthStat()
 {
 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;
 }
 //-----------------------------------------------------------------------------
-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__);
 /*
@@ -383,12 +384,12 @@ if (authorizedBy.size())
         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
-        if (&(*ci->second) != this)
+        if (u != this)
             {
             errorStr = "IP address " + inet_ntostring(ip) + " alredy in use";
             return -1;
@@ -397,7 +398,7 @@ if (authorizedBy.size())
     }
 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";
@@ -424,7 +425,7 @@ ScanMessage();
 return 0;
 }
 //-----------------------------------------------------------------------------
-void USER::Unauthorize(const BASE_AUTH * auth)
+void USER_IMPL::Unauthorize(const AUTH * auth)
 {
 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();
 }
 //-----------------------------------------------------------------------------
-void USER::Connect(bool fakeConnect)
+void USER_IMPL::Connect(bool fakeConnect)
 {
 /*
  *  Connect user to Internet. This function is differ from Authorize() !!!
@@ -458,7 +459,7 @@ STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 if (!fakeConnect)
     {
-    string scriptOnConnect = settings->GetScriptDir() + "/OnConnect";
+    string scriptOnConnect = settings->GetScriptsDir() + "/OnConnect";
 
     if (access(scriptOnConnect.c_str(), X_OK) == 0)
         {
@@ -499,7 +500,7 @@ if (!fakeConnect)
     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() !!!
@@ -515,7 +516,7 @@ if (!lastIPForDisconnect)
 
 if (!fakeDisconnect)
     {
-    string scriptOnDisonnect = settings->GetScriptDir() + "/OnDisconnect";
+    string scriptOnDisonnect = settings->GetScriptsDir() + "/OnDisconnect";
 
     if (access(scriptOnDisonnect.c_str(), X_OK) == 0)
         {
@@ -561,7 +562,7 @@ sessionUpload = zeroSesssion;
 sessionDownload = zeroSesssion;
 }
 //-----------------------------------------------------------------------------
-void USER::PrintUser() const
+void USER_IMPL::PrintUser() const
 {
 //return;
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
@@ -598,7 +599,7 @@ cout << "lastActivityTime=" << lastActivityTime << endl;
 cout << "============================================================" << endl;
 }
 //-----------------------------------------------------------------------------
-void USER::Run()
+void USER_IMPL::Run()
 {
 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());
@@ -669,7 +670,7 @@ else
     pingTime = stgTime;
 }
 //-----------------------------------------------------------------------------
-bool USER::IsInetable()
+bool USER_IMPL::IsInetable()
 {
 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
@@ -690,7 +691,7 @@ if (settings->GetShowFeeInCash())
 return (cash - tariff->GetFee() >= -credit);
 }
 //-----------------------------------------------------------------------------
-string USER::GetEnabledDirs()
+string USER_IMPL::GetEnabledDirs()
 {
 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
@@ -701,9 +702,9 @@ return dirs;
 }
 //-----------------------------------------------------------------------------
 #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
-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__);
@@ -756,8 +757,8 @@ if (tt == TRAFF_UP ||
         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();
     }
@@ -793,9 +794,9 @@ else
 }
 //-----------------------------------------------------------------------------
 #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
-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__);
@@ -847,8 +848,8 @@ if (tt == TRAFF_DOWN ||
     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();
     }
@@ -883,35 +884,35 @@ 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);
 }
 //-----------------------------------------------------------------------------
-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);
 }
 //-----------------------------------------------------------------------------
-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);
 }
 //-----------------------------------------------------------------------------
-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);
 }
 //-----------------------------------------------------------------------------
-void USER::OnAdd()
+void USER_IMPL::OnAdd()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
-string scriptOnAdd = settings->GetScriptDir() + "/OnUserAdd";
+string scriptOnAdd = settings->GetScriptsDir() + "/OnUserAdd";
 
 if (access(scriptOnAdd.c_str(), X_OK) == 0)
     {
@@ -929,11 +930,11 @@ else
     }
 }
 //-----------------------------------------------------------------------------
-void USER::OnDelete()
+void USER_IMPL::OnDelete()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
-string scriptOnDel = settings->GetScriptDir() + "/OnUserDel";
+string scriptOnDel = settings->GetScriptsDir() + "/OnUserDel";
 
 if (access(scriptOnDel.c_str(), X_OK) == 0)
     {
@@ -953,7 +954,7 @@ else
 Run();
 }
 //-----------------------------------------------------------------------------
-int USER::WriteDetailStat(bool hard)
+int USER_IMPL::WriteDetailStat(bool hard)
 {
 printfd(__FILE__, "USER::WriteDetailedStat() - saved size = %d\n", traffStatSaved.second.size());
 
@@ -980,7 +981,7 @@ printfd(__FILE__, "USER::WriteDetailedStat() - size = %d\n", ts.size());
 
 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());
@@ -990,16 +991,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);
-            traffStatSaved.first = lastWriteDeatiledStat;
+            traffStatSaved.first = lastWriteDetailedStat;
             }
         return -1;
         }
     }
-lastWriteDeatiledStat = stgTime;
+lastWriteDetailedStat = stgTime;
 return 0;
 }
 //-----------------------------------------------------------------------------
-double USER::GetPassiveTimePart() const
+double USER_IMPL::GetPassiveTimePart() const
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
@@ -1026,7 +1027,7 @@ if (dt < 0)
 return double(dt) / (secMonth);
 }
 //-----------------------------------------------------------------------------
-void USER::SetPassiveTimeAsNewUser()
+void USER_IMPL::SetPassiveTimeAsNewUser()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
@@ -1039,7 +1040,7 @@ double pt = (tm.tm_mday - 1) / (double)daysCurrMon;
 passiveTime = (time_t)(pt * 24 * 3600 * daysCurrMon);
 }
 //-----------------------------------------------------------------------------
-void USER::MidnightResetSessionStat()
+void USER_IMPL::MidnightResetSessionStat()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
@@ -1050,7 +1051,7 @@ if (connected)
     }
 }
 //-----------------------------------------------------------------------------
-void USER::ProcessNewMonth()
+void USER_IMPL::ProcessNewMonth()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 //  Reset traff
@@ -1090,7 +1091,7 @@ if (nextTariff.ConstData() != "")
     }
 }
 //-----------------------------------------------------------------------------
-void USER::ProcessDayFeeSpread()
+void USER_IMPL::ProcessDayFeeSpread()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
@@ -1107,7 +1108,7 @@ property.cash.Set(c - f, sysAdmin, login, store, "Subscriber fee charge");
 ResetPassiveTime();
 }
 //-----------------------------------------------------------------------------
-void USER::ProcessDayFee()
+void USER_IMPL::ProcessDayFee()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
@@ -1140,14 +1141,14 @@ printfd(__FILE__, "login: %8s   Fee=%f PassiveTimePart=%f fee=%f\n",
 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");
 }
 //-----------------------------------------------------------------------------
-int USER::AddMessage(STG_MSG * msg)
+int USER_IMPL::AddMessage(STG_MSG * msg)
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
@@ -1186,11 +1187,11 @@ else
 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;
-set<const BASE_AUTH*>::iterator it(authorizedBy.begin());
+set<const AUTH*>::iterator it(authorizedBy.begin());
 while (it != authorizedBy.end())
     {
     if (!(*it++)->SendMessage(msg, currIP))
@@ -1209,7 +1210,7 @@ if (!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