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