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