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