projects/stargazer/user_impl.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Date: 27.10.2002
  19  */
  20
  21 /*
  22  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  23  */
  24
  25 /*
  26  $Revision: 1.101 $
  27  $Date: 2010/11/03 10:50:03 $
  28  $Author: faust $
  29  */
  30
  31 #ifndef _GNU_SOURCE
  32 #define _GNU_SOURCE
  33 #endif
  34
  35 #include <pthread.h>
  36 #include <unistd.h> // access
  37
  38 #include <cassert>
  39 #include <cstdlib>
  40
  41 #include "stg/users.h"
  42 #include "stg/common.h"
  43 #include "stg/scriptexecuter.h"
  44 #include "stg/tariff.h"
  45 #include "stg/tariffs.h"
  46 #include "stg/admin.h"
  47 #include "user_impl.h"
  48 #include "settings_impl.h"
  49 #include "stg_timer.h"
  50
  51 #ifdef USE_ABSTRACT_SETTINGS
  52 USER_IMPL::USER_IMPL(const SETTINGS * s,
  53            const STORE * st,
  54            const TARIFFS * t,
  55            const ADMIN * a,
  56            const USERS * u)
  57     : USER(),
  58       users(u),
  59       property(s->GetScriptsDir()),
  60       WriteServLog(GetStgLogger()),
  61       lastScanMessages(0),
  62       login(),
  63       id(0),
  64       __connected(0),
  65       connected(__connected),
  66       enabledDirs(),
  67       userIDGenerator(),
  68       __currIP(0),
  69       currIP(__currIP),
  70       lastIPForDisconnect(0),
  71       pingTime(0),
  72       sysAdmin(a),
  73       store(st),
  74       tariffs(t),
  75       tariff(NULL),
  76       traffStat(),
  77       traffStatSaved(),
  78       settings(s),
  79       authorizedBy(),
  80       messages(),
  81       deleted(false),
  82       lastWriteStat(0),
  83       lastWriteDetailedStat(0),
  84       cash(property.cash),
  85       up(property.up),
  86       down(property.down),
  87       lastCashAdd(property.lastCashAdd),
  88       passiveTime(property.passiveTime),
  89       lastCashAddTime(property.lastCashAddTime),
  90       freeMb(property.freeMb),
  91       lastActivityTime(property.lastActivityTime),
  92       password(property.password),
  93       passive(property.passive),
  94       disabled(property.disabled),
  95       disabledDetailStat(property.disabledDetailStat),
  96       alwaysOnline(property.alwaysOnline),
  97       tariffName(property.tariffName),
  98       nextTariff(property.nextTariff),
  99       address(property.address),
 100       note(property.note),
 101       group(property.group),
 102       email(property.email),
 103       phone(property.phone),
 104       realName(property.realName),
 105       credit(property.credit),
 106       creditExpire(property.creditExpire),
 107       ips(property.ips),
 108       userdata0(property.userdata0),
 109       userdata1(property.userdata1),
 110       userdata2(property.userdata2),
 111       userdata3(property.userdata3),
 112       userdata4(property.userdata4),
 113       userdata5(property.userdata5),
 114       userdata6(property.userdata6),
 115       userdata7(property.userdata7),
 116       userdata8(property.userdata8),
 117       userdata9(property.userdata9),
 118       sessionUpload(),
 119       sessionDownload(),
 120       passiveNotifier(this),
 121       tariffNotifier(this),
 122       cashNotifier(this),
 123       ipNotifier(this),
 124       mutex(),
 125       errorStr()
 126 {
 127 password = "*_EMPTY_PASSWORD_*";
 128 tariffName = NO_TARIFF_NAME;
 129 ips = StrToIPS("*");
 130 lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();
 131 lastWriteDetailedStat = stgTime;
 132
 133 property.tariffName.AddBeforeNotifier(&tariffNotifier);
 134 property.passive.AddBeforeNotifier(&passiveNotifier);
 135 property.cash.AddBeforeNotifier(&cashNotifier);
 136 ips.AddAfterNotifier(&ipNotifier);
 137
 138 pthread_mutexattr_t attr;
 139 pthread_mutexattr_init(&attr);
 140 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 141 pthread_mutex_init(&mutex, &attr);
 142 }
 143 #else
 144 USER_IMPL::USER_IMPL(const SETTINGS_IMPL * s,
 145                      const STORE * st,
 146                      const TARIFFS * t,
 147                      const ADMIN * a,
 148                      const USERS * u)
 149     : USER(),
 150       users(u),
 151       property(s->GetScriptsDir()),
 152       WriteServLog(GetStgLogger()),
 153       lastScanMessages(0),
 154       login(),
 155       id(0),
 156       __connected(0),
 157       connected(__connected),
 158       enabledDirs(),
 159       userIDGenerator(),
 160       __currIP(0),
 161       currIP(__currIP),
 162       lastIPForDisconnect(0),
 163       pingTime(0),
 164       sysAdmin(a),
 165       store(st),
 166       tariffs(t),
 167       tariff(NULL),
 168       traffStat(),
 169       traffStatSaved(),
 170       settings(s),
 171       authorizedBy(),
 172       messages(),
 173       deleted(false),
 174       lastWriteStat(0),
 175       lastWriteDetailedStat(0),
 176       cash(property.cash),
 177       up(property.up),
 178       down(property.down),
 179       lastCashAdd(property.lastCashAdd),
 180       passiveTime(property.passiveTime),
 181       lastCashAddTime(property.lastCashAddTime),
 182       freeMb(property.freeMb),
 183       lastActivityTime(property.lastActivityTime),
 184       password(property.password),
 185       passive(property.passive),
 186       disabled(property.disabled),
 187       disabledDetailStat(property.disabledDetailStat),
 188       alwaysOnline(property.alwaysOnline),
 189       tariffName(property.tariffName),
 190       nextTariff(property.nextTariff),
 191       address(property.address),
 192       note(property.note),
 193       group(property.group),
 194       email(property.email),
 195       phone(property.phone),
 196       realName(property.realName),
 197       credit(property.credit),
 198       creditExpire(property.creditExpire),
 199       ips(property.ips),
 200       userdata0(property.userdata0),
 201       userdata1(property.userdata1),
 202       userdata2(property.userdata2),
 203       userdata3(property.userdata3),
 204       userdata4(property.userdata4),
 205       userdata5(property.userdata5),
 206       userdata6(property.userdata6),
 207       userdata7(property.userdata7),
 208       userdata8(property.userdata8),
 209       userdata9(property.userdata9),
 210       sessionUpload(),
 211       sessionDownload(),
 212       passiveNotifier(this),
 213       tariffNotifier(this),
 214       cashNotifier(this),
 215       ipNotifier(this),
 216       mutex(),
 217       errorStr()
 218 {
 219 password = "*_EMPTY_PASSWORD_*";
 220 tariffName = NO_TARIFF_NAME;
 221 ips = StrToIPS("*");
 222 lastWriteStat = stgTime + random() % settings->GetStatWritePeriod();
 223 lastWriteDetailedStat = stgTime;
 224
 225 property.tariffName.AddBeforeNotifier(&tariffNotifier);
 226 property.passive.AddBeforeNotifier(&passiveNotifier);
 227 property.cash.AddBeforeNotifier(&cashNotifier);
 228 ips.AddAfterNotifier(&ipNotifier);
 229
 230 pthread_mutexattr_t attr;
 231 pthread_mutexattr_init(&attr);
 232 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 233 pthread_mutex_init(&mutex, &attr);
 234 }
 235 #endif
 236 //-----------------------------------------------------------------------------
 237 USER_IMPL::USER_IMPL(const USER_IMPL & u)
 238     : USER(),
 239       users(u.users),
 240       property(u.settings->GetScriptsDir()),
 241       WriteServLog(GetStgLogger()),
 242       lastScanMessages(0),
 243       login(u.login),
 244       id(u.id),
 245       __connected(0),
 246       connected(__connected),
 247       enabledDirs(),
 248       userIDGenerator(u.userIDGenerator),
 249       __currIP(u.__currIP),
 250       currIP(__currIP),
 251       lastIPForDisconnect(0),
 252       pingTime(u.pingTime),
 253       sysAdmin(u.sysAdmin),
 254       store(u.store),
 255       tariffs(u.tariffs),
 256       tariff(u.tariff),
 257       traffStat(u.traffStat),
 258       traffStatSaved(u.traffStatSaved),
 259       settings(u.settings),
 260       authorizedBy(),
 261       messages(u.messages),
 262       deleted(u.deleted),
 263       lastWriteStat(u.lastWriteStat),
 264       lastWriteDetailedStat(u.lastWriteDetailedStat),
 265       cash(property.cash),
 266       up(property.up),
 267       down(property.down),
 268       lastCashAdd(property.lastCashAdd),
 269       passiveTime(property.passiveTime),
 270       lastCashAddTime(property.lastCashAddTime),
 271       freeMb(property.freeMb),
 272       lastActivityTime(property.lastActivityTime),
 273       password(property.password),
 274       passive(property.passive),
 275       disabled(property.disabled),
 276       disabledDetailStat(property.disabledDetailStat),
 277       alwaysOnline(property.alwaysOnline),
 278       tariffName(property.tariffName),
 279       nextTariff(property.nextTariff),
 280       address(property.address),
 281       note(property.note),
 282       group(property.group),
 283       email(property.email),
 284       phone(property.phone),
 285       realName(property.realName),
 286       credit(property.credit),
 287       creditExpire(property.creditExpire),
 288       ips(property.ips),
 289       userdata0(property.userdata0),
 290       userdata1(property.userdata1),
 291       userdata2(property.userdata2),
 292       userdata3(property.userdata3),
 293       userdata4(property.userdata4),
 294       userdata5(property.userdata5),
 295       userdata6(property.userdata6),
 296       userdata7(property.userdata7),
 297       userdata8(property.userdata8),
 298       userdata9(property.userdata9),
 299       sessionUpload(),
 300       sessionDownload(),
 301       passiveNotifier(this),
 302       tariffNotifier(this),
 303       cashNotifier(this),
 304       ipNotifier(this),
 305       mutex(),
 306       errorStr()
 307 {
 308 if (&u == this)
 309     return;
 310
 311 property.tariffName.AddBeforeNotifier(&tariffNotifier);
 312 property.passive.AddBeforeNotifier(&passiveNotifier);
 313 property.cash.AddBeforeNotifier(&cashNotifier);
 314 ips.AddAfterNotifier(&ipNotifier);
 315
 316 property.SetProperties(u.property);
 317
 318 pthread_mutexattr_t attr;
 319 pthread_mutexattr_init(&attr);
 320 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 321 pthread_mutex_init(&mutex, &attr);
 322 }
 323 //-----------------------------------------------------------------------------
 324 USER_IMPL::~USER_IMPL()
 325 {
 326 property.passive.DelBeforeNotifier(&passiveNotifier);
 327 property.tariffName.DelBeforeNotifier(&tariffNotifier);
 328 pthread_mutex_destroy(&mutex);
 329 }
 330 //-----------------------------------------------------------------------------
 331 void USER_IMPL::SetLogin(string const & l)
 332 {
 333 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 334 assert(login.empty() && "Login is already set");
 335 login = l;
 336 id = userIDGenerator.GetNextID();
 337 }
 338 //-----------------------------------------------------------------------------
 339 int USER_IMPL::ReadConf()
 340 {
 341 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 342 USER_CONF conf;
 343
 344 if (store->RestoreUserConf(&conf, login))
 345     {
 346     WriteServLog("Cannot read conf for user %s.", login.c_str());
 347     WriteServLog("%s", store->GetStrError().c_str());
 348     printfd(__FILE__, "Cannot read conf for user %s.\n", login.c_str());
 349     printfd(__FILE__, "%s\n", store->GetStrError().c_str());
 350     return -1;
 351     }
 352
 353 property.SetConf(conf);
 354
 355 tariff = tariffs->FindByName(tariffName);
 356 if (tariff == NULL)
 357     {
 358     WriteServLog("Cannot read user %s. Tariff %s not exist.",
 359                  login.c_str(), property.tariffName.Get().c_str());
 360     return -1;
 361     }
 362
 363 std::vector<STG_MSG_HDR> hdrsList;
 364
 365 if (store->GetMessageHdrs(&hdrsList, login))
 366     {
 367     printfd(__FILE__, "Error GetMessageHdrs %s\n", store->GetStrError().c_str());
 368     WriteServLog("Cannot read user %s. Error reading message headers: %s.",
 369                  login.c_str(),
 370                  store->GetStrError().c_str());
 371     return -1;
 372     }
 373
 374 std::vector<STG_MSG_HDR>::const_iterator it;
 375 for (it = hdrsList.begin(); it != hdrsList.end(); ++it)
 376     {
 377     STG_MSG msg;
 378     if (store->GetMessage(it->id, &msg, login) == 0)
 379         {
 380         messages.push_back(msg);
 381         }
 382     }
 383
 384 return 0;
 385 }
 386 //-----------------------------------------------------------------------------
 387 int USER_IMPL::ReadStat()
 388 {
 389 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 390 USER_STAT stat;
 391
 392 if (store->RestoreUserStat(&stat, login))
 393     {
 394     WriteServLog("Cannot read stat for user %s.", login.c_str());
 395     WriteServLog("%s", store->GetStrError().c_str());
 396     printfd(__FILE__, "Cannot read stat for user %s.\n", login.c_str());
 397     printfd(__FILE__, "%s\n", store->GetStrError().c_str());
 398     return -1;
 399     }
 400
 401 property.SetStat(stat);
 402
 403 return 0;
 404 }
 405 //-----------------------------------------------------------------------------
 406 int USER_IMPL::WriteConf()
 407 {
 408 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 409 USER_CONF conf(property.GetConf());
 410
 411 printfd(__FILE__, "USER::WriteConf()\n");
 412
 413 if (store->SaveUserConf(conf, login))
 414     {
 415     WriteServLog("Cannot write conf for user %s.", login.c_str());
 416     WriteServLog("%s", store->GetStrError().c_str());
 417     printfd(__FILE__, "Cannot write conf for user %s.\n", login.c_str());
 418     printfd(__FILE__, "%s\n", store->GetStrError().c_str());
 419     return -1;
 420     }
 421
 422 return 0;
 423 }
 424 //-----------------------------------------------------------------------------
 425 int USER_IMPL::WriteStat()
 426 {
 427 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 428 USER_STAT stat(property.GetStat());
 429
 430 if (store->SaveUserStat(stat, login))
 431     {
 432     WriteServLog("Cannot write stat for user %s.", login.c_str());
 433     WriteServLog("%s", store->GetStrError().c_str());
 434     printfd(__FILE__, "Cannot write stat for user %s.\n", login.c_str());
 435     printfd(__FILE__, "%s\n", store->GetStrError().c_str());
 436     return -1;
 437     }
 438
 439 lastWriteStat = stgTime;
 440
 441 return 0;
 442 }
 443 //-----------------------------------------------------------------------------
 444 int USER_IMPL::WriteMonthStat()
 445 {
 446 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 447 time_t tt = stgTime - 3600;
 448 struct tm t1;
 449 localtime_r(&tt, &t1);
 450
 451 USER_STAT stat(property.GetStat());
 452 if (store->SaveMonthStat(stat, t1.tm_mon, t1.tm_year, login))
 453     {
 454     WriteServLog("Cannot write month stat for user %s.", login.c_str());
 455     WriteServLog("%s", store->GetStrError().c_str());
 456     printfd(__FILE__, "Cannot write month stat for user %s.\n", login.c_str());
 457     printfd(__FILE__, "%s\n", store->GetStrError().c_str());
 458     return -1;
 459     }
 460
 461 return 0;
 462 }
 463 //-----------------------------------------------------------------------------
 464 int USER_IMPL::Authorize(uint32_t ip, uint32_t dirs, const AUTH * auth)
 465 {
 466 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 467 /*
 468  *  Authorize user. It only means that user will be authorized. Nothing more.
 469  *  User can be connected or disconnected while authorized.
 470  *  Example: user is authorized but disconnected due to 0 money or blocking
 471  */
 472
 473 /*
 474  * Prevent double authorization by identical authorizers
 475  */
 476 if (authorizedBy.find(auth) != authorizedBy.end())
 477     return 0;
 478
 479 if (!ip)
 480     return -1;
 481
 482 for (int i = 0; i < DIR_NUM; i++)
 483     {
 484     enabledDirs[i] = dirs & (1 << i);
 485     }
 486
 487 if (authorizedBy.size())
 488     {
 489     if (currIP != ip)
 490         {
 491         //  We are already authorized, but with different IP address
 492         errorStr = "User " + login + " already authorized with IP address " + inet_ntostring(ip);
 493         return -1;
 494         }
 495
 496     USER * u = NULL;
 497     if (!users->FindByIPIdx(ip, &u))
 498         {
 499         //  Address is already present in IP-index
 500         //  If it's not our IP - throw an error
 501         if (u != this)
 502             {
 503             errorStr = "IP address " + inet_ntostring(ip) + " already in use";
 504             return -1;
 505             }
 506         }
 507     }
 508 else
 509     {
 510     if (users->IsIPInIndex(ip))
 511         {
 512         //  Address is already present in IP-index
 513         errorStr = "IP address " + inet_ntostring(ip) + " already in use";
 514         return -1;
 515         }
 516
 517     if (ips.ConstData().IsIPInIPS(ip))
 518         {
 519         currIP = ip;
 520         lastIPForDisconnect = currIP;
 521         }
 522     else
 523         {
 524         printfd(__FILE__, " user %s: ips = %s\n", login.c_str(), ips.ConstData().GetIpStr().c_str());
 525         errorStr = "IP address " + inet_ntostring(ip) + " not belong user " + login;
 526         return -1;
 527         }
 528     }
 529
 530 authorizedBy.insert(auth);
 531
 532 ScanMessage();
 533
 534 return 0;
 535 }
 536 //-----------------------------------------------------------------------------
 537 void USER_IMPL::Unauthorize(const AUTH * auth)
 538 {
 539 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 540 /*
 541  *  Authorizer tries to unauthorize user, that was not authorized by it
 542  */
 543 if (!authorizedBy.erase(auth))
 544     return;
 545
 546 if (authorizedBy.empty())
 547     {
 548     lastIPForDisconnect = currIP;
 549     currIP = 0; // DelUser in traffcounter
 550     return;
 551     }
 552 }
 553 //-----------------------------------------------------------------------------
 554 bool USER_IMPL::IsAuthorizedBy(const AUTH * auth) const
 555 {
 556 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 557 //  Is this user authorized by specified authorizer?
 558 return authorizedBy.find(auth) != authorizedBy.end();
 559 }
 560 //-----------------------------------------------------------------------------
 561 void USER_IMPL::Connect(bool fakeConnect)
 562 {
 563 /*
 564  *  Connect user to Internet. This function is differ from Authorize() !!!
 565  */
 566
 567 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 568
 569 if (!fakeConnect)
 570     {
 571     string scriptOnConnect = settings->GetScriptsDir() + "/OnConnect";
 572
 573     if (access(scriptOnConnect.c_str(), X_OK) == 0)
 574         {
 575         char dirsStr[DIR_NUM + 1];
 576         dirsStr[DIR_NUM] = 0;
 577         for (int i = 0; i < DIR_NUM; i++)
 578             {
 579             dirsStr[i] = enabledDirs[i] ? '1' : '0';
 580             }
 581
 582         string scriptOnConnectParams;
 583         strprintf(&scriptOnConnectParams,
 584                 "%s \"%s\" \"%s\" \"%f\" \"%d\" \"%s\"",
 585                 scriptOnConnect.c_str(),
 586                 login.c_str(),
 587                 inet_ntostring(currIP).c_str(),
 588                 (double)cash,
 589                 id,
 590                 dirsStr);
 591
 592         ScriptExec(scriptOnConnectParams.c_str());
 593         }
 594     else
 595         {
 596         WriteServLog("Script %s cannot be executed. File not found.", scriptOnConnect.c_str());
 597         }
 598
 599     connected = true;
 600     }
 601
 602 if (store->WriteUserConnect(login, currIP))
 603     {
 604     WriteServLog("Cannot write connect for user %s.", login.c_str());
 605     WriteServLog("%s", store->GetStrError().c_str());
 606     }
 607
 608 if (!fakeConnect)
 609     lastIPForDisconnect = currIP;
 610 }
 611 //-----------------------------------------------------------------------------
 612 void USER_IMPL::Disconnect(bool fakeDisconnect, const std::string & reason)
 613 {
 614 /*
 615  *  Disconnect user from Internet. This function is differ from UnAuthorize() !!!
 616  */
 617
 618 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 619
 620 if (!lastIPForDisconnect)
 621     {
 622     printfd(__FILE__, "lastIPForDisconnect\n");
 623     return;
 624     }
 625
 626 if (!fakeDisconnect)
 627     {
 628     string scriptOnDisonnect = settings->GetScriptsDir() + "/OnDisconnect";
 629
 630     if (access(scriptOnDisonnect.c_str(), X_OK) == 0)
 631         {
 632         char dirsStr[DIR_NUM + 1];
 633         dirsStr[DIR_NUM] = 0;
 634         for (int i = 0; i < DIR_NUM; i++)
 635             {
 636             dirsStr[i] = enabledDirs[i] ? '1' : '0';
 637             }
 638
 639         string scriptOnDisonnectParams;
 640         strprintf(&scriptOnDisonnectParams,
 641                 "%s \"%s\" \"%s\" \"%f\" \"%d\" \"%s\"",
 642                 scriptOnDisonnect.c_str(),
 643                 login.c_str(),
 644                 inet_ntostring(lastIPForDisconnect).c_str(),
 645                 (double)cash,
 646                 id,
 647                 dirsStr);
 648
 649         ScriptExec(scriptOnDisonnectParams.c_str());
 650         }
 651     else
 652         {
 653         WriteServLog("Script OnDisconnect cannot be executed. File not found.");
 654         }
 655
 656     connected = false;
 657     }
 658
 659 if (store->WriteUserDisconnect(login, up, down, sessionUpload, sessionDownload, cash, freeMb, reason))
 660     {
 661     WriteServLog("Cannot write disconnect for user %s.", login.c_str());
 662     WriteServLog("%s", store->GetStrError().c_str());
 663     }
 664
 665 if (!fakeDisconnect)
 666     lastIPForDisconnect = 0;
 667
 668 DIR_TRAFF zeroSesssion;
 669
 670 sessionUpload = zeroSesssion;
 671 sessionDownload = zeroSesssion;
 672 }
 673 //-----------------------------------------------------------------------------
 674 void USER_IMPL::PrintUser() const
 675 {
 676 //return;
 677 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 678 cout << "============================================================" << endl;
 679 cout << "id=" << id << endl;
 680 cout << "login=" << login << endl;
 681 cout << "password=" << password << endl;
 682 cout << "passive=" << passive << endl;
 683 cout << "disabled=" << disabled << endl;
 684 cout << "disabledDetailStat=" << disabledDetailStat << endl;
 685 cout << "alwaysOnline=" << alwaysOnline << endl;
 686 cout << "tariffName=" << tariffName << endl;
 687 cout << "address=" << address << endl;
 688 cout << "phone=" << phone << endl;
 689 cout << "email=" << email << endl;
 690 cout << "note=" << note << endl;
 691 cout << "realName=" <<realName << endl;
 692 cout << "group=" << group << endl;
 693 cout << "credit=" << credit << endl;
 694 cout << "nextTariff=" << nextTariff << endl;
 695 cout << "userdata0" << userdata0 << endl;
 696 cout << "userdata1" << userdata1 << endl;
 697 cout << "creditExpire=" << creditExpire << endl;
 698 cout << "ips=" << ips << endl;
 699 cout << "------------------------" << endl;
 700 cout << "up=" << up << endl;
 701 cout << "down=" << down << endl;
 702 cout << "cash=" << cash << endl;
 703 cout << "freeMb=" << freeMb << endl;
 704 cout << "lastCashAdd=" << lastCashAdd << endl;
 705 cout << "lastCashAddTime=" << lastCashAddTime << endl;
 706 cout << "passiveTime=" << passiveTime << endl;
 707 cout << "lastActivityTime=" << lastActivityTime << endl;
 708 cout << "============================================================" << endl;
 709 }
 710 //-----------------------------------------------------------------------------
 711 void USER_IMPL::Run()
 712 {
 713 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 714
 715 if (stgTime > static_cast<time_t>(lastWriteStat + settings->GetStatWritePeriod()))
 716     {
 717     printfd(__FILE__, "USER::WriteStat user=%s\n", GetLogin().c_str());
 718     WriteStat();
 719     }
 720 if (creditExpire.ConstData() && creditExpire.ConstData() < stgTime)
 721     {
 722     WriteServLog("User: %s. Credit expired.", login.c_str());
 723     credit = 0;
 724     creditExpire = 0;
 725     WriteConf();
 726     }
 727
 728 if (passive.ConstData()
 729     && (stgTime % 30 == 0)
 730     && (passiveTime.ModificationTime() != stgTime))
 731     {
 732     passiveTime = passiveTime + (stgTime - passiveTime.ModificationTime());
 733     printfd(__FILE__, "===== %s: passiveTime=%d =====\n", login.c_str(), passiveTime.ConstData());
 734     }
 735
 736 if (!authorizedBy.empty())
 737     {
 738     if (connected)
 739         {
 740         property.Stat().lastActivityTime = stgTime;
 741         }
 742     if (!connected && IsInetable())
 743         {
 744         Connect();
 745         }
 746     if (connected && !IsInetable())
 747         {
 748         if (disabled)
 749             Disconnect(false, "disabled");
 750         else if (passive)
 751             Disconnect(false, "passive");
 752         else
 753             Disconnect(false, "no cash");
 754         }
 755
 756     if (stgTime - lastScanMessages > 10)
 757         {
 758         ScanMessage();
 759         lastScanMessages = stgTime;
 760         }
 761     }
 762 else
 763     {
 764     if (connected)
 765         {
 766         Disconnect(false, "not authorized");
 767         }
 768     }
 769
 770 }
 771 //-----------------------------------------------------------------------------
 772 void USER_IMPL::UpdatePingTime(time_t t)
 773 {
 774 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 775 //printfd(__FILE__, "UpdatePingTime(%d) %s\n", t, login.c_str());
 776 if (t)
 777     pingTime = t;
 778 else
 779     pingTime = stgTime;
 780 }
 781 //-----------------------------------------------------------------------------
 782 bool USER_IMPL::IsInetable()
 783 {
 784 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 785
 786 if (disabled || passive)
 787     return false;
 788
 789 if (settings->GetFreeMbAllowInet())
 790     {
 791     if (freeMb >= 0)
 792         return true;
 793     }
 794
 795 if (settings->GetShowFeeInCash() || tariff == NULL)
 796     {
 797     return (cash >= -credit);
 798     }
 799
 800 return (cash - tariff->GetFee() >= -credit);
 801 }
 802 //-----------------------------------------------------------------------------
 803 string USER_IMPL::GetEnabledDirs()
 804 {
 805 //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 806
 807 string dirs = "";
 808 for(int i = 0; i < DIR_NUM; i++)
 809     dirs += enabledDirs[i] ? "1" : "0";
 810 return dirs;
 811 }
 812 //-----------------------------------------------------------------------------
 813 #ifdef TRAFF_STAT_WITH_PORTS
 814 void USER_IMPL::AddTraffStatU(int dir, uint32_t ip, uint16_t port, uint32_t len)
 815 #else
 816 void USER_IMPL::AddTraffStatU(int dir, uint32_t ip, uint32_t len)
 817 #endif
 818 {
 819 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 820
 821 if (!connected || tariff == NULL)
 822     return;
 823
 824 double cost = 0;
 825 DIR_TRAFF dt(up);
 826
 827 int64_t traff = tariff->GetTraffByType(up.ConstData()[dir], down.ConstData()[dir]);
 828 int64_t threshold = tariff->GetThreshold(dir) * 1024 * 1024;
 829
 830 dt[dir] += len;
 831
 832 int tt = tariff->GetTraffType();
 833 if (tt == TRAFF_UP ||
 834     tt == TRAFF_UP_DOWN ||
 835     // Check NEW traff data
 836     (tt == TRAFF_MAX && dt[dir] > down.ConstData()[dir]))
 837     {
 838     double dc = 0;
 839     if (traff < threshold &&
 840         traff + len >= threshold)
 841         {
 842         // cash = partBeforeThreshold * priceBeforeThreshold +
 843         //        partAfterThreshold * priceAfterThreshold
 844         int64_t before = threshold - traff; // Chunk part before threshold
 845         int64_t after = len - before; // Chunk part after threshold
 846         dc = tariff->GetPriceWithTraffType(up.ConstData()[dir], // Traff before chunk
 847                                            down.ConstData()[dir],
 848                                            dir,
 849                                            stgTime) * before +
 850              tariff->GetPriceWithTraffType(dt[dir], // Traff after chunk
 851                                            down.ConstData()[dir],
 852                                            dir,
 853                                            stgTime) * after;
 854         }
 855     else
 856         {
 857         dc = tariff->GetPriceWithTraffType(up.ConstData()[dir],
 858                                            down.ConstData()[dir],
 859                                            dir,
 860                                            stgTime) * len;
 861         }
 862
 863     if (freeMb.ConstData() <= 0) // FreeMb is exhausted
 864         cost = dc;
 865     else if (freeMb.ConstData() < dc) // FreeMb is partially exhausted
 866         cost = dc - freeMb.ConstData();
 867
 868     // Direct access to internal data structures via friend-specifier
 869     property.Stat().freeMb -= dc;
 870     property.Stat().cash -= cost;
 871     cash.ModifyTime();
 872     freeMb.ModifyTime();
 873     }
 874
 875 up = dt;
 876 sessionUpload[dir] += len;
 877
 878 //Add detailed stat
 879
 880 if (!settings->GetWriteFreeMbTraffCost() &&
 881      freeMb.ConstData() >= 0)
 882     cost = 0;
 883
 884 #ifdef TRAFF_STAT_WITH_PORTS
 885 IP_DIR_PAIR idp(ip, dir, port);
 886 #else
 887 IP_DIR_PAIR idp(ip, dir);
 888 #endif
 889
 890 map<IP_DIR_PAIR, STAT_NODE>::iterator lb;
 891 lb = traffStat.lower_bound(idp);
 892 if (lb == traffStat.end() || lb->first != idp)
 893     {
 894     traffStat.insert(lb,
 895                      pair<IP_DIR_PAIR, STAT_NODE>(idp,
 896                                                   STAT_NODE(len, 0, cost)));
 897     }
 898 else
 899     {
 900     lb->second.cash += cost;
 901     lb->second.up += len;
 902     }
 903 }
 904 //-----------------------------------------------------------------------------
 905 #ifdef TRAFF_STAT_WITH_PORTS
 906 void USER_IMPL::AddTraffStatD(int dir, uint32_t ip, uint16_t port, uint32_t len)
 907 #else
 908 void USER_IMPL::AddTraffStatD(int dir, uint32_t ip, uint32_t len)
 909 #endif
 910 {
 911 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 912
 913 if (!connected || tariff == NULL)
 914     return;
 915
 916 double cost = 0;
 917 DIR_TRAFF dt(down);
 918
 919 int64_t traff = tariff->GetTraffByType(up.ConstData()[dir], down.ConstData()[dir]);
 920 int64_t threshold = tariff->GetThreshold(dir) * 1024 * 1024;
 921
 922 dt[dir] += len;
 923
 924 int tt = tariff->GetTraffType();
 925 if (tt == TRAFF_DOWN ||
 926     tt == TRAFF_UP_DOWN ||
 927     // Check NEW traff data
 928     (tt == TRAFF_MAX && up.ConstData()[dir] <= dt[dir]))
 929     {
 930     double dc = 0;
 931     if (traff < threshold &&
 932         traff + len >= threshold)
 933         {
 934         // cash = partBeforeThreshold * priceBeforeThreshold +
 935         //        partAfterThreshold * priceAfterThreshold
 936         int64_t before = threshold - traff; // Chunk part before threshold
 937         int64_t after = len - before; // Chunk part after threshold
 938         dc = tariff->GetPriceWithTraffType(up.ConstData()[dir],
 939                                            down.ConstData()[dir], // Traff before chunk
 940                                            dir,
 941                                            stgTime) * before +
 942              tariff->GetPriceWithTraffType(up.ConstData()[dir],
 943                                            dt[dir], // Traff after chunk
 944                                            dir,
 945                                            stgTime) * after;
 946         }
 947     else
 948         {
 949         dc = tariff->GetPriceWithTraffType(up.ConstData()[dir],
 950                                            down.ConstData()[dir],
 951                                            dir,
 952                                            stgTime) * len;
 953         }
 954
 955     if (freeMb.ConstData() <= 0) // FreeMb is exhausted
 956         cost = dc;
 957     else if (freeMb.ConstData() < dc) // FreeMb is partially exhausted
 958         cost = dc - freeMb.ConstData();
 959
 960     property.Stat().freeMb -= dc;
 961     property.Stat().cash -= cost;
 962     cash.ModifyTime();
 963     freeMb.ModifyTime();
 964     }
 965
 966 down = dt;
 967 sessionDownload[dir] += len;
 968
 969 //Add detailed stat
 970
 971 if (!settings->GetWriteFreeMbTraffCost() &&
 972      freeMb.ConstData() >= 0)
 973     cost = 0;
 974
 975 #ifdef TRAFF_STAT_WITH_PORTS
 976 IP_DIR_PAIR idp(ip, dir, port);
 977 #else
 978 IP_DIR_PAIR idp(ip, dir);
 979 #endif
 980
 981 map<IP_DIR_PAIR, STAT_NODE>::iterator lb;
 982 lb = traffStat.lower_bound(idp);
 983 if (lb == traffStat.end() || lb->first != idp)
 984     {
 985     traffStat.insert(lb,
 986                      pair<IP_DIR_PAIR, STAT_NODE>(idp,
 987                                                   STAT_NODE(0, len, cost)));
 988     }
 989 else
 990     {
 991     lb->second.cash += cost;
 992     lb->second.down += len;
 993     }
 994 }
 995 //-----------------------------------------------------------------------------
 996 void USER_IMPL::AddCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
 997 {
 998 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 999 currIP.AddBeforeNotifier(n);
1000 }
1001 //-----------------------------------------------------------------------------
1002 void USER_IMPL::DelCurrIPBeforeNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
1003 {
1004 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1005 currIP.DelBeforeNotifier(n);
1006 }
1007 //-----------------------------------------------------------------------------
1008 void USER_IMPL::AddCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
1009 {
1010 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1011 currIP.AddAfterNotifier(n);
1012 }
1013 //-----------------------------------------------------------------------------
1014 void USER_IMPL::DelCurrIPAfterNotifier(PROPERTY_NOTIFIER_BASE<uint32_t> * n)
1015 {
1016 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1017 currIP.DelAfterNotifier(n);
1018 }
1019 //-----------------------------------------------------------------------------
1020 void USER_IMPL::AddConnectedBeforeNotifier(PROPERTY_NOTIFIER_BASE<bool> * n)
1021 {
1022 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1023 connected.AddBeforeNotifier(n);
1024 }
1025 //-----------------------------------------------------------------------------
1026 void USER_IMPL::DelConnectedBeforeNotifier(PROPERTY_NOTIFIER_BASE<bool> * n)
1027 {
1028 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1029 connected.DelBeforeNotifier(n);
1030 }
1031 //-----------------------------------------------------------------------------
1032 void USER_IMPL::AddConnectedAfterNotifier(PROPERTY_NOTIFIER_BASE<bool> * n)
1033 {
1034 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1035 connected.AddAfterNotifier(n);
1036 }
1037 //-----------------------------------------------------------------------------
1038 void USER_IMPL::DelConnectedAfterNotifier(PROPERTY_NOTIFIER_BASE<bool> * n)
1039 {
1040 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1041 connected.DelAfterNotifier(n);
1042 }
1043 //-----------------------------------------------------------------------------
1044 void USER_IMPL::OnAdd()
1045 {
1046 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1047
1048 string scriptOnAdd = settings->GetScriptsDir() + "/OnUserAdd";
1049
1050 if (access(scriptOnAdd.c_str(), X_OK) == 0)
1051     {
1052     string scriptOnAddParams;
1053     strprintf(&scriptOnAddParams,
1054             "%s \"%s\"",
1055             scriptOnAdd.c_str(),
1056             login.c_str());
1057
1058     ScriptExec(scriptOnAddParams.c_str());
1059     }
1060 else
1061     {
1062     WriteServLog("Script %s cannot be executed. File not found.", scriptOnAdd.c_str());
1063     }
1064 }
1065 //-----------------------------------------------------------------------------
1066 void USER_IMPL::OnDelete()
1067 {
1068 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1069
1070 string scriptOnDel = settings->GetScriptsDir() + "/OnUserDel";
1071
1072 if (access(scriptOnDel.c_str(), X_OK) == 0)
1073     {
1074     string scriptOnDelParams;
1075     strprintf(&scriptOnDelParams,
1076             "%s \"%s\"",
1077             scriptOnDel.c_str(),
1078             login.c_str());
1079
1080     ScriptExec(scriptOnDelParams.c_str());
1081     }
1082 else
1083     {
1084     WriteServLog("Script %s cannot be executed. File not found.", scriptOnDel.c_str());
1085     }
1086
1087 Run();
1088 }
1089 //-----------------------------------------------------------------------------
1090 int USER_IMPL::WriteDetailStat(bool hard)
1091 {
1092 printfd(__FILE__, "USER::WriteDetailedStat() - saved size = %d\n", traffStatSaved.second.size());
1093
1094 if (!traffStatSaved.second.empty())
1095     {
1096     if (store->WriteDetailedStat(traffStatSaved.second, traffStatSaved.first, login))
1097         {
1098         printfd(__FILE__, "USER::WriteDetailStat() - failed to write detail stat from queue\n");
1099         WriteServLog("Cannot write detail stat from queue (of size %d recs) for user %s.", traffStatSaved.second.size(), login.c_str());
1100         WriteServLog("%s", store->GetStrError().c_str());
1101         return -1;
1102         }
1103     traffStatSaved.second.erase(traffStatSaved.second.begin(), traffStatSaved.second.end());
1104     }
1105
1106 TRAFF_STAT ts;
1107
1108     {
1109     STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1110     ts.swap(traffStat);
1111     }
1112
1113 printfd(__FILE__, "USER::WriteDetailedStat() - size = %d\n", ts.size());
1114
1115 if (ts.size() && !disabledDetailStat)
1116     {
1117     if (store->WriteDetailedStat(ts, lastWriteDetailedStat, login))
1118         {
1119         printfd(__FILE__, "USER::WriteDetailStat() - failed to write current detail stat\n");
1120         WriteServLog("Cannot write detail stat for user %s.", login.c_str());
1121         WriteServLog("%s", store->GetStrError().c_str());
1122         if (!hard)
1123             {
1124             printfd(__FILE__, "USER::WriteDetailStat() - pushing detail stat to queue\n");
1125             STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1126             traffStatSaved.second.swap(ts);
1127             traffStatSaved.first = lastWriteDetailedStat;
1128             }
1129         return -1;
1130         }
1131     }
1132 lastWriteDetailedStat = stgTime;
1133 return 0;
1134 }
1135 //-----------------------------------------------------------------------------
1136 double USER_IMPL::GetPassiveTimePart() const
1137 {
1138 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1139
1140 static int daysInMonth[12] =
1141 {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
1142
1143 struct tm tms;
1144 time_t t = stgTime;
1145 localtime_r(&t, &tms);
1146
1147 time_t secMonth = daysInMonth[(tms.tm_mon + 11) % 12] * 24 * 3600; // Previous month
1148
1149 if (tms.tm_year % 4 == 0 && tms.tm_mon == 1)
1150     {
1151     // Leap year
1152     secMonth += 24 * 3600;
1153     }
1154
1155 int dt = secMonth - passiveTime;
1156
1157 if (dt < 0)
1158     dt = 0;
1159
1160 return double(dt) / (secMonth);
1161 }
1162 //-----------------------------------------------------------------------------
1163 void USER_IMPL::SetPassiveTimeAsNewUser()
1164 {
1165 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1166
1167 time_t t = stgTime;
1168 struct tm tm;
1169 localtime_r(&t, &tm);
1170 int daysCurrMon = DaysInCurrentMonth();
1171 double pt = (tm.tm_mday - 1) / (double)daysCurrMon;
1172
1173 passiveTime = (time_t)(pt * 24 * 3600 * daysCurrMon);
1174 }
1175 //-----------------------------------------------------------------------------
1176 void USER_IMPL::MidnightResetSessionStat()
1177 {
1178 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1179
1180 if (connected)
1181     {
1182     Disconnect(true, "fake");
1183     Connect(true);
1184     }
1185 }
1186 //-----------------------------------------------------------------------------
1187 void USER_IMPL::ProcessNewMonth()
1188 {
1189 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1190 //  Reset traff
1191 if (connected)
1192     {
1193     Disconnect(true, "fake");
1194     }
1195 DIR_TRAFF zeroTarff;
1196
1197 WriteMonthStat();
1198
1199 up = zeroTarff;
1200 down = zeroTarff;
1201
1202 if (connected)
1203     {
1204     Connect(true);
1205     }
1206
1207 //  Set new tariff
1208 if (nextTariff.ConstData() != "")
1209     {
1210     const TARIFF * nt;
1211     nt = tariffs->FindByName(nextTariff);
1212     if (nt == NULL)
1213         {
1214         WriteServLog("Cannot change tariff for user %s. Tariff %s not exist.",
1215                      login.c_str(), property.tariffName.Get().c_str());
1216         }
1217     else
1218         {
1219         property.tariffName.Set(nextTariff, sysAdmin, login, store);
1220         //tariff = nt;
1221         }
1222     ResetNextTariff();
1223     WriteConf();
1224     }
1225 }
1226 //-----------------------------------------------------------------------------
1227 void USER_IMPL::ProcessDayFeeSpread()
1228 {
1229 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1230
1231 if (passive.ConstData() || tariff == NULL)
1232     return;
1233
1234 double fee = tariff->GetFee() / DaysInCurrentMonth();
1235
1236 if (fee == 0.0)
1237     return;
1238
1239 double c = cash;
1240 switch (settings->GetFeeChargeType())
1241     {
1242     case 0:
1243         property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
1244         break;
1245     case 1:
1246         if (c > 0)
1247             property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
1248         break;
1249     case 2:
1250         if (c > fee)
1251             property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
1252         break;
1253     }
1254 ResetPassiveTime();
1255 }
1256 //-----------------------------------------------------------------------------
1257 void USER_IMPL::ProcessDayFee()
1258 {
1259 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1260
1261 if (tariff == NULL)
1262     return;
1263
1264 double passiveTimePart = 1.0;
1265 if (!settings->GetFullFee())
1266     {
1267     passiveTimePart = GetPassiveTimePart();
1268     }
1269 else
1270     {
1271     if (passive.ConstData())
1272         {
1273         printfd(__FILE__, "Don't charge fee `cause we are passive\n");
1274         return;
1275         }
1276     }
1277 double fee = tariff->GetFee() * passiveTimePart;
1278
1279 ResetPassiveTime();
1280
1281 if (fee == 0.0)
1282     {
1283     SetPrepaidTraff();
1284     return;
1285     }
1286
1287 double c = cash;
1288 printfd(__FILE__, "login: %8s   Fee=%f PassiveTimePart=%f fee=%f\n",
1289         login.c_str(),
1290         tariff->GetFee(),
1291         passiveTimePart,
1292         fee);
1293 switch (settings->GetFeeChargeType())
1294     {
1295     case 0:
1296         property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
1297         SetPrepaidTraff();
1298         break;
1299     case 1:
1300         if (c > 0)
1301             {
1302             property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
1303             SetPrepaidTraff();
1304             }
1305         break;
1306     case 2:
1307         if (c > fee)
1308             {
1309             property.cash.Set(c - fee, sysAdmin, login, store, "Subscriber fee charge");
1310             SetPrepaidTraff();
1311             }
1312         break;
1313     }
1314 }
1315 //-----------------------------------------------------------------------------
1316 void USER_IMPL::SetPrepaidTraff()
1317 {
1318 if (tariff != NULL)
1319     property.freeMb.Set(tariff->GetFree(), sysAdmin, login, store, "Prepaid traffic");
1320 }
1321 //-----------------------------------------------------------------------------
1322 int USER_IMPL::AddMessage(STG_MSG * msg)
1323 {
1324 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1325
1326 if (SendMessage(*msg))
1327     {
1328     if (store->AddMessage(msg, login))
1329         {
1330         errorStr = store->GetStrError();
1331         WriteServLog("Error adding message: '%s'", errorStr.c_str());
1332         printfd(__FILE__, "Error adding message: '%s'\n", errorStr.c_str());
1333         return -1;
1334         }
1335     messages.push_back(*msg);
1336     }
1337 else
1338     {
1339     if (msg->header.repeat > 0)
1340         {
1341         msg->header.repeat--;
1342         #ifndef DEBUG
1343         //TODO: gcc v. 4.x generate ICE on x86_64
1344         msg->header.lastSendTime = time(NULL);
1345         #else
1346         msg->header.lastSendTime = stgTime;
1347         #endif
1348         if (store->AddMessage(msg, login))
1349             {
1350             errorStr = store->GetStrError();
1351             WriteServLog("Error adding repeatable message: '%s'", errorStr.c_str());
1352             printfd(__FILE__, "Error adding repeatable message: '%s'\n", errorStr.c_str());
1353             return -1;
1354             }
1355         messages.push_back(*msg);
1356         }
1357     }
1358 return 0;
1359 }
1360 //-----------------------------------------------------------------------------
1361 int USER_IMPL::SendMessage(STG_MSG & msg) const
1362 {
1363 // No lock `cause we are already locked from caller
1364 int ret = -1;
1365 set<const AUTH*>::iterator it(authorizedBy.begin());
1366 while (it != authorizedBy.end())
1367     {
1368     if (!(*it++)->SendMessage(msg, currIP))
1369         ret = 0;
1370     }
1371 if (!ret)
1372     {
1373 #ifndef DEBUG
1374     //TODO: gcc v. 4.x generate ICE on x86_64
1375     msg.header.lastSendTime = time(NULL);
1376 #else
1377     msg.header.lastSendTime = stgTime;
1378 #endif
1379     msg.header.repeat--;
1380     }
1381 return ret;
1382 }
1383 //-----------------------------------------------------------------------------
1384 void USER_IMPL::ScanMessage()
1385 {
1386 // No lock `cause we are already locked from caller
1387 // We need not check for the authorizedBy `cause it has already checked by caller
1388
1389 std::list<STG_MSG>::iterator it(messages.begin());
1390 while (it != messages.end())
1391     {
1392     if (settings->GetMessageTimeout() > 0 &&
1393         difftime(stgTime, it->header.creationTime) > settings->GetMessageTimeout())
1394         {
1395         // Timeout exceeded
1396         if (store->DelMessage(it->header.id, login))
1397             {
1398             WriteServLog("Error deleting message: '%s'", store->GetStrError().c_str());
1399             printfd(__FILE__, "Error deleting message: '%s'\n", store->GetStrError().c_str());
1400             }
1401         messages.erase(it++);
1402         continue;
1403         }
1404     if (it->GetNextSendTime() <= stgTime)
1405         {
1406         if (SendMessage(*it))
1407             {
1408             // We need to check all messages in queue for timeout
1409             ++it;
1410             continue;
1411             }
1412         if (it->header.repeat < 0)
1413             {
1414             if (store->DelMessage(it->header.id, login))
1415                 {
1416                 WriteServLog("Error deleting message: '%s'", store->GetStrError().c_str());
1417                 printfd(__FILE__, "Error deleting message: '%s'\n", store->GetStrError().c_str());
1418                 }
1419             messages.erase(it++);
1420             }
1421         else
1422             {
1423             if (store->EditMessage(*it, login))
1424                 {
1425                 WriteServLog("Error modifying message: '%s'", store->GetStrError().c_str());
1426                 printfd(__FILE__, "Error modifying message: '%s'\n", store->GetStrError().c_str());
1427                 }
1428             ++it;
1429             }
1430         }
1431     else
1432         {
1433         ++it;
1434         }
1435     }
1436 }
1437 //-----------------------------------------------------------------------------
1438 //-----------------------------------------------------------------------------
1439 //-----------------------------------------------------------------------------
1440 void CHG_PASSIVE_NOTIFIER::Notify(const int & oldPassive, const int & newPassive)
1441 {
1442 if (newPassive && !oldPassive && user->tariff != NULL)
1443     user->property.cash.Set(user->cash - user->tariff->GetPassiveCost(),
1444                             user->sysAdmin,
1445                             user->login,
1446                             user->store,
1447                             "Freeze");
1448 }
1449 //-----------------------------------------------------------------------------
1450 void CHG_TARIFF_NOTIFIER::Notify(const string &, const string & newTariff)
1451 {
1452 if (user->settings->GetReconnectOnTariffChange() && user->connected)
1453     user->Disconnect(false, "Change tariff");
1454 user->tariff = user->tariffs->FindByName(newTariff);
1455 if (user->settings->GetReconnectOnTariffChange() &&
1456     !user->authorizedBy.empty() &&
1457     user->IsInetable())
1458     user->Connect(false);
1459 }
1460 //-----------------------------------------------------------------------------
1461 void CHG_CASH_NOTIFIER::Notify(const double & oldCash, const double & newCash)
1462 {
1463 user->lastCashAddTime = *const_cast<time_t *>(&stgTime);
1464 user->lastCashAdd = newCash - oldCash;
1465 }
1466 //-----------------------------------------------------------------------------
1467 void CHG_IPS_NOTIFIER::Notify(const USER_IPS & from, const USER_IPS & to)
1468 {
1469     printfd(__FILE__, "Change IP from '%s' to '%s'\n", from.GetIpStr().c_str(), to.GetIpStr().c_str());
1470     if (user->connected)
1471         user->Disconnect(false, "Change IP");
1472     if (!user->authorizedBy.empty() && user->IsInetable())
1473         user->Connect(false);
1474 }
1475 //-----------------------------------------------------------------------------