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