]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/store/mysql/mysql_store.cpp
Small refactoring in RESETABLE.
[stg.git] / projects / stargazer / plugins / store / mysql / mysql_store.cpp
1 #include <sys/time.h>
2 #include <cerrno>
3 #include <cstdio>
4 #include <cstdlib>
5 #include <algorithm>
6
7 #include <mysql.h>
8 #include <errmsg.h>
9
10 #include "stg/user_ips.h"
11 #include "stg/user_conf.h"
12 #include "stg/user_stat.h"
13 #include "stg/blowfish.h"
14 #include "stg/plugin_creator.h"
15 #include "mysql_store.h"
16
17 #define adm_enc_passwd "cjeifY8m3"
18
19 namespace
20 {
21 char qbuf[4096];
22
23 const int pt_mega = 1024 * 1024;
24 const std::string badSyms = "'`";
25 const char repSym = '\"';
26 const int RepitTimes = 3;
27
28 template <typename T>
29 int GetInt(const std::string & str, T * val, T defaultVal = T())
30 {
31     char *res;
32     
33     *val = static_cast<T>(strtoll(str.c_str(), &res, 10));
34     
35     if (*res != 0) 
36     {
37         *val = defaultVal; //Error!
38         return EINVAL;
39     }
40
41     return 0;
42 }
43
44 int GetDouble(const std::string & str, double * val, double defaultVal)
45 {
46     char *res;
47     
48     *val = strtod(str.c_str(), &res);
49     
50     if (*res != 0) 
51     {
52         *val = defaultVal; //Error!
53         return EINVAL;
54     }
55
56     return 0;
57 }
58
59 int GetTime(const std::string & str, time_t * val, time_t defaultVal)
60 {
61     char *res;
62     
63     *val = strtol(str.c_str(), &res, 10);
64     
65     if (*res != 0) 
66     {
67         *val = defaultVal; //Error!
68         return EINVAL;
69     }
70
71     return 0;
72 }
73
74 //-----------------------------------------------------------------------------
75 std::string ReplaceStr(std::string source, const std::string symlist, const char chgsym)
76 {
77     std::string::size_type pos=0;
78
79     while( (pos = source.find_first_of(symlist,pos)) != std::string::npos)
80         source.replace(pos, 1,1, chgsym);
81
82     return source;
83 }
84
85 int GetULongLongInt(const std::string & str, uint64_t * val, uint64_t defaultVal)
86 {
87     char *res;
88     
89     *val = strtoull(str.c_str(), &res, 10);
90     
91     if (*res != 0) 
92     {
93         *val = defaultVal; //Error!
94         return EINVAL;
95     }
96
97     return 0;
98
99
100 PLUGIN_CREATOR<MYSQL_STORE> msc;
101 }
102
103 extern "C" STORE * GetStore();
104 //-----------------------------------------------------------------------------
105 //-----------------------------------------------------------------------------
106 //-----------------------------------------------------------------------------
107 STORE * GetStore()
108 {
109 return msc.GetPlugin();
110 }
111 //-----------------------------------------------------------------------------
112 MYSQL_STORE_SETTINGS::MYSQL_STORE_SETTINGS()
113     : settings(NULL),
114       errorStr(),
115       dbUser(),
116       dbPass(),
117       dbName(),
118       dbHost()
119 {
120 }
121 //-----------------------------------------------------------------------------
122 int MYSQL_STORE_SETTINGS::ParseParam(const std::vector<PARAM_VALUE> & moduleParams, 
123                         const std::string & name, std::string & result)
124 {
125 PARAM_VALUE pv;
126 pv.param = name;
127 std::vector<PARAM_VALUE>::const_iterator pvi;
128 pvi = find(moduleParams.begin(), moduleParams.end(), pv);
129 if (pvi == moduleParams.end())
130     {
131     errorStr = "Parameter \'" + name + "\' not found.";
132     return -1;
133     }
134     
135 result = pvi->value[0];
136
137 return 0;
138 }
139 //-----------------------------------------------------------------------------
140 int MYSQL_STORE_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
141 {
142 if (ParseParam(s.moduleParams, "user", dbUser) < 0 &&
143     ParseParam(s.moduleParams, "dbuser", dbUser) < 0)
144     return -1;
145 if (ParseParam(s.moduleParams, "password", dbPass) < 0 &&
146     ParseParam(s.moduleParams, "rootdbpass", dbPass) < 0)
147     return -1;
148 if (ParseParam(s.moduleParams, "database", dbName) < 0 &&
149     ParseParam(s.moduleParams, "dbname", dbName) < 0)
150     return -1;
151 if (ParseParam(s.moduleParams, "server", dbHost) < 0 &&
152     ParseParam(s.moduleParams, "dbhost", dbHost) < 0)
153     return -1;
154
155 return 0;
156 }
157 //-----------------------------------------------------------------------------
158 //-----------------------------------------------------------------------------
159 //-----------------------------------------------------------------------------
160 MYSQL_STORE::MYSQL_STORE()
161     : errorStr(),
162       version("mysql_store v.0.67"),
163       storeSettings(),
164       settings(),
165       logger(GetPluginLogger(GetStgLogger(), "store_mysql"))
166 {
167 }
168 //-----------------------------------------------------------------------------
169 int    MYSQL_STORE::MysqlQuery(const char* sQuery,MYSQL * sock) const
170 {
171     int ret;
172
173     if( (ret = mysql_query(sock,sQuery)) )
174     {
175         for(int i=0; i<RepitTimes; i++)
176         {
177             if( (ret = mysql_query(sock,sQuery)) )
178                 ;//need to send error result
179             else
180                 return 0;
181         }
182     }
183     
184     return ret;
185 }
186 //-----------------------------------------------------------------------------
187
188 //-----------------------------------------------------------------------------
189 int MYSQL_STORE::ParseSettings()
190 {
191 int ret = storeSettings.ParseSettings(settings);
192 MYSQL mysql;
193 MYSQL * sock;
194 mysql_init(&mysql);
195 if (ret)
196     errorStr = storeSettings.GetStrError();
197 else
198 {
199     if(storeSettings.GetDBPassword().length() == 0)
200     {
201         errorStr = "Database password must be not empty. Please read Manual.";
202         return -1;
203     }
204     
205     if (!(sock = mysql_real_connect(&mysql,storeSettings.GetDBHost().c_str(),
206             storeSettings.GetDBUser().c_str(),storeSettings.GetDBPassword().c_str(),
207             0,0,NULL,0)))
208         {
209             errorStr = "Couldn't connect to mysql engine! With error:\n";
210             errorStr += mysql_error(&mysql);
211             mysql_close(sock);
212             ret = -1;
213         }
214     else
215     {
216          if(mysql_select_db(sock, storeSettings.GetDBName().c_str()))
217          {
218              std::string res = "CREATE DATABASE " + storeSettings.GetDBName();
219             
220             if(MysqlQuery(res.c_str(),sock))
221             {
222                 errorStr = "Couldn't create database! With error:\n";
223                 errorStr += mysql_error(sock);
224                 mysql_close(sock);
225                 ret = -1;
226             }
227             else
228             {
229                  if(mysql_select_db(sock, storeSettings.GetDBName().c_str()))
230                  {
231                     errorStr = "Couldn't select database! With error:\n";
232                     errorStr += mysql_error(sock);
233                     mysql_close(sock);
234                     ret = -1;
235                  }
236                  ret = CheckAllTables(sock);
237             }
238          }
239          else
240              ret = CheckAllTables(sock);
241          mysql_close(sock);
242     }
243     
244 }
245 return ret;
246 }
247 //-----------------------------------------------------------------------------
248 bool MYSQL_STORE::IsTablePresent(const std::string & str,MYSQL * sock)
249 {
250 MYSQL_RES* result;
251
252 if (!(result=mysql_list_tables(sock,str.c_str() )))
253 {
254     errorStr = "Couldn't get tables list With error:\n";
255     errorStr += mysql_error(sock);
256     mysql_close(sock);
257     return -1;
258 }
259
260 my_ulonglong num_rows =  mysql_num_rows(result);
261
262 if(result)
263     mysql_free_result(result);
264
265 return num_rows == 1;
266 }
267 //-----------------------------------------------------------------------------
268 int MYSQL_STORE::CheckAllTables(MYSQL * sock)
269 {
270 //admins-----------------------------------------------------------------------
271 if(!IsTablePresent("admins",sock))
272 {
273     sprintf(qbuf,"CREATE TABLE admins (login VARCHAR(40) DEFAULT '' PRIMARY KEY,"\
274         "password VARCHAR(150) DEFAULT '*',ChgConf TINYINT DEFAULT 0,"\
275         "ChgPassword TINYINT DEFAULT 0,ChgStat TINYINT DEFAULT 0,"\
276         "ChgCash TINYINT DEFAULT 0,UsrAddDel TINYINT DEFAULT 0,"\
277         "ChgTariff TINYINT DEFAULT 0,ChgAdmin TINYINT DEFAULT 0)");
278     
279     if(MysqlQuery(qbuf,sock))
280     {
281         errorStr = "Couldn't create admin table list With error:\n";
282         errorStr += mysql_error(sock);
283         mysql_close(sock);
284         return -1;
285     }
286
287     sprintf(qbuf,"INSERT INTO admins SET login='admin',"\
288         "password='geahonjehjfofnhammefahbbbfbmpkmkmmefahbbbfbmpkmkmmefahbbbfbmpkmkaa',"\
289         "ChgConf=1,ChgPassword=1,ChgStat=1,ChgCash=1,UsrAddDel=1,ChgTariff=1,ChgAdmin=1");
290     
291     if(MysqlQuery(qbuf,sock))
292     {
293         errorStr = "Couldn't create default admin. With error:\n";
294         errorStr += mysql_error(sock);
295         mysql_close(sock);
296         return -1;
297     }
298 }
299
300 //tariffs-----------------------------------------------------------------------
301 std::string param, res;
302 if(!IsTablePresent("tariffs",sock))
303 {
304     res = "CREATE TABLE tariffs (name VARCHAR(40) DEFAULT '' PRIMARY KEY,";
305         
306     for (int i = 0; i < DIR_NUM; i++)
307         {
308         strprintf(&param, " PriceDayA%d DOUBLE DEFAULT 0.0,", i); 
309         res += param;
310     
311         strprintf(&param, " PriceDayB%d DOUBLE DEFAULT 0.0,", i);
312         res += param;
313             
314         strprintf(&param, " PriceNightA%d DOUBLE DEFAULT 0.0,", i);
315         res += param;
316     
317         strprintf(&param, " PriceNightB%d DOUBLE DEFAULT 0.0,", i);
318         res += param;
319             
320         strprintf(&param, " Threshold%d INT DEFAULT 0,", i);
321         res += param;
322     
323         strprintf(&param, " Time%d VARCHAR(15) DEFAULT '0:0-0:0',", i);
324         res += param;
325     
326         strprintf(&param, " NoDiscount%d INT DEFAULT 0,", i);
327         res += param;
328     
329         strprintf(&param, " SinglePrice%d INT DEFAULT 0,", i);
330         res += param;
331         }
332     
333     res += "PassiveCost DOUBLE DEFAULT 0.0, Fee DOUBLE DEFAULT 0.0,"\
334         "Free DOUBLE DEFAULT 0.0, TraffType VARCHAR(10) DEFAULT '')";
335     
336     if(MysqlQuery(res.c_str(),sock))
337     {
338         errorStr = "Couldn't create tariffs table list With error:\n";
339         errorStr += mysql_error(sock);
340         mysql_close(sock);
341         return -1;
342     }
343
344     res = "INSERT INTO tariffs SET name='tariff',";
345         
346     for (int i = 0; i < DIR_NUM; i++)
347         {
348         strprintf(&param, " NoDiscount%d=1,", i);
349         res += param;
350     
351         strprintf(&param, " Threshold%d=0,", i);
352         res += param;
353     
354         strprintf(&param, " Time%d='0:0-0:0',", i);
355         res += param;
356     
357         if(i != 0 && i != 1)
358         {
359             strprintf(&param, " SinglePrice%d=0,", i);
360             res += param;        
361         }
362     
363         if(i != 1)
364         {
365             strprintf(&param, " PriceDayA%d=0.0,", i); 
366             res += param;        
367         }
368         if(i != 1)
369         {
370             strprintf(&param, " PriceDayB%d=0.0,", i);        
371             res += param;    
372         }
373     
374         if(i != 0)
375         {
376             strprintf(&param, " PriceNightA%d=0.0,", i); 
377             res += param;        
378         }
379         if(i != 0)
380         {
381             strprintf(&param, " PriceNightB%d=0.0,", i);        
382             res += param;    
383         }
384         }
385     
386     res += "PassiveCost=0.0, Fee=10.0, Free=0,"\
387         "SinglePrice0=1, SinglePrice1=1,PriceDayA1=0.75,PriceDayB1=0.75,"\
388         "PriceNightA0=1.0,PriceNightB0=1.0,TraffType='up+down'";
389     
390     if(MysqlQuery(res.c_str(),sock))
391     {
392         errorStr = "Couldn't create default tariff. With error:\n";
393         errorStr += mysql_error(sock);
394         mysql_close(sock);
395         return -1;
396     }
397 }
398
399 //users-----------------------------------------------------------------------
400 if(!IsTablePresent("users",sock))
401 {
402     res = "CREATE TABLE users (login VARCHAR(50) NOT NULL DEFAULT '' PRIMARY KEY, Password VARCHAR(150) NOT NULL DEFAULT '*',"\
403         "Passive INT(3) DEFAULT 0,Down INT(3) DEFAULT 0,DisabledDetailStat INT(3) DEFAULT 0,AlwaysOnline INT(3) DEFAULT 0,Tariff VARCHAR(40) NOT NULL DEFAULT '',"\
404         "Address VARCHAR(254) NOT NULL DEFAULT '',Phone VARCHAR(128) NOT NULL DEFAULT '',Email VARCHAR(50) NOT NULL DEFAULT '',"\
405         "Note TEXT NOT NULL,RealName VARCHAR(254) NOT NULL DEFAULT '',StgGroup VARCHAR(40) NOT NULL DEFAULT '',"\
406         "Credit DOUBLE DEFAULT 0, TariffChange VARCHAR(40) NOT NULL DEFAULT '',";
407     
408     for (int i = 0; i < USERDATA_NUM; i++)
409         {
410         strprintf(&param, " Userdata%d VARCHAR(254) NOT NULL,", i);
411         res += param;
412         }
413     
414     param = " CreditExpire INT(11) DEFAULT 0,";
415     res += param;
416     
417     strprintf(&param, " IP VARCHAR(254) DEFAULT '*',");
418     res += param;
419     
420     for (int i = 0; i < DIR_NUM; i++)
421         {
422         strprintf(&param, " D%d BIGINT(30) DEFAULT 0,", i);
423         res += param;
424     
425         strprintf(&param, " U%d BIGINT(30) DEFAULT 0,", i);
426         res += param;
427         }
428     
429     strprintf(&param, "Cash DOUBLE DEFAULT 0,FreeMb DOUBLE DEFAULT 0,LastCashAdd DOUBLE DEFAULT 0,"\
430         "LastCashAddTime INT(11) DEFAULT 0,PassiveTime INT(11) DEFAULT 0,LastActivityTime INT(11) DEFAULT 0,"\
431         "NAS VARCHAR(17) NOT NULL, INDEX (AlwaysOnline), INDEX (IP), INDEX (Address),"\
432         " INDEX (Tariff),INDEX (Phone),INDEX (Email),INDEX (RealName))");
433     res += param;
434         
435     if(MysqlQuery(res.c_str(),sock))
436     {
437         errorStr = "Couldn't create users table list With error:\n";
438         errorStr += mysql_error(sock);
439         errorStr += "\n\n" + res;
440         mysql_close(sock);
441         return -1;
442     }
443
444     res = "INSERT INTO users SET login='test',Address='',AlwaysOnline=0,"\
445         "Credit=0.0,CreditExpire=0,Down=0,Email='',DisabledDetailStat=0,"\
446         "StgGroup='',IP='192.168.1.1',Note='',Passive=0,Password='123456',"\
447         "Phone='', RealName='',Tariff='tariff',TariffChange='',Userdata0='',"\
448         "Userdata1='',";
449     
450     for (int i = 0; i < DIR_NUM; i++)
451         {
452         strprintf(&param, " D%d=0,", i);
453         res += param;
454     
455         strprintf(&param, " U%d=0,", i);
456         res += param;
457         }
458     
459     res += "Cash=10.0,FreeMb=0.0,LastActivityTime=0,LastCashAdd=0,"\
460         "LastCashAddTime=0, PassiveTime=0";
461         
462     if(MysqlQuery(res.c_str(),sock))
463     {
464         errorStr = "Couldn't create default user. With error:\n";
465         errorStr += mysql_error(sock);
466         mysql_close(sock);
467         return -1;
468     }
469 }
470 /*
471 //logs-----------------------------------------------------------------------
472 if(!IsTablePresent("logs"))
473 {
474     sprintf(qbuf,"CREATE TABLE logs (unid INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, login VARCHAR(40),text TEXT)");
475     
476     if(MysqlQuery(qbuf))
477     {
478         errorStr = "Couldn't create admin table list With error:\n";
479         errorStr += mysql_error(sock);
480         return -1;
481     }
482 }
483 */
484 //messages---------------------------------------------------------------------
485 if(!IsTablePresent("messages",sock))
486 {
487     sprintf(qbuf,"CREATE TABLE messages (login VARCHAR(40) DEFAULT '', id BIGINT, "\
488             "type INT, lastSendTime INT, creationTime INT, showTime INT,"\
489             "stgRepeat INT, repeatPeriod INT, text TEXT)");
490     
491     if(MysqlQuery(qbuf,sock))
492     {
493         errorStr = "Couldn't create messages table. With error:\n";
494         errorStr += mysql_error(sock);
495         mysql_close(sock);
496         return -1;
497     }
498 }
499
500 //month_stat-------------------------------------------------------------------
501 if(!IsTablePresent("stat",sock))
502 {
503     res = "CREATE TABLE stat (login VARCHAR(50), month TINYINT, year SMALLINT,";
504     
505     for (int i = 0; i < DIR_NUM; i++)
506         {
507         strprintf(&param, " U%d BIGINT,", i); 
508         res += param;
509             
510         strprintf(&param, " D%d BIGINT,", i); 
511         res += param;
512         }
513         
514     res += " cash DOUBLE, INDEX (login))";
515     
516     if(MysqlQuery(res.c_str(),sock))
517     {
518         errorStr = "Couldn't create stat table. With error:\n";
519         errorStr += mysql_error(sock);
520         mysql_close(sock);
521         return -1;
522     }
523 }
524
525 return 0;
526 }
527 //-----------------------------------------------------------------------------
528 //-----------------------------------------------------------------------------
529
530 int MYSQL_STORE::GetAllParams(std::vector<std::string> * ParamList, 
531                             const std::string & table, const std::string & name) const
532 {
533 MYSQL_RES *res;
534 MYSQL_ROW row;
535 MYSQL * sock=NULL;
536 my_ulonglong num, i;
537     
538 ParamList->clear();
539     
540 sprintf(qbuf,"SELECT %s FROM %s", name.c_str(), table.c_str());
541     
542 if(MysqlGetQuery(qbuf,sock))
543 {
544     errorStr = "Couldn't GetAllParams Query for: ";
545     errorStr += name + " - " + table + "\n";
546     errorStr += mysql_error(sock);
547     mysql_close(sock);
548     return -1;
549 }
550
551 if (!(res=mysql_store_result(sock)))
552 {
553     errorStr = "Couldn't GetAllParams Results for: ";
554     errorStr += name + " - " + table + "\n";
555     errorStr += mysql_error(sock);
556     return -1;
557 }
558
559 num = mysql_num_rows(res);
560
561 for(i = 0; i < num; i++)
562 {
563     row = mysql_fetch_row(res);    
564     ParamList->push_back(row[0]);
565 }
566
567 mysql_free_result(res);
568 mysql_close(sock);
569
570 return 0;
571 }
572
573 //-----------------------------------------------------------------------------
574 int MYSQL_STORE::GetUsersList(std::vector<std::string> * usersList) const
575 {
576 if(GetAllParams(usersList, "users", "login"))
577     return -1;
578
579 return 0;
580 }
581 //-----------------------------------------------------------------------------
582 int MYSQL_STORE::GetAdminsList(std::vector<std::string> * adminsList) const
583 {
584 if(GetAllParams(adminsList, "admins", "login"))
585     return -1;
586
587 return 0;
588 }
589 //-----------------------------------------------------------------------------
590 int MYSQL_STORE::GetTariffsList(std::vector<std::string> * tariffsList) const
591 {
592 if(GetAllParams(tariffsList, "tariffs", "name"))
593     return -1;
594
595 return 0;
596 }
597 //-----------------------------------------------------------------------------
598 int MYSQL_STORE::AddUser(const std::string & login) const
599 {
600 sprintf(qbuf,"INSERT INTO users SET login='%s'", login.c_str());
601     
602 if(MysqlSetQuery(qbuf))
603 {
604     errorStr = "Couldn't add user:\n";
605     //errorStr += mysql_error(sock);
606     return -1;
607 }
608
609 return 0;
610 }
611 //-----------------------------------------------------------------------------
612 int MYSQL_STORE::DelUser(const std::string & login) const
613 {
614 sprintf(qbuf,"DELETE FROM users WHERE login='%s' LIMIT 1", login.c_str());
615     
616 if(MysqlSetQuery(qbuf))
617 {
618     errorStr = "Couldn't delete user:\n";
619     //errorStr += mysql_error(sock);
620     return -1;
621 }
622
623 return 0;
624 }
625 //-----------------------------------------------------------------------------
626 int MYSQL_STORE::RestoreUserConf(USER_CONF * conf, const std::string & login) const
627 {
628 MYSQL_RES *res;
629 MYSQL_ROW row;
630 MYSQL * sock;
631 std::string query;
632
633 query = "SELECT login, Password, Passive, Down, DisabledDetailStat, \
634          AlwaysOnline, Tariff, Address, Phone, Email, Note, \
635          RealName, StgGroup, Credit, TariffChange, ";
636
637 for (int i = 0; i < USERDATA_NUM; i++)
638 {
639     sprintf(qbuf, "Userdata%d, ", i);
640     query += qbuf;
641 }
642
643 query += "CreditExpire, IP FROM users WHERE login='";
644 query += login + "' LIMIT 1";
645
646 //sprintf(qbuf,"SELECT * FROM users WHERE login='%s' LIMIT 1", login.c_str());
647     
648 if(MysqlGetQuery(query.c_str(),sock))
649 {
650     errorStr = "Couldn't restore Tariff(on query):\n";
651     errorStr += mysql_error(sock);
652     mysql_close(sock);
653     return -1;
654 }
655
656 if (!(res=mysql_store_result(sock)))
657 {
658     errorStr = "Couldn't restore Tariff(on getting result):\n";
659     errorStr += mysql_error(sock);
660     mysql_close(sock);
661     return -1;
662 }
663
664 if (mysql_num_rows(res) != 1)
665 {
666     errorStr = "User not found";
667     mysql_close(sock);
668     return -1;
669 }
670
671 row = mysql_fetch_row(res);
672
673 std::string param;
674
675 conf->password = row[1];
676
677 if (conf->password.empty())
678     {
679     mysql_free_result(res);
680     errorStr = "User \'" + login + "\' password is blank.";
681     mysql_close(sock);
682     return -1;
683     }
684
685 if (GetInt(row[2],&conf->passive) != 0)
686     {
687     mysql_free_result(res);
688     errorStr = "User \'" + login + "\' data not read. Parameter Passive.";
689     mysql_close(sock);
690     return -1;
691     }
692
693 if (GetInt(row[3], &conf->disabled) != 0)
694     {
695     mysql_free_result(res);
696     errorStr = "User \'" + login + "\' data not read. Parameter Down.";
697     mysql_close(sock);
698     return -1;
699     }
700
701 if (GetInt(row[4], &conf->disabledDetailStat) != 0)
702     {
703     mysql_free_result(res);
704     errorStr = "User \'" + login + "\' data not read. Parameter DisabledDetailStat.";
705     mysql_close(sock);
706     return -1;
707     }
708
709 if (GetInt(row[5], &conf->alwaysOnline) != 0)
710     {
711     mysql_free_result(res);
712     errorStr = "User \'" + login + "\' data not read. Parameter AlwaysOnline.";
713     mysql_close(sock);
714     return -1;
715     }
716
717 conf->tariffName = row[6];
718
719 if (conf->tariffName.empty()) 
720     {
721     mysql_free_result(res);
722     errorStr = "User \'" + login + "\' tariff is blank.";
723     mysql_close(sock);
724     return -1;
725     }
726
727 conf->address = row[7];
728 conf->phone = row[8];
729 conf->email = row[9];
730 conf->note = row[10];
731 conf->realName = row[11];
732 conf->group = row[12];
733
734 if (GetDouble(row[13], &conf->credit, 0) != 0)
735     {
736     mysql_free_result(res);
737     errorStr = "User \'" + login + "\' data not read. Parameter Credit.";
738     mysql_close(sock);
739     return -1;
740     }
741
742 conf->nextTariff = row[14];
743
744 for (int i = 0; i < USERDATA_NUM; i++)
745     {
746     conf->userdata[i] = row[15+i];
747     }
748
749 GetTime(row[15+USERDATA_NUM], &conf->creditExpire, 0);
750     
751 std::string ipStr = row[16+USERDATA_NUM];
752 USER_IPS i;
753 try
754     {
755     i = StrToIPS(ipStr);
756     }
757 catch (const std::string & s)
758     {
759     mysql_free_result(res);
760     errorStr = "User \'" + login + "\' data not read. Parameter IP address. " + s;
761     mysql_close(sock);
762     return -1;
763     }
764 conf->ips = i;
765
766 mysql_free_result(res);
767 mysql_close(sock);
768
769 return 0;
770 }
771 //-----------------------------------------------------------------------------
772 int MYSQL_STORE::RestoreUserStat(USER_STAT * stat, const std::string & login) const
773 {
774 MYSQL_RES *res;
775 MYSQL_ROW row;
776 MYSQL * sock;
777
778 std::string query;
779
780 query = "SELECT ";
781
782 for (int i = 0; i < DIR_NUM; i++)
783 {
784     sprintf(qbuf, "D%d, U%d, ", i, i);
785     query += qbuf;
786 }
787
788 query += "Cash, FreeMb, LastCashAdd, LastCashAddTime, PassiveTime, LastActivityTime \
789           FROM users WHERE login = '";
790 query += login + "'";
791
792 //sprintf(qbuf,"SELECT * FROM users WHERE login='%s' LIMIT 1", login.c_str());
793     
794 if(MysqlGetQuery(query.c_str() ,sock))
795 {
796     errorStr = "Couldn't restore UserStat(on query):\n";
797     errorStr += mysql_error(sock);
798     mysql_close(sock);
799     return -1;
800 }
801
802 if (!(res=mysql_store_result(sock)))
803 {
804     errorStr = "Couldn't restore UserStat(on getting result):\n";
805     errorStr += mysql_error(sock);
806     mysql_close(sock);
807     return -1;
808 }
809
810 row = mysql_fetch_row(res);
811
812 unsigned int startPos=0;
813
814 char s[22];
815
816 for (int i = 0; i < DIR_NUM; i++)
817     {
818     uint64_t traff;
819     sprintf(s, "D%d", i);
820     if (GetULongLongInt(row[startPos+i*2], &traff, 0) != 0)
821         {
822         mysql_free_result(res);
823         errorStr = "User \'" + login + "\' stat not read. Parameter " + std::string(s);
824         mysql_close(sock);
825         return -1;
826         }
827     stat->down[i] = traff;
828
829     sprintf(s, "U%d", i);
830     if (GetULongLongInt(row[startPos+i*2+1], &traff, 0) != 0)
831         {
832         mysql_free_result(res);
833         errorStr =   "User \'" + login + "\' stat not read. Parameter " + std::string(s);
834         mysql_close(sock);
835         return -1;
836         }
837     stat->up[i] = traff;
838     }//for
839
840 startPos += (2*DIR_NUM);
841
842 if (GetDouble(row[startPos], &stat->cash, 0) != 0)
843     {
844     mysql_free_result(res);
845     errorStr =   "User \'" + login + "\' stat not read. Parameter Cash";
846     mysql_close(sock);
847     return -1;
848     }
849
850 if (GetDouble(row[startPos+1],&stat->freeMb, 0) != 0)
851     {
852     mysql_free_result(res);
853     errorStr =   "User \'" + login + "\' stat not read. Parameter FreeMb";
854     mysql_close(sock);
855     return -1;
856     }
857
858 if (GetDouble(row[startPos+2], &stat->lastCashAdd, 0) != 0)
859     {
860     mysql_free_result(res);
861     errorStr =   "User \'" + login + "\' stat not read. Parameter LastCashAdd";
862     mysql_close(sock);
863     return -1;
864     }
865
866 if (GetTime(row[startPos+3], &stat->lastCashAddTime, 0) != 0)
867     {
868     mysql_free_result(res);
869     errorStr =   "User \'" + login + "\' stat not read. Parameter LastCashAddTime";
870     mysql_close(sock);
871     return -1;
872     }
873
874 if (GetTime(row[startPos+4], &stat->passiveTime, 0) != 0)
875     {
876     mysql_free_result(res);
877     errorStr =   "User \'" + login + "\' stat not read. Parameter PassiveTime";
878     mysql_close(sock);
879     return -1;
880     }
881
882 if (GetTime(row[startPos+5], &stat->lastActivityTime, 0) != 0)
883     {
884     mysql_free_result(res);
885     errorStr =   "User \'" + login + "\' stat not read. Parameter LastActivityTime";
886     mysql_close(sock);
887     return -1;
888     }
889
890 mysql_free_result(res);
891 mysql_close(sock);
892 return 0;
893 }
894 //-----------------------------------------------------------------------------
895 int MYSQL_STORE::SaveUserConf(const USER_CONF & conf, const std::string & login) const
896 {
897 std::string param;
898 std::string res;
899
900 strprintf(&res,"UPDATE users SET Password='%s', Passive=%d, Down=%d, DisabledDetailStat = %d, "\
901     "AlwaysOnline=%d, Tariff='%s', Address='%s', Phone='%s', Email='%s', "\
902     "Note='%s', RealName='%s', StgGroup='%s', Credit=%f, TariffChange='%s', ", 
903     conf.password.c_str(),
904     conf.passive,
905     conf.disabled,
906     conf.disabledDetailStat,
907     conf.alwaysOnline,
908     conf.tariffName.c_str(),
909     (ReplaceStr(conf.address,badSyms,repSym)).c_str(),
910     (ReplaceStr(conf.phone,badSyms,repSym)).c_str(),
911     (ReplaceStr(conf.email,badSyms,repSym)).c_str(),
912     (ReplaceStr(conf.note,badSyms,repSym)).c_str(),
913     (ReplaceStr(conf.realName,badSyms,repSym)).c_str(),
914     (ReplaceStr(conf.group,badSyms,repSym)).c_str(),
915     conf.credit,
916     conf.nextTariff.c_str()
917     );
918
919 for (int i = 0; i < USERDATA_NUM; i++)
920     {
921     strprintf(&param, " Userdata%d='%s',", i, 
922         (ReplaceStr(conf.userdata[i],badSyms,repSym)).c_str());
923     res += param;
924     }
925     
926 strprintf(&param, " CreditExpire=%d,", conf.creditExpire);
927 res += param;
928
929 std::ostringstream ipStr;
930 ipStr << conf.ips;
931
932 strprintf(&param, " IP='%s'", ipStr.str().c_str());
933 res += param;
934
935 strprintf(&param, " WHERE login='%s' LIMIT 1", login.c_str());
936 res += param;
937
938 if(MysqlSetQuery(res.c_str()))
939 {
940     errorStr = "Couldn't save user conf:\n";
941     //errorStr += mysql_error(sock);
942     return -1;
943 }
944
945 return 0;
946 }
947 //-----------------------------------------------------------------------------
948 int MYSQL_STORE::SaveUserStat(const USER_STAT & stat, const std::string & login) const
949 {
950 std::string param;
951 std::string res;
952
953 res = "UPDATE users SET";
954
955 for (int i = 0; i < DIR_NUM; i++)
956     {
957     strprintf(&param, " D%d=%lld,", i, stat.down[i]);
958     res += param;
959
960     strprintf(&param, " U%d=%lld,", i, stat.up[i]);
961     res += param;
962     }
963
964 strprintf(&param, " Cash=%f, FreeMb=%f, LastCashAdd=%f, LastCashAddTime=%d,"\
965     " PassiveTime=%d, LastActivityTime=%d", 
966     stat.cash,
967     stat.freeMb,
968     stat.lastCashAdd,
969     stat.lastCashAddTime,
970     stat.passiveTime,
971     stat.lastActivityTime
972     );
973 res += param;
974
975 strprintf(&param, " WHERE login='%s' LIMIT 1", login.c_str());
976 res += param;
977
978 if(MysqlSetQuery(res.c_str()))
979 {
980     errorStr = "Couldn't save user stat:\n";
981 //    errorStr += mysql_error(sock);
982     return -1;
983 }
984
985 return 0;
986 }
987 //-----------------------------------------------------------------------------
988 int MYSQL_STORE::WriteLogString(const std::string & str, const std::string & login) const
989 {
990 std::string res, tempStr;
991 time_t t;
992 tm * lt;
993
994 t = time(NULL);
995 lt = localtime(&t);
996
997 MYSQL_RES* result;
998 MYSQL * sock;
999 strprintf(&tempStr, "logs_%02d_%4d", lt->tm_mon+1, lt->tm_year+1900);
1000 if (!(sock=MysqlConnect())){
1001     errorStr = "Couldn't connect to Server";
1002     return -1;
1003 }
1004 if (!(result=mysql_list_tables(sock,tempStr.c_str() )))
1005 {
1006     errorStr = "Couldn't get table " + tempStr + ":\n";
1007     errorStr += mysql_error(sock);
1008     mysql_close(sock);
1009     return -1;
1010 }
1011
1012 my_ulonglong num_rows =  mysql_num_rows(result);
1013
1014 mysql_free_result(result);
1015
1016 if (num_rows < 1)
1017 {
1018     sprintf(qbuf,"CREATE TABLE logs_%02d_%4d (unid INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, login VARCHAR(40),text TEXT)",
1019     lt->tm_mon+1, lt->tm_year+1900);
1020     
1021     if(MysqlQuery(qbuf,sock))
1022     {
1023         errorStr = "Couldn't create WriteDetailedStat table:\n";
1024         errorStr += mysql_error(sock);
1025         mysql_close(sock);
1026         return -1;
1027     }
1028 }
1029
1030 strprintf(&res, "%s -- %s",LogDate(t), str.c_str());
1031
1032 std::string send;
1033
1034 strprintf(&send,"INSERT INTO logs_%02d_%4d SET login='%s', text='%s'",
1035         lt->tm_mon+1, lt->tm_year+1900,
1036     login.c_str(), (ReplaceStr(res,badSyms,repSym)).c_str());
1037
1038 if(MysqlQuery(send.c_str(),sock))
1039 {
1040     errorStr = "Couldn't write log string:\n";
1041     errorStr += mysql_error(sock);
1042     mysql_close(sock);
1043     return -1;
1044 }
1045 mysql_close(sock);
1046 return 0;
1047
1048 }
1049 //-----------------------------------------------------------------------------
1050 int MYSQL_STORE::WriteUserChgLog(const std::string & login,
1051                                  const std::string & admLogin,
1052                                  uint32_t       admIP,
1053                                  const std::string & paramName,
1054                                  const std::string & oldValue,
1055                                  const std::string & newValue,
1056                                  const std::string & message) const
1057 {
1058 std::string userLogMsg = "Admin \'" + admLogin + "\', " + inet_ntostring(admIP) + ": \'"
1059     + paramName + "\' parameter changed from \'" + oldValue +
1060     "\' to \'" + newValue + "\'. " + message;
1061
1062 return WriteLogString(userLogMsg, login);
1063 }
1064 //-----------------------------------------------------------------------------
1065 int MYSQL_STORE::WriteUserConnect(const std::string & login, uint32_t ip) const
1066 {
1067 std::string logStr = "Connect, " + inet_ntostring(ip);
1068 return WriteLogString(logStr, login);
1069 }
1070 //-----------------------------------------------------------------------------
1071 int MYSQL_STORE::WriteUserDisconnect(const std::string & login,
1072                                      const DIR_TRAFF & up,
1073                                      const DIR_TRAFF & down,
1074                                      const DIR_TRAFF & sessionUp,
1075                                      const DIR_TRAFF & sessionDown,
1076                                      double cash,
1077                                      double /*freeMb*/,
1078                                      const std::string & /*reason*/) const
1079 {
1080 std::string logStr = "Disconnect, ";
1081 std::ostringstream sssu;
1082 std::ostringstream sssd;
1083 std::ostringstream ssmu;
1084 std::ostringstream ssmd;
1085 std::ostringstream sscash;
1086
1087 ssmu << up;
1088 ssmd << down;
1089
1090 sssu << sessionUp;
1091 sssd << sessionDown;
1092
1093 sscash << cash;
1094
1095 logStr += " session upload: \'";
1096 logStr += sssu.str();
1097 logStr += "\' session download: \'";
1098 logStr += sssd.str();
1099 logStr += "\' month upload: \'";
1100 logStr += ssmu.str();
1101 logStr += "\' month download: \'";
1102 logStr += ssmd.str();
1103 logStr += "\' cash: \'";
1104 logStr += sscash.str();
1105 logStr += "\'";
1106
1107 return WriteLogString(logStr, login);
1108 }
1109 //-----------------------------------------------------------------------------
1110 int MYSQL_STORE::SaveMonthStat(const USER_STAT & stat, int month, int year, 
1111                                 const std::string & login) const
1112 {
1113 std::string param, res;
1114
1115 strprintf(&res, "INSERT INTO stat SET login='%s', month=%d, year=%d,", 
1116     login.c_str(), month+1, year+1900);
1117     
1118 for (int i = 0; i < DIR_NUM; i++)
1119     {
1120     strprintf(&param, " U%d=%lld,", i, stat.up[i]); 
1121     res += param;
1122
1123     strprintf(&param, " D%d=%lld,", i, stat.down[i]);        
1124     res += param;
1125     }
1126     
1127 strprintf(&param, " cash=%f", stat.cash);        
1128 res += param;
1129
1130 if(MysqlSetQuery(res.c_str()))
1131 {
1132     errorStr = "Couldn't SaveMonthStat:\n";
1133     //errorStr += mysql_error(sock);
1134     return -1;
1135 }
1136
1137 return 0;
1138 }
1139 //-----------------------------------------------------------------------------*/
1140 int MYSQL_STORE::AddAdmin(const std::string & login) const
1141 {
1142 sprintf(qbuf,"INSERT INTO admins SET login='%s'", login.c_str());
1143     
1144 if(MysqlSetQuery(qbuf))
1145 {
1146     errorStr = "Couldn't add admin:\n";
1147     //errorStr += mysql_error(sock);
1148     return -1;
1149 }
1150
1151 return 0;
1152 }
1153 //-----------------------------------------------------------------------------*/
1154 int MYSQL_STORE::DelAdmin(const std::string & login) const
1155 {
1156 sprintf(qbuf,"DELETE FROM admins where login='%s' LIMIT 1", login.c_str());
1157     
1158 if(MysqlSetQuery(qbuf))
1159 {
1160     errorStr = "Couldn't delete admin:\n";
1161     //errorStr += mysql_error(sock);
1162     return -1;
1163 }
1164
1165 return 0;
1166 }
1167 //-----------------------------------------------------------------------------*/
1168 int MYSQL_STORE::SaveAdmin(const ADMIN_CONF & ac) const
1169 {
1170 char passwordE[2 * ADM_PASSWD_LEN + 2];
1171 char pass[ADM_PASSWD_LEN + 1];
1172 char adminPass[ADM_PASSWD_LEN + 1];
1173
1174 memset(pass, 0, sizeof(pass));
1175 memset(adminPass, 0, sizeof(adminPass));
1176
1177 BLOWFISH_CTX ctx;
1178 EnDecodeInit(adm_enc_passwd, strlen(adm_enc_passwd), &ctx);
1179
1180 strncpy(adminPass, ac.password.c_str(), ADM_PASSWD_LEN);
1181 adminPass[ADM_PASSWD_LEN - 1] = 0;
1182
1183 for (int i = 0; i < ADM_PASSWD_LEN/8; i++)
1184     {
1185     EncodeString(pass + 8*i, adminPass + 8*i, &ctx);
1186     }
1187
1188 pass[ADM_PASSWD_LEN - 1] = 0;
1189 Encode12(passwordE, pass, ADM_PASSWD_LEN);
1190
1191 sprintf(qbuf,"UPDATE admins SET password='%s', ChgConf=%d, ChgPassword=%d, "\
1192     "ChgStat=%d, ChgCash=%d, UsrAddDel=%d, ChgTariff=%d, ChgAdmin=%d "\
1193     "WHERE login='%s' LIMIT 1", 
1194     passwordE,
1195     ac.priv.userConf,
1196     ac.priv.userPasswd,
1197     ac.priv.userStat,
1198     ac.priv.userCash,
1199     ac.priv.userAddDel,
1200     ac.priv.tariffChg,
1201     ac.priv.adminChg,
1202     ac.login.c_str()
1203     );
1204
1205 if(MysqlSetQuery(qbuf))
1206 {
1207     errorStr = "Couldn't save admin:\n";
1208     //errorStr += mysql_error(sock);
1209     return -1;
1210 }
1211
1212 return 0;
1213 }
1214 //-----------------------------------------------------------------------------
1215 int MYSQL_STORE::RestoreAdmin(ADMIN_CONF * ac, const std::string & login) const
1216 {
1217 char pass[ADM_PASSWD_LEN + 1];
1218 char password[ADM_PASSWD_LEN + 1];
1219 char passwordE[2*ADM_PASSWD_LEN + 2];
1220 BLOWFISH_CTX ctx;
1221
1222 memset(pass, 0, sizeof(pass));
1223 memset(password, 0, sizeof(password));
1224 memset(passwordE, 0, sizeof(passwordE));
1225
1226 std::string p;
1227 MYSQL_RES *res;
1228 MYSQL_ROW row;
1229 MYSQL * sock;
1230 sprintf(qbuf,"SELECT * FROM admins WHERE login='%s' LIMIT 1", login.c_str());
1231     
1232 if(MysqlGetQuery(qbuf,sock))
1233 {
1234     errorStr = "Couldn't restore admin:\n";
1235     errorStr += mysql_error(sock);
1236     mysql_close(sock);
1237     return -1;
1238 }
1239
1240 if (!(res=mysql_store_result(sock)))
1241 {
1242     errorStr = "Couldn't restore admin:\n";
1243     errorStr += mysql_error(sock);
1244     mysql_close(sock);
1245     return -1;
1246 }
1247
1248 if ( mysql_num_rows(res) == 0)
1249 {
1250     mysql_free_result(res);
1251     errorStr = "Couldn't restore admin as couldn't found him in table.\n";
1252     mysql_close(sock);
1253     return -1;
1254 }
1255   
1256 row = mysql_fetch_row(res);
1257
1258 p = row[1];
1259
1260 if(p.length() == 0)
1261 {
1262     mysql_free_result(res);
1263     errorStr = "Error in parameter password";
1264     mysql_close(sock);
1265     return -1;
1266 }
1267
1268 memset(passwordE, 0, sizeof(passwordE));
1269 strncpy(passwordE, p.c_str(), 2*ADM_PASSWD_LEN);
1270
1271 memset(pass, 0, sizeof(pass));
1272
1273 if (passwordE[0] != 0)
1274     {
1275     Decode21(pass, passwordE);
1276     EnDecodeInit(adm_enc_passwd, strlen(adm_enc_passwd), &ctx);
1277
1278     for (int i = 0; i < ADM_PASSWD_LEN/8; i++)
1279         {
1280         DecodeString(password + 8*i, pass + 8*i, &ctx);
1281         }
1282     }
1283 else
1284     {
1285     password[0] = 0;
1286     }
1287
1288 ac->password = password;
1289
1290 uint16_t a;
1291
1292 if (GetInt(row[2], &a) == 0) 
1293     ac->priv.userConf = a;
1294 else
1295     {
1296     mysql_free_result(res);
1297     errorStr = "Error in parameter ChgConf";
1298     mysql_close(sock);
1299     return -1;
1300     }
1301
1302 if (GetInt(row[3], &a) == 0) 
1303     ac->priv.userPasswd = a;
1304 else
1305     {
1306     mysql_free_result(res);
1307     errorStr = "Error in parameter ChgPassword";
1308     mysql_close(sock);
1309     return -1;
1310     }
1311
1312 if (GetInt(row[4], &a) == 0) 
1313     ac->priv.userStat = a;
1314 else
1315     {
1316     mysql_free_result(res);
1317     errorStr = "Error in parameter ChgStat";
1318     mysql_close(sock);
1319     return -1;
1320     }
1321
1322 if (GetInt(row[5], &a) == 0) 
1323     ac->priv.userCash = a;
1324 else
1325     {
1326     mysql_free_result(res);
1327     errorStr = "Error in parameter ChgCash";
1328     mysql_close(sock);
1329     return -1;
1330     }
1331
1332 if (GetInt(row[6], &a) == 0) 
1333     ac->priv.userAddDel = a;
1334 else
1335     {
1336     mysql_free_result(res);
1337     errorStr = "Error in parameter UsrAddDel";
1338     mysql_close(sock);
1339     return -1;
1340     }
1341
1342 if (GetInt(row[7], &a) == 0) 
1343     ac->priv.tariffChg = a;
1344 else
1345     {
1346     mysql_free_result(res);
1347     errorStr = "Error in parameter ChgTariff";
1348     mysql_close(sock);
1349     return -1;
1350     }
1351
1352 if (GetInt(row[8], &a) == 0) 
1353     ac->priv.adminChg = a;
1354 else
1355     {
1356     mysql_free_result(res);
1357     errorStr = "Error in parameter ChgAdmin";
1358     mysql_close(sock);
1359     return -1;
1360     }
1361
1362 mysql_free_result(res);
1363 mysql_close(sock);
1364 return 0;
1365 }
1366 //-----------------------------------------------------------------------------
1367 int MYSQL_STORE::AddTariff(const std::string & name) const
1368 {
1369 sprintf(qbuf,"INSERT INTO tariffs SET name='%s'", name.c_str());
1370     
1371 if(MysqlSetQuery(qbuf))
1372 {
1373     errorStr = "Couldn't add tariff:\n";
1374 //    errorStr += mysql_error(sock);
1375     return -1;
1376 }
1377
1378 return 0;
1379 }
1380 //-----------------------------------------------------------------------------
1381 int MYSQL_STORE::DelTariff(const std::string & name) const
1382 {
1383 sprintf(qbuf,"DELETE FROM tariffs WHERE name='%s' LIMIT 1", name.c_str());
1384     
1385 if(MysqlSetQuery(qbuf))
1386 {
1387     errorStr = "Couldn't delete tariff: ";
1388 //    errorStr += mysql_error(sock);
1389     return -1;
1390 }
1391
1392 return 0;
1393 }
1394 //-----------------------------------------------------------------------------
1395 int MYSQL_STORE::RestoreTariff(TARIFF_DATA * td, const std::string & tariffName) const
1396 {
1397 MYSQL_RES *res;
1398 MYSQL_ROW row;
1399 MYSQL * sock;
1400 sprintf(qbuf,"SELECT * FROM tariffs WHERE name='%s' LIMIT 1", tariffName.c_str());
1401     
1402 if(MysqlGetQuery(qbuf,sock))
1403 {
1404     errorStr = "Couldn't restore Tariff:\n";
1405     errorStr += mysql_error(sock);
1406     mysql_close(sock);
1407     return -1;
1408 }
1409
1410 if (!(res=mysql_store_result(sock)))
1411 {
1412     errorStr = "Couldn't restore Tariff:\n";
1413     errorStr += mysql_error(sock);
1414     mysql_close(sock);
1415     return -1;
1416 }
1417
1418 std::string str;
1419 td->tariffConf.name = tariffName;
1420
1421 row = mysql_fetch_row(res);
1422
1423 std::string param;
1424 for (int i = 0; i<DIR_NUM; i++)
1425     {
1426     strprintf(&param, "Time%d", i);
1427     str = row[6+i*8];
1428     if (str.length() == 0)
1429         {
1430         mysql_free_result(res);
1431         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1432         mysql_close(sock);
1433         return -1;
1434         }
1435
1436     ParseTariffTimeStr(str.c_str(), 
1437                        td->dirPrice[i].hDay, 
1438                        td->dirPrice[i].mDay, 
1439                        td->dirPrice[i].hNight, 
1440                        td->dirPrice[i].mNight);
1441
1442     strprintf(&param, "PriceDayA%d", i);
1443     if (GetDouble(row[1+i*8], &td->dirPrice[i].priceDayA, 0.0) < 0)
1444         {
1445         mysql_free_result(res);
1446         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1447         mysql_close(sock);
1448         return -1;
1449         }
1450     td->dirPrice[i].priceDayA /= (1024*1024);
1451
1452     strprintf(&param, "PriceDayB%d", i);
1453     if (GetDouble(row[2+i*8], &td->dirPrice[i].priceDayB, 0.0) < 0)
1454         {
1455         mysql_free_result(res);
1456         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1457         mysql_close(sock);
1458         return -1;
1459         }
1460     td->dirPrice[i].priceDayB /= (1024*1024);
1461
1462     strprintf(&param, "PriceNightA%d", i);
1463     if (GetDouble(row[3+i*8], &td->dirPrice[i].priceNightA, 0.0) < 0)
1464         {
1465         mysql_free_result(res);
1466         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1467         mysql_close(sock);
1468         return -1;
1469         }
1470     td->dirPrice[i].priceNightA /= (1024*1024);
1471
1472     strprintf(&param, "PriceNightB%d", i);
1473     if (GetDouble(row[4+i*8], &td->dirPrice[i].priceNightB, 0.0) < 0)
1474         {
1475         mysql_free_result(res);
1476         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1477         mysql_close(sock);
1478         return -1;
1479         }
1480     td->dirPrice[i].priceNightB /= (1024*1024);
1481
1482     strprintf(&param, "Threshold%d", i);
1483     if (GetInt(row[5+i*8], &td->dirPrice[i].threshold) < 0)
1484         {
1485         mysql_free_result(res);
1486         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1487         mysql_close(sock);
1488         return -1;
1489         }
1490
1491     strprintf(&param, "SinglePrice%d", i);
1492     if (GetInt(row[8+i*8], &td->dirPrice[i].singlePrice) < 0)
1493         {
1494         mysql_free_result(res);
1495         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1496         mysql_close(sock);
1497         return -1;
1498         }
1499
1500     strprintf(&param, "NoDiscount%d", i);
1501     if (GetInt(row[7+i*8], &td->dirPrice[i].noDiscount) < 0)
1502         {
1503         mysql_free_result(res);
1504         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1505         mysql_close(sock);
1506         return -1;
1507         }
1508     }//main for
1509
1510 if (GetDouble(row[2+8*DIR_NUM], &td->tariffConf.fee, 0.0) < 0)
1511     {
1512     mysql_free_result(res);
1513     errorStr = "Cannot read tariff " + tariffName + ". Parameter Fee";
1514     mysql_close(sock);
1515     return -1;
1516     }
1517
1518 if (GetDouble(row[3+8*DIR_NUM], &td->tariffConf.free, 0.0) < 0)
1519     {
1520     mysql_free_result(res);
1521     errorStr = "Cannot read tariff " + tariffName + ". Parameter Free";
1522     mysql_close(sock);
1523     return -1;
1524     }
1525
1526 if (GetDouble(row[1+8*DIR_NUM], &td->tariffConf.passiveCost, 0.0) < 0)
1527     {
1528     mysql_free_result(res);
1529     errorStr = "Cannot read tariff " + tariffName + ". Parameter PassiveCost";
1530     mysql_close(sock);
1531     return -1;
1532     }
1533
1534     str = row[4+8*DIR_NUM];
1535     param = "TraffType";
1536     
1537     if (str.length() == 0)
1538         {
1539         mysql_free_result(res);
1540         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1541         mysql_close(sock);
1542         return -1;
1543         }
1544
1545 if (!strcasecmp(str.c_str(), "up"))
1546     td->tariffConf.traffType = TRAFF_UP;
1547 else
1548     if (!strcasecmp(str.c_str(), "down"))
1549         td->tariffConf.traffType = TRAFF_DOWN;
1550     else
1551         if (!strcasecmp(str.c_str(), "up+down"))
1552             td->tariffConf.traffType = TRAFF_UP_DOWN;
1553         else
1554             if (!strcasecmp(str.c_str(), "max"))
1555                 td->tariffConf.traffType = TRAFF_MAX;
1556             else
1557                 {
1558                 mysql_free_result(res);
1559                 errorStr = "Cannot read tariff " + tariffName + ". Parameter TraffType incorrect";
1560                 mysql_close(sock);
1561                 return -1;
1562                 }
1563
1564 mysql_free_result(res);
1565 mysql_close(sock);
1566 return 0;
1567 }
1568 //-----------------------------------------------------------------------------
1569 int MYSQL_STORE::SaveTariff(const TARIFF_DATA & td, const std::string & tariffName) const
1570 {
1571 std::string param;
1572
1573 std::string res="UPDATE tariffs SET";
1574
1575 for (int i = 0; i < DIR_NUM; i++)
1576     {
1577     strprintf(&param, " PriceDayA%d=%f,", i, 
1578         td.dirPrice[i].priceDayA * pt_mega);
1579     res += param;
1580
1581     strprintf(&param, " PriceDayB%d=%f,", i, 
1582         td.dirPrice[i].priceDayB * pt_mega);        
1583     res += param;
1584         
1585     strprintf(&param, " PriceNightA%d=%f,", i,
1586         td.dirPrice[i].priceNightA * pt_mega);
1587     res += param;
1588
1589     strprintf(&param, " PriceNightB%d=%f,", i, 
1590         td.dirPrice[i].priceNightB * pt_mega);
1591     res += param;
1592         
1593     strprintf(&param, " Threshold%d=%d,", i, 
1594         td.dirPrice[i].threshold);
1595     res += param;
1596
1597     std::string s;
1598     strprintf(&param, " Time%d", i);
1599
1600     strprintf(&s, "%0d:%0d-%0d:%0d", 
1601             td.dirPrice[i].hDay,
1602             td.dirPrice[i].mDay,
1603             td.dirPrice[i].hNight,
1604             td.dirPrice[i].mNight);
1605
1606     res += (param + "='" + s + "',");
1607
1608     strprintf(&param, " NoDiscount%d=%d,", i, 
1609         td.dirPrice[i].noDiscount);
1610     res += param;
1611
1612     strprintf(&param, " SinglePrice%d=%d,", i, 
1613         td.dirPrice[i].singlePrice);
1614     res += param;
1615     }
1616
1617 strprintf(&param, " PassiveCost=%f,", td.tariffConf.passiveCost);
1618 res += param;
1619
1620 strprintf(&param, " Fee=%f,", td.tariffConf.fee);
1621 res += param;
1622
1623 strprintf(&param, " Free=%f,", td.tariffConf.free);
1624 res += param;
1625
1626 switch (td.tariffConf.traffType)
1627     {
1628     case TRAFF_UP:
1629         res += " TraffType='up'";
1630         break;
1631     case TRAFF_DOWN:
1632         res += " TraffType='down'";
1633         break;
1634     case TRAFF_UP_DOWN:
1635         res += " TraffType='up+down'";
1636         break;
1637     case TRAFF_MAX:
1638         res += " TraffType='max'";
1639         break;
1640     }
1641 strprintf(&param, " WHERE name='%s' LIMIT 1", tariffName.c_str());
1642 res += param;
1643
1644 if(MysqlSetQuery(res.c_str()))
1645 {
1646     errorStr = "Couldn't save admin:\n";
1647     //errorStr += mysql_error(sock);
1648     return -1;
1649 }
1650
1651 return 0;
1652 }
1653 //-----------------------------------------------------------------------------
1654 int MYSQL_STORE::WriteDetailedStat(const std::map<IP_DIR_PAIR, STAT_NODE> & statTree, 
1655                                    time_t lastStat, 
1656                                    const std::string & login) const
1657 {
1658 std::string res, stTime, endTime, tempStr;
1659 time_t t;
1660 tm * lt;
1661
1662 t = time(NULL);
1663 lt = localtime(&t);
1664
1665 if (lt->tm_hour == 0 && lt->tm_min <= 5)
1666     {
1667         t -= 3600 * 24;
1668         lt = localtime(&t);
1669     }
1670
1671 MYSQL_RES* result;
1672 MYSQL * sock;
1673 strprintf(&tempStr, "detailstat_%02d_%4d", lt->tm_mon+1, lt->tm_year+1900);
1674
1675 if (!(sock=MysqlConnect())){
1676     mysql_close(sock);
1677     return -1;
1678 }
1679
1680 if (!(result=mysql_list_tables(sock,tempStr.c_str() )))
1681 {
1682     errorStr = "Couldn't get table " + tempStr + ":\n";
1683     errorStr += mysql_error(sock);
1684     mysql_close(sock);
1685     return -1;
1686 }
1687
1688 my_ulonglong num_rows =  mysql_num_rows(result);
1689
1690 mysql_free_result(result);
1691
1692 if (num_rows < 1)
1693 {
1694     sprintf(qbuf,"CREATE TABLE detailstat_%02d_%4d (login VARCHAR(40) DEFAULT '',"\
1695         "day TINYINT DEFAULT 0,startTime TIME,endTime TIME,"\
1696         "IP VARCHAR(17) DEFAULT '',dir INT DEFAULT 0,"\
1697         "down BIGINT DEFAULT 0,up BIGINT DEFAULT 0, cash DOUBLE DEFAULT 0.0, INDEX (login), INDEX(dir), INDEX(day), INDEX(IP))",
1698     lt->tm_mon+1, lt->tm_year+1900);
1699     
1700     if(MysqlQuery(qbuf,sock))
1701     {
1702         errorStr = "Couldn't create WriteDetailedStat table:\n";
1703         errorStr += mysql_error(sock);
1704         mysql_close(sock);
1705         return -1;
1706     }
1707 }
1708
1709 struct tm * lt1;
1710 struct tm * lt2;
1711
1712 lt1 = localtime(&lastStat);
1713
1714 int h1, m1, s1;
1715 int h2, m2, s2;
1716
1717 h1 = lt1->tm_hour;
1718 m1 = lt1->tm_min;
1719 s1 = lt1->tm_sec;
1720
1721 lt2 = localtime(&t);
1722
1723 h2 = lt2->tm_hour;
1724 m2 = lt2->tm_min;
1725 s2 = lt2->tm_sec;
1726     
1727 strprintf(&stTime, "%02d:%02d:%02d", h1, m1, s1);
1728 strprintf(&endTime, "%02d:%02d:%02d", h2, m2, s2);
1729
1730 strprintf(&res,"INSERT INTO detailstat_%02d_%4d SET login='%s',"\
1731     "day=%d,startTime='%s',endTime='%s',", 
1732     lt->tm_mon+1, lt->tm_year+1900,
1733     login.c_str(),
1734     lt->tm_mday,
1735     stTime.c_str(),
1736     endTime.c_str()
1737     );
1738
1739 std::map<IP_DIR_PAIR, STAT_NODE>::const_iterator stIter;
1740 stIter = statTree.begin();
1741
1742 while (stIter != statTree.end())
1743     {
1744         strprintf(&tempStr,"IP='%s', dir=%d, down=%lld, up=%lld, cash=%f", 
1745                 inet_ntostring(stIter->first.ip).c_str(),
1746                 stIter->first.dir, 
1747                 stIter->second.down, 
1748                 stIter->second.up, 
1749                 stIter->second.cash
1750             );
1751     
1752         if( MysqlQuery((res+tempStr).c_str(),sock) )
1753         {
1754             errorStr = "Couldn't insert data in WriteDetailedStat:\n";
1755             errorStr += mysql_error(sock);
1756             mysql_close(sock);
1757             return -1;
1758         }
1759
1760         result=mysql_store_result(sock);
1761         if(result)
1762             mysql_free_result(result);
1763
1764         ++stIter;
1765     }
1766 mysql_close(sock);
1767 return 0;
1768 }
1769 //-----------------------------------------------------------------------------
1770 int MYSQL_STORE::AddMessage(STG_MSG * msg, const std::string & login) const
1771 {
1772 struct timeval tv;
1773
1774 gettimeofday(&tv, NULL);
1775
1776 msg->header.id = static_cast<uint64_t>(tv.tv_sec) * 1000000 + static_cast<uint64_t>(tv.tv_usec);
1777
1778 sprintf(qbuf,"INSERT INTO messages SET login='%s', id=%lld", 
1779     login.c_str(),
1780     static_cast<long long>(msg->header.id)
1781     );
1782     
1783 if(MysqlSetQuery(qbuf))
1784 {
1785     errorStr = "Couldn't add message:\n";
1786     //errorStr += mysql_error(sock);
1787     return -1;
1788 }
1789
1790 return EditMessage(*msg, login);
1791 }
1792 //-----------------------------------------------------------------------------
1793 int MYSQL_STORE::EditMessage(const STG_MSG & msg, const std::string & login) const
1794 {
1795 std::string res;
1796
1797 strprintf(&res,"UPDATE messages SET type=%d, lastSendTime=%u, creationTime=%u, "\
1798     "showTime=%u, stgRepeat=%d, repeatPeriod=%u, text='%s' "\
1799     "WHERE login='%s' AND id=%lld LIMIT 1", 
1800     msg.header.type,
1801     msg.header.lastSendTime,
1802     msg.header.creationTime,
1803     msg.header.showTime,
1804     msg.header.repeat,
1805     msg.header.repeatPeriod,
1806     (ReplaceStr(msg.text,badSyms,repSym)).c_str(),
1807     login.c_str(),
1808     msg.header.id
1809     );
1810
1811 if(MysqlSetQuery(res.c_str()))
1812 {
1813     errorStr = "Couldn't edit message:\n";
1814     //errorStr += mysql_error(sock);
1815     return -1;
1816 }
1817
1818 return 0;
1819 }
1820 //-----------------------------------------------------------------------------
1821 int MYSQL_STORE::GetMessage(uint64_t id, STG_MSG * msg, const std::string & login) const
1822 {
1823 MYSQL_RES *res;
1824 MYSQL_ROW row;
1825 MYSQL * sock;
1826
1827 sprintf(qbuf,"SELECT * FROM messages WHERE login='%s' AND id=%llu LIMIT 1",
1828         login.c_str(), static_cast<unsigned long long>(id));
1829     
1830 if(MysqlGetQuery(qbuf,sock))
1831 {
1832     errorStr = "Couldn't GetMessage:\n";
1833     errorStr += mysql_error(sock);
1834     mysql_close(sock);
1835     return -1;
1836 }
1837
1838 if (!(res=mysql_store_result(sock)))
1839 {
1840     errorStr = "Couldn't GetMessage:\n";
1841     errorStr += mysql_error(sock);
1842     mysql_close(sock);
1843     return -1;
1844 }
1845
1846 row = mysql_fetch_row(res);
1847
1848 if(row[2]&&str2x(row[2], msg->header.type))
1849 {
1850     mysql_free_result(res);
1851     errorStr = "Invalid value in message header for user: " + login;
1852     mysql_close(sock);
1853     return -1;
1854 }
1855
1856 if(row[3] && str2x(row[3], msg->header.lastSendTime))
1857 {
1858     mysql_free_result(res);
1859     errorStr = "Invalid value in message header for user: " + login;
1860     mysql_close(sock);
1861     return -1;
1862 }
1863
1864 if(row[4] && str2x(row[4], msg->header.creationTime))
1865 {
1866     mysql_free_result(res);
1867     errorStr = "Invalid value in message header for user: " + login;
1868     mysql_close(sock);
1869     return -1;
1870 }
1871
1872 if(row[5] && str2x(row[5], msg->header.showTime))
1873 {
1874     mysql_free_result(res);
1875     errorStr = "Invalid value in message header for user: " + login;
1876     mysql_close(sock);
1877     return -1;
1878 }
1879
1880 if(row[6] && str2x(row[6], msg->header.repeat))
1881 {
1882     mysql_free_result(res);
1883     errorStr = "Invalid value in message header for user: " + login;
1884     mysql_close(sock);
1885     return -1;
1886 }
1887
1888 if(row[7] && str2x(row[7], msg->header.repeatPeriod))
1889 {
1890     mysql_free_result(res);
1891     errorStr = "Invalid value in message header for user: " + login;
1892     mysql_close(sock);
1893     return -1;
1894 }
1895
1896 msg->header.id = id;
1897 msg->text = row[8];
1898
1899 mysql_free_result(res);
1900 mysql_close(sock);
1901 return 0;
1902 }
1903 //-----------------------------------------------------------------------------
1904 int MYSQL_STORE::DelMessage(uint64_t id, const std::string & login) const
1905 {
1906 sprintf(qbuf,"DELETE FROM messages WHERE login='%s' AND id=%lld LIMIT 1", 
1907         login.c_str(), static_cast<long long>(id));
1908     
1909 if(MysqlSetQuery(qbuf))
1910 {
1911     errorStr = "Couldn't delete Message:\n";
1912     //errorStr += mysql_error(sock);
1913     return -1;
1914 }
1915
1916 return 0;
1917 }
1918 //-----------------------------------------------------------------------------
1919 int MYSQL_STORE::GetMessageHdrs(std::vector<STG_MSG_HDR> * hdrsList, const std::string & login) const
1920 {
1921 MYSQL_RES *res;
1922 MYSQL_ROW row;
1923 MYSQL * sock;
1924 sprintf(qbuf,"SELECT * FROM messages WHERE login='%s'", login.c_str());
1925     
1926 if(MysqlGetQuery(qbuf,sock))
1927 {
1928     errorStr = "Couldn't GetMessageHdrs:\n";
1929     errorStr += mysql_error(sock);
1930     mysql_close(sock);
1931     return -1;
1932 }
1933
1934 if (!(res=mysql_store_result(sock)))
1935 {
1936     errorStr = "Couldn't GetMessageHdrs:\n";
1937     errorStr += mysql_error(sock);
1938     mysql_close(sock);
1939     return -1;
1940 }
1941
1942 unsigned int i;
1943 my_ulonglong num_rows = mysql_num_rows(res);
1944 uint64_t id = 0;
1945
1946 for (i = 0; i < num_rows; i++)
1947 {
1948     row = mysql_fetch_row(res);
1949     if (str2x(row[1], id))
1950         continue;
1951     
1952     STG_MSG_HDR hdr;
1953     if (row[2]) 
1954         if(str2x(row[2], hdr.type))
1955             continue;
1956
1957     if (row[3])
1958         if(str2x(row[3], hdr.lastSendTime))
1959             continue;
1960
1961     if (row[4])
1962         if(str2x(row[4], hdr.creationTime))
1963             continue;
1964
1965     if (row[5])
1966         if(str2x(row[5], hdr.showTime))
1967             continue;
1968
1969     if (row[6])
1970         if(str2x(row[6], hdr.repeat))
1971             continue;
1972
1973     if (row[7])
1974         if(str2x(row[7], hdr.repeatPeriod))
1975             continue;
1976
1977     hdr.id = id;
1978     hdrsList->push_back(hdr);
1979 }
1980
1981 mysql_free_result(res);
1982 mysql_close(sock);
1983 return 0;
1984 }
1985 //-----------------------------------------------------------------------------
1986
1987 int MYSQL_STORE::MysqlSetQuery(const char * Query) const {
1988
1989     MYSQL * sock;
1990     int ret=MysqlGetQuery(Query,sock);
1991     mysql_close(sock);
1992     return ret;
1993 }
1994 //-----------------------------------------------------------------------------
1995 int  MYSQL_STORE::MysqlGetQuery(const char * Query,MYSQL * & sock) const {
1996     if (!(sock=MysqlConnect())) {
1997         return -1;
1998     }
1999     return   MysqlQuery(Query,sock);
2000 }
2001 //-----------------------------------------------------------------------------
2002 MYSQL *  MYSQL_STORE::MysqlConnect() const {
2003     MYSQL * sock;
2004     if ( !(sock=mysql_init(NULL)) ){
2005         errorStr= "mysql init susck\n";
2006         return NULL;
2007     }
2008     if (!(sock = mysql_real_connect(sock,storeSettings.GetDBHost().c_str(),
2009             storeSettings.GetDBUser().c_str(),storeSettings.GetDBPassword().c_str(),
2010             0,0,NULL,0)))
2011         {
2012             errorStr = "Couldn't connect to mysql engine! With error:\n";
2013             errorStr += mysql_error(sock);
2014             return NULL;
2015         }
2016     else{
2017          if(mysql_select_db(sock, storeSettings.GetDBName().c_str())){
2018              errorStr = "Database lost !\n";
2019              return NULL;
2020          }
2021     }
2022     return sock;
2023 }
2024 //-----------------------------------------------------------------------------