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