#include <cassert>
#include <cstdlib>
-
+#include <cmath>
+#include <algorithm>
+#include <functional>
+
+#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 "users.h"
-#include "common.h"
#include "settings_impl.h"
-#include "script_executer.h"
-#include "tariff.h"
-#include "tariffs.h"
-#include "admin.h"
+#include "stg_timer.h"
-USER_IMPL::USER_IMPL(const SETTINGS_IMPL * s,
+#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),
+ : USER(),
+ users(u),
property(s->GetScriptsDir()),
WriteServLog(GetStgLogger()),
+ lastScanMessages(0),
login(),
id(0),
__connected(0),
connected(__connected),
+ enabledDirs(),
userIDGenerator(),
__currIP(0),
currIP(__currIP),
sysAdmin(a),
store(st),
tariffs(t),
- tariff(tariffs->GetNoTariff()),
+ tariff(NULL),
+ traffStat(),
+ traffStatSaved(),
+ settings(s),
+ authorizedBy(),
+ messages(),
+ deleted(false),
+ lastWriteStat(0),
+ lastWriteDetailedStat(0),
cash(property.cash),
up(property.up),
down(property.down),
userdata7(property.userdata7),
userdata8(property.userdata8),
userdata9(property.userdata9),
+ sessionUpload(),
+ sessionDownload(),
passiveNotifier(this),
tariffNotifier(this),
cashNotifier(this),
- ipNotifier(this)
+ ipNotifier(this),
+ mutex(),
+ errorStr()
{
-settings = s;
-
password = "*_EMPTY_PASSWORD_*";
tariffName = NO_TARIFF_NAME;
-connected = 0;
-tariff = tariffs->GetNoTariff();
ips = StrToIPS("*");
-deleted = false;
lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();
lastWriteDetailedStat = stgTime;
property.tariffName.AddBeforeNotifier(&tariffNotifier);
property.passive.AddBeforeNotifier(&passiveNotifier);
+property.disabled.AddAfterNotifier(&disabledNotifier);
property.cash.AddBeforeNotifier(&cashNotifier);
-currIP.AddAfterNotifier(&ipNotifier);
+ips.AddAfterNotifier(&ipNotifier);
-lastScanMessages = 0;
+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 USERS * u)
+ : USER(),
+ users(u),
+ property(s->GetScriptsDir()),
+ WriteServLog(GetStgLogger()),
+ lastScanMessages(0),
+ login(),
+ id(0),
+ __connected(0),
+ connected(__connected),
+ enabledDirs(),
+ userIDGenerator(),
+ __currIP(0),
+ currIP(__currIP),
+ lastIPForDisconnect(0),
+ pingTime(0),
+ sysAdmin(a),
+ store(st),
+ tariffs(t),
+ tariff(NULL),
+ traffStat(),
+ traffStatSaved(),
+ settings(s),
+ authorizedBy(),
+ messages(),
+ deleted(false),
+ lastWriteStat(0),
+ lastWriteDetailedStat(0),
+ 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),
+ sessionUpload(),
+ sessionDownload(),
+ passiveNotifier(this),
+ disabledNotifier(this),
+ tariffNotifier(this),
+ cashNotifier(this),
+ ipNotifier(this),
+ mutex(),
+ errorStr()
+{
+password = "*_EMPTY_PASSWORD_*";
+tariffName = NO_TARIFF_NAME;
+ips = StrToIPS("*");
+lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();
+lastWriteDetailedStat = stgTime;
+
+property.tariffName.AddBeforeNotifier(&tariffNotifier);
+property.passive.AddBeforeNotifier(&passiveNotifier);
+property.disabled.AddAfterNotifier(&disabledNotifier);
+property.cash.AddBeforeNotifier(&cashNotifier);
+ips.AddAfterNotifier(&ipNotifier);
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&mutex, &attr);
}
+#endif
//-----------------------------------------------------------------------------
USER_IMPL::USER_IMPL(const USER_IMPL & u)
- : users(u.users),
+ : USER(),
+ users(u.users),
property(u.settings->GetScriptsDir()),
WriteServLog(GetStgLogger()),
+ lastScanMessages(0),
login(u.login),
id(u.id),
- __connected(u.__connected),
+ __connected(0),
connected(__connected),
+ enabledDirs(),
+ userIDGenerator(u.userIDGenerator),
__currIP(u.__currIP),
currIP(__currIP),
lastIPForDisconnect(0),
store(u.store),
tariffs(u.tariffs),
tariff(u.tariff),
+ traffStat(u.traffStat),
+ traffStatSaved(u.traffStatSaved),
+ settings(u.settings),
+ authorizedBy(),
+ messages(u.messages),
+ deleted(u.deleted),
+ lastWriteStat(u.lastWriteStat),
+ lastWriteDetailedStat(u.lastWriteDetailedStat),
cash(property.cash),
up(property.up),
down(property.down),
userdata7(property.userdata7),
userdata8(property.userdata8),
userdata9(property.userdata9),
+ sessionUpload(),
+ sessionDownload(),
passiveNotifier(this),
+ disabledNotifier(this),
tariffNotifier(this),
cashNotifier(this),
- ipNotifier(this)
+ ipNotifier(this),
+ mutex(),
+ errorStr()
{
if (&u == this)
return;
-connected = 0;
-
-deleted = u.deleted;
-
-lastWriteStat = u.lastWriteStat;
-lastWriteDetailedStat = u.lastWriteDetailedStat;
-
-settings = u.settings;
-
property.tariffName.AddBeforeNotifier(&tariffNotifier);
property.passive.AddBeforeNotifier(&passiveNotifier);
+property.disabled.AddAfterNotifier(&disabledNotifier);
property.cash.AddBeforeNotifier(&cashNotifier);
-currIP.AddAfterNotifier(&ipNotifier);
-
-lastScanMessages = 0;
+ips.AddAfterNotifier(&ipNotifier);
property.SetProperties(u.property);
//-----------------------------------------------------------------------------
USER_IMPL::~USER_IMPL()
{
-property.passive.DelBeforeNotifier(&passiveNotifier);
property.tariffName.DelBeforeNotifier(&tariffNotifier);
+property.passive.DelBeforeNotifier(&passiveNotifier);
+property.disabled.DelAfterNotifier(&disabledNotifier);
+property.cash.DelBeforeNotifier(&cashNotifier);
pthread_mutex_destroy(&mutex);
}
//-----------------------------------------------------------------------------
-void USER_IMPL::SetLogin(string const & l)
+void USER_IMPL::SetLogin(const std::string & l)
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
assert(login.empty() && "Login is already set");
if (store->GetMessageHdrs(&hdrsList, login))
{
printfd(__FILE__, "Error GetMessageHdrs %s\n", store->GetStrError().c_str());
+ WriteServLog("Cannot read user %s. Error reading message headers: %s.",
+ login.c_str(),
+ store->GetStrError().c_str());
return -1;
}
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());
enabledDirs[i] = dirs & (1 << i);
}
-if (authorizedBy.size())
+if (!authorizedBy.empty())
{
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;
}
// If it's not our IP - throw an error
if (u != this)
{
- errorStr = "IP address " + inet_ntostring(ip) + " alredy in use";
+ errorStr = "IP address " + inet_ntostring(ip) + " already in use";
return -1;
}
}
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 authorizedBy.find(auth) != authorizedBy.end();
}
//-----------------------------------------------------------------------------
+std::vector<std::string> USER_IMPL::GetAuthorizers() const
+{
+ std::vector<std::string> list;
+ std::transform(authorizedBy.begin(), authorizedBy.end(), std::back_inserter(list), std::mem_fun(&AUTH::GetVersion));
+ return list;
+}
+//-----------------------------------------------------------------------------
void USER_IMPL::Connect(bool fakeConnect)
{
/*
if (!fakeConnect)
{
- string scriptOnConnect = settings->GetScriptsDir() + "/OnConnect";
+ std::string scriptOnConnect = settings->GetScriptsDir() + "/OnConnect";
if (access(scriptOnConnect.c_str(), X_OK) == 0)
{
dirsStr[i] = enabledDirs[i] ? '1' : '0';
}
- string scriptOnConnectParams;
+ std::string scriptOnConnectParams;
strprintf(&scriptOnConnectParams,
"%s \"%s\" \"%s\" \"%f\" \"%d\" \"%s\"",
scriptOnConnect.c_str(),
login.c_str(),
inet_ntostring(currIP).c_str(),
- (double)cash,
+ cash.ConstData(),
id,
dirsStr);
- ScriptExec(scriptOnConnectParams);
+ ScriptExec(scriptOnConnectParams.c_str());
}
else
{
if (!fakeDisconnect)
{
- string scriptOnDisonnect = settings->GetScriptsDir() + "/OnDisconnect";
+ std::string scriptOnDisonnect = settings->GetScriptsDir() + "/OnDisconnect";
if (access(scriptOnDisonnect.c_str(), X_OK) == 0)
{
dirsStr[i] = enabledDirs[i] ? '1' : '0';
}
- string scriptOnDisonnectParams;
+ std::string scriptOnDisonnectParams;
strprintf(&scriptOnDisonnectParams,
"%s \"%s\" \"%s\" \"%f\" \"%d\" \"%s\"",
scriptOnDisonnect.c_str(),
login.c_str(),
inet_ntostring(lastIPForDisconnect).c_str(),
- (double)cash,
+ cash.ConstData(),
id,
dirsStr);
- ScriptExec(scriptOnDisonnectParams);
+ ScriptExec(scriptOnDisonnectParams.c_str());
}
else
{
{
//return;
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-cout << "============================================================" << endl;
-cout << "id=" << id << endl;
-cout << "login=" << login << endl;
-cout << "password=" << password << endl;
-cout << "passive=" << passive << endl;
-cout << "disabled=" << disabled << endl;
-cout << "disabledDetailStat=" << disabledDetailStat << endl;
-cout << "alwaysOnline=" << alwaysOnline << endl;
-cout << "tariffName=" << tariffName << endl;
-cout << "address=" << address << endl;
-cout << "phone=" << phone << endl;
-cout << "email=" << email << endl;
-cout << "note=" << note << endl;
-cout << "realName=" <<realName << endl;
-cout << "group=" << group << endl;
-cout << "credit=" << credit << endl;
-cout << "nextTariff=" << nextTariff << endl;
-cout << "userdata0" << userdata0 << endl;
-cout << "userdata1" << userdata1 << endl;
-cout << "creditExpire=" << creditExpire << endl;
-cout << "ips=" << ips << endl;
-cout << "------------------------" << endl;
-cout << "up=" << up << endl;
-cout << "down=" << down << endl;
-cout << "cash=" << cash << endl;
-cout << "freeMb=" << freeMb << endl;
-cout << "lastCashAdd=" << lastCashAdd << endl;
-cout << "lastCashAddTime=" << lastCashAddTime << endl;
-cout << "passiveTime=" << passiveTime << endl;
-cout << "lastActivityTime=" << lastActivityTime << endl;
-cout << "============================================================" << endl;
+std::cout << "============================================================" << std::endl;
+std::cout << "id=" << id << std::endl;
+std::cout << "login=" << login << std::endl;
+std::cout << "password=" << password << std::endl;
+std::cout << "passive=" << passive << std::endl;
+std::cout << "disabled=" << disabled << std::endl;
+std::cout << "disabledDetailStat=" << disabledDetailStat << std::endl;
+std::cout << "alwaysOnline=" << alwaysOnline << std::endl;
+std::cout << "tariffName=" << tariffName << std::endl;
+std::cout << "address=" << address << std::endl;
+std::cout << "phone=" << phone << std::endl;
+std::cout << "email=" << email << std::endl;
+std::cout << "note=" << note << std::endl;
+std::cout << "realName=" <<realName << std::endl;
+std::cout << "group=" << group << std::endl;
+std::cout << "credit=" << credit << std::endl;
+std::cout << "nextTariff=" << nextTariff << std::endl;
+std::cout << "userdata0" << userdata0 << std::endl;
+std::cout << "userdata1" << userdata1 << std::endl;
+std::cout << "creditExpire=" << creditExpire << std::endl;
+std::cout << "ips=" << ips << std::endl;
+std::cout << "------------------------" << std::endl;
+std::cout << "up=" << up << std::endl;
+std::cout << "down=" << down << std::endl;
+std::cout << "cash=" << cash << std::endl;
+std::cout << "freeMb=" << freeMb << std::endl;
+std::cout << "lastCashAdd=" << lastCashAdd << std::endl;
+std::cout << "lastCashAddTime=" << lastCashAddTime << std::endl;
+std::cout << "passiveTime=" << passiveTime << std::endl;
+std::cout << "lastActivityTime=" << lastActivityTime << std::endl;
+std::cout << "============================================================" << std::endl;
}
//-----------------------------------------------------------------------------
void USER_IMPL::Run()
{
if (connected)
{
- lastActivityTime = *const_cast<time_t *>(&stgTime);
+ property.Stat().lastActivityTime = stgTime;
}
if (!connected && IsInetable())
{
return true;
}
-if (settings->GetShowFeeInCash())
+if (settings->GetShowFeeInCash() || tariff == NULL)
{
return (cash >= -credit);
}
return (cash - tariff->GetFee() >= -credit);
}
//-----------------------------------------------------------------------------
-string USER_IMPL::GetEnabledDirs()
+std::string USER_IMPL::GetEnabledDirs()
{
//STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-string dirs = "";
+std::string dirs = "";
for(int i = 0; i < DIR_NUM; i++)
dirs += enabledDirs[i] ? "1" : "0";
return dirs;
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-if (!connected)
+if (!connected || tariff == NULL)
return;
double cost = 0;
IP_DIR_PAIR idp(ip, dir);
#endif
-map<IP_DIR_PAIR, STAT_NODE>::iterator lb;
+std::map<IP_DIR_PAIR, STAT_NODE>::iterator lb;
lb = traffStat.lower_bound(idp);
if (lb == traffStat.end() || lb->first != idp)
{
traffStat.insert(lb,
- pair<IP_DIR_PAIR, STAT_NODE>(idp,
- STAT_NODE(len, 0, cost)));
+ std::make_pair(idp,
+ STAT_NODE(len, 0, cost)));
}
else
{
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-if (!connected)
+if (!connected || tariff == NULL)
return;
double cost = 0;
IP_DIR_PAIR idp(ip, dir);
#endif
-map<IP_DIR_PAIR, STAT_NODE>::iterator lb;
+std::map<IP_DIR_PAIR, STAT_NODE>::iterator lb;
lb = traffStat.lower_bound(idp);
if (lb == traffStat.end() || lb->first != idp)
{
traffStat.insert(lb,
- pair<IP_DIR_PAIR, STAT_NODE>(idp,
- STAT_NODE(0, len, cost)));
+ std::make_pair(idp,
+ STAT_NODE(0, len, cost)));
}
else
{
}
}
//-----------------------------------------------------------------------------
-void USER_IMPL::AddCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::AddCurrIPBeforeNotifier(CURR_IP_NOTIFIER * notifier)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+currIP.AddBeforeNotifier(notifier);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::DelCurrIPBeforeNotifier(const CURR_IP_NOTIFIER * notifier)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+currIP.DelBeforeNotifier(notifier);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::AddCurrIPAfterNotifier(CURR_IP_NOTIFIER * notifier)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+currIP.AddAfterNotifier(notifier);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::DelCurrIPAfterNotifier(const CURR_IP_NOTIFIER * notifier)
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-currIP.AddBeforeNotifier(n);
+currIP.DelAfterNotifier(notifier);
}
//-----------------------------------------------------------------------------
-void USER_IMPL::DelCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::AddConnectedBeforeNotifier(CONNECTED_NOTIFIER * notifier)
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-currIP.DelBeforeNotifier(n);
+connected.AddBeforeNotifier(notifier);
}
//-----------------------------------------------------------------------------
-void USER_IMPL::AddCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::DelConnectedBeforeNotifier(const CONNECTED_NOTIFIER * notifier)
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-currIP.AddAfterNotifier(n);
+connected.DelBeforeNotifier(notifier);
}
//-----------------------------------------------------------------------------
-void USER_IMPL::DelCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::AddConnectedAfterNotifier(CONNECTED_NOTIFIER * notifier)
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-currIP.DelAfterNotifier(n);
+connected.AddAfterNotifier(notifier);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::DelConnectedAfterNotifier(const CONNECTED_NOTIFIER * notifier)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+connected.DelAfterNotifier(notifier);
}
//-----------------------------------------------------------------------------
void USER_IMPL::OnAdd()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-string scriptOnAdd = settings->GetScriptsDir() + "/OnUserAdd";
+std::string scriptOnAdd = settings->GetScriptsDir() + "/OnUserAdd";
if (access(scriptOnAdd.c_str(), X_OK) == 0)
{
- string scriptOnAddParams;
+ std::string scriptOnAddParams;
strprintf(&scriptOnAddParams,
"%s \"%s\"",
scriptOnAdd.c_str(),
login.c_str());
- ScriptExec(scriptOnAddParams);
+ ScriptExec(scriptOnAddParams.c_str());
}
else
{
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-string scriptOnDel = settings->GetScriptsDir() + "/OnUserDel";
+std::string scriptOnDel = settings->GetScriptsDir() + "/OnUserDel";
if (access(scriptOnDel.c_str(), X_OK) == 0)
{
- string scriptOnDelParams;
+ std::string scriptOnDelParams;
strprintf(&scriptOnDelParams,
"%s \"%s\"",
scriptOnDel.c_str(),
login.c_str());
- ScriptExec(scriptOnDelParams);
+ ScriptExec(scriptOnDelParams.c_str());
}
else
{
secMonth += 24 * 3600;
}
-int dt = secMonth - passiveTime;
+time_t dt = secMonth - passiveTime;
if (dt < 0)
dt = 0;
-return double(dt) / (secMonth);
+return static_cast<double>(dt) / secMonth;
}
//-----------------------------------------------------------------------------
void USER_IMPL::SetPassiveTimeAsNewUser()
struct tm tm;
localtime_r(&t, &tm);
int daysCurrMon = DaysInCurrentMonth();
-double pt = (tm.tm_mday - 1) / (double)daysCurrMon;
+double pt = tm.tm_mday - 1;
+pt /= daysCurrMon;
-passiveTime = (time_t)(pt * 24 * 3600 * daysCurrMon);
+passiveTime = static_cast<time_t>(pt * 24 * 3600 * daysCurrMon);
}
//-----------------------------------------------------------------------------
void USER_IMPL::MidnightResetSessionStat()
else
{
property.tariffName.Set(nextTariff, sysAdmin, login, store);
- tariff = nt;
+ //tariff = nt;
}
ResetNextTariff();
WriteConf();
{
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 (std::fabs(fee) < 1.0e-3)
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 + credit >= 0)
+ property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+ break;
+ case 2:
+ if (c + credit >= fee)
+ property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+ break;
+ case 3:
+ if (c >= 0)
+ property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+ break;
+ }
ResetPassiveTime();
}
//-----------------------------------------------------------------------------
{
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 (std::fabs(fee) < 1.0e-3)
+ {
+ SetPrepaidTraff();
return;
+ }
double c = cash;
-printfd(__FILE__, "login: %8s Fee=%f PassiveTimePart=%f fee=%f\n",
+printfd(__FILE__, "login: %8s Cash=%f Credit=%f Fee=%f PassiveTimePart=%f fee=%f\n",
login.c_str(),
+ cash.ConstData(),
+ credit.ConstData(),
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 + credit >= 0)
+ {
+ property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+ SetPrepaidTraff();
+ }
+ break;
+ case 2:
+ if (c + credit >= fee)
+ {
+ property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+ SetPrepaidTraff();
+ }
+ break;
+ case 3:
+ if (c >= 0)
+ {
+ property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+ SetPrepaidTraff();
+ }
+ break;
+ }
}
//-----------------------------------------------------------------------------
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_IMPL::AddMessage(STG_MSG * msg)
msg->header.repeat--;
#ifndef DEBUG
//TODO: gcc v. 4.x generate ICE on x86_64
- msg->header.lastSendTime = time(NULL);
+ msg->header.lastSendTime = static_cast<int>(time(NULL));
#else
- msg->header.lastSendTime = stgTime;
+ msg->header.lastSendTime = static_cast<int>(stgTime);
#endif
if (store->AddMessage(msg, login))
{
{
// No lock `cause we are already locked from caller
int ret = -1;
-set<const AUTH*>::iterator it(authorizedBy.begin());
+std::set<const AUTH*>::iterator it(authorizedBy.begin());
while (it != authorizedBy.end())
{
if (!(*it++)->SendMessage(msg, currIP))
{
#ifndef DEBUG
//TODO: gcc v. 4.x generate ICE on x86_64
- msg.header.lastSendTime = time(NULL);
+ msg.header.lastSendTime = static_cast<int>(time(NULL));
#else
- msg.header.lastSendTime = stgTime;
+ msg.header.lastSendTime = static_cast<int>(stgTime);
#endif
msg.header.repeat--;
}
++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,
"Freeze");
}
//-----------------------------------------------------------------------------
-void CHG_TARIFF_NOTIFIER::Notify(const string &, const string & newTariff)
+void CHG_DISABLED_NOTIFIER::Notify(const int & oldValue, const int & newValue)
+{
+if (oldValue && !newValue && user->GetConnected())
+ {
+ user->Disconnect(false, "disabled");
+ }
+else if (!oldValue && newValue && user->IsInetable())
+ {
+ user->Connect(false);
+ }
+
+}
+//-----------------------------------------------------------------------------
+void CHG_TARIFF_NOTIFIER::Notify(const std::string &, const std::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