projects/stargazer/plugins/store/postgresql/postgresql_store_users.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  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  19  */
  20
  21 /*
  22  *  User manipulation methods
  23  *
  24  *  $Revision: 1.14 $
  25  *  $Date: 2010/05/07 07:26:36 $
  26  *
  27  */
  28
  29 #include <string>
  30 #include <vector>
  31 #include <sstream>
  32 #include <ctime>
  33
  34 #include <libpq-fe.h>
  35
  36 #include "stg_const.h"
  37 #include "postgresql_store.h"
  38 #include "stg_locker.h"
  39 #include "../../../stg_timer.h"
  40
  41 //-----------------------------------------------------------------------------
  42 int POSTGRESQL_STORE::GetUsersList(vector<string> * usersList) const
  43 {
  44 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
  45
  46 if (PQstatus(connection) != CONNECTION_OK)
  47     {
  48     printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
  49     if (Reset())
  50         {
  51         strError = "Connection lost";
  52         printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): '%s'\n", strError.c_str());
  53         return -1;
  54         }
  55     }
  56
  57 PGresult * result;
  58
  59 if (StartTransaction())
  60     {
  61     printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): 'Failed to start transaction'\n");
  62     return -1;
  63     }
  64
  65 result = PQexec(connection, "SELECT name FROM tb_users");
  66
  67 if (PQresultStatus(result) != PGRES_TUPLES_OK)
  68     {
  69     strError = PQresultErrorMessage(result);
  70     PQclear(result);
  71     printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): '%s'\n", strError.c_str());
  72     if (RollbackTransaction())
  73         {
  74         printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): 'Failed to rollback transaction'\n");
  75         }
  76     return -1;
  77     }
  78
  79 int tuples = PQntuples(result);
  80
  81 for (int i = 0; i < tuples; ++i)
  82     {
  83     usersList->push_back(PQgetvalue(result, i, 0));
  84     }
  85
  86 PQclear(result);
  87
  88 if (CommitTransaction())
  89     {
  90     printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): 'Failed to commit transaction'\n");
  91     return -1;
  92     }
  93
  94 return 0;
  95 }
  96
  97 //-----------------------------------------------------------------------------
  98 int POSTGRESQL_STORE::AddUser(const string & name) const
  99 {
 100 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 101
 102 if (PQstatus(connection) != CONNECTION_OK)
 103     {
 104     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
 105     if (Reset())
 106         {
 107         strError = "Connection lost";
 108         printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): '%s'\n", strError.c_str());
 109         return -1;
 110         }
 111     }
 112
 113 PGresult * result;
 114
 115 if (StartTransaction())
 116     {
 117     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to start transaction'\n");
 118     return -1;
 119     }
 120
 121 std::string elogin = name;
 122
 123 if (EscapeString(elogin))
 124     {
 125     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to escape login'\n");
 126     if (RollbackTransaction())
 127         {
 128         printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to rollback transaction'\n");
 129         }
 130     return -1;
 131     }
 132
 133 std::stringstream query;
 134 query << "SELECT sp_add_user('" << elogin << "')";
 135
 136 result = PQexec(connection, query.str().c_str());
 137
 138 if (PQresultStatus(result) != PGRES_TUPLES_OK)
 139     {
 140     strError = PQresultErrorMessage(result);
 141     PQclear(result);
 142     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): '%s'\n", strError.c_str());
 143     if (RollbackTransaction())
 144         {
 145         printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to rollback transaction'\n");
 146         }
 147     return -1;
 148     }
 149
 150 PQclear(result);
 151
 152 if (CommitTransaction())
 153     {
 154     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to commit transaction'\n");
 155     return -1;
 156     }
 157
 158 return 0;
 159 }
 160
 161 //-----------------------------------------------------------------------------
 162 int POSTGRESQL_STORE::DelUser(const string & login) const
 163 {
 164 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 165
 166 if (PQstatus(connection) != CONNECTION_OK)
 167     {
 168     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
 169     if (Reset())
 170         {
 171         strError = "Connection lost";
 172         printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): '%s'\n", strError.c_str());
 173         return -1;
 174         }
 175     }
 176
 177 PGresult * result;
 178
 179 if (StartTransaction())
 180     {
 181     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to start transaction'\n");
 182     return -1;
 183     }
 184
 185 std::string elogin = login;
 186
 187 if (EscapeString(elogin))
 188     {
 189     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to escape login'\n");
 190     if (RollbackTransaction())
 191         {
 192         printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to rollback transaction'\n");
 193         }
 194     return -1;
 195     }
 196
 197 std::stringstream query;
 198 query << "DELETE FROM tb_users WHERE name = '" << elogin << "'";
 199
 200 result = PQexec(connection, query.str().c_str());
 201
 202 if (PQresultStatus(result) != PGRES_COMMAND_OK)
 203     {
 204     strError = PQresultErrorMessage(result);
 205     PQclear(result);
 206     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): '%s'\n", strError.c_str());
 207     if (RollbackTransaction())
 208         {
 209         printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to rollback transaction'\n");
 210         }
 211     return -1;
 212     }
 213
 214 PQclear(result);
 215
 216 if (CommitTransaction())
 217     {
 218     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to commit transaction'\n");
 219     return -1;
 220     }
 221
 222 return 0;
 223 }
 224 //-----------------------------------------------------------------------------
 225 int POSTGRESQL_STORE::SaveUserStat(const USER_STAT & stat,
 226                                    const string & login) const
 227 {
 228 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 229
 230 return SaveStat(stat, login);
 231 }
 232 //-----------------------------------------------------------------------------
 233 int POSTGRESQL_STORE::SaveStat(const USER_STAT & stat,
 234                                const string & login,
 235                                int year,
 236                                int month) const
 237 {
 238 if (PQstatus(connection) != CONNECTION_OK)
 239     {
 240     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
 241     if (Reset())
 242         {
 243         strError = "Connection lost";
 244         printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): '%s'\n", strError.c_str());
 245         return -1;
 246         }
 247     }
 248
 249 PGresult * result;
 250
 251 if (StartTransaction())
 252     {
 253     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to start transaction'\n");
 254     return -1;
 255     }
 256
 257 std::string elogin = login;
 258
 259 if (EscapeString(elogin))
 260     {
 261     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to escape login'\n");
 262     if (RollbackTransaction())
 263         {
 264         printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to rollback transaction'\n");
 265         }
 266     return -1;
 267     }
 268
 269 std::stringstream query;
 270 query << "UPDATE tb_users SET "
 271             "cash = " << stat.cash << ", "
 272             "free_mb = " << stat.freeMb << ", "
 273             "last_activity_time = CAST('" << Int2TS(stat.lastActivityTime) << "' AS TIMESTAMP), "
 274             "last_cash_add = " << stat.lastCashAdd << ", "
 275             "last_cash_add_time = CAST('" << Int2TS(stat.lastCashAddTime) << "' AS TIMESTAMP), "
 276             "passive_time = " << stat.passiveTime << " "
 277          "WHERE name = '" << elogin << "'";
 278
 279 result = PQexec(connection, query.str().c_str());
 280
 281 if (PQresultStatus(result) != PGRES_COMMAND_OK)
 282     {
 283     strError = PQresultErrorMessage(result);
 284     PQclear(result);
 285     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): '%s'\n", strError.c_str());
 286     if (RollbackTransaction())
 287         {
 288         printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to rollback transaction'\n");
 289         }
 290     return -1;
 291     }
 292
 293 PQclear(result);
 294
 295 std::string date;
 296
 297 MakeDate(date, year, month);
 298
 299 for (int dir = 0; dir < DIR_NUM; ++dir)
 300     {
 301     query.str("");
 302     query << "SELECT sp_add_stats_traffic ("
 303                 "'" << elogin << "', "
 304                 "CAST('" << date << "' AS DATE), "
 305                 "CAST(" << dir << " AS SMALLINT), "
 306                 "CAST(" << stat.up[dir] << " AS BIGINT), "
 307                 "CAST(" << stat.down[dir] << " AS BIGINT))";
 308
 309     result = PQexec(connection, query.str().c_str());
 310
 311     if (PQresultStatus(result) != PGRES_TUPLES_OK)
 312         {
 313         strError = PQresultErrorMessage(result);
 314         PQclear(result);
 315         printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): '%s'\n", strError.c_str());
 316         if (RollbackTransaction())
 317             {
 318             printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to rollback transaction'\n");
 319             }
 320         return -1;
 321         }
 322
 323     PQclear(result);
 324     }
 325
 326 if (CommitTransaction())
 327     {
 328     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to commit transaction'\n");
 329     return -1;
 330     }
 331
 332 return 0;
 333 }
 334
 335 //-----------------------------------------------------------------------------
 336 int POSTGRESQL_STORE::SaveUserConf(const USER_CONF & conf,
 337                                  const string & login) const
 338 {
 339 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 340
 341 if (PQstatus(connection) != CONNECTION_OK)
 342     {
 343     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
 344     if (Reset())
 345         {
 346         strError = "Connection lost";
 347         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): '%s'\n", strError.c_str());
 348         return -1;
 349         }
 350     }
 351
 352 PGresult * result;
 353
 354 if (StartTransaction())
 355     {
 356     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to start transaction'\n");
 357     return -1;
 358     }
 359
 360 std::string elogin = login;
 361
 362 if (EscapeString(elogin))
 363     {
 364     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape login'\n");
 365     if (RollbackTransaction())
 366         {
 367         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 368         }
 369     return -1;
 370     }
 371
 372 std::stringstream query;
 373 query << "SELECT pk_user FROM tb_users WHERE name = '" << elogin << "'";
 374
 375 result = PQexec(connection, query.str().c_str());
 376
 377 if (PQresultStatus(result) != PGRES_TUPLES_OK)
 378     {
 379     strError = PQresultErrorMessage(result);
 380     PQclear(result);
 381     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): '%s'\n", strError.c_str());
 382     if (RollbackTransaction())
 383         {
 384         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 385         }
 386     return -1;
 387     }
 388
 389 int tuples = PQntuples(result);
 390
 391 if (tuples != 1)
 392     {
 393     strError = "Failed to fetch user's ID";
 394     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
 395     PQclear(result);
 396     if (RollbackTransaction())
 397         {
 398         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 399         }
 400     return -1;
 401     }
 402
 403 std::stringstream tuple;
 404 tuple << PQgetvalue(result, 0, 0);
 405
 406 PQclear(result);
 407
 408 uint32_t uid;
 409
 410 tuple >> uid;
 411
 412 std::string eaddress = conf.address;
 413 std::string eemail = conf.email;
 414 std::string egroup = conf.group;
 415 std::string enote = conf.note;
 416 std::string epassword = conf.password;
 417 std::string ephone = conf.phone;
 418 std::string erealname = conf.realName;
 419 std::string etariffname = conf.tariffName;
 420 std::string enexttariff = conf.nextTariff;
 421 std::string ecorporation = conf.corp;
 422
 423 if (EscapeString(eaddress))
 424     {
 425     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape address'\n");
 426     if (RollbackTransaction())
 427         {
 428         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 429         }
 430     return -1;
 431     }
 432
 433 if (EscapeString(eemail))
 434     {
 435     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape email'\n");
 436     if (RollbackTransaction())
 437         {
 438         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 439         }
 440     return -1;
 441     }
 442
 443 if (EscapeString(egroup))
 444     {
 445     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape group'\n");
 446     if (RollbackTransaction())
 447         {
 448         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 449         }
 450     return -1;
 451     }
 452
 453 if (EscapeString(enote))
 454     {
 455     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape note'\n");
 456     if (RollbackTransaction())
 457         {
 458         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 459         }
 460     return -1;
 461     }
 462
 463 if (EscapeString(epassword))
 464     {
 465     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape password'\n");
 466     if (RollbackTransaction())
 467         {
 468         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 469         }
 470     return -1;
 471     }
 472
 473 if (EscapeString(ephone))
 474     {
 475     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape phone'\n");
 476     if (RollbackTransaction())
 477         {
 478         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 479         }
 480     return -1;
 481     }
 482
 483 if (EscapeString(erealname))
 484     {
 485     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape real name'\n");
 486     if (RollbackTransaction())
 487         {
 488         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 489         }
 490     return -1;
 491     }
 492
 493 if (EscapeString(etariffname))
 494     {
 495     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape tariff name'\n");
 496     if (RollbackTransaction())
 497         {
 498         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 499         }
 500     return -1;
 501     }
 502
 503 if (EscapeString(enexttariff))
 504     {
 505     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape next tariff name'\n");
 506     if (RollbackTransaction())
 507         {
 508         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 509         }
 510     return -1;
 511     }
 512
 513 if (EscapeString(ecorporation))
 514     {
 515     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape corporation name'\n");
 516     if (RollbackTransaction())
 517         {
 518         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 519         }
 520     return -1;
 521     }
 522
 523 query.str("");
 524 query << "UPDATE tb_users SET "
 525              "address = '" << eaddress << "', "
 526              "always_online = " << (conf.alwaysOnline ? "'t'" : "'f'") << ", "
 527              "credit = " << conf.credit << ", "
 528              "credit_expire = CAST('" << Int2TS(conf.creditExpire) << "' AS TIMESTAMP), "
 529              "disabled = " << (conf.disabled ? "'t'" : "'f'") << ", "
 530              "disabled_detail_stat = " << (conf.disabledDetailStat ? "'t'" : "'f'") << ", "
 531              "email = '" << eemail << "', "
 532              "grp = '" << egroup << "', "
 533              "note = '" << enote << "', "
 534              "passive = " << (conf.passive ? "'t'" : "'f'") << ", "
 535              "passwd = '" << epassword << "', "
 536              "phone = '" << ephone << "', "
 537              "real_name = '" << erealname << "', "
 538              "fk_tariff = (SELECT pk_tariff "
 539                    "FROM tb_tariffs "
 540                    "WHERE name = '" << etariffname << "'), "
 541              "fk_tariff_change = (SELECT pk_tariff "
 542                    "FROM tb_tariffs "
 543                    "WHERE name = '" << enexttariff << "'), "
 544              "fk_corporation = (SELECT pk_corporation "
 545                    "FROM tb_corporations "
 546                    "WHERE name = '" << ecorporation << "') "
 547          "WHERE pk_user = " << uid;
 548
 549 result = PQexec(connection, query.str().c_str());
 550
 551 if (PQresultStatus(result) != PGRES_COMMAND_OK)
 552     {
 553     strError = PQresultErrorMessage(result);
 554     PQclear(result);
 555     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): '%s'\n", strError.c_str());
 556     if (RollbackTransaction())
 557         {
 558         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 559         }
 560     return -1;
 561     }
 562
 563 PQclear(result);
 564
 565 if (SaveUserServices(uid, conf.service))
 566     {
 567     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to save user's services'\n");
 568     if (RollbackTransaction())
 569         {
 570         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 571         }
 572     return -1;
 573     }
 574
 575 if (SaveUserData(uid, conf.userdata))
 576     {
 577     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to save user's data'\n");
 578     if (RollbackTransaction())
 579         {
 580         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 581         }
 582     return -1;
 583     }
 584
 585 if (SaveUserIPs(uid, conf.ips))
 586     {
 587     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to save user's IPs'\n");
 588     if (RollbackTransaction())
 589         {
 590         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
 591         }
 592     return -1;
 593     }
 594
 595 if (CommitTransaction())
 596     {
 597     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to commit transaction'\n");
 598     return -1;
 599     }
 600
 601 return 0;
 602 }
 603
 604 //-----------------------------------------------------------------------------
 605 int POSTGRESQL_STORE::RestoreUserStat(USER_STAT * stat,
 606                                     const string & login) const
 607 {
 608 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 609
 610 if (PQstatus(connection) != CONNECTION_OK)
 611     {
 612     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
 613     if (Reset())
 614         {
 615         strError = "Connection lost";
 616         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): '%s'\n", strError.c_str());
 617         return -1;
 618         }
 619     }
 620
 621 PGresult * result;
 622
 623 if (StartTransaction())
 624     {
 625     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to start transaction'\n");
 626     return -1;
 627     }
 628
 629 std::string elogin = login;
 630
 631 if (EscapeString(elogin))
 632     {
 633     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to escape login'\n");
 634     if (RollbackTransaction())
 635         {
 636         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
 637         }
 638     return -1;
 639     }
 640
 641 std::stringstream query;
 642 query << "SELECT cash, free_mb, "
 643             "last_activity_time, last_cash_add, "
 644             "last_cash_add_time, passive_time "
 645          "FROM tb_users "
 646          "WHERE name = '" << elogin << "'";
 647
 648 result = PQexec(connection, query.str().c_str());
 649
 650 if (PQresultStatus(result) != PGRES_TUPLES_OK)
 651     {
 652     strError = PQresultErrorMessage(result);
 653     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): '%s'\n", strError.c_str());
 654     PQclear(result);
 655     if (RollbackTransaction())
 656         {
 657         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
 658         }
 659     return -1;
 660     }
 661
 662 int tuples = PQntuples(result);
 663
 664 if (tuples != 1)
 665     {
 666     strError = "Failed to fetch user's stat";
 667     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
 668     PQclear(result);
 669     if (RollbackTransaction())
 670         {
 671         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
 672         }
 673     return -1;
 674     }
 675
 676 std::stringstream tuple;
 677 tuple << PQgetvalue(result, 0, 0) << " ";
 678 tuple << PQgetvalue(result, 0, 1) << " ";
 679 stat->lastActivityTime = TS2Int(PQgetvalue(result, 0, 2));
 680 tuple << PQgetvalue(result, 0, 3) << " ";
 681 stat->lastCashAddTime = TS2Int(PQgetvalue(result, 0, 4));
 682 tuple << PQgetvalue(result, 0, 5) << " ";
 683
 684 PQclear(result);
 685
 686 tuple >> stat->cash
 687       >> stat->freeMb
 688       >> stat->lastCashAdd
 689       >> stat->passiveTime;
 690
 691 query.str("");
 692
 693 query << "SELECT dir_num, upload, download "
 694          "FROM tb_stats_traffic "
 695          "WHERE fk_user IN (SELECT pk_user FROM tb_users WHERE name = '" << elogin << "') AND "
 696                "DATE_TRUNC('month', stats_date) = DATE_TRUNC('month', CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP))";
 697
 698 result = PQexec(connection, query.str().c_str());
 699
 700 if (PQresultStatus(result) != PGRES_TUPLES_OK)
 701     {
 702     strError = PQresultErrorMessage(result);
 703     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): '%s'\n", strError.c_str());
 704     PQclear(result);
 705     if (RollbackTransaction())
 706         {
 707         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
 708         }
 709     return -1;
 710     }
 711
 712 tuples = PQntuples(result);
 713
 714 for (int i = 0; i < tuples; ++i)
 715     {
 716     std::stringstream tuple;
 717     tuple << PQgetvalue(result, i, 0) << " ";
 718     tuple << PQgetvalue(result, i, 1) << " ";
 719     tuple << PQgetvalue(result, i, 2) << " ";
 720
 721     int dir;
 722
 723     tuple >> dir;
 724     tuple >> stat->up[dir];
 725     tuple >> stat->down[dir];
 726     }
 727
 728 PQclear(result);
 729
 730 if (CommitTransaction())
 731     {
 732     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to commit transaction'\n");
 733     return -1;
 734     }
 735
 736 return 0;
 737 }
 738
 739 //-----------------------------------------------------------------------------
 740 int POSTGRESQL_STORE::RestoreUserConf(USER_CONF * conf,
 741                                     const string & login) const
 742 {
 743 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 744
 745 if (PQstatus(connection) != CONNECTION_OK)
 746     {
 747     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
 748     if (Reset())
 749         {
 750         strError = "Connection lost";
 751         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
 752         return -1;
 753         }
 754     }
 755
 756 PGresult * result;
 757
 758 if (StartTransaction())
 759     {
 760     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to start transaction'\n");
 761     return -1;
 762     }
 763
 764 std::string elogin = login;
 765
 766 if (EscapeString(elogin))
 767     {
 768     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to escape login'\n");
 769     if (RollbackTransaction())
 770         {
 771         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
 772         }
 773     return -1;
 774     }
 775
 776 std::stringstream query;
 777 query << "SELECT tb_users.pk_user, tb_users.address, tb_users.always_online, "
 778                 "tb_users.credit, tb_users.credit_expire, tb_users.disabled, "
 779                 "tb_users.disabled_detail_stat, tb_users.email, tb_users.grp, "
 780                 "tb_users.note, tb_users.passive, tb_users.passwd, tb_users.phone, "
 781                 "tb_users.real_name, tf1.name, tf2.name, tb_corporations.name "
 782          "FROM tb_users LEFT JOIN tb_tariffs AS tf1 "
 783                             "ON tf1.pk_tariff = tb_users.fk_tariff "
 784                        "LEFT JOIN tb_tariffs AS tf2 "
 785                             "ON tf2.pk_tariff = tb_users.fk_tariff_change "
 786                        "LEFT JOIN tb_corporations "
 787                             "ON tb_corporations.pk_corporation = tb_users.fk_corporation "
 788          "WHERE tb_users.name = '" << elogin << "'";
 789
 790 result = PQexec(connection, query.str().c_str());
 791
 792 if (PQresultStatus(result) != PGRES_TUPLES_OK)
 793     {
 794     strError = PQresultErrorMessage(result);
 795     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
 796     PQclear(result);
 797     if (RollbackTransaction())
 798         {
 799         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
 800         }
 801     return -1;
 802     }
 803
 804 int tuples = PQntuples(result);
 805
 806 if (tuples != 1)
 807     {
 808     strError = "Failed to fetch user's stat";
 809     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
 810     PQclear(result);
 811     if (RollbackTransaction())
 812         {
 813         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
 814         }
 815     return -1;
 816     }
 817
 818 uint32_t uid;
 819
 820 std::stringstream tuple;
 821
 822 tuple << PQgetvalue(result, 0, 0) << " ";               // uid
 823 conf->address = PQgetvalue(result, 0, 1);               // address
 824 conf->alwaysOnline = !strncmp(PQgetvalue(result, 0, 2), "t", 1);
 825 tuple << PQgetvalue(result, 0, 3) << " ";               // credit
 826 conf->creditExpire = TS2Int(PQgetvalue(result, 0, 4));  // creditExpire
 827 conf->disabled = !strncmp(PQgetvalue(result, 0, 5), "t", 1);
 828 conf->disabledDetailStat = !strncmp(PQgetvalue(result, 0, 6), "t", 1);
 829 conf->email = PQgetvalue(result, 0, 7);                 // email
 830 conf->group = PQgetvalue(result, 0, 8);                 // group
 831 conf->note = PQgetvalue(result, 0, 9);                  // note
 832 conf->passive = !strncmp(PQgetvalue(result, 0, 10), "t", 1);
 833 conf->password = PQgetvalue(result, 0, 11);             // password
 834 conf->phone = PQgetvalue(result, 0, 12);                // phone
 835 conf->realName = PQgetvalue(result, 0, 13);             // realName
 836 conf->tariffName = PQgetvalue(result, 0, 14);           // tariffName
 837 conf->nextTariff = PQgetvalue(result, 0, 15);           // nextTariff
 838 conf->corp = PQgetvalue(result, 0, 16);                 // corp
 839
 840 PQclear(result);
 841
 842 if (conf->tariffName == "")
 843     conf->tariffName = NO_TARIFF_NAME;
 844 if (conf->corp == "")
 845     conf->corp = NO_CORP_NAME;
 846
 847 tuple >> uid
 848       >> conf->credit;
 849
 850 query.str("");
 851 query << "SELECT name FROM tb_services "
 852          "WHERE pk_service IN (SELECT fk_service "
 853                               "FROM tb_users_services "
 854                               "WHERE fk_user = " << uid << ")";
 855
 856 result = PQexec(connection, query.str().c_str());
 857
 858 if (PQresultStatus(result) != PGRES_TUPLES_OK)
 859     {
 860     strError = PQresultErrorMessage(result);
 861     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
 862     PQclear(result);
 863     if (RollbackTransaction())
 864         {
 865         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
 866         }
 867     return -1;
 868     }
 869
 870 tuples = PQntuples(result);
 871
 872 for (int i = 0; i < tuples; ++i)
 873     {
 874     conf->service.push_back(PQgetvalue(result, i, 0));
 875     }
 876
 877 PQclear(result);
 878
 879 query.str("");
 880 query << "SELECT num, data "
 881          "FROM tb_users_data "
 882          "WHERE fk_user = " << uid;
 883
 884 result = PQexec(connection, query.str().c_str());
 885
 886 if (PQresultStatus(result) != PGRES_TUPLES_OK)
 887     {
 888     strError = PQresultErrorMessage(result);
 889     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
 890     PQclear(result);
 891     if (RollbackTransaction())
 892         {
 893         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
 894         }
 895     return -1;
 896     }
 897
 898 tuples = PQntuples(result);
 899
 900 for (int i = 0; i < tuples; ++i)
 901     {
 902     int num;
 903     if (str2x(PQgetvalue(result, i, 0), num))
 904         {
 905         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to convert string to int'\n");
 906         }
 907     else
 908         {
 909         conf->userdata[i] = PQgetvalue(result, i, 1);
 910         }
 911     }
 912
 913 PQclear(result);
 914
 915 query.str("");
 916 query << "SELECT host(ip), masklen(ip) "
 917          "FROM tb_allowed_ip "
 918          "WHERE fk_user = " << uid;
 919
 920 result = PQexec(connection, query.str().c_str());
 921
 922 if (PQresultStatus(result) != PGRES_TUPLES_OK)
 923     {
 924     strError = PQresultErrorMessage(result);
 925     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
 926     PQclear(result);
 927     if (RollbackTransaction())
 928         {
 929         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
 930         }
 931     return -1;
 932     }
 933
 934 tuples = PQntuples(result);
 935
 936 conf->ips.Erase();
 937 for (int i = 0; i < tuples; ++i)
 938     {
 939     IP_MASK ipm;
 940
 941     int ip, mask;
 942
 943     ip = inet_strington(PQgetvalue(result, i, 0));
 944
 945     if (str2x(PQgetvalue(result, i, 1), mask))
 946         {
 947         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to fetch mask'\n");
 948         continue;
 949         }
 950
 951     ipm.ip = ip;
 952     ipm.mask = mask;
 953
 954     conf->ips.Add(ipm);
 955     }
 956
 957 PQclear(result);
 958
 959 if (CommitTransaction())
 960     {
 961     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to commit transaction'\n");
 962     return -1;
 963     }
 964
 965 return 0;
 966 }
 967
 968 //-----------------------------------------------------------------------------
 969 int POSTGRESQL_STORE::WriteUserChgLog(const string & login,
 970                                     const string & admLogin,
 971                                     uint32_t admIP,
 972                                     const string & paramName,
 973                                     const string & oldValue,
 974                                     const string & newValue,
 975                                     const string & message = "") const
 976 {
 977 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 978
 979 if (PQstatus(connection) != CONNECTION_OK)
 980     {
 981     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
 982     if (Reset())
 983         {
 984         strError = "Connection lost";
 985         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): '%s'\n", strError.c_str());
 986         return -1;
 987         }
 988     }
 989
 990 PGresult * result;
 991
 992 if (StartTransaction())
 993     {
 994     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to start transaction'\n");
 995     return -1;
 996     }
 997
 998 std::string elogin(login);
 999 std::string eadminLogin(admLogin);
1000 std::string eparam(paramName);
1001 std::string eold(oldValue);
1002 std::string enew(newValue);
1003 std::string emessage(message);
1004
1005 if (EscapeString(elogin))
1006     {
1007     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape login'\n");
1008     if (RollbackTransaction())
1009         {
1010         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1011         }
1012     return -1;
1013     }
1014
1015 if (EscapeString(eadminLogin))
1016     {
1017     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape admin's login'\n");
1018     if (RollbackTransaction())
1019         {
1020         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1021         }
1022     return -1;
1023     }
1024
1025 if (EscapeString(eparam))
1026     {
1027     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape param's name'\n");
1028     if (RollbackTransaction())
1029         {
1030         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1031         }
1032     return -1;
1033     }
1034
1035 if (EscapeString(eold))
1036     {
1037     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape old value'\n");
1038     if (RollbackTransaction())
1039         {
1040         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1041         }
1042     return -1;
1043     }
1044
1045 if (EscapeString(enew))
1046     {
1047     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape new value'\n");
1048     if (RollbackTransaction())
1049         {
1050         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1051         }
1052     return -1;
1053     }
1054
1055 std::stringstream query;
1056 query << "SELECT sp_add_param_log_entry("
1057             "'" << elogin << "', "
1058             "'" << eadminLogin << "', CAST('"
1059             << inet_ntostring(admIP) << "/32' AS INET), "
1060             "'" << eparam << "', "
1061             "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1062             "'" << eold << "', "
1063             "'" << enew << "', "
1064             "'" << emessage << "')";
1065
1066 result = PQexec(connection, query.str().c_str());
1067
1068 if (PQresultStatus(result) != PGRES_TUPLES_OK)
1069     {
1070     strError = PQresultErrorMessage(result);
1071     PQclear(result);
1072     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): '%s'\n", strError.c_str());
1073     if (RollbackTransaction())
1074         {
1075         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1076         }
1077     return -1;
1078     }
1079
1080 PQclear(result);
1081
1082 if (CommitTransaction())
1083     {
1084     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to commit transaction'\n");
1085     return -1;
1086     }
1087
1088 return 0;
1089 }
1090
1091 //-----------------------------------------------------------------------------
1092 int POSTGRESQL_STORE::WriteUserConnect(const string & login, uint32_t ip) const
1093 {
1094 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1095
1096 if (PQstatus(connection) != CONNECTION_OK)
1097     {
1098     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
1099     if (Reset())
1100         {
1101         strError = "Connection lost";
1102         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): '%s'\n", strError.c_str());
1103         return -1;
1104         }
1105     }
1106
1107 PGresult * result;
1108
1109 if (StartTransaction())
1110     {
1111     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to start transaction'\n");
1112     return -1;
1113     }
1114
1115 std::string elogin(login);
1116
1117 if (EscapeString(elogin))
1118     {
1119     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to escape login'\n");
1120     if (RollbackTransaction())
1121         {
1122         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to rollback transaction'\n");
1123         }
1124     return -1;
1125     }
1126
1127 std::stringstream query;
1128 if (version < 6)
1129     {
1130     query << "SELECT sp_add_session_log_entry("
1131                  "'" << elogin << "', "
1132                  "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1133                  "'c', CAST('"
1134                  << inet_ntostring(ip) << "/32' AS INET), 0)";
1135     }
1136 else
1137     {
1138     query << "SELECT sp_add_session_log_entry("
1139                  "'" << elogin << "', "
1140                  "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1141                  "'c', CAST('"
1142                  << inet_ntostring(ip) << "/32' AS INET), 0, 0, '')";
1143     }
1144
1145 result = PQexec(connection, query.str().c_str());
1146
1147 if (PQresultStatus(result) != PGRES_TUPLES_OK)
1148     {
1149     strError = PQresultErrorMessage(result);
1150     PQclear(result);
1151     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): '%s'\n", strError.c_str());
1152     if (RollbackTransaction())
1153         {
1154         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to rollback transaction'\n");
1155         }
1156     return -1;
1157     }
1158
1159 PQclear(result);
1160
1161 if (CommitTransaction())
1162     {
1163     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to commit transaction'\n");
1164     return -1;
1165     }
1166
1167 return 0;
1168 }
1169
1170 //-----------------------------------------------------------------------------
1171 int POSTGRESQL_STORE::WriteUserDisconnect(const string & login,
1172                     const DIR_TRAFF & up,
1173                     const DIR_TRAFF & down,
1174                     const DIR_TRAFF & sessionUp,
1175                     const DIR_TRAFF & sessionDown,
1176                     double cash,
1177                     double freeMb,
1178                     const std::string & reason) const
1179 {
1180 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1181
1182 if (PQstatus(connection) != CONNECTION_OK)
1183     {
1184     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
1185     if (Reset())
1186         {
1187         strError = "Connection lost";
1188         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): '%s'\n", strError.c_str());
1189         return -1;
1190         }
1191     }
1192
1193 PGresult * result;
1194
1195 if (StartTransaction())
1196     {
1197     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to start transaction'\n");
1198     return -1;
1199     }
1200
1201 std::string elogin(login);
1202
1203 if (EscapeString(elogin))
1204     {
1205     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to escape login'\n");
1206     if (RollbackTransaction())
1207         {
1208         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1209         }
1210     return -1;
1211     }
1212
1213 std::string ereason(reason);
1214
1215 if (EscapeString(ereason))
1216     {
1217     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to escape reason'\n");
1218     if (RollbackTransaction())
1219         {
1220         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1221         }
1222     return -1;
1223     }
1224
1225 std::stringstream query;
1226 if (version < 6)
1227     {
1228     // Old database version - no freeMb logging support
1229     query << "SELECT sp_add_session_log_entry("
1230                 "'" << elogin << "', "
1231                 "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1232                 "'d', CAST('0.0.0.0/0' AS INET), "
1233                 << cash << ")";
1234     }
1235 else
1236     {
1237     query << "SELECT sp_add_session_log_entry("
1238                 "'" << elogin << "', "
1239                 "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1240                 "'d', CAST('0.0.0.0/0' AS INET), "
1241                 << cash << ", " << freeMb << ", '" << ereason << "')";
1242     }
1243
1244 result = PQexec(connection, query.str().c_str());
1245
1246 if (PQresultStatus(result) != PGRES_TUPLES_OK)
1247     {
1248     strError = PQresultErrorMessage(result);
1249     PQclear(result);
1250     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): '%s'\n", strError.c_str());
1251     if (RollbackTransaction())
1252         {
1253         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1254         }
1255     return -1;
1256     }
1257
1258 int tuples = PQntuples(result);
1259
1260 if (tuples != 1)
1261     {
1262     strError = "Failed to fetch session's log ID";
1263     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
1264     PQclear(result);
1265     if (RollbackTransaction())
1266         {
1267         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1268         }
1269     return -1;
1270     }
1271
1272 uint32_t lid;
1273
1274 if (str2x(PQgetvalue(result, 0, 0), lid))
1275     {
1276     strError = "Failed to convert string to int";
1277     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): '%s'\n", strError.c_str());
1278     PQclear(result);
1279     if (RollbackTransaction())
1280         {
1281         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1282         }
1283     return -1;
1284     }
1285
1286 PQclear(result);
1287
1288 for (int i = 0; i < DIR_NUM; ++i)
1289     {
1290     std::stringstream query;
1291     query << "INSERT INTO tb_sessions_data "
1292                 "(fk_session_log, "
1293                  "dir_num, "
1294                  "session_upload, "
1295                  "session_download, "
1296                  "month_upload, "
1297                  "month_download)"
1298              "VALUES ("
1299                 << lid << ", "
1300                 << i << ", "
1301                 << sessionUp[i] << ", "
1302                 << sessionDown[i] << ", "
1303                 << up[i] << ", "
1304                 << down[i] << ")";
1305
1306     result = PQexec(connection, query.str().c_str());
1307
1308     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1309         {
1310         strError = PQresultErrorMessage(result);
1311         PQclear(result);
1312         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): '%s'\n", strError.c_str());
1313         if (RollbackTransaction())
1314             {
1315             printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1316             }
1317         return -1;
1318         }
1319
1320     PQclear(result);
1321     }
1322
1323 if (CommitTransaction())
1324     {
1325     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to commit transaction'\n");
1326     return -1;
1327     }
1328
1329 return 0;
1330 }
1331
1332 //-----------------------------------------------------------------------------
1333 int POSTGRESQL_STORE::WriteDetailedStat(const map<IP_DIR_PAIR, STAT_NODE> & statTree,
1334                                       time_t lastStat,
1335                                       const string & login) const
1336 {
1337 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1338
1339 if (PQstatus(connection) != CONNECTION_OK)
1340     {
1341     printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
1342     if (Reset())
1343         {
1344         strError = "Connection lost";
1345         printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): '%s'\n", strError.c_str());
1346         return -1;
1347         }
1348     }
1349
1350 PGresult * result;
1351
1352 if (StartTransaction())
1353     {
1354     printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to start transaction'\n");
1355     return -1;
1356     }
1357
1358 std::string elogin(login);
1359
1360 if (EscapeString(elogin))
1361     {
1362     printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to escape login'\n");
1363     if (RollbackTransaction())
1364         {
1365         printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to rollback transaction'\n");
1366         }
1367     return -1;
1368     }
1369
1370 map<IP_DIR_PAIR, STAT_NODE>::const_iterator it;
1371 time_t currTime = time(NULL);
1372
1373 for (it = statTree.begin(); it != statTree.end(); ++it)
1374     {
1375     std::stringstream query;
1376     query << "INSERT INTO tb_detail_stats "
1377                 "(till_time, from_time, fk_user, "
1378                  "dir_num, ip, download, upload, cost) "
1379              "VALUES ("
1380                 "CAST('" << Int2TS(currTime) << "' AS TIMESTAMP), "
1381                 "CAST('" << Int2TS(lastStat) << "' AS TIMESTAMP), "
1382                 "(SELECT pk_user FROM tb_users WHERE name = '" << elogin << "'), "
1383                 << it->first.dir << ", "
1384                 << "CAST('" << inet_ntostring(it->first.ip) << "' AS INET), "
1385                 << it->second.down << ", "
1386                 << it->second.up << ", "
1387                 << it->second.cash << ")";
1388
1389     result = PQexec(connection, query.str().c_str());
1390
1391     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1392         {
1393         strError = PQresultErrorMessage(result);
1394         PQclear(result);
1395         printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): '%s'\n", strError.c_str());
1396         if (RollbackTransaction())
1397             {
1398             printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to rollback transaction'\n");
1399             }
1400         return -1;
1401         }
1402
1403     PQclear(result);
1404     }
1405
1406 if (CommitTransaction())
1407     {
1408     printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to commit transaction'\n");
1409     return -1;
1410     }
1411
1412 return 0;
1413 }
1414
1415 //-----------------------------------------------------------------------------
1416 int POSTGRESQL_STORE::SaveMonthStat(const USER_STAT & stat, int month, int year, const string & login) const
1417 {
1418 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1419
1420 return SaveStat(stat, login, year, month);
1421 }
1422
1423 //-----------------------------------------------------------------------------
1424 int POSTGRESQL_STORE::SaveUserServices(uint32_t uid,
1425                                        const std::vector<std::string> & services) const
1426 {
1427 PGresult * result;
1428
1429 std::stringstream query;
1430 query << "DELETE FROM tb_users_services WHERE fk_user = " << uid;
1431
1432 result = PQexec(connection, query.str().c_str());
1433
1434 if (PQresultStatus(result) != PGRES_COMMAND_OK)
1435     {
1436     strError = PQresultErrorMessage(result);
1437     PQclear(result);
1438     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserServices(): '%s'\n", strError.c_str());
1439     return -1;
1440     }
1441
1442 PQclear(result);
1443
1444 std::vector<std::string>::const_iterator it;
1445
1446 for (it = services.begin(); it != services.end(); ++it)
1447     {
1448     std::string ename = *it;
1449
1450     if (EscapeString(ename))
1451         {
1452         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserServices(): 'Failed to escape service name'\n");
1453         return -1;
1454         }
1455
1456     std::stringstream query;
1457     query << "INSERT INTO tb_users_services "
1458                 "(fk_user, fk_service) "
1459              "VALUES "
1460                 "(" << uid << ", "
1461                   "(SELECT pk_service "
1462                    "FROM tb_services "
1463                    "WHERE name = '" << ename << "'))";
1464
1465     result = PQexec(connection, query.str().c_str());
1466
1467     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1468         {
1469         strError = PQresultErrorMessage(result);
1470         PQclear(result);
1471         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserServices(): '%s'\n", strError.c_str());
1472         return -1;
1473         }
1474
1475     PQclear(result);
1476     }
1477
1478 return 0;
1479 }
1480
1481 //-----------------------------------------------------------------------------
1482 int POSTGRESQL_STORE::SaveUserIPs(uint32_t uid,
1483                                   const USER_IPS & ips) const
1484 {
1485 PGresult * result;
1486
1487 std::stringstream query;
1488 query << "DELETE FROM tb_allowed_ip WHERE fk_user = " << uid;
1489
1490 result = PQexec(connection, query.str().c_str());
1491
1492 if (PQresultStatus(result) != PGRES_COMMAND_OK)
1493     {
1494     strError = PQresultErrorMessage(result);
1495     PQclear(result);
1496     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserIPs(): '%s'\n", strError.c_str());
1497     return -1;
1498     }
1499
1500 PQclear(result);
1501
1502 for (int i = 0; i < ips.Count(); ++i)
1503     {
1504     std::stringstream query;
1505     query << "INSERT INTO tb_allowed_ip "
1506                 "(fk_user, ip) "
1507              "VALUES "
1508                 "(" << uid << ", CAST('"
1509                     << inet_ntostring(ips[i].ip) << "/"
1510                     << static_cast<int>(ips[i].mask) << "' AS INET))";
1511
1512     result = PQexec(connection, query.str().c_str());
1513
1514     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1515         {
1516         strError = PQresultErrorMessage(result);
1517         PQclear(result);
1518         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserIPs(): '%s'\n", strError.c_str());
1519         return -1;
1520         }
1521
1522     PQclear(result);
1523     }
1524
1525 return 0;
1526 }
1527
1528 //-----------------------------------------------------------------------------
1529 int POSTGRESQL_STORE::SaveUserData(uint32_t uid,
1530                                    const std::vector<std::string> & data) const
1531 {
1532 for (unsigned i = 0; i < data.size(); ++i)
1533     {
1534     std::string edata = data[i];
1535
1536     if (EscapeString(edata))
1537         {
1538         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserData(): 'Failed to escape userdata field'\n");
1539         return -1;
1540         }
1541
1542     PGresult * result;
1543
1544     std::stringstream query;
1545     query << "SELECT sp_set_user_data("
1546                 << uid << ", "
1547                 << "CAST(" << i << " AS SMALLINT), "
1548                 << "'" << edata << "')";
1549
1550     result = PQexec(connection, query.str().c_str());
1551
1552     if (PQresultStatus(result) != PGRES_TUPLES_OK)
1553         {
1554         strError = PQresultErrorMessage(result);
1555         PQclear(result);
1556         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserData(): '%s'\n", strError.c_str());
1557         return -1;
1558         }
1559
1560     PQclear(result);
1561     }
1562
1563 return 0;
1564 }
1565