#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"
+#include "stg_timer.h"
+
+#ifdef USE_ABSTRACT_SETTINGS
+USER_IMPL::USER_IMPL(const SETTINGS * s,
+ const STORE * st,
+ const TARIFFS * t,
+ const ADMIN * a,
+ const USERS * u)
+ : USER(),
+ 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 ADMIN & a,
- const map<uint32_t, user_iter> * ipIdx)
- : property(s),
+ const ADMIN * a,
+ const USERS * u)
+ : USER(),
+ users(u),
+ property(s->GetScriptsDir()),
WriteServLog(GetStgLogger()),
login(),
id(0),
sysAdmin(a),
store(st),
tariffs(t),
- tariff(tariffs->GetNoTariff()),
+ tariff(NULL),
cash(property.cash),
up(property.up),
down(property.down),
ipNotifier(this)
{
settings = s;
-ipIndex = ipIdx;
password = "*_EMPTY_PASSWORD_*";
tariffName = NO_TARIFF_NAME;
connected = 0;
-tariff = tariffs->GetNoTariff();
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);
-currIP.AddAfterNotifier(&ipNotifier);
+ips.AddAfterNotifier(&ipNotifier);
lastScanMessages = 0;
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)
+ : USER(),
+ users(u.users),
+ property(u.settings->GetScriptsDir()),
WriteServLog(GetStgLogger()),
login(u.login),
id(u.id),
connected = 0;
-ipIndex = u.ipIndex;
-
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);
-currIP.AddAfterNotifier(&ipNotifier);
+ips.AddAfterNotifier(&ipNotifier);
lastScanMessages = 0;
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");
id = userIDGenerator.GetNextID();
}
//-----------------------------------------------------------------------------
-int USER::ReadConf()
+int USER_IMPL::ReadConf()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
USER_CONF conf;
return 0;
}
//-----------------------------------------------------------------------------
-int USER::ReadStat()
+int USER_IMPL::ReadStat()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
USER_STAT stat;
return 0;
}
//-----------------------------------------------------------------------------
-int USER::WriteConf()
+int USER_IMPL::WriteConf()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
USER_CONF conf(property.GetConf());
return 0;
}
//-----------------------------------------------------------------------------
-int USER::WriteStat()
+int USER_IMPL::WriteStat()
{
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());
return 0;
}
//-----------------------------------------------------------------------------
-int USER::WriteMonthStat()
+int USER_IMPL::WriteMonthStat()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
time_t tt = stgTime - 3600;
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__);
/*
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;
}
- 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";
+ errorStr = "IP address " + inet_ntostring(ip) + " already in use";
return -1;
}
}
}
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";
+ errorStr = "IP address " + inet_ntostring(ip) + " already in use";
return -1;
}
return 0;
}
//-----------------------------------------------------------------------------
-void USER::Unauthorize(const BASE_AUTH * auth)
+void USER_IMPL::Unauthorize(const AUTH * auth)
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
/*
}
}
//-----------------------------------------------------------------------------
-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() !!!
if (!fakeConnect)
{
- string scriptOnConnect = settings->GetScriptDir() + "/OnConnect";
+ string scriptOnConnect = settings->GetScriptsDir() + "/OnConnect";
if (access(scriptOnConnect.c_str(), X_OK) == 0)
{
id,
dirsStr);
- ScriptExec(scriptOnConnectParams);
+ ScriptExec(scriptOnConnectParams.c_str());
}
else
{
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() !!!
if (!fakeDisconnect)
{
- string scriptOnDisonnect = settings->GetScriptDir() + "/OnDisconnect";
+ string scriptOnDisonnect = settings->GetScriptsDir() + "/OnDisconnect";
if (access(scriptOnDisonnect.c_str(), X_OK) == 0)
{
id,
dirsStr);
- ScriptExec(scriptOnDisonnectParams);
+ ScriptExec(scriptOnDisonnectParams.c_str());
}
else
{
sessionDownload = zeroSesssion;
}
//-----------------------------------------------------------------------------
-void USER::PrintUser() const
+void USER_IMPL::PrintUser() const
{
//return;
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
cout << "============================================================" << endl;
}
//-----------------------------------------------------------------------------
-void USER::Run()
+void USER_IMPL::Run()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
{
if (connected)
{
- lastActivityTime = *const_cast<time_t *>(&stgTime);
+ property.Stat().lastActivityTime = stgTime;
}
if (!connected && IsInetable())
{
}
//-----------------------------------------------------------------------------
-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());
pingTime = stgTime;
}
//-----------------------------------------------------------------------------
-bool USER::IsInetable()
+bool USER_IMPL::IsInetable()
{
//STG_LOCKER lock(&mutex, __FILE__, __LINE__);
return true;
}
-if (settings->GetShowFeeInCash())
+if (settings->GetShowFeeInCash() || tariff == NULL)
{
return (cash >= -credit);
}
return (cash - tariff->GetFee() >= -credit);
}
//-----------------------------------------------------------------------------
-string USER::GetEnabledDirs()
+string USER_IMPL::GetEnabledDirs()
{
//STG_LOCKER lock(&mutex, __FILE__, __LINE__);
}
//-----------------------------------------------------------------------------
#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__);
-if (!connected)
+if (!connected || tariff == NULL)
return;
double cost = 0;
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();
}
}
//-----------------------------------------------------------------------------
#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__);
-if (!connected)
+if (!connected || tariff == NULL)
return;
double cost = 0;
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();
}
}
}
//-----------------------------------------------------------------------------
-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::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__);
-string scriptOnAdd = settings->GetScriptDir() + "/OnUserAdd";
+string scriptOnAdd = settings->GetScriptsDir() + "/OnUserAdd";
if (access(scriptOnAdd.c_str(), X_OK) == 0)
{
scriptOnAdd.c_str(),
login.c_str());
- ScriptExec(scriptOnAddParams);
+ ScriptExec(scriptOnAddParams.c_str());
}
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)
{
scriptOnDel.c_str(),
login.c_str());
- ScriptExec(scriptOnDelParams);
+ ScriptExec(scriptOnDelParams.c_str());
}
else
{
Run();
}
//-----------------------------------------------------------------------------
-int USER::WriteDetailStat(bool hard)
+int USER_IMPL::WriteDetailStat(bool hard)
{
printfd(__FILE__, "USER::WriteDetailedStat() - saved size = %d\n", traffStatSaved.second.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());
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__);
return double(dt) / (secMonth);
}
//-----------------------------------------------------------------------------
-void USER::SetPassiveTimeAsNewUser()
+void USER_IMPL::SetPassiveTimeAsNewUser()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
passiveTime = (time_t)(pt * 24 * 3600 * daysCurrMon);
}
//-----------------------------------------------------------------------------
-void USER::MidnightResetSessionStat()
+void USER_IMPL::MidnightResetSessionStat()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
}
}
//-----------------------------------------------------------------------------
-void USER::ProcessNewMonth()
+void USER_IMPL::ProcessNewMonth()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
// Reset traff
else
{
property.tariffName.Set(nextTariff, sysAdmin, login, store);
- tariff = nt;
+ //tariff = nt;
}
ResetNextTariff();
WriteConf();
}
}
//-----------------------------------------------------------------------------
-void USER::ProcessDayFeeSpread()
+void USER_IMPL::ProcessDayFeeSpread()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-if (passive.ConstData())
+if (passive.ConstData() || tariff == NULL)
return;
-double f = tariff->GetFee() / DaysInCurrentMonth();
+double fee = tariff->GetFee() / DaysInCurrentMonth();
-if (f == 0.0)
+if (fee == 0.0)
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();
}
//-----------------------------------------------------------------------------
-void USER::ProcessDayFee()
+void USER_IMPL::ProcessDayFee()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+if (tariff == NULL)
+ return;
+
double passiveTimePart = 1.0;
if (!settings->GetFullFee())
{
return;
}
}
-double f = tariff->GetFee() * passiveTimePart;
+double fee = tariff->GetFee() * passiveTimePart;
ResetPassiveTime();
-if (f == 0.0)
+if (fee == 0.0)
+ {
+ SetPrepaidTraff();
return;
+ }
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__);
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))
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
++it;
}
}
+ else
+ {
+ ++it;
+ }
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
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,
//-----------------------------------------------------------------------------
void CHG_TARIFF_NOTIFIER::Notify(const string &, const string & newTariff)
{
+if (user->settings->GetReconnectOnTariffChange() && user->connected)
+ user->Disconnect(false, "Change tariff");
user->tariff = user->tariffs->FindByName(newTariff);
+if (user->settings->GetReconnectOnTariffChange() &&
+ !user->authorizedBy.empty() &&
+ user->IsInetable())
+ user->Connect(false);
}
//-----------------------------------------------------------------------------
void CHG_CASH_NOTIFIER::Notify(const double & oldCash, const double & newCash)
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(false, "Change IP");
+ if (!user->authorizedBy.empty() && user->IsInetable())
+ user->Connect(false);
}
//-----------------------------------------------------------------------------
git.stg.codes / stg.git / blobdiff