]> git.stg.codes - stg.git/blob - stargazer/plugins/store/files/file_store.cpp
Public interfaces: part 1
[stg.git] / stargazer / plugins / store / files / file_store.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 : Boris Mikhailenko <stg34@stargazer.dp.ua>
19  */
20
21 /*
22  $Revision: 1.67 $
23  $Date: 2010/10/07 19:53:11 $
24  $Author: faust $
25  */
26
27 #ifndef _GNU_SOURCE
28 #define _GNU_SOURCE
29 #endif
30
31 #include "file_store.h"
32
33 #include "stg/common.h"
34 #include "stg/user_ips.h"
35 #include "stg/user_conf.h"
36 #include "stg/user_stat.h"
37 #include "stg/const.h"
38 #include "stg/blowfish.h"
39 #include "stg/logger.h"
40 #include "stg/locker.h"
41 #include "stg/admin_conf.h"
42 #include "stg/tariff.h"
43 #include "stg/tariff_conf.h"
44 #include "stg/service_conf.h"
45
46 #include <sstream>
47 #include <algorithm>
48 #include <cstdio>
49 #include <ctime>
50 #include <cerrno>
51 #include <cstring>
52
53 #include <pwd.h>
54 #include <grp.h>
55 #include <sys/stat.h>
56 #include <unistd.h>
57 #include <sys/time.h>
58 #include <fcntl.h>
59 #include <dirent.h>
60
61 #define DELETED_USERS_DIR   "deleted_users"
62
63 #define adm_enc_passwd "cjeifY8m3"
64
65 int GetFileList(std::vector<std::string> * fileList, const std::string & directory, mode_t mode, const std::string & ext);
66
67 const int pt_mega = 1024 * 1024;
68 //-----------------------------------------------------------------------------
69 //-----------------------------------------------------------------------------
70 //-----------------------------------------------------------------------------
71 namespace
72 {
73
74 bool CheckAndCreate(const std::string & dir, mode_t mode)
75 {
76 if (access(dir.c_str(), F_OK) == 0)
77     return true;
78 if (mkdir(dir.c_str(), mode) == 0)
79     return true;
80 return false;
81 }
82
83 }
84
85 extern "C" STG::Store* GetStore()
86 {
87     static FILES_STORE plugin;
88     return &plugin;
89 }
90 //-----------------------------------------------------------------------------
91 FILES_STORE_SETTINGS::FILES_STORE_SETTINGS()
92     : settings(NULL),
93       statMode(0),
94       statUID(0),
95       statGID(0),
96       confMode(0),
97       confUID(0),
98       confGID(0),
99       userLogMode(0),
100       userLogUID(0),
101       userLogGID(0),
102       removeBak(true),
103       readBak(true)
104 {
105 }
106 //-----------------------------------------------------------------------------
107 int FILES_STORE_SETTINGS::ParseOwner(const std::vector<STG::ParamValue> & moduleParams, const std::string & owner, uid_t * uid)
108 {
109 STG::ParamValue pv;
110 pv.param = owner;
111 std::vector<STG::ParamValue>::const_iterator pvi;
112 pvi = find(moduleParams.begin(), moduleParams.end(), pv);
113 if (pvi == moduleParams.end() || pvi->value.empty())
114     {
115     errorStr = "Parameter \'" + owner + "\' not found.";
116     printfd(__FILE__, "%s\n", errorStr.c_str());
117     return -1;
118     }
119 if (User2UID(pvi->value[0].c_str(), uid) < 0)
120     {
121     errorStr = "Parameter \'" + owner + "\': Unknown user \'" + pvi->value[0] + "\'";
122     printfd(__FILE__, "%s\n", errorStr.c_str());
123     return -1;
124     }
125 return 0;
126 }
127 //-----------------------------------------------------------------------------
128 int FILES_STORE_SETTINGS::ParseGroup(const std::vector<STG::ParamValue> & moduleParams, const std::string & group, gid_t * gid)
129 {
130 STG::ParamValue pv;
131 pv.param = group;
132 std::vector<STG::ParamValue>::const_iterator pvi;
133 pvi = find(moduleParams.begin(), moduleParams.end(), pv);
134 if (pvi == moduleParams.end() || pvi->value.empty())
135     {
136     errorStr = "Parameter \'" + group + "\' not found.";
137     printfd(__FILE__, "%s\n", errorStr.c_str());
138     return -1;
139     }
140 if (Group2GID(pvi->value[0].c_str(), gid) < 0)
141     {
142     errorStr = "Parameter \'" + group + "\': Unknown group \'" + pvi->value[0] + "\'";
143     printfd(__FILE__, "%s\n", errorStr.c_str());
144     return -1;
145     }
146 return 0;
147 }
148 //-----------------------------------------------------------------------------
149 int FILES_STORE_SETTINGS::ParseYesNo(const std::string & value, bool * val)
150 {
151 if (0 == strcasecmp(value.c_str(), "yes"))
152     {
153     *val = true;
154     return 0;
155     }
156 if (0 == strcasecmp(value.c_str(), "no"))
157     {
158     *val = false;
159     return 0;
160     }
161
162 errorStr = "Incorrect value \'" + value + "\'.";
163 return -1;
164 }
165 //-----------------------------------------------------------------------------
166 int FILES_STORE_SETTINGS::ParseMode(const std::vector<STG::ParamValue> & moduleParams, const std::string & modeStr, mode_t * mode)
167 {
168 STG::ParamValue pv;
169 pv.param = modeStr;
170 std::vector<STG::ParamValue>::const_iterator pvi;
171 pvi = find(moduleParams.begin(), moduleParams.end(), pv);
172 if (pvi == moduleParams.end() || pvi->value.empty())
173     {
174     errorStr = "Parameter \'" + modeStr + "\' not found.";
175     printfd(__FILE__, "%s\n", errorStr.c_str());
176     return -1;
177     }
178 if (Str2Mode(pvi->value[0].c_str(), mode) < 0)
179     {
180     errorStr = "Parameter \'" + modeStr + "\': Incorrect mode \'" + pvi->value[0] + "\'";
181     printfd(__FILE__, "%s\n", errorStr.c_str());
182     return -1;
183     }
184 return 0;
185 }
186 //-----------------------------------------------------------------------------
187 int FILES_STORE_SETTINGS::ParseSettings(const STG::ModuleSettings & s)
188 {
189 if (ParseOwner(s.moduleParams, "StatOwner", &statUID) < 0)
190     return -1;
191 if (ParseGroup(s.moduleParams, "StatGroup", &statGID) < 0)
192     return -1;
193 if (ParseMode(s.moduleParams, "StatMode", &statMode) < 0)
194     return -1;
195
196 if (ParseOwner(s.moduleParams, "ConfOwner", &confUID) < 0)
197     return -1;
198 if (ParseGroup(s.moduleParams, "ConfGroup", &confGID) < 0)
199     return -1;
200 if (ParseMode(s.moduleParams, "ConfMode", &confMode) < 0)
201     return -1;
202
203 if (ParseOwner(s.moduleParams, "UserLogOwner", &userLogUID) < 0)
204     return -1;
205 if (ParseGroup(s.moduleParams, "UserLogGroup", &userLogGID) < 0)
206     return -1;
207 if (ParseMode(s.moduleParams, "UserLogMode", &userLogMode) < 0)
208     return -1;
209
210 std::vector<STG::ParamValue>::const_iterator pvi;
211 STG::ParamValue pv;
212 pv.param = "RemoveBak";
213 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
214 if (pvi == s.moduleParams.end() || pvi->value.empty())
215     {
216     removeBak = true;
217     }
218 else
219     {
220     if (ParseYesNo(pvi->value[0], &removeBak))
221         {
222         printfd(__FILE__, "Cannot parse parameter 'RemoveBak'\n");
223         return -1;
224         }
225     }
226
227 pv.param = "ReadBak";
228 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
229 if (pvi == s.moduleParams.end() || pvi->value.empty())
230     {
231     readBak = false;
232     }
233 else
234     {
235     if (ParseYesNo(pvi->value[0], &readBak))
236         {
237         printfd(__FILE__, "Cannot parse parameter 'ReadBak'\n");
238         return -1;
239         }
240     }
241
242 pv.param = "WorkDir";
243 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
244 if (pvi == s.moduleParams.end() || pvi->value.empty())
245     {
246     errorStr = "Parameter \'WorkDir\' not found.";
247     printfd(__FILE__, "Parameter 'WorkDir' not found\n");
248     return -1;
249     }
250
251 workDir = pvi->value[0];
252 if (workDir.size() && workDir[workDir.size() - 1] == '/')
253     {
254     workDir.resize(workDir.size() - 1);
255     }
256 usersDir = workDir + "/users/";
257 if (!CheckAndCreate(usersDir, GetConfModeDir()))
258     {
259     errorStr = usersDir + " doesn't exist. Failed to create.";
260     printfd(__FILE__, "%s\n", errorStr.c_str());
261     return -1;
262     }
263 tariffsDir = workDir + "/tariffs/";
264 if (!CheckAndCreate(tariffsDir, GetConfModeDir()))
265     {
266     errorStr = tariffsDir + " doesn't exist. Failed to create.";
267     printfd(__FILE__, "%s\n", errorStr.c_str());
268     return -1;
269     }
270 adminsDir = workDir + "/admins/";
271 if (!CheckAndCreate(adminsDir, GetConfModeDir()))
272     {
273     errorStr = adminsDir + " doesn't exist. Failed to create.";
274     printfd(__FILE__, "%s\n", errorStr.c_str());
275     return -1;
276     }
277 servicesDir = workDir + "/services/";
278 if (!CheckAndCreate(servicesDir, GetConfModeDir()))
279     {
280     errorStr = servicesDir + " doesn't exist. Failed to create.";
281     printfd(__FILE__, "%s\n", errorStr.c_str());
282     return -1;
283     }
284
285 return 0;
286 }
287 //-----------------------------------------------------------------------------
288 const std::string & FILES_STORE_SETTINGS::GetStrError() const
289 {
290 return errorStr;
291 }
292 //-----------------------------------------------------------------------------
293 int FILES_STORE_SETTINGS::User2UID(const char * user, uid_t * uid)
294 {
295 struct passwd * pw;
296 pw = getpwnam(user);
297 if (!pw)
298     {
299     errorStr = std::string("User \'") + std::string(user) + std::string("\' not found in system.");
300     printfd(__FILE__, "%s\n", errorStr.c_str());
301     return -1;
302     }
303
304 *uid = pw->pw_uid;
305 return 0;
306 }
307 //-----------------------------------------------------------------------------
308 int FILES_STORE_SETTINGS::Group2GID(const char * gr, gid_t * gid)
309 {
310 struct group * grp;
311 grp = getgrnam(gr);
312 if (!grp)
313     {
314     errorStr = std::string("Group \'") + std::string(gr) + std::string("\' not found in system.");
315     printfd(__FILE__, "%s\n", errorStr.c_str());
316     return -1;
317     }
318
319 *gid = grp->gr_gid;
320 return 0;
321 }
322 //-----------------------------------------------------------------------------
323 int FILES_STORE_SETTINGS::Str2Mode(const char * str, mode_t * mode)
324 {
325 char a;
326 char b;
327 char c;
328 if (strlen(str) > 3)
329     {
330     errorStr = std::string("Error parsing mode \'") + str + std::string("\'");
331     printfd(__FILE__, "%s\n", errorStr.c_str());
332     return -1;
333     }
334
335 for (int i = 0; i < 3; i++)
336     if (str[i] > '7' || str[i] < '0')
337         {
338         errorStr = std::string("Error parsing mode \'") + str + std::string("\'");
339         printfd(__FILE__, "%s\n", errorStr.c_str());
340         return -1;
341         }
342
343 a = str[0] - '0';
344 b = str[1] - '0';
345 c = str[2] - '0';
346
347 *mode = ((mode_t)c) + ((mode_t)b << 3) + ((mode_t)a << 6);
348
349 return 0;
350 }
351 //-----------------------------------------------------------------------------
352 mode_t FILES_STORE_SETTINGS::GetStatModeDir() const
353 {
354 mode_t mode = statMode;
355 if (statMode & S_IRUSR) mode |= S_IXUSR;
356 if (statMode & S_IRGRP) mode |= S_IXGRP;
357 if (statMode & S_IROTH) mode |= S_IXOTH;
358 return mode;
359 }
360 //-----------------------------------------------------------------------------
361 mode_t FILES_STORE_SETTINGS::GetConfModeDir() const
362 {
363 mode_t mode = confMode;
364 if (confMode & S_IRUSR) mode |= S_IXUSR;
365 if (confMode & S_IRGRP) mode |= S_IXGRP;
366 if (confMode & S_IROTH) mode |= S_IXOTH;
367 return mode;
368 }
369 //-----------------------------------------------------------------------------
370 //-----------------------------------------------------------------------------
371 //-----------------------------------------------------------------------------
372 FILES_STORE::FILES_STORE()
373     : version("file_store v.1.04"),
374       logger(STG::PluginLogger::get("store_files"))
375 {
376 pthread_mutexattr_t attr;
377 pthread_mutexattr_init(&attr);
378 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
379 pthread_mutex_init(&mutex, &attr);
380 }
381 //-----------------------------------------------------------------------------
382 int FILES_STORE::ParseSettings()
383 {
384 int ret = storeSettings.ParseSettings(settings);
385 if (ret)
386     {
387     STG_LOCKER lock(&mutex);
388     errorStr = storeSettings.GetStrError();
389     }
390 return ret;
391 }
392 //-----------------------------------------------------------------------------
393 int FILES_STORE::GetUsersList(std::vector<std::string> * userList) const
394 {
395 std::vector<std::string> files;
396
397 if (GetFileList(&files, storeSettings.GetUsersDir(), S_IFDIR, ""))
398     {
399     STG_LOCKER lock(&mutex);
400     errorStr = "Failed to open '" + storeSettings.GetUsersDir() + "': " + std::string(strerror(errno));
401     return -1;
402     }
403
404 STG_LOCKER lock(&mutex);
405
406 userList->swap(files);
407
408 return 0;
409 }
410 //-----------------------------------------------------------------------------
411 int FILES_STORE::GetAdminsList(std::vector<std::string> * adminList) const
412 {
413 std::vector<std::string> files;
414
415 if (GetFileList(&files, storeSettings.GetAdminsDir(), S_IFREG, ".adm"))
416     {
417     STG_LOCKER lock(&mutex);
418     errorStr = "Failed to open '" + storeSettings.GetAdminsDir() + "': " + std::string(strerror(errno));
419     return -1;
420     }
421
422 STG_LOCKER lock(&mutex);
423
424 adminList->swap(files);
425
426 return 0;
427 }
428 //-----------------------------------------------------------------------------
429 int FILES_STORE::GetTariffsList(std::vector<std::string> * tariffList) const
430 {
431 std::vector<std::string> files;
432
433 if (GetFileList(&files, storeSettings.GetTariffsDir(), S_IFREG, ".tf"))
434     {
435     STG_LOCKER lock(&mutex);
436     errorStr = "Failed to open '" + storeSettings.GetTariffsDir() + "': " + std::string(strerror(errno));
437     return -1;
438     }
439
440 STG_LOCKER lock(&mutex);
441
442 tariffList->swap(files);
443
444 return 0;
445 }
446 //-----------------------------------------------------------------------------
447 int FILES_STORE::GetServicesList(std::vector<std::string> * list) const
448 {
449 std::vector<std::string> files;
450
451 if (GetFileList(&files, storeSettings.GetServicesDir(), S_IFREG, ".serv"))
452     {
453     STG_LOCKER lock(&mutex);
454     errorStr = "Failed to open '" + storeSettings.GetServicesDir() + "': " + std::string(strerror(errno));
455     return -1;
456     }
457
458 STG_LOCKER lock(&mutex);
459
460 list->swap(files);
461
462 return 0;
463 }
464 //-----------------------------------------------------------------------------
465 int FILES_STORE::RemoveDir(const char * path) const
466 {
467 DIR * d = opendir(path);
468
469 if (!d)
470     {
471     errorStr = "failed to open dir. Message: '";
472     errorStr += strerror(errno);
473     errorStr += "'";
474     printfd(__FILE__, "FILE_STORE::RemoveDir() - Failed to open dir '%s': '%s'\n", path, strerror(errno));
475     return -1;
476     }
477
478 dirent * entry;
479 while ((entry = readdir(d)))
480     {
481     if (!(strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")))
482         continue;
483
484     std::string str = path;
485     str += "/" + std::string(entry->d_name);
486
487     struct stat st;
488     if (stat(str.c_str(), &st))
489         continue;
490
491     if ((st.st_mode & S_IFREG))
492         {
493         if (unlink(str.c_str()))
494             {
495             STG_LOCKER lock(&mutex);
496             errorStr = "unlink failed. Message: '";
497             errorStr += strerror(errno);
498             errorStr += "'";
499             printfd(__FILE__, "FILES_STORE::RemoveDir() - unlink failed. Message: '%s'\n", strerror(errno));
500             closedir(d);
501             return -1;
502             }
503         }
504
505     if (!(st.st_mode & S_IFDIR))
506         {
507         if (RemoveDir(str.c_str()))
508             {
509             closedir(d);
510             return -1;
511             }
512
513         }
514     }
515
516 closedir(d);
517
518 if (rmdir(path))
519     {
520     STG_LOCKER lock(&mutex);
521     errorStr = "rmdir failed. Message: '";
522     errorStr += strerror(errno);
523     errorStr += "'";
524     printfd(__FILE__, "FILES_STORE::RemoveDir() - rmdir failed. Message: '%s'\n", strerror(errno));
525     return -1;
526     }
527
528 return 0;
529 }
530 //-----------------------------------------------------------------------------
531 int FILES_STORE::AddUser(const std::string & login) const
532 {
533 std::string fileName;
534
535 strprintf(&fileName, "%s%s", storeSettings.GetUsersDir().c_str(), login.c_str());
536
537 if (mkdir(fileName.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == -1)
538     {
539     STG_LOCKER lock(&mutex);
540     errorStr = std::string("mkdir failed. Message: '") + strerror(errno) + "'";
541     printfd(__FILE__, "FILES_STORE::AddUser - mkdir failed. Message: '%s'\n", strerror(errno));
542     return -1;
543     }
544
545 strprintf(&fileName, "%s%s/conf", storeSettings.GetUsersDir().c_str(), login.c_str());
546 if (Touch(fileName))
547     {
548     STG_LOCKER lock(&mutex);
549     errorStr = "Cannot create file \"" + fileName + "\'";
550     printfd(__FILE__, "FILES_STORE::AddUser - fopen failed. Message: '%s'\n", strerror(errno));
551     return -1;
552     }
553
554 strprintf(&fileName, "%s%s/stat", storeSettings.GetUsersDir().c_str(), login.c_str());
555 if (Touch(fileName))
556     {
557     STG_LOCKER lock(&mutex);
558     errorStr = "Cannot create file \"" + fileName + "\'";
559     printfd(__FILE__, "FILES_STORE::AddUser - fopen failed. Message: '%s'\n", strerror(errno));
560     return -1;
561     }
562 return 0;
563 }
564 //-----------------------------------------------------------------------------
565 int FILES_STORE::DelUser(const std::string & login) const
566 {
567 std::string dirName;
568 std::string dirName1;
569
570 strprintf(&dirName, "%s/%s", storeSettings.GetWorkDir().c_str(), DELETED_USERS_DIR);
571 if (access(dirName.c_str(), F_OK) != 0)
572     {
573     if (mkdir(dirName.c_str(), 0700) != 0)
574         {
575         STG_LOCKER lock(&mutex);
576         errorStr = "Directory '" + dirName + "' cannot be created.";
577         printfd(__FILE__, "FILES_STORE::DelUser - mkdir failed. Message: '%s'\n", strerror(errno));
578         return -1;
579         }
580     }
581
582 if (access(dirName.c_str(), F_OK) == 0)
583     {
584     strprintf(&dirName, "%s/%s/%s.%lu", storeSettings.GetWorkDir().c_str(), DELETED_USERS_DIR, login.c_str(), time(NULL));
585     strprintf(&dirName1, "%s/%s", storeSettings.GetUsersDir().c_str(), login.c_str());
586     if (rename(dirName1.c_str(), dirName.c_str()))
587         {
588         STG_LOCKER lock(&mutex);
589         errorStr = "Error moving dir from " + dirName1 + " to " + dirName;
590         printfd(__FILE__, "FILES_STORE::DelUser - rename failed. Message: '%s'\n", strerror(errno));
591         return -1;
592         }
593     }
594 else
595     {
596     strprintf(&dirName, "%s/%s", storeSettings.GetUsersDir().c_str(), login.c_str());
597     if (RemoveDir(dirName.c_str()))
598         {
599         return -1;
600         }
601     }
602 return 0;
603 }
604 //-----------------------------------------------------------------------------
605 int FILES_STORE::RestoreUserConf(STG::UserConf * conf, const std::string & login) const
606 {
607 std::string fileName;
608 fileName = storeSettings.GetUsersDir() + "/" + login + "/conf";
609 if (RestoreUserConf(conf, login, fileName))
610     {
611     if (!storeSettings.GetReadBak())
612         {
613         return -1;
614         }
615     return RestoreUserConf(conf, login, fileName + ".bak");
616     }
617 return 0;
618 }
619 //-----------------------------------------------------------------------------
620 int FILES_STORE::RestoreUserConf(STG::UserConf * conf, const std::string & login, const std::string & fileName) const
621 {
622 CONFIGFILE cf(fileName);
623 int e = cf.Error();
624
625 if (e)
626     {
627     STG_LOCKER lock(&mutex);
628     errorStr = "User \'" + login + "\' data not read.";
629     printfd(__FILE__, "FILES_STORE::RestoreUserConf - conf read failed for user '%s'\n", login.c_str());
630     return -1;
631     }
632
633 if (cf.ReadString("Password", &conf->password, "") < 0)
634     {
635     STG_LOCKER lock(&mutex);
636     errorStr = "User \'" + login + "\' data not read. Parameter Password.";
637     printfd(__FILE__, "FILES_STORE::RestoreUserConf - password read failed for user '%s'\n", login.c_str());
638     return -1;
639     }
640 if (conf->password.empty())
641     {
642     STG_LOCKER lock(&mutex);
643     errorStr = "User \'" + login + "\' password is blank.";
644     printfd(__FILE__, "FILES_STORE::RestoreUserConf - password is blank for user '%s'\n", login.c_str());
645     return -1;
646     }
647
648 if (cf.ReadString("tariff", &conf->tariffName, "") < 0)
649     {
650     STG_LOCKER lock(&mutex);
651     errorStr = "User \'" + login + "\' data not read. Parameter Tariff.";
652     printfd(__FILE__, "FILES_STORE::RestoreUserConf - tariff read failed for user '%s'\n", login.c_str());
653     return -1;
654     }
655 if (conf->tariffName.empty())
656     {
657     STG_LOCKER lock(&mutex);
658     errorStr = "User \'" + login + "\' tariff is blank.";
659     printfd(__FILE__, "FILES_STORE::RestoreUserConf - tariff is blank for user '%s'\n", login.c_str());
660     return -1;
661     }
662
663 std::string ipStr;
664 cf.ReadString("IP", &ipStr, "?");
665 try
666     {
667     conf->ips = STG::UserIPs::parse(ipStr);
668     }
669 catch (const std::string & s)
670     {
671     STG_LOCKER lock(&mutex);
672     errorStr = "User \'" + login + "\' data not read. Parameter IP address. " + s;
673     printfd(__FILE__, "FILES_STORE::RestoreUserConf - ip read failed for user '%s'\n", login.c_str());
674     return -1;
675     }
676
677 if (cf.ReadInt("alwaysOnline", &conf->alwaysOnline, 0) != 0)
678     {
679     STG_LOCKER lock(&mutex);
680     errorStr = "User \'" + login + "\' data not read. Parameter AlwaysOnline.";
681     printfd(__FILE__, "FILES_STORE::RestoreUserConf - alwaysonline read failed for user '%s'\n", login.c_str());
682     return -1;
683     }
684
685 if (cf.ReadInt("down", &conf->disabled, 0) != 0)
686     {
687     STG_LOCKER lock(&mutex);
688     errorStr = "User \'" + login + "\' data not read. Parameter Down.";
689     printfd(__FILE__, "FILES_STORE::RestoreUserConf - down read failed for user '%s'\n", login.c_str());
690     return -1;
691     }
692
693 if (cf.ReadInt("passive", &conf->passive, 0) != 0)
694     {
695     STG_LOCKER lock(&mutex);
696     errorStr = "User \'" + login + "\' data not read. Parameter Passive.";
697     printfd(__FILE__, "FILES_STORE::RestoreUserConf - passive read failed for user '%s'\n", login.c_str());
698     return -1;
699     }
700
701 cf.ReadInt("DisabledDetailStat", &conf->disabledDetailStat, 0);
702 cf.ReadTime("CreditExpire", &conf->creditExpire, 0);
703 cf.ReadString("TariffChange", &conf->nextTariff, "");
704 cf.ReadString("Group", &conf->group, "");
705 cf.ReadString("RealName", &conf->realName, "");
706 cf.ReadString("Address", &conf->address, "");
707 cf.ReadString("Phone", &conf->phone, "");
708 cf.ReadString("Note", &conf->note, "");
709 cf.ReadString("email", &conf->email, "");
710
711 char userdataName[12];
712 for (int i = 0; i < USERDATA_NUM; i++)
713     {
714     snprintf(userdataName, 12, "Userdata%d", i);
715     cf.ReadString(userdataName, &conf->userdata[i], "");
716     }
717
718 if (cf.ReadDouble("Credit", &conf->credit, 0) != 0)
719     {
720     STG_LOCKER lock(&mutex);
721     errorStr = "User \'" + login + "\' data not read. Parameter Credit.";
722     printfd(__FILE__, "FILES_STORE::RestoreUserConf - credit read failed for user '%s'\n", login.c_str());
723     return -1;
724     }
725
726 return 0;
727 }
728 //-----------------------------------------------------------------------------
729 int FILES_STORE::RestoreUserStat(STG::UserStat * stat, const std::string & login) const
730 {
731 std::string fileName;
732 fileName = storeSettings.GetUsersDir() + "/" + login + "/stat";
733
734 if (RestoreUserStat(stat, login, fileName))
735     {
736     if (!storeSettings.GetReadBak())
737         {
738         return -1;
739         }
740     return RestoreUserStat(stat, login, fileName + ".bak");
741     }
742 return 0;
743 }
744 //-----------------------------------------------------------------------------
745 int FILES_STORE::RestoreUserStat(STG::UserStat * stat, const std::string & login, const std::string & fileName) const
746 {
747 CONFIGFILE cf(fileName);
748
749 int e = cf.Error();
750
751 if (e)
752     {
753     STG_LOCKER lock(&mutex);
754     errorStr = "User \'" + login + "\' stat not read. Cannot open file " + fileName + ".";
755     printfd(__FILE__, "FILES_STORE::RestoreUserStat - stat read failed for user '%s'\n", login.c_str());
756     return -1;
757     }
758
759 char s[22];
760
761 for (int i = 0; i < DIR_NUM; i++)
762     {
763     uint64_t traff;
764     snprintf(s, 22, "D%d", i);
765     if (cf.ReadULongLongInt(s, &traff, 0) != 0)
766         {
767         STG_LOCKER lock(&mutex);
768         errorStr = "User \'" + login + "\' stat not read. Parameter " + std::string(s);
769         printfd(__FILE__, "FILES_STORE::RestoreUserStat - download stat read failed for user '%s'\n", login.c_str());
770         return -1;
771         }
772     stat->monthDown[i] = traff;
773
774     snprintf(s, 22, "U%d", i);
775     if (cf.ReadULongLongInt(s, &traff, 0) != 0)
776         {
777         STG_LOCKER lock(&mutex);
778         errorStr =   "User \'" + login + "\' stat not read. Parameter " + std::string(s);
779         printfd(__FILE__, "FILES_STORE::RestoreUserStat - upload stat read failed for user '%s'\n", login.c_str());
780         return -1;
781         }
782     stat->monthUp[i] = traff;
783     }
784
785 if (cf.ReadDouble("Cash", &stat->cash, 0) != 0)
786     {
787     STG_LOCKER lock(&mutex);
788     errorStr =   "User \'" + login + "\' stat not read. Parameter Cash";
789     printfd(__FILE__, "FILES_STORE::RestoreUserStat - cash read failed for user '%s'\n", login.c_str());
790     return -1;
791     }
792
793 if (cf.ReadDouble("FreeMb", &stat->freeMb, 0) != 0)
794     {
795     STG_LOCKER lock(&mutex);
796     errorStr =   "User \'" + login + "\' stat not read. Parameter FreeMb";
797     printfd(__FILE__, "FILES_STORE::RestoreUserStat - freemb read failed for user '%s'\n", login.c_str());
798     return -1;
799     }
800
801 if (cf.ReadTime("LastCashAddTime", &stat->lastCashAddTime, 0) != 0)
802     {
803     STG_LOCKER lock(&mutex);
804     errorStr =   "User \'" + login + "\' stat not read. Parameter LastCashAddTime";
805     printfd(__FILE__, "FILES_STORE::RestoreUserStat - lastcashaddtime read failed for user '%s'\n", login.c_str());
806     return -1;
807     }
808
809 if (cf.ReadTime("PassiveTime", &stat->passiveTime, 0) != 0)
810     {
811     STG_LOCKER lock(&mutex);
812     errorStr =   "User \'" + login + "\' stat not read. Parameter PassiveTime";
813     printfd(__FILE__, "FILES_STORE::RestoreUserStat - passivetime read failed for user '%s'\n", login.c_str());
814     return -1;
815     }
816
817 if (cf.ReadDouble("LastCashAdd", &stat->lastCashAdd, 0) != 0)
818     {
819     STG_LOCKER lock(&mutex);
820     errorStr =   "User \'" + login + "\' stat not read. Parameter LastCashAdd";
821     printfd(__FILE__, "FILES_STORE::RestoreUserStat - lastcashadd read failed for user '%s'\n", login.c_str());
822     return -1;
823     }
824
825 if (cf.ReadTime("LastActivityTime", &stat->lastActivityTime, 0) != 0)
826     {
827     STG_LOCKER lock(&mutex);
828     errorStr =   "User \'" + login + "\' stat not read. Parameter LastActivityTime";
829     printfd(__FILE__, "FILES_STORE::RestoreUserStat - lastactivitytime read failed for user '%s'\n", login.c_str());
830     return -1;
831     }
832
833 return 0;
834 }
835 //-----------------------------------------------------------------------------
836 int FILES_STORE::SaveUserConf(const STG::UserConf & conf, const std::string & login) const
837 {
838 std::string fileName;
839 fileName = storeSettings.GetUsersDir() + "/" + login + "/conf";
840
841 CONFIGFILE cfstat(fileName, true);
842
843 int e = cfstat.Error();
844
845 if (e)
846     {
847     STG_LOCKER lock(&mutex);
848     errorStr = std::string("User \'") + login + "\' conf not written\n";
849     printfd(__FILE__, "FILES_STORE::SaveUserConf - conf write failed for user '%s'\n", login.c_str());
850     return -1;
851     }
852
853 e = chmod(fileName.c_str(), storeSettings.GetConfMode());
854 e += chown(fileName.c_str(), storeSettings.GetConfUID(), storeSettings.GetConfGID());
855
856 if (e)
857     {
858     STG_LOCKER lock(&mutex);
859     printfd(__FILE__, "FILES_STORE::SaveUserConf - chmod/chown failed for user '%s'. Error: '%s'\n", login.c_str(), strerror(errno));
860     }
861
862 cfstat.WriteString("Password",     conf.password);
863 cfstat.WriteInt   ("Passive",      conf.passive);
864 cfstat.WriteInt   ("Down",         conf.disabled);
865 cfstat.WriteInt("DisabledDetailStat", conf.disabledDetailStat);
866 cfstat.WriteInt   ("AlwaysOnline", conf.alwaysOnline);
867 cfstat.WriteString("Tariff",       conf.tariffName);
868 cfstat.WriteString("Address",      conf.address);
869 cfstat.WriteString("Phone",        conf.phone);
870 cfstat.WriteString("Email",        conf.email);
871 cfstat.WriteString("Note",         conf.note);
872 cfstat.WriteString("RealName",     conf.realName);
873 cfstat.WriteString("Group",        conf.group);
874 cfstat.WriteDouble("Credit",       conf.credit);
875 cfstat.WriteString("TariffChange", conf.nextTariff);
876
877 char userdataName[12];
878 for (int i = 0; i < USERDATA_NUM; i++)
879     {
880     snprintf(userdataName, 12, "Userdata%d", i);
881     cfstat.WriteString(userdataName, conf.userdata[i]);
882     }
883 cfstat.WriteInt("CreditExpire",    conf.creditExpire);
884
885 std::ostringstream ipStr;
886 ipStr << conf.ips;
887 cfstat.WriteString("IP", ipStr.str());
888
889 return 0;
890 }
891 //-----------------------------------------------------------------------------
892 int FILES_STORE::SaveUserStat(const STG::UserStat & stat, const std::string & login) const
893 {
894 std::string fileName;
895 fileName = storeSettings.GetUsersDir() + "/" + login + "/stat";
896
897     {
898     CONFIGFILE cfstat(fileName, true);
899     int e = cfstat.Error();
900
901     if (e)
902         {
903         STG_LOCKER lock(&mutex);
904         errorStr = std::string("User \'") + login + "\' stat not written\n";
905         printfd(__FILE__, "FILES_STORE::SaveUserStat - stat write failed for user '%s'\n", login.c_str());
906         return -1;
907         }
908
909     for (int i = 0; i < DIR_NUM; i++)
910         {
911         char s[22];
912         snprintf(s, 22, "D%d", i);
913         cfstat.WriteInt(s, stat.monthDown[i]);
914         snprintf(s, 22, "U%d", i);
915         cfstat.WriteInt(s, stat.monthUp[i]);
916         }
917
918     cfstat.WriteDouble("Cash", stat.cash);
919     cfstat.WriteDouble("FreeMb", stat.freeMb);
920     cfstat.WriteDouble("LastCashAdd", stat.lastCashAdd);
921     cfstat.WriteInt("LastCashAddTime", stat.lastCashAddTime);
922     cfstat.WriteInt("PassiveTime", stat.passiveTime);
923     cfstat.WriteInt("LastActivityTime", stat.lastActivityTime);
924     }
925
926 int e = chmod(fileName.c_str(), storeSettings.GetStatMode());
927 e += chown(fileName.c_str(), storeSettings.GetStatUID(), storeSettings.GetStatGID());
928
929 if (e)
930     {
931     STG_LOCKER lock(&mutex);
932     printfd(__FILE__, "FILES_STORE::SaveUserStat - chmod/chown failed for user '%s'. Error: '%s'\n", login.c_str(), strerror(errno));
933     }
934
935 return 0;
936 }
937 //-----------------------------------------------------------------------------
938 int FILES_STORE::WriteLogString(const std::string & str, const std::string & login) const
939 {
940 FILE * f;
941 time_t tm = time(NULL);
942 std::string fileName;
943 fileName = storeSettings.GetUsersDir() + "/" + login + "/log";
944 f = fopen(fileName.c_str(), "at");
945
946 if (f)
947     {
948     fprintf(f, "%s", LogDate(tm));
949     fprintf(f, " -- ");
950     fprintf(f, "%s", str.c_str());
951     fprintf(f, "\n");
952     fclose(f);
953     }
954 else
955     {
956     STG_LOCKER lock(&mutex);
957     errorStr = "Cannot open \'" + fileName + "\'";
958     printfd(__FILE__, "FILES_STORE::WriteLogString - log write failed for user '%s'\n", login.c_str());
959     return -1;
960     }
961
962 int e = chmod(fileName.c_str(), storeSettings.GetLogMode());
963 e += chown(fileName.c_str(), storeSettings.GetLogUID(), storeSettings.GetLogGID());
964
965 if (e)
966     {
967     STG_LOCKER lock(&mutex);
968     printfd(__FILE__, "FILES_STORE::WriteLogString - chmod/chown failed for user '%s'. Error: '%s'\n", login.c_str(), strerror(errno));
969     }
970
971 return 0;
972 }
973 //-----------------------------------------------------------------------------
974 int FILES_STORE::WriteLog2String(const std::string & str, const std::string & login) const
975 {
976 FILE * f;
977 time_t tm = time(NULL);
978 std::string fileName;
979 fileName = storeSettings.GetUsersDir() + "/" + login + "/log2";
980 f = fopen(fileName.c_str(), "at");
981
982 if (f)
983     {
984     fprintf(f, "%s", LogDate(tm));
985     fprintf(f, " -- ");
986     fprintf(f, "%s", str.c_str());
987     fprintf(f, "\n");
988     fclose(f);
989     }
990 else
991     {
992     STG_LOCKER lock(&mutex);
993     errorStr = "Cannot open \'" + fileName + "\'";
994     printfd(__FILE__, "FILES_STORE::WriteLogString - log write failed for user '%s'\n", login.c_str());
995     return -1;
996     }
997
998 int e = chmod(fileName.c_str(), storeSettings.GetLogMode());
999 e += chown(fileName.c_str(), storeSettings.GetLogUID(), storeSettings.GetLogGID());
1000
1001 if (e)
1002     {
1003     STG_LOCKER lock(&mutex);
1004     printfd(__FILE__, "FILES_STORE::WriteLogString - chmod/chown failed for user '%s'. Error: '%s'\n", login.c_str(), strerror(errno));
1005     }
1006
1007 return 0;
1008 }
1009 //-----------------------------------------------------------------------------
1010 int FILES_STORE::WriteUserChgLog(const std::string & login,
1011                                  const std::string & admLogin,
1012                                  uint32_t       admIP,
1013                                  const std::string & paramName,
1014                                  const std::string & oldValue,
1015                                  const std::string & newValue,
1016                                  const std::string & message) const
1017 {
1018 std::string userLogMsg = "Admin \'" + admLogin + "\', " + inet_ntostring(admIP) + ": \'"
1019     + paramName + "\' parameter changed from \'" + oldValue +
1020     "\' to \'" + newValue + "\'. " + message;
1021
1022 return WriteLogString(userLogMsg, login);
1023 }
1024 //-----------------------------------------------------------------------------
1025 int FILES_STORE::WriteUserConnect(const std::string & login, uint32_t ip) const
1026 {
1027 std::string logStr = "Connect, " + inet_ntostring(ip);
1028 if (WriteLogString(logStr, login))
1029     return -1;
1030 return WriteLog2String(logStr, login);
1031 }
1032 //-----------------------------------------------------------------------------
1033 int FILES_STORE::WriteUserDisconnect(const std::string & login,
1034                                      const STG::DirTraff & monthUp,
1035                                      const STG::DirTraff & monthDown,
1036                                      const STG::DirTraff & sessionUp,
1037                                      const STG::DirTraff & sessionDown,
1038                                      double cash,
1039                                      double freeMb,
1040                                      const std::string & reason) const
1041 {
1042 std::ostringstream logStr;
1043 logStr << "Disconnect, "
1044        << " session upload: \'"
1045        << sessionUp
1046        << "\' session download: \'"
1047        << sessionDown
1048        << "\' month upload: \'"
1049        << monthUp
1050        << "\' month download: \'"
1051        << monthDown
1052        << "\' cash: \'"
1053        << cash
1054        << "\'";
1055
1056 if (WriteLogString(logStr.str(), login))
1057     return -1;
1058
1059 logStr << " freeMb: \'"
1060        << freeMb
1061        << "\'"
1062        << " reason: \'"
1063        << reason
1064        << "\'";
1065
1066 return WriteLog2String(logStr.str(), login);
1067 }
1068 //-----------------------------------------------------------------------------
1069 int FILES_STORE::SaveMonthStat(const STG::UserStat & stat, int month, int year, const std::string & login) const
1070 {
1071 // Classic stats
1072 std::string stat1;
1073 strprintf(&stat1,"%s/%s/stat.%d.%02d",
1074         storeSettings.GetUsersDir().c_str(), login.c_str(), year + 1900, month + 1);
1075
1076 CONFIGFILE s(stat1, true);
1077
1078 if (s.Error())
1079     {
1080     STG_LOCKER lock(&mutex);
1081     errorStr = "Cannot create file '" + stat1 + "'";
1082     printfd(__FILE__, "FILES_STORE::SaveMonthStat - month stat write failed for user '%s'\n", login.c_str());
1083     return -1;
1084     }
1085
1086 // New stats
1087 std::string stat2;
1088 strprintf(&stat2,"%s/%s/stat2.%d.%02d",
1089         storeSettings.GetUsersDir().c_str(), login.c_str(), year + 1900, month + 1);
1090
1091 CONFIGFILE s2(stat2, true);
1092
1093 if (s2.Error())
1094     {
1095     STG_LOCKER lock(&mutex);
1096     errorStr = "Cannot create file '" + stat2 + "'";
1097     printfd(__FILE__, "FILES_STORE::SaveMonthStat - month stat write failed for user '%s'\n", login.c_str());
1098     return -1;
1099     }
1100
1101 for (size_t i = 0; i < DIR_NUM; i++)
1102     {
1103     char dirName[3];
1104     snprintf(dirName, 3, "U%llu", (unsigned long long)i);
1105     s.WriteInt(dirName, stat.monthUp[i]); // Classic
1106     s2.WriteInt(dirName, stat.monthUp[i]); // New
1107     snprintf(dirName, 3, "D%llu", (unsigned long long)i);
1108     s.WriteInt(dirName, stat.monthDown[i]); // Classic
1109     s2.WriteInt(dirName, stat.monthDown[i]); // New
1110     }
1111
1112 // Classic
1113 s.WriteDouble("cash", stat.cash);
1114
1115 // New
1116 s2.WriteDouble("Cash", stat.cash);
1117 s2.WriteDouble("FreeMb", stat.freeMb);
1118 s2.WriteDouble("LastCashAdd", stat.lastCashAdd);
1119 s2.WriteInt("LastCashAddTime", stat.lastCashAddTime);
1120 s2.WriteInt("PassiveTime", stat.passiveTime);
1121 s2.WriteInt("LastActivityTime", stat.lastActivityTime);
1122
1123 return 0;
1124 }
1125 //-----------------------------------------------------------------------------*/
1126 int FILES_STORE::AddAdmin(const std::string & login) const
1127 {
1128 std::string fileName;
1129 strprintf(&fileName, "%s/%s.adm", storeSettings.GetAdminsDir().c_str(), login.c_str());
1130
1131 if (Touch(fileName))
1132     {
1133     STG_LOCKER lock(&mutex);
1134     errorStr = "Cannot create file " + fileName;
1135     printfd(__FILE__, "FILES_STORE::AddAdmin - failed to add admin '%s'\n", login.c_str());
1136     return -1;
1137     }
1138
1139 return 0;
1140 }
1141 //-----------------------------------------------------------------------------*/
1142 int FILES_STORE::DelAdmin(const std::string & login) const
1143 {
1144 std::string fileName;
1145 strprintf(&fileName, "%s/%s.adm", storeSettings.GetAdminsDir().c_str(), login.c_str());
1146 if (unlink(fileName.c_str()))
1147     {
1148     STG_LOCKER lock(&mutex);
1149     errorStr = "unlink failed. Message: '";
1150     errorStr += strerror(errno);
1151     errorStr += "'";
1152     printfd(__FILE__, "FILES_STORE::DelAdmin - unlink failed. Message: '%s'\n", strerror(errno));
1153     }
1154 return 0;
1155 }
1156 //-----------------------------------------------------------------------------*/
1157 int FILES_STORE::SaveAdmin(const STG::AdminConf & ac) const
1158 {
1159 std::string fileName;
1160
1161 strprintf(&fileName, "%s/%s.adm", storeSettings.GetAdminsDir().c_str(), ac.login.c_str());
1162
1163     {
1164     CONFIGFILE cf(fileName, true);
1165
1166     int e = cf.Error();
1167
1168     if (e)
1169         {
1170         STG_LOCKER lock(&mutex);
1171         errorStr = "Cannot write admin " + ac.login + ". " + fileName;
1172         printfd(__FILE__, "FILES_STORE::SaveAdmin - failed to save admin '%s'\n", ac.login.c_str());
1173         return -1;
1174         }
1175
1176     char pass[ADM_PASSWD_LEN + 1];
1177     memset(pass, 0, sizeof(pass));
1178
1179     char adminPass[ADM_PASSWD_LEN + 1];
1180     memset(adminPass, 0, sizeof(adminPass));
1181
1182     BLOWFISH_CTX ctx;
1183     InitContext(adm_enc_passwd, strlen(adm_enc_passwd), &ctx);
1184
1185     strncpy(adminPass, ac.password.c_str(), ADM_PASSWD_LEN);
1186     adminPass[ADM_PASSWD_LEN - 1] = 0;
1187
1188     for (int i = 0; i < ADM_PASSWD_LEN/8; i++)
1189         {
1190         EncryptBlock(pass + 8*i, adminPass + 8*i, &ctx);
1191         }
1192
1193     pass[ADM_PASSWD_LEN - 1] = 0;
1194     char passwordE[2 * ADM_PASSWD_LEN + 2];
1195     Encode12(passwordE, pass, ADM_PASSWD_LEN);
1196
1197     cf.WriteString("password", passwordE);
1198     cf.WriteInt("ChgConf",     ac.priv.userConf);
1199     cf.WriteInt("ChgPassword", ac.priv.userPasswd);
1200     cf.WriteInt("ChgStat",     ac.priv.userStat);
1201     cf.WriteInt("ChgCash",     ac.priv.userCash);
1202     cf.WriteInt("UsrAddDel",   ac.priv.userAddDel);
1203     cf.WriteInt("ChgTariff",   ac.priv.tariffChg);
1204     cf.WriteInt("ChgAdmin",    ac.priv.adminChg);
1205     cf.WriteInt("ChgService",  ac.priv.serviceChg);
1206     cf.WriteInt("ChgCorp",     ac.priv.corpChg);
1207     }
1208
1209 return 0;
1210 }
1211 //-----------------------------------------------------------------------------
1212 int FILES_STORE::RestoreAdmin(STG::AdminConf * ac, const std::string & login) const
1213 {
1214 std::string fileName;
1215 strprintf(&fileName, "%s/%s.adm", storeSettings.GetAdminsDir().c_str(), login.c_str());
1216 CONFIGFILE cf(fileName);
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 std::string p;
1223
1224 if (cf.Error())
1225     {
1226     STG_LOCKER lock(&mutex);
1227     errorStr = "Cannot open " + fileName;
1228     printfd(__FILE__, "FILES_STORE::RestoreAdmin - failed to restore admin '%s'\n", ac->login.c_str());
1229     return -1;
1230     }
1231
1232 if (cf.ReadString("password", &p, "*"))
1233     {
1234     STG_LOCKER lock(&mutex);
1235     errorStr = "Error in parameter password";
1236     printfd(__FILE__, "FILES_STORE::RestoreAdmin - password read failed for admin '%s'\n", ac->login.c_str());
1237     return -1;
1238     }
1239
1240 memset(passwordE, 0, sizeof(passwordE));
1241 strncpy(passwordE, p.c_str(), 2*ADM_PASSWD_LEN);
1242
1243 memset(pass, 0, sizeof(pass));
1244
1245 if (passwordE[0] != 0)
1246     {
1247     Decode21(pass, passwordE);
1248     InitContext(adm_enc_passwd, strlen(adm_enc_passwd), &ctx);
1249
1250     for (int i = 0; i < ADM_PASSWD_LEN/8; i++)
1251         {
1252         DecryptBlock(password + 8*i, pass + 8*i, &ctx);
1253         }
1254     }
1255 else
1256     {
1257     password[0] = 0;
1258     }
1259
1260 ac->password = password;
1261
1262 uint16_t a;
1263
1264 if (cf.ReadUShortInt("ChgConf", &a, 0) == 0)
1265     ac->priv.userConf = a;
1266 else
1267     {
1268     STG_LOCKER lock(&mutex);
1269     errorStr = "Error in parameter ChgConf";
1270     printfd(__FILE__, "FILES_STORE::RestoreAdmin - chgconf read failed for admin '%s'\n", ac->login.c_str());
1271     return -1;
1272     }
1273
1274 if (cf.ReadUShortInt("ChgPassword", &a, 0) == 0)
1275     ac->priv.userPasswd = a;
1276 else
1277     {
1278     STG_LOCKER lock(&mutex);
1279     errorStr = "Error in parameter ChgPassword";
1280     printfd(__FILE__, "FILES_STORE::RestoreAdmin - chgpassword read failed for admin '%s'\n", ac->login.c_str());
1281     return -1;
1282     }
1283
1284 if (cf.ReadUShortInt("ChgStat", &a, 0) == 0)
1285     ac->priv.userStat = a;
1286 else
1287     {
1288     STG_LOCKER lock(&mutex);
1289     errorStr = "Error in parameter ChgStat";
1290     printfd(__FILE__, "FILES_STORE::RestoreAdmin - chgstat read failed for admin '%s'\n", ac->login.c_str());
1291     return -1;
1292     }
1293
1294 if (cf.ReadUShortInt("ChgCash", &a, 0) == 0)
1295     ac->priv.userCash = a;
1296 else
1297     {
1298     STG_LOCKER lock(&mutex);
1299     errorStr = "Error in parameter ChgCash";
1300     printfd(__FILE__, "FILES_STORE::RestoreAdmin - chgcash read failed for admin '%s'\n", ac->login.c_str());
1301     return -1;
1302     }
1303
1304 if (cf.ReadUShortInt("UsrAddDel", &a, 0) == 0)
1305     ac->priv.userAddDel = a;
1306 else
1307     {
1308     STG_LOCKER lock(&mutex);
1309     errorStr = "Error in parameter UsrAddDel";
1310     printfd(__FILE__, "FILES_STORE::RestoreAdmin - usradddel read failed for admin '%s'\n", ac->login.c_str());
1311     return -1;
1312     }
1313
1314 if (cf.ReadUShortInt("ChgAdmin", &a, 0) == 0)
1315     ac->priv.adminChg = a;
1316 else
1317     {
1318     STG_LOCKER lock(&mutex);
1319     errorStr = "Error in parameter ChgAdmin";
1320     printfd(__FILE__, "FILES_STORE::RestoreAdmin - chgadmin read failed for admin '%s'\n", ac->login.c_str());
1321     return -1;
1322     }
1323
1324 if (cf.ReadUShortInt("ChgTariff", &a, 0) == 0)
1325     ac->priv.tariffChg = a;
1326 else
1327     {
1328     STG_LOCKER lock(&mutex);
1329     errorStr = "Error in parameter ChgTariff";
1330     printfd(__FILE__, "FILES_STORE::RestoreAdmin - chgtariff read failed for admin '%s'\n", ac->login.c_str());
1331     return -1;
1332     }
1333
1334 if (cf.ReadUShortInt("ChgService", &a, 0) == 0)
1335     ac->priv.serviceChg = a;
1336 else
1337     ac->priv.serviceChg = 0;
1338
1339 if (cf.ReadUShortInt("ChgCorp", &a, 0) == 0)
1340     ac->priv.corpChg = a;
1341 else
1342     ac->priv.corpChg = 0;
1343
1344 return 0;
1345 }
1346 //-----------------------------------------------------------------------------
1347 int FILES_STORE::AddTariff(const std::string & name) const
1348 {
1349 std::string fileName;
1350 strprintf(&fileName, "%s/%s.tf", storeSettings.GetTariffsDir().c_str(), name.c_str());
1351 if (Touch(fileName))
1352     {
1353     STG_LOCKER lock(&mutex);
1354     errorStr = "Cannot create file " + fileName;
1355     printfd(__FILE__, "FILES_STORE::AddTariff - failed to add tariff '%s'\n", name.c_str());
1356     return -1;
1357     }
1358 return 0;
1359 }
1360 //-----------------------------------------------------------------------------
1361 int FILES_STORE::DelTariff(const std::string & name) const
1362 {
1363 std::string fileName;
1364 strprintf(&fileName, "%s/%s.tf", storeSettings.GetTariffsDir().c_str(), name.c_str());
1365 if (unlink(fileName.c_str()))
1366     {
1367     STG_LOCKER lock(&mutex);
1368     errorStr = "unlink failed. Message: '";
1369     errorStr += strerror(errno);
1370     errorStr += "'";
1371     printfd(__FILE__, "FILES_STORE::DelTariff - unlink failed. Message: '%s'\n", strerror(errno));
1372     }
1373 return 0;
1374 }
1375 //-----------------------------------------------------------------------------
1376 int FILES_STORE::RestoreTariff(STG::TariffData * td, const std::string & tariffName) const
1377 {
1378 std::string fileName = storeSettings.GetTariffsDir() + "/" + tariffName + ".tf";
1379 CONFIGFILE conf(fileName);
1380 std::string str;
1381 td->tariffConf.name = tariffName;
1382
1383 if (conf.Error() != 0)
1384     {
1385     STG_LOCKER lock(&mutex);
1386     errorStr = "Cannot read file " + fileName;
1387     printfd(__FILE__, "FILES_STORE::RestoreTariff - failed to read tariff '%s'\n", tariffName.c_str());
1388     return -1;
1389     }
1390
1391 std::string param;
1392 for (int i = 0; i<DIR_NUM; i++)
1393     {
1394     strprintf(&param, "Time%d", i);
1395     if (conf.ReadString(param, &str, "00:00-00:00") < 0)
1396         {
1397         STG_LOCKER lock(&mutex);
1398         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1399         printfd(__FILE__, "FILES_STORE::RestoreTariff - time%d read failed for tariff '%s'\n", i, tariffName.c_str());
1400         return -1;
1401         }
1402
1403     ParseTariffTimeStr(str.c_str(),
1404                        td->dirPrice[i].hDay,
1405                        td->dirPrice[i].mDay,
1406                        td->dirPrice[i].hNight,
1407                        td->dirPrice[i].mNight);
1408
1409     strprintf(&param, "PriceDayA%d", i);
1410     if (conf.ReadDouble(param, &td->dirPrice[i].priceDayA, 0.0) < 0)
1411         {
1412         STG_LOCKER lock(&mutex);
1413         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1414         printfd(__FILE__, "FILES_STORE::RestoreTariff - pricedaya read failed for tariff '%s'\n", tariffName.c_str());
1415         return -1;
1416         }
1417     td->dirPrice[i].priceDayA /= (1024*1024);
1418
1419     strprintf(&param, "PriceDayB%d", i);
1420     if (conf.ReadDouble(param, &td->dirPrice[i].priceDayB, 0.0) < 0)
1421         {
1422         STG_LOCKER lock(&mutex);
1423         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1424         printfd(__FILE__, "FILES_STORE::RestoreTariff - pricedayb read failed for tariff '%s'\n", tariffName.c_str());
1425         return -1;
1426         }
1427     td->dirPrice[i].priceDayB /= (1024*1024);
1428
1429     strprintf(&param, "PriceNightA%d", i);
1430     if (conf.ReadDouble(param, &td->dirPrice[i].priceNightA, 0.0) < 0)
1431         {
1432         STG_LOCKER lock(&mutex);
1433         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1434         printfd(__FILE__, "FILES_STORE::RestoreTariff - pricenighta read failed for tariff '%s'\n", tariffName.c_str());
1435         return -1;
1436         }
1437     td->dirPrice[i].priceNightA /= (1024*1024);
1438
1439     strprintf(&param, "PriceNightB%d", i);
1440     if (conf.ReadDouble(param, &td->dirPrice[i].priceNightB, 0.0) < 0)
1441         {
1442         STG_LOCKER lock(&mutex);
1443         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1444         printfd(__FILE__, "FILES_STORE::RestoreTariff - pricenightb read failed for tariff '%s'\n", tariffName.c_str());
1445         return -1;
1446         }
1447     td->dirPrice[i].priceNightB /= (1024*1024);
1448
1449     strprintf(&param, "Threshold%d", i);
1450     if (conf.ReadInt(param, &td->dirPrice[i].threshold, 0) < 0)
1451         {
1452         STG_LOCKER lock(&mutex);
1453         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1454         printfd(__FILE__, "FILES_STORE::RestoreTariff - threshold read failed for tariff '%s'\n", tariffName.c_str());
1455         return -1;
1456         }
1457
1458     strprintf(&param, "SinglePrice%d", i);
1459     if (conf.ReadInt(param, &td->dirPrice[i].singlePrice, 0) < 0)
1460         {
1461         STG_LOCKER lock(&mutex);
1462         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1463         printfd(__FILE__, "FILES_STORE::RestoreTariff - singleprice read failed for tariff '%s'\n", tariffName.c_str());
1464         return -1;
1465         }
1466
1467     strprintf(&param, "NoDiscount%d", i);
1468     if (conf.ReadInt(param, &td->dirPrice[i].noDiscount, 0) < 0)
1469         {
1470         STG_LOCKER lock(&mutex);
1471         errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
1472         printfd(__FILE__, "FILES_STORE::RestoreTariff - nodiscount read failed for tariff '%s'\n", tariffName.c_str());
1473         return -1;
1474         }
1475     }
1476
1477 if (conf.ReadDouble("Fee", &td->tariffConf.fee, 0) < 0)
1478     {
1479     STG_LOCKER lock(&mutex);
1480     errorStr = "Cannot read tariff " + tariffName + ". Parameter Fee";
1481     printfd(__FILE__, "FILES_STORE::RestoreTariff - fee read failed for tariff '%s'\n", tariffName.c_str());
1482     return -1;
1483     }
1484
1485 if (conf.ReadDouble("Free", &td->tariffConf.free, 0) < 0)
1486     {
1487     STG_LOCKER lock(&mutex);
1488     errorStr = "Cannot read tariff " + tariffName + ". Parameter Free";
1489     printfd(__FILE__, "FILES_STORE::RestoreTariff - free read failed for tariff '%s'\n", tariffName.c_str());
1490     return -1;
1491     }
1492
1493 if (conf.ReadDouble("PassiveCost", &td->tariffConf.passiveCost, 0) < 0)
1494     {
1495     STG_LOCKER lock(&mutex);
1496     errorStr = "Cannot read tariff " + tariffName + ". Parameter PassiveCost";
1497     printfd(__FILE__, "FILES_STORE::RestoreTariff - passivecost read failed for tariff '%s'\n", tariffName.c_str());
1498     return -1;
1499     }
1500
1501 if (conf.ReadString("TraffType", &str, "") < 0)
1502     {
1503     STG_LOCKER lock(&mutex);
1504     errorStr = "Cannot read tariff " + tariffName + ". Parameter TraffType";
1505     printfd(__FILE__, "FILES_STORE::RestoreTariff - trafftype read failed for tariff '%s'\n", tariffName.c_str());
1506     return -1;
1507     }
1508
1509 td->tariffConf.traffType = STG::Tariff::parseTraffType(str);
1510
1511 if (conf.ReadString("Period", &str, "month") < 0)
1512     td->tariffConf.period = STG::Tariff::MONTH;
1513 else
1514     td->tariffConf.period = STG::Tariff::parsePeriod(str);
1515
1516 if (conf.ReadString("ChangePolicy", &str, "allow") < 0)
1517     td->tariffConf.changePolicy = STG::Tariff::ALLOW;
1518 else
1519     td->tariffConf.changePolicy = STG::Tariff::parseChangePolicy(str);
1520
1521 conf.ReadTime("ChangePolicyTimeout", &td->tariffConf.changePolicyTimeout, 0);
1522 return 0;
1523 }
1524 //-----------------------------------------------------------------------------
1525 int FILES_STORE::SaveTariff(const STG::TariffData & td, const std::string & tariffName) const
1526 {
1527 std::string fileName = storeSettings.GetTariffsDir() + "/" + tariffName + ".tf";
1528
1529     {
1530     CONFIGFILE cf(fileName, true);
1531
1532     int e = cf.Error();
1533
1534     if (e)
1535         {
1536         STG_LOCKER lock(&mutex);
1537         errorStr = "Error writing tariff " + tariffName;
1538         printfd(__FILE__, "FILES_STORE::RestoreTariff - failed to save tariff '%s'\n", tariffName.c_str());
1539         return e;
1540         }
1541
1542     std::string param;
1543     for (int i = 0; i < DIR_NUM; i++)
1544         {
1545         strprintf(&param, "PriceDayA%d", i);
1546         cf.WriteDouble(param, td.dirPrice[i].priceDayA * pt_mega);
1547
1548         strprintf(&param, "PriceDayB%d", i);
1549         cf.WriteDouble(param, td.dirPrice[i].priceDayB * pt_mega);
1550
1551         strprintf(&param, "PriceNightA%d", i);
1552         cf.WriteDouble(param, td.dirPrice[i].priceNightA * pt_mega);
1553
1554         strprintf(&param, "PriceNightB%d", i);
1555         cf.WriteDouble(param, td.dirPrice[i].priceNightB * pt_mega);
1556
1557         strprintf(&param, "Threshold%d", i);
1558         cf.WriteInt(param, td.dirPrice[i].threshold);
1559
1560         std::string s;
1561         strprintf(&param, "Time%d", i);
1562
1563         strprintf(&s, "%0d:%0d-%0d:%0d",
1564                 td.dirPrice[i].hDay,
1565                 td.dirPrice[i].mDay,
1566                 td.dirPrice[i].hNight,
1567                 td.dirPrice[i].mNight);
1568
1569         cf.WriteString(param, s);
1570
1571         strprintf(&param, "NoDiscount%d", i);
1572         cf.WriteInt(param, td.dirPrice[i].noDiscount);
1573
1574         strprintf(&param, "SinglePrice%d", i);
1575         cf.WriteInt(param, td.dirPrice[i].singlePrice);
1576         }
1577
1578     cf.WriteDouble("PassiveCost", td.tariffConf.passiveCost);
1579     cf.WriteDouble("Fee", td.tariffConf.fee);
1580     cf.WriteDouble("Free", td.tariffConf.free);
1581     cf.WriteString("TraffType", STG::Tariff::toString(td.tariffConf.traffType));
1582     cf.WriteString("Period", STG::Tariff::toString(td.tariffConf.period));
1583     cf.WriteString("ChangePolicy", STG::Tariff::toString(td.tariffConf.changePolicy));
1584     cf.WriteTime("ChangePolicyTimeout", td.tariffConf.changePolicyTimeout);
1585     }
1586
1587 return 0;
1588 }
1589 //-----------------------------------------------------------------------------*/
1590 int FILES_STORE::AddService(const std::string & name) const
1591 {
1592 std::string fileName;
1593 strprintf(&fileName, "%s/%s.serv", storeSettings.GetServicesDir().c_str(), name.c_str());
1594
1595 if (Touch(fileName))
1596     {
1597     STG_LOCKER lock(&mutex);
1598     errorStr = "Cannot create file " + fileName;
1599     printfd(__FILE__, "FILES_STORE::AddService - failed to add service '%s'\n", name.c_str());
1600     return -1;
1601     }
1602
1603 return 0;
1604 }
1605 //-----------------------------------------------------------------------------*/
1606 int FILES_STORE::DelService(const std::string & name) const
1607 {
1608 std::string fileName;
1609 strprintf(&fileName, "%s/%s.serv", storeSettings.GetServicesDir().c_str(), name.c_str());
1610 if (unlink(fileName.c_str()))
1611     {
1612     STG_LOCKER lock(&mutex);
1613     errorStr = "unlink failed. Message: '";
1614     errorStr += strerror(errno);
1615     errorStr += "'";
1616     printfd(__FILE__, "FILES_STORE::DelAdmin - unlink failed. Message: '%s'\n", strerror(errno));
1617     }
1618 return 0;
1619 }
1620 //-----------------------------------------------------------------------------*/
1621 int FILES_STORE::SaveService(const STG::ServiceConf & conf) const
1622 {
1623 std::string fileName;
1624
1625 strprintf(&fileName, "%s/%s.serv", storeSettings.GetServicesDir().c_str(), conf.name.c_str());
1626
1627     {
1628     CONFIGFILE cf(fileName, true);
1629
1630     int e = cf.Error();
1631
1632     if (e)
1633         {
1634         STG_LOCKER lock(&mutex);
1635         errorStr = "Cannot write service " + conf.name + ". " + fileName;
1636         printfd(__FILE__, "FILES_STORE::SaveService - failed to save service '%s'\n", conf.name.c_str());
1637         return -1;
1638         }
1639
1640     cf.WriteString("name", conf.name);
1641     cf.WriteString("comment", conf.comment);
1642     cf.WriteDouble("cost", conf.cost);
1643     cf.WriteInt("pay_day", conf.payDay);
1644     }
1645
1646 return 0;
1647 }
1648 //-----------------------------------------------------------------------------
1649 int FILES_STORE::RestoreService(STG::ServiceConf * conf, const std::string & name) const
1650 {
1651 std::string fileName;
1652 strprintf(&fileName, "%s/%s.serv", storeSettings.GetServicesDir().c_str(), name.c_str());
1653 CONFIGFILE cf(fileName);
1654
1655 if (cf.Error())
1656     {
1657     STG_LOCKER lock(&mutex);
1658     errorStr = "Cannot open " + fileName;
1659     printfd(__FILE__, "FILES_STORE::RestoreService - failed to restore service '%s'\n", name.c_str());
1660     return -1;
1661     }
1662
1663 if (cf.ReadString("name", &conf->name, name))
1664     {
1665     STG_LOCKER lock(&mutex);
1666     errorStr = "Error in parameter 'name'";
1667     printfd(__FILE__, "FILES_STORE::RestoreService - name read failed for service '%s'\n", name.c_str());
1668     return -1;
1669     }
1670
1671 if (cf.ReadString("comment", &conf->comment, ""))
1672     {
1673     STG_LOCKER lock(&mutex);
1674     errorStr = "Error in parameter 'comment'";
1675     printfd(__FILE__, "FILES_STORE::RestoreService - comment read failed for service '%s'\n", name.c_str());
1676     return -1;
1677     }
1678
1679 if (cf.ReadDouble("cost", &conf->cost, 0.0))
1680     {
1681     STG_LOCKER lock(&mutex);
1682     errorStr = "Error in parameter 'cost'";
1683     printfd(__FILE__, "FILES_STORE::RestoreService - cost read failed for service '%s'\n", name.c_str());
1684     return -1;
1685     }
1686
1687 unsigned short value = 0;
1688 if (cf.ReadUShortInt("pay_day", &value, 0))
1689     {
1690     STG_LOCKER lock(&mutex);
1691     errorStr = "Error in parameter 'pay_day'";
1692     printfd(__FILE__, "FILES_STORE::RestoreService - pay day read failed for service '%s'\n", name.c_str());
1693     return -1;
1694     }
1695 conf->payDay = value;
1696
1697 return 0;
1698 }
1699 //-----------------------------------------------------------------------------
1700 int FILES_STORE::WriteDetailedStat(const STG::TraffStat & statTree,
1701                                    time_t lastStat,
1702                                    const std::string & login) const
1703 {
1704 char fn[FN_STR_LEN];
1705 char dn[FN_STR_LEN];
1706 FILE * statFile;
1707 time_t t;
1708 tm * lt;
1709
1710 t = time(NULL);
1711
1712 snprintf(dn, FN_STR_LEN, "%s/%s/detail_stat", storeSettings.GetUsersDir().c_str(), login.c_str());
1713 if (access(dn, F_OK) != 0)
1714     {
1715     if (mkdir(dn, 0700) != 0)
1716         {
1717         STG_LOCKER lock(&mutex);
1718         errorStr = "Directory \'" + std::string(dn) + "\' cannot be created.";
1719         printfd(__FILE__, "FILES_STORE::WriteDetailStat - mkdir failed. Message: '%s'\n", strerror(errno));
1720         return -1;
1721         }
1722     }
1723
1724 int e = chown(dn, storeSettings.GetStatUID(), storeSettings.GetStatGID());
1725 e += chmod(dn, storeSettings.GetStatModeDir());
1726
1727 if (e)
1728     {
1729     STG_LOCKER lock(&mutex);
1730     printfd(__FILE__, "FILES_STORE::WriteDetailStat - chmod/chown failed for user '%s'. Error: '%s'\n", login.c_str(), strerror(errno));
1731     }
1732
1733 lt = localtime(&t);
1734
1735 if (lt->tm_hour == 0 && lt->tm_min <= 5)
1736     {
1737     t -= 3600 * 24;
1738     lt = localtime(&t);
1739     }
1740
1741 snprintf(dn, FN_STR_LEN, "%s/%s/detail_stat/%d",
1742          storeSettings.GetUsersDir().c_str(),
1743          login.c_str(),
1744          lt->tm_year+1900);
1745
1746 if (access(dn, F_OK) != 0)
1747     {
1748     if (mkdir(dn, 0700) != 0)
1749         {
1750         STG_LOCKER lock(&mutex);
1751         errorStr = "Directory \'" + std::string(dn) + "\' cannot be created.";
1752         printfd(__FILE__, "FILES_STORE::WriteDetailStat - mkdir failed. Message: '%s'\n", strerror(errno));
1753         return -1;
1754         }
1755     }
1756
1757 e = chown(dn, storeSettings.GetStatUID(), storeSettings.GetStatGID());
1758 e += chmod(dn, storeSettings.GetStatModeDir());
1759
1760 if (e)
1761     {
1762     STG_LOCKER lock(&mutex);
1763     printfd(__FILE__, "FILES_STORE::WriteDetailStat - chmod/chown failed for user '%s'. Error: '%s'\n", login.c_str(), strerror(errno));
1764     }
1765
1766 snprintf(dn, FN_STR_LEN, "%s/%s/detail_stat/%d/%s%d", 
1767          storeSettings.GetUsersDir().c_str(),
1768          login.c_str(),
1769          lt->tm_year+1900,
1770          lt->tm_mon+1 < 10 ? "0" : "",
1771          lt->tm_mon+1);
1772 if (access(dn, F_OK) != 0)
1773     {
1774     if (mkdir(dn, 0700) != 0)
1775         {
1776         STG_LOCKER lock(&mutex);
1777         errorStr = "Directory \'" + std::string(dn) + "\' cannot be created.";
1778         printfd(__FILE__, "FILES_STORE::WriteDetailStat - mkdir failed. Message: '%s'\n", strerror(errno));
1779         return -1;
1780         }
1781     }
1782
1783 e = chown(dn, storeSettings.GetStatUID(), storeSettings.GetStatGID());
1784 e += chmod(dn, storeSettings.GetStatModeDir());
1785
1786 if (e)
1787     {
1788     STG_LOCKER lock(&mutex);
1789     printfd(__FILE__, "FILES_STORE::WriteDetailStat - chmod/chown failed for user '%s'. Error: '%s'\n", login.c_str(), strerror(errno));
1790     }
1791
1792 snprintf(fn, FN_STR_LEN, "%s/%s%d", dn, lt->tm_mday < 10 ? "0" : "", lt->tm_mday);
1793
1794 statFile = fopen (fn, "at");
1795
1796 if (!statFile)
1797     {
1798     STG_LOCKER lock(&mutex);
1799     errorStr = "File \'" + std::string(fn) + "\' cannot be written.";
1800     printfd(__FILE__, "FILES_STORE::WriteDetailStat - fopen failed. Message: '%s'\n", strerror(errno));
1801     return -1;
1802     }
1803
1804 struct tm * lt1;
1805 struct tm * lt2;
1806
1807 lt1 = localtime(&lastStat);
1808
1809 int h1, m1, s1;
1810 int h2, m2, s2;
1811
1812 h1 = lt1->tm_hour;
1813 m1 = lt1->tm_min;
1814 s1 = lt1->tm_sec;
1815
1816 lt2 = localtime(&t);
1817
1818 h2 = lt2->tm_hour;
1819 m2 = lt2->tm_min;
1820 s2 = lt2->tm_sec;
1821
1822 if (fprintf(statFile, "-> %02d.%02d.%02d - %02d.%02d.%02d\n",
1823             h1, m1, s1, h2, m2, s2) < 0)
1824     {
1825     STG_LOCKER lock(&mutex);
1826     errorStr = std::string("fprint failed. Message: '") + strerror(errno) + "'";
1827     printfd(__FILE__, "FILES_STORE::WriteDetailStat - fprintf failed. Message: '%s'\n", strerror(errno));
1828     fclose(statFile);
1829     return -1;
1830     }
1831
1832 auto stIter = statTree.begin();
1833
1834 while (stIter != statTree.end())
1835     {
1836     const auto u = std::to_string(stIter->second.up);
1837     const auto d = std::to_string(stIter->second.down);
1838     #ifdef TRAFF_STAT_WITH_PORTS
1839     if (fprintf(statFile, "%17s:%hu\t%15d\t%15s\t%15s\t%f\n",
1840                 inet_ntostring(stIter->first.ip).c_str(),
1841                 stIter->first.port,
1842                 stIter->first.dir,
1843                 d.c_str(),
1844                 u.c_str(),
1845                 stIter->second.cash) < 0)
1846         {
1847         STG_LOCKER lock(&mutex);
1848         errorStr = "fprint failed. Message: '";
1849         errorStr += strerror(errno);
1850         errorStr += "'";
1851         printfd(__FILE__, "FILES_STORE::WriteDetailStat - fprintf failed. Message: '%s'\n", strerror(errno));
1852         fclose(statFile);
1853         return -1;
1854         }
1855     #else
1856     if (fprintf(statFile, "%17s\t%15d\t%15s\t%15s\t%f\n",
1857                 inet_ntostring(stIter->first.ip).c_str(),
1858                 stIter->first.dir,
1859                 d.c_str(),
1860                 u.c_str(),
1861                 stIter->second.cash) < 0)
1862         {
1863         STG_LOCKER lock(&mutex);
1864         errorStr = std::string("fprint failed. Message: '");
1865         errorStr += strerror(errno);
1866         errorStr += "'";
1867         printfd(__FILE__, "FILES_STORE::WriteDetailStat - fprintf failed. Message: '%s'\n", strerror(errno));
1868         fclose(statFile);
1869         return -1;
1870         }
1871     #endif
1872
1873     ++stIter;
1874     }
1875
1876 fclose(statFile);
1877
1878 e = chown(fn, storeSettings.GetStatUID(), storeSettings.GetStatGID());
1879 e += chmod(fn, storeSettings.GetStatMode());
1880
1881 if (e)
1882     {
1883     STG_LOCKER lock(&mutex);
1884     printfd(__FILE__, "FILES_STORE::WriteDetailStat - chmod/chown failed for user '%s'. Error: '%s'\n", login.c_str(), strerror(errno));
1885     }
1886
1887 return 0;
1888 }
1889 //-----------------------------------------------------------------------------
1890 int FILES_STORE::AddMessage(STG::Message * msg, const std::string & login) const
1891 {
1892 std::string fn;
1893 std::string dn;
1894 struct timeval tv;
1895
1896 strprintf(&dn, "%s/%s/messages", storeSettings.GetUsersDir().c_str(), login.c_str());
1897 if (access(dn.c_str(), F_OK) != 0)
1898     {
1899     if (mkdir(dn.c_str(), 0700) != 0)
1900         {
1901         STG_LOCKER lock(&mutex);
1902         errorStr = "Directory \'";
1903         errorStr += dn;
1904         errorStr += "\' cannot be created.";
1905         printfd(__FILE__, "FILES_STORE::AddMessage - mkdir failed. Message: '%s'\n", strerror(errno));
1906         return -1;
1907         }
1908     }
1909
1910 chmod(dn.c_str(), storeSettings.GetConfModeDir());
1911
1912 gettimeofday(&tv, NULL);
1913
1914 msg->header.id = ((long long)tv.tv_sec) * 1000000 + ((long long)tv.tv_usec);
1915 strprintf(&fn, "%s/%lld", dn.c_str(), msg->header.id);
1916
1917 if (Touch(fn))
1918     {
1919     STG_LOCKER lock(&mutex);
1920     errorStr = "File \'";
1921     errorStr += fn;
1922     errorStr += "\' cannot be writen.";
1923     printfd(__FILE__, "FILES_STORE::AddMessage - fopen failed. Message: '%s'\n", strerror(errno));
1924     return -1;
1925     }
1926
1927 return EditMessage(*msg, login);
1928 }
1929 //-----------------------------------------------------------------------------
1930 int FILES_STORE::EditMessage(const STG::Message & msg, const std::string & login) const
1931 {
1932 std::string fileName;
1933
1934 FILE * msgFile;
1935 strprintf(&fileName, "%s/%s/messages/%lld", storeSettings.GetUsersDir().c_str(), login.c_str(), msg.header.id);
1936
1937 if (access(fileName.c_str(), F_OK) != 0)
1938     {
1939     STG_LOCKER lock(&mutex);
1940     errorStr = "Message for user \'";
1941     errorStr += login + "\' with ID \'";
1942     errorStr += std::to_string(msg.header.id) + "\' does not exist.";
1943     printfd(__FILE__, "FILES_STORE::EditMessage - %s\n", errorStr.c_str());
1944     return -1;
1945     }
1946
1947 Touch(fileName + ".new");
1948
1949 msgFile = fopen((fileName + ".new").c_str(), "wt");
1950 if (!msgFile)
1951     {
1952     STG_LOCKER lock(&mutex);
1953     errorStr = "File \'" + fileName + "\' cannot be writen.";
1954     printfd(__FILE__, "FILES_STORE::EditMessage - fopen failed. Message: '%s'\n", strerror(errno));
1955     return -1;
1956     }
1957
1958 bool res = true;
1959 res &= (fprintf(msgFile, "%u\n", msg.header.type) >= 0);
1960 res &= (fprintf(msgFile, "%u\n", msg.header.lastSendTime) >= 0);
1961 res &= (fprintf(msgFile, "%u\n", msg.header.creationTime) >= 0);
1962 res &= (fprintf(msgFile, "%u\n", msg.header.showTime) >= 0);
1963 res &= (fprintf(msgFile, "%d\n", msg.header.repeat) >= 0);
1964 res &= (fprintf(msgFile, "%u\n", msg.header.repeatPeriod) >= 0);
1965 res &= (fprintf(msgFile, "%s", msg.text.c_str()) >= 0);
1966
1967 if (!res)
1968     {
1969     STG_LOCKER lock(&mutex);
1970     errorStr = std::string("fprintf failed. Message: '") + strerror(errno) + "'";
1971     printfd(__FILE__, "FILES_STORE::EditMessage - fprintf failed. Message: '%s'\n", strerror(errno));
1972     fclose(msgFile);
1973     return -1;
1974     }
1975
1976 fclose(msgFile);
1977
1978 chmod((fileName + ".new").c_str(), storeSettings.GetConfMode());
1979
1980 if (rename((fileName + ".new").c_str(), fileName.c_str()) < 0)
1981     {
1982     STG_LOCKER lock(&mutex);
1983     errorStr = "Error moving dir from " + fileName + ".new to " + fileName;
1984     printfd(__FILE__, "FILES_STORE::EditMessage - rename failed. Message: '%s'\n", strerror(errno));
1985     return -1;
1986     }
1987
1988 return 0;
1989 }
1990 //-----------------------------------------------------------------------------
1991 int FILES_STORE::GetMessage(uint64_t id, STG::Message * msg, const std::string & login) const
1992 {
1993 std::string fn;
1994 strprintf(&fn, "%s/%s/messages/%lld", storeSettings.GetUsersDir().c_str(), login.c_str(), id);
1995 msg->header.id = id;
1996 return ReadMessage(fn, &msg->header, &msg->text);
1997 }
1998 //-----------------------------------------------------------------------------
1999 int FILES_STORE::DelMessage(uint64_t id, const std::string & login) const
2000 {
2001 std::string fn;
2002 strprintf(&fn, "%s/%s/messages/%lld", storeSettings.GetUsersDir().c_str(), login.c_str(), id);
2003
2004 return unlink(fn.c_str());
2005 }
2006 //-----------------------------------------------------------------------------
2007 int FILES_STORE::GetMessageHdrs(std::vector<STG::Message::Header> * hdrsList, const std::string & login) const
2008 {
2009 std::string dn(storeSettings.GetUsersDir() + "/" + login + "/messages/");
2010
2011 if (access(dn.c_str(), F_OK) != 0)
2012     {
2013     return 0;
2014     }
2015
2016 std::vector<std::string> messages;
2017 GetFileList(&messages, dn, S_IFREG, "");
2018
2019 for (unsigned i = 0; i < messages.size(); i++)
2020     {
2021     unsigned long long id = 0;
2022
2023     if (str2x(messages[i].c_str(), id))
2024         {
2025         if (unlink((dn + messages[i]).c_str()))
2026             {
2027             STG_LOCKER lock(&mutex);
2028             errorStr = std::string("unlink failed. Message: '") + strerror(errno) + "'";
2029             printfd(__FILE__, "FILES_STORE::GetMessageHdrs - unlink failed. Message: '%s'\n", strerror(errno));
2030             return -1;
2031             }
2032         continue;
2033         }
2034
2035     STG::Message::Header hdr;
2036     if (ReadMessage(dn + messages[i], &hdr, NULL))
2037         {
2038         return -1;
2039         }
2040
2041     if (hdr.repeat < 0)
2042         {
2043         if (unlink((dn + messages[i]).c_str()))
2044             {
2045             STG_LOCKER lock(&mutex);
2046             errorStr = std::string("unlink failed. Message: '") + strerror(errno) + "'";
2047             printfd(__FILE__, "FILES_STORE::GetMessageHdrs - unlink failed. Message: '%s'\n", strerror(errno));
2048             return -1;
2049             }
2050         continue;
2051         }
2052
2053     hdr.id = id;
2054     hdrsList->push_back(hdr);
2055     }
2056 return 0;
2057 }
2058 //-----------------------------------------------------------------------------
2059 int FILES_STORE::ReadMessage(const std::string & fileName,
2060                              STG::Message::Header * hdr,
2061                              std::string * text) const
2062 {
2063 FILE * msgFile;
2064 msgFile = fopen(fileName.c_str(), "rt");
2065 if (!msgFile)
2066     {
2067     STG_LOCKER lock(&mutex);
2068     errorStr = "File \'";
2069     errorStr += fileName;
2070     errorStr += "\' cannot be openned.";
2071     printfd(__FILE__, "FILES_STORE::ReadMessage - fopen failed. Message: '%s'\n", strerror(errno));
2072     return -1;
2073     }
2074 char p[20];
2075 unsigned * d[6];
2076 d[0] = &hdr->type;
2077 d[1] = &hdr->lastSendTime;
2078 d[2] = &hdr->creationTime;
2079 d[3] = &hdr->showTime;
2080 d[4] = (unsigned*)(&hdr->repeat);
2081 d[5] = &hdr->repeatPeriod;
2082
2083 memset(p, 0, sizeof(p));
2084
2085 for (int pos = 0; pos < 6; pos++)
2086     {
2087     if (fgets(p, sizeof(p) - 1, msgFile) == NULL) {
2088         STG_LOCKER lock(&mutex);
2089         errorStr = "Cannot read file \'";
2090         errorStr += fileName;
2091         errorStr += "\'. Missing data.";
2092         printfd(__FILE__, "FILES_STORE::ReadMessage - cannot read file (missing data)\n");
2093         printfd(__FILE__, "FILES_STORE::ReadMessage - position: %d\n", pos);
2094         fclose(msgFile);
2095         return -1;
2096     }
2097
2098     char * ep;
2099     ep = strrchr(p, '\r');
2100     if (ep) *ep = 0;
2101     ep = strrchr(p, '\n');
2102     if (ep) *ep = 0;
2103
2104     if (feof(msgFile))
2105         {
2106         STG_LOCKER lock(&mutex);
2107         errorStr = "Cannot read file \'";
2108         errorStr += fileName;
2109         errorStr += "\'. Missing data.";
2110         printfd(__FILE__, "FILES_STORE::ReadMessage - cannot read file (feof)\n");
2111         printfd(__FILE__, "FILES_STORE::ReadMessage - position: %d\n", pos);
2112         fclose(msgFile);
2113         return -1;
2114         }
2115
2116     if (str2x(p, *(d[pos])))
2117         {
2118         STG_LOCKER lock(&mutex);
2119         errorStr = "Cannot read file \'";
2120         errorStr += fileName;
2121         errorStr += "\'. Incorrect value. \'";
2122         errorStr += p;
2123         errorStr += "\'";
2124         printfd(__FILE__, "FILES_STORE::ReadMessage - incorrect value\n");
2125         fclose(msgFile);
2126         return -1;
2127         }
2128     }
2129
2130 char txt[2048];
2131 memset(txt, 0, sizeof(txt));
2132 if (text)
2133     {
2134     text->erase(text->begin(), text->end());
2135     while (!feof(msgFile))
2136         {
2137         txt[0] = 0;
2138         if (fgets(txt, sizeof(txt) - 1, msgFile) == NULL) {
2139             break;
2140         }
2141
2142         (*text) += txt;
2143         }
2144     }
2145 fclose(msgFile);
2146 return 0;
2147 }
2148 //-----------------------------------------------------------------------------
2149 int FILES_STORE::Touch(const std::string & path) const
2150 {
2151 FILE * f = fopen(path.c_str(), "wb");
2152 if (f)
2153     {
2154     fclose(f);
2155     return 0;
2156     }
2157 return -1;
2158 }
2159 //-----------------------------------------------------------------------------
2160 int GetFileList(std::vector<std::string> * fileList, const std::string & directory, mode_t mode, const std::string & ext)
2161 {
2162 DIR * d = opendir(directory.c_str());
2163
2164 if (!d)
2165     {
2166     printfd(__FILE__, "GetFileList - Failed to open dir '%s': '%s'\n", directory.c_str(), strerror(errno));
2167     return -1;
2168     }
2169
2170 dirent * entry;
2171 while ((entry = readdir(d)))
2172     {
2173     if (!(strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")))
2174         continue;
2175
2176     std::string str = directory + "/" + std::string(entry->d_name);
2177
2178     struct stat st;
2179     if (stat(str.c_str(), &st))
2180         continue;
2181
2182     if (!(st.st_mode & mode)) // Filter by mode
2183         continue;
2184
2185     if (!ext.empty())
2186         {
2187         // Check extension
2188         size_t d_nameLen = strlen(entry->d_name);
2189         if (d_nameLen <= ext.size())
2190             continue;
2191
2192         if (ext == entry->d_name + (d_nameLen - ext.size()))
2193             {
2194             entry->d_name[d_nameLen - ext.size()] = 0;
2195             fileList->push_back(entry->d_name);
2196             }
2197         }
2198     else
2199         {
2200         fileList->push_back(entry->d_name);
2201         }
2202     }
2203
2204 closedir(d);
2205
2206 return 0;
2207 }
2208 //-----------------------------------------------------------------------------