Moved CHG_USER and SEND_MESSAGE parsers from global scope.

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

diff --git a/projects/stargazer/user_impl.cpp b/projects/stargazer/user_impl.cpp
index d8368c4d41b1885821af69c158b4da0afe4dc417..13cf0b77dc87cd4c1337c6cefc530db7e728572a 100644 (file)
--- a/projects/stargazer/user_impl.cpp
+++ b/projects/stargazer/user_impl.cpp
@@ -32,31 +32,41 @@
 #define _GNU_SOURCE
 #endif
 
 #define _GNU_SOURCE
 #endif
 

-#include <pthread.h>
-#include <unistd.h> // access
+#include "user_impl.h"
+#include "settings_impl.h"
+#include "stg_timer.h"
+
+#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 <algorithm>
+#include <functional>

 
 #include <cassert>
 
 #include <cassert>

+#include <cstdlib>
+#include <cmath>

 
 

-#include "user.h"
-#include "common.h"
-#include "settings.h"
-#include "script_executer.h"
-#include "tariff.h"
-#include "tariffs.h"
-#include "admin.h"
+#include <pthread.h>
+#include <unistd.h> // access

 
 

-USER::USER(const SETTINGS * s,
-           const BASE_STORE * st,
+#ifdef USE_ABSTRACT_SETTINGS
+USER_IMPL::USER_IMPL(const SETTINGS * 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)
+    : USER(),
+      users(u),
+      property(s->GetScriptsDir()),

       WriteServLog(GetStgLogger()),
       WriteServLog(GetStgLogger()),

-      login(),
+      lastScanMessages(0),

       id(0),
       __connected(0),
       connected(__connected),
       id(0),
       __connected(0),
       connected(__connected),

-      userIDGenerator(),

       __currIP(0),
       currIP(__currIP),
       lastIPForDisconnect(0),
       __currIP(0),
       currIP(__currIP),
       lastIPForDisconnect(0),


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

-      tariff(tariffs->GetNoTariff()),
+      tariff(NULL),
+      settings(s),
+      authorizedModificationTime(0),
+      deleted(false),
+      lastWriteStat(0),
+      lastWriteDetailedStat(0),

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


@@ -104,38 +119,120 @@ USER::USER(const SETTINGS * s,
       cashNotifier(this),
       ipNotifier(this)
 {
       cashNotifier(this),
       ipNotifier(this)
 {

-settings = s;
-ipIndex = ipIdx;
-

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

-connected = 0;
-tariff = tariffs->GetNoTariff();

 ips = StrToIPS("*");
 ips = StrToIPS("*");

-deleted = false;

 lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();
 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);

+property.disabled.AddAfterNotifier(&disabledNotifier);

 property.cash.AddBeforeNotifier(&cashNotifier);
 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),
+      id(0),
+      __connected(0),
+      connected(__connected),
+      __currIP(0),
+      currIP(__currIP),
+      lastIPForDisconnect(0),
+      pingTime(0),
+      sysAdmin(a),
+      store(st),
+      tariffs(t),
+      tariff(NULL),
+      settings(s),
+      authorizedModificationTime(0),
+      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),
+      passiveNotifier(this),
+      disabledNotifier(this),
+      tariffNotifier(this),
+      cashNotifier(this),
+      ipNotifier(this)
+{
+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);
 }
 
 pthread_mutexattr_t attr;
 pthread_mutexattr_init(&attr);
 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 pthread_mutex_init(&mutex, &attr);
 }

+#endif

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

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

       WriteServLog(GetStgLogger()),
       WriteServLog(GetStgLogger()),

+      lastScanMessages(0),

       login(u.login),
       id(u.id),
       login(u.login),
       id(u.id),

-      __connected(u.__connected),
+      __connected(0),

       connected(__connected),
       connected(__connected),

+      userIDGenerator(u.userIDGenerator),

       __currIP(u.__currIP),
       currIP(__currIP),
       lastIPForDisconnect(0),
       __currIP(u.__currIP),
       currIP(__currIP),
       lastIPForDisconnect(0),


@@ -144,6 +241,14 @@ USER::USER(const USER & u)
       store(u.store),
       tariffs(u.tariffs),
       tariff(u.tariff),
       store(u.store),
       tariffs(u.tariffs),
       tariff(u.tariff),

+      traffStat(u.traffStat),
+      traffStatSaved(u.traffStatSaved),
+      settings(u.settings),
+      authorizedModificationTime(u.authorizedModificationTime),
+      messages(u.messages),
+      deleted(u.deleted),
+      lastWriteStat(u.lastWriteStat),
+      lastWriteDetailedStat(u.lastWriteDetailedStat),

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


@@ -178,7 +283,10 @@ USER::USER(const USER & u)
       userdata7(property.userdata7),
       userdata8(property.userdata8),
       userdata9(property.userdata9),
       userdata7(property.userdata7),
       userdata8(property.userdata8),
       userdata9(property.userdata9),

+      sessionUpload(),
+      sessionDownload(),

       passiveNotifier(this),
       passiveNotifier(this),

+      disabledNotifier(this),

       tariffNotifier(this),
       cashNotifier(this),
       ipNotifier(this)
       tariffNotifier(this),
       cashNotifier(this),
       ipNotifier(this)


@@ -186,23 +294,11 @@ USER::USER(const USER & u)
 if (&u == this)
     return;
 
 if (&u == this)
     return;
 

-connected = 0;
-
-ipIndex = u.ipIndex;
-
-deleted = u.deleted;
-
-lastWriteStat = u.lastWriteStat;
-lastWriteDeatiledStat = u.lastWriteDeatiledStat;
-
-settings = u.settings;
-

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

+property.disabled.AddAfterNotifier(&disabledNotifier);

 property.cash.AddBeforeNotifier(&cashNotifier);
 property.cash.AddBeforeNotifier(&cashNotifier);

-currIP.AddAfterNotifier(&ipNotifier);
-
-lastScanMessages = 0;
+ips.AddAfterNotifier(&ipNotifier);

 
 property.SetProperties(u.property);
 
 
 property.SetProperties(u.property);
 


@@ -212,14 +308,16 @@ 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);
 property.tariffName.DelBeforeNotifier(&tariffNotifier);

+property.passive.DelBeforeNotifier(&passiveNotifier);
+property.disabled.DelAfterNotifier(&disabledNotifier);
+property.cash.DelBeforeNotifier(&cashNotifier);

 pthread_mutex_destroy(&mutex);
 }
 //-----------------------------------------------------------------------------
 pthread_mutex_destroy(&mutex);
 }
 //-----------------------------------------------------------------------------

-void USER::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");
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 assert(login.empty() && "Login is already set");


@@ -227,7 +325,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;


@@ -256,6 +354,9 @@ std::vector<STG_MSG_HDR> hdrsList;
 if (store->GetMessageHdrs(&hdrsList, login))
     {
     printfd(__FILE__, "Error GetMessageHdrs %s\n", store->GetStrError().c_str());
 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;
     }
 
     return -1;
     }
 


@@ -272,7 +373,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 +392,7 @@ property.SetStat(stat);
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

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

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


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

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

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

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

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


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


@@ -374,33 +473,33 @@ for (int i = 0; i < DIR_NUM; i++)
     enabledDirs[i] = dirs & (1 << i);
     }
 
     enabledDirs[i] = dirs & (1 << i);
     }
 

-if (authorizedBy.size())
+if (!authorizedBy.empty())

     {
     if (currIP != ip)
         {
         //  We are already authorized, but with different IP address
     {
     if (currIP != ip)
         {
         //  We are already authorized, but with different IP address

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

         return -1;
         }
 
         return -1;
         }
 

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

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

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

             {
             {

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

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

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

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

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

         return -1;
         }
 
         return -1;
         }
 


@@ -417,6 +516,8 @@ else
         }
     }
 
         }
     }
 

+if (authorizedBy.empty())
+    authorizedModificationTime = stgTime;

 authorizedBy.insert(auth);
 
 ScanMessage();
 authorizedBy.insert(auth);
 
 ScanMessage();


@@ -424,7 +525,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__);
 /*


@@ -435,20 +536,28 @@ if (!authorizedBy.erase(auth))
 
 if (authorizedBy.empty())
     {
 
 if (authorizedBy.empty())
     {

+    authorizedModificationTime = stgTime;

     lastIPForDisconnect = currIP;
     currIP = 0; // DelUser in traffcounter
     return;
     }
 }
 //-----------------------------------------------------------------------------
     lastIPForDisconnect = currIP;
     currIP = 0; // DelUser in traffcounter
     return;
     }
 }
 //-----------------------------------------------------------------------------

-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)
+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)

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


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

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

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


@@ -469,17 +578,25 @@ if (!fakeConnect)
             dirsStr[i] = enabledDirs[i] ? '1' : '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(),
         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);
 
                 id,
                 dirsStr);
 

-        ScriptExec(scriptOnConnectParams);
+        std::vector<std::string>::const_iterator it(settings->GetScriptParams().begin());
+        while (it != settings->GetScriptParams().end())
+            {
+            scriptOnConnectParams += " \"" + GetParamValue(it->c_str()) + "\"";
+            ++it;
+            }
+
+        ScriptExec(scriptOnConnectParams.c_str());

         }
     else
         {
         }
     else
         {


@@ -499,7 +616,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 +632,8 @@ if (!lastIPForDisconnect)
 
 if (!fakeDisconnect)
     {
 
 if (!fakeDisconnect)
     {

-    string scriptOnDisonnect = settings->GetScriptDir() + "/OnDisconnect";
+    lastDisconnectReason = reason;
+    std::string scriptOnDisonnect = settings->GetScriptsDir() + "/OnDisconnect";

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


@@ -526,17 +644,24 @@ if (!fakeDisconnect)
             dirsStr[i] = enabledDirs[i] ? '1' : '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(),
         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);
 
                 id,
                 dirsStr);
 

-        ScriptExec(scriptOnDisonnectParams);
+        std::vector<std::string>::const_iterator it(settings->GetScriptParams().begin());
+        while (it != settings->GetScriptParams().end())
+            {
+            scriptOnDisonnectParams += " \"" + GetParamValue(it->c_str()) + "\"";
+            ++it;
+            }
+
+        ScriptExec(scriptOnDisonnectParams.c_str());

         }
     else
         {
         }
     else
         {


@@ -561,44 +686,44 @@ 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__);

-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::Run()
+void USER_IMPL::Run()

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


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

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

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


@@ -659,7 +784,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 +794,7 @@ else
     pingTime = stgTime;
 }
 //-----------------------------------------------------------------------------
     pingTime = stgTime;
 }
 //-----------------------------------------------------------------------------

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

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


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

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

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


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

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

 {
 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 //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;
 }
 //-----------------------------------------------------------------------------
 #ifdef TRAFF_STAT_WITH_PORTS
 for(int i = 0; i < DIR_NUM; i++)
     dirs += enabledDirs[i] ? "1" : "0";
 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
 #else

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

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

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

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


@@ -756,8 +881,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();
     }


@@ -777,13 +902,13 @@ IP_DIR_PAIR idp(ip, dir, port);
 IP_DIR_PAIR idp(ip, dir);
 #endif
 
 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,
 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
     {
     }
 else
     {


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

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

 #else
 #else

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

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

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

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


@@ -847,8 +972,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();
     }


@@ -868,13 +993,13 @@ IP_DIR_PAIR idp(ip, dir, port);
 IP_DIR_PAIR idp(ip, dir);
 #endif
 
 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,
 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
     {
     }
 else
     {


@@ -883,45 +1008,69 @@ else
     }
 }
 //-----------------------------------------------------------------------------
     }
 }
 //-----------------------------------------------------------------------------

-void USER::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.DelAfterNotifier(notifier);
+}
+//-----------------------------------------------------------------------------
+void USER_IMPL::AddConnectedBeforeNotifier(CONNECTED_NOTIFIER * notifier)

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

-currIP.AddBeforeNotifier(n);
+connected.AddBeforeNotifier(notifier);

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

-void USER::DelCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::DelConnectedBeforeNotifier(const CONNECTED_NOTIFIER * notifier)

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

-currIP.DelBeforeNotifier(n);
+connected.DelBeforeNotifier(notifier);

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

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

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

-currIP.AddAfterNotifier(n);
+connected.AddAfterNotifier(notifier);

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

-void USER::DelCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
+void USER_IMPL::DelConnectedAfterNotifier(const CONNECTED_NOTIFIER * notifier)

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

-currIP.DelAfterNotifier(n);
+connected.DelAfterNotifier(notifier);

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

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

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

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

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

-    string scriptOnAddParams;
+    std::string scriptOnAddParams;

     strprintf(&scriptOnAddParams,
             "%s \"%s\"",
             scriptOnAdd.c_str(),
             login.c_str());
 
     strprintf(&scriptOnAddParams,
             "%s \"%s\"",
             scriptOnAdd.c_str(),
             login.c_str());
 

-    ScriptExec(scriptOnAddParams);
+    ScriptExec(scriptOnAddParams.c_str());

     }
 else
     {
     }
 else
     {


@@ -929,21 +1078,21 @@ 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";
+std::string scriptOnDel = settings->GetScriptsDir() + "/OnUserDel";

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

-    string scriptOnDelParams;
+    std::string scriptOnDelParams;

     strprintf(&scriptOnDelParams,
             "%s \"%s\"",
             scriptOnDel.c_str(),
             login.c_str());
 
     strprintf(&scriptOnDelParams,
             "%s \"%s\"",
             scriptOnDel.c_str(),
             login.c_str());
 

-    ScriptExec(scriptOnDelParams);
+    ScriptExec(scriptOnDelParams.c_str());

     }
 else
     {
     }
 else
     {


@@ -953,7 +1102,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 +1129,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 +1139,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__);
 


@@ -1018,15 +1167,15 @@ if (tms.tm_year % 4 == 0 && tms.tm_mon == 1)
     secMonth += 24 * 3600;
     }
 
     secMonth += 24 * 3600;
     }
 

-int dt = secMonth - passiveTime;
+time_t dt = secMonth - passiveTime;

 
 if (dt < 0)
     dt = 0;
 
 
 if (dt < 0)
     dt = 0;
 

-return double(dt) / (secMonth);
+return static_cast<double>(dt) / secMonth;

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

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

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


@@ -1034,12 +1183,13 @@ time_t t = stgTime;
 struct tm tm;
 localtime_r(&t, &tm);
 int daysCurrMon = DaysInCurrentMonth();
 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::MidnightResetSessionStat()
+void USER_IMPL::MidnightResetSessionStat()

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


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

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

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


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

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

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

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

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

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

     return;
 
     return;
 

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

 
 

-if (f == 0.0)
+if (std::fabs(fee) < 1.0e-3)

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

-property.cash.Set(c - f, sysAdmin, login, store, "Subscriber fee charge");
+switch (settings->GetFeeChargeType())
+    {
+    case 0:
+        property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
+        break;
+    case 1:
+        if (c + 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();
 }
 //-----------------------------------------------------------------------------
 ResetPassiveTime();
 }
 //-----------------------------------------------------------------------------

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

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

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

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


@@ -1124,30 +1294,61 @@ else
         return;
         }
     }
         return;
         }
     }

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

 
 ResetPassiveTime();
 
 
 ResetPassiveTime();
 

-if (f == 0.0)
+if (std::fabs(fee) < 1.0e-3)
+    {
+    SetPrepaidTraff();

     return;
     return;

+    }

 
 double c = cash;
 
 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(),
         login.c_str(),

+        cash.ConstData(),
+        credit.ConstData(),

         tariff->GetFee(),
         passiveTimePart,
         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::SetPrepaidTraff()
+void USER_IMPL::SetPrepaidTraff()

 {
 {

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

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

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

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


@@ -1169,9 +1370,9 @@ else
         msg->header.repeat--;
         #ifndef DEBUG
         //TODO: gcc v. 4.x generate ICE on x86_64
         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
         #else

-        msg->header.lastSendTime = stgTime;
+        msg->header.lastSendTime = static_cast<int>(stgTime);

         #endif
         if (store->AddMessage(msg, login))
             {
         #endif
         if (store->AddMessage(msg, login))
             {


@@ -1186,11 +1387,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());
+std::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))


@@ -1200,16 +1401,16 @@ if (!ret)
     {
 #ifndef DEBUG
     //TODO: gcc v. 4.x generate ICE on x86_64
     {
 #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
 #else

-    msg.header.lastSendTime = stgTime;
+    msg.header.lastSendTime = static_cast<int>(stgTime);

 #endif
     msg.header.repeat--;
     }
 return ret;
 }
 //-----------------------------------------------------------------------------
 #endif
     msg.header.repeat--;
     }
 return ret;
 }
 //-----------------------------------------------------------------------------

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

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


@@ -1256,14 +1457,55 @@ while (it != messages.end())
             ++it;
             }
         }
             ++it;
             }
         }

+    else
+        {
+        ++it;
+        }
+    }
+}
+//-----------------------------------------------------------------------------
+std::string USER_IMPL::GetParamValue(const std::string & name) const
+{
+if (name == "freeMb")       return property.freeMb.ToString();
+if (name == "passive")      return property.passive.ToString();
+if (name == "disabled")     return property.disabled.ToString();
+if (name == "alwaysOnline") return property.alwaysOnline.ToString();
+if (name == "tariffName")   return property.tariffName;
+if (name == "nextTariff")   return property.nextTariff;
+if (name == "address")      return property.address;
+if (name == "note")         return property.note;
+if (name == "group")        return property.group;
+if (name == "email")        return property.email;
+if (name == "phone")        return property.phone;
+if (name == "realName")     return property.realName;
+if (name == "credit")       return property.credit.ToString();
+if (name == "userdata0")    return property.userdata0;
+if (name == "userdata1")    return property.userdata1;
+if (name == "userdata2")    return property.userdata2;
+if (name == "userdata3")    return property.userdata3;
+if (name == "userdata4")    return property.userdata4;
+if (name == "userdata5")    return property.userdata5;
+if (name == "userdata6")    return property.userdata6;
+if (name == "userdata7")    return property.userdata7;
+if (name == "userdata8")    return property.userdata8;
+if (name == "userdata9")    return property.userdata9;
+if (name == "cash")         return property.cash.ToString();
+if (name == "id")
+    {
+    std::stringstream stream;
+    stream << id;
+    return stream.str();;

     }
     }

+if (name == "login")        return login;
+if (name == "ip")           return currIP.ToString();
+return "";

 }
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 void CHG_PASSIVE_NOTIFIER::Notify(const int & oldPassive, const int & newPassive)
 {
 }
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 void CHG_PASSIVE_NOTIFIER::Notify(const int & oldPassive, const int & newPassive)
 {

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

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


@@ -1271,9 +1513,28 @@ if (newPassive && !oldPassive)
                             "Freeze");
 }
 //-----------------------------------------------------------------------------
                             "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);
 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)
 }
 //-----------------------------------------------------------------------------
 void CHG_CASH_NOTIFIER::Notify(const double & oldCash, const double & newCash)


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

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

 {
 {

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

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