projects/stargazer/plugins/configuration/sgconfig/parser.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 #include "parser.h"
  22
  23 #include "stg/tariffs.h"
  24 #include "stg/admin.h"
  25 #include "stg/users.h"
  26 #include "stg/user_property.h"
  27 #include "stg/settings.h"
  28 #include "stg/logger.h"
  29 #include "stg/version.h"
  30 #include "stg/store.h"
  31
  32 #include <cstring>
  33 #include <cstdio> // sprintf
  34
  35 #include <sys/utsname.h>
  36
  37 #define  UNAME_LEN      (256)
  38
  39 namespace
  40 {
  41
  42 std::string UserToXML(const USER & user, bool loginInStart, bool showPass, time_t lastTime = 0)
  43 {
  44 std::string answer;
  45
  46 if (loginInStart)
  47     answer += "<User result=\"ok\">";
  48 else
  49     answer += "<User result=\"ok\" login=\"" + user.GetLogin() + "\">";
  50
  51 answer += "<Login value=\"" + user.GetLogin() + "\"/>";
  52
  53 if (user.GetProperty().password.ModificationTime() > lastTime)
  54     {
  55     if (showPass)
  56         answer += "<Password value=\"" + user.GetProperty().password.Get() + "\" />";
  57     else
  58         answer += "<Password value=\"++++++\"/>";
  59     }
  60
  61 if (user.GetProperty().cash.ModificationTime() > lastTime)
  62     answer += "<Cash value=\"" + x2str(user.GetProperty().cash.Get()) + "\"/>";
  63 if (user.GetProperty().freeMb.ModificationTime() > lastTime)
  64     answer += "<FreeMb value=\"" + x2str(user.GetProperty().freeMb.Get()) + "\"/>";
  65 if (user.GetProperty().credit.ModificationTime() > lastTime)
  66     answer += "<Credit value=\"" + x2str(user.GetProperty().credit.Get()) + "\"/>";
  67
  68 if (user.GetProperty().nextTariff.Get() != "")
  69     {
  70     if (user.GetProperty().tariffName.ModificationTime() > lastTime ||
  71         user.GetProperty().nextTariff.ModificationTime() > lastTime)
  72         answer += "<Tariff value=\"" + user.GetProperty().tariffName.Get() + "/" + user.GetProperty().nextTariff.Get() + "\"/>";
  73     }
  74 else
  75     {
  76     if (user.GetProperty().tariffName.ModificationTime() > lastTime)
  77         answer += "<Tariff value=\"" + user.GetProperty().tariffName.Get() + "\"/>";
  78     }
  79
  80 if (user.GetProperty().note.ModificationTime() > lastTime)
  81     answer += "<Note value=\"" + Encode12str(user.GetProperty().note) + "\"/>";
  82 if (user.GetProperty().phone.ModificationTime() > lastTime)
  83     answer += "<Phone value=\"" + Encode12str(user.GetProperty().phone) + "\"/>";
  84 if (user.GetProperty().address.ModificationTime() > lastTime)
  85     answer += "<Address value=\"" + Encode12str(user.GetProperty().address) + "\"/>";
  86 if (user.GetProperty().email.ModificationTime() > lastTime)
  87     answer += "<Email value=\"" + Encode12str(user.GetProperty().email) + "\"/>";
  88
  89 std::vector<const USER_PROPERTY_LOGGED<std::string> *> userdata;
  90 userdata.push_back(user.GetProperty().userdata0.GetPointer());
  91 userdata.push_back(user.GetProperty().userdata1.GetPointer());
  92 userdata.push_back(user.GetProperty().userdata2.GetPointer());
  93 userdata.push_back(user.GetProperty().userdata3.GetPointer());
  94 userdata.push_back(user.GetProperty().userdata4.GetPointer());
  95 userdata.push_back(user.GetProperty().userdata5.GetPointer());
  96 userdata.push_back(user.GetProperty().userdata6.GetPointer());
  97 userdata.push_back(user.GetProperty().userdata7.GetPointer());
  98 userdata.push_back(user.GetProperty().userdata8.GetPointer());
  99 userdata.push_back(user.GetProperty().userdata9.GetPointer());
 100
 101 for (size_t i = 0; i < userdata.size(); i++)
 102     if (userdata[i]->ModificationTime() > lastTime)
 103         answer += "<UserData" + x2str(i) + " value=\"" + Encode12str(userdata[i]->Get()) + "\" />";
 104
 105 if (user.GetProperty().realName.ModificationTime() > lastTime)
 106     answer += "<Name value=\"" + Encode12str(user.GetProperty().realName) + "\"/>";
 107 if (user.GetProperty().group.ModificationTime() > lastTime)
 108     answer += "<Group value=\"" + Encode12str(user.GetProperty().group) + "\"/>";
 109 if (user.GetConnectedModificationTime() > lastTime)
 110     answer += std::string("<Status value=\"") + (user.GetConnected() ? "1" : "0") + "\"/>";
 111 if (user.GetProperty().alwaysOnline.ModificationTime() > lastTime)
 112     answer += std::string("<AOnline value=\"") + (user.GetProperty().alwaysOnline.Get() ? "1" : "0") + "\"/>";
 113 if (user.GetCurrIPModificationTime() > lastTime)
 114     answer += "<CurrIP value=\"" + inet_ntostring(user.GetCurrIP()) + "\"/>";
 115 if (user.GetPingTime() > lastTime)
 116     answer += "<PingTime value=\"" + x2str(user.GetPingTime()) + "\"/>";
 117 if (user.GetProperty().ips.ModificationTime() > lastTime)
 118     answer += "<IP value=\"" + user.GetProperty().ips.Get().GetIpStr() + "\"/>";
 119
 120 answer += "<Traff";
 121 const DIR_TRAFF & upload(user.GetProperty().down.Get());
 122 const DIR_TRAFF & download(user.GetProperty().up.Get());
 123 if (user.GetProperty().up.ModificationTime() > lastTime)
 124     for (size_t j = 0; j < DIR_NUM; j++)
 125         answer += " MU" + x2str(j) + "=\"" + x2str(upload[j]) + "\"";
 126 if (user.GetProperty().down.ModificationTime() > lastTime)
 127     for (size_t j = 0; j < DIR_NUM; j++)
 128         answer += " MD" + x2str(j) + "=\"" + x2str(download[j]) + "\"";
 129 if (user.GetSessionUploadModificationTime() > lastTime)
 130     for (size_t j = 0; j < DIR_NUM; j++)
 131         answer += " SU" + x2str(j) + "=\"" + x2str(user.GetSessionUpload()[j]) + "\"";
 132 if (user.GetSessionDownloadModificationTime() > lastTime)
 133     for (size_t j = 0; j < DIR_NUM; j++)
 134         answer += " SD" + x2str(j) + "=\"" + x2str(user.GetSessionDownload()[j]) + "\"";
 135 answer += "/>";
 136
 137 if (user.GetProperty().disabled.ModificationTime() > lastTime)
 138     answer += std::string("<Down value=\"") + (user.GetProperty().disabled.Get() ? "1" : "0") + "\"/>";
 139 if (user.GetProperty().disabledDetailStat.ModificationTime() > lastTime)
 140     answer += std::string("<DisableDetailStat value=\"") + (user.GetProperty().disabledDetailStat.Get() ? "1" : "0") + "\"/>";
 141 if (user.GetProperty().passive.ModificationTime() > lastTime)
 142     answer += std::string("<Passive value=\"") + (user.GetProperty().passive.Get() ? "1" : "0") + "\"/>";
 143 if (user.GetProperty().lastCashAdd.ModificationTime() > lastTime)
 144     answer += "<LastCash value=\"" + x2str(user.GetProperty().lastCashAdd.Get()) + "\"/>";
 145 if (user.GetProperty().lastCashAddTime.ModificationTime() > lastTime)
 146     answer += "<LastTimeCash value=\"" + x2str(user.GetProperty().lastCashAddTime.Get()) + "\"/>";
 147 if (user.GetProperty().lastActivityTime.ModificationTime() > lastTime)
 148     answer += "<LastActivityTime value=\"" + x2str(user.GetProperty().lastActivityTime.Get()) + "\"/>";
 149 if (user.GetProperty().creditExpire.ModificationTime() > lastTime)
 150     answer += "<CreditExpire value=\"" + x2str(user.GetProperty().creditExpire.Get()) + "\"/>";
 151
 152 if (lastTime == 0)
 153     {
 154     answer += "<AuthorizedBy>";
 155     std::vector<std::string> list(user.GetAuthorizers());
 156     for (std::vector<std::string>::const_iterator it = list.begin(); it != list.end(); ++it)
 157         answer += "<Auth name=\"" + *it + "\"/>";
 158     answer += "</AuthorizedBy>";
 159     }
 160
 161 answer += "</User>";
 162
 163 return answer;
 164 }
 165
 166 } // namespace anonymous
 167
 168 //-----------------------------------------------------------------------------
 169 //  GET SERVER INFO
 170 //-----------------------------------------------------------------------------
 171 int PARSER_GET_SERVER_INFO::ParseStart(void *, const char *el, const char **)
 172 {
 173 answer.clear();
 174 if (strcasecmp(el, "GetServerInfo") == 0)
 175     {
 176     return 0;
 177     }
 178 return -1;
 179 }
 180 //-----------------------------------------------------------------------------
 181 int PARSER_GET_SERVER_INFO::ParseEnd(void *, const char *el)
 182 {
 183 if (strcasecmp(el, "GetServerInfo") == 0)
 184     {
 185     CreateAnswer();
 186     return 0;
 187     }
 188 return -1;
 189 }
 190 //-----------------------------------------------------------------------------
 191 void PARSER_GET_SERVER_INFO::CreateAnswer()
 192 {
 193 char un[UNAME_LEN];
 194 struct utsname utsn;
 195
 196 uname(&utsn);
 197 un[0] = 0;
 198
 199 strcat(un, utsn.sysname);
 200 strcat(un, " ");
 201 strcat(un, utsn.release);
 202 strcat(un, " ");
 203 strcat(un, utsn.machine);
 204 strcat(un, " ");
 205 strcat(un, utsn.nodename);
 206
 207 answer.clear();
 208 answer += "<ServerInfo>";
 209 answer += std::string("<version value=\"") + SERVER_VERSION + "\"/>";
 210 answer += "<tariff_num value=\"" + x2str(tariffs->Count()) + "\"/>";
 211 answer += "<tariff value=\"2\"/>";
 212 answer += "<user_num value=\"" + x2str(users->Count()) + "\"/>";
 213 answer += std::string("<uname value=\"") + un + "\"/>";
 214 answer += "<dir_num value=\"" + x2str(DIR_NUM) + "\"/>";
 215 answer += "<day_fee value=\"" + x2str(settings->GetDayFee()) + "\"/>";
 216
 217 for (size_t i = 0; i< DIR_NUM; i++)
 218     answer += "<dir_name_" + x2str(i) + " value=\"" + Encode12str(settings->GetDirName(i)) + "\"/>";
 219
 220 answer += "</ServerInfo>";
 221 }
 222 //-----------------------------------------------------------------------------
 223 //  GET USER
 224 //-----------------------------------------------------------------------------
 225 int PARSER_GET_USER::ParseStart(void *, const char *el, const char **attr)
 226 {
 227 if (strcasecmp(el, "GetUser") == 0)
 228     {
 229     if (attr[0] && attr[1])
 230         login = attr[1];
 231     else
 232         {
 233         //login.clear();
 234         login.erase(login.begin(), login.end());
 235         return -1;
 236         }
 237     return 0;
 238     }
 239 return -1;
 240 }
 241 //-----------------------------------------------------------------------------
 242 int PARSER_GET_USER::ParseEnd(void *, const char *el)
 243 {
 244 if (strcasecmp(el, "GetUser") == 0)
 245     {
 246     CreateAnswer();
 247     return 0;
 248     }
 249 return -1;
 250 }
 251 //-----------------------------------------------------------------------------
 252 void PARSER_GET_USER::CreateAnswer()
 253 {
 254 USER_PTR u;
 255
 256 answer.clear();
 257
 258 if (users->FindByName(login, &u))
 259     {
 260     answer = "<User result=\"error\" reason=\"User not found.\"/>";
 261     return;
 262     }
 263
 264 answer = UserToXML(*u, false, currAdmin->GetPriv()->userConf || currAdmin->GetPriv()->userPasswd);
 265 }
 266 //-----------------------------------------------------------------------------
 267 //  GET USERS
 268 //-----------------------------------------------------------------------------
 269 int PARSER_GET_USERS::ParseStart(void *, const char *el, const char ** attr)
 270 {
 271 /*if (attr && *attr && *(attr+1))
 272     {
 273     printfd(__FILE__, "attr=%s %s\n", *attr, *(attr+1));
 274     }
 275 else
 276     {
 277     printfd(__FILE__, "attr = NULL\n");
 278     }*/
 279
 280 lastUpdateFound = false;
 281 if (strcasecmp(el, "GetUsers") == 0)
 282     {
 283     while (attr && *attr && *(attr+1))
 284         {
 285         if (strcasecmp(*attr, "LastUpdate") == 0)
 286             {
 287             if (str2x(*(attr+1), lastUserUpdateTime) == 0)
 288                 {
 289                 //printfd(__FILE__, "lastUserUpdateTime=%d\n", lastUserUpdateTime);
 290                 lastUpdateFound = true;
 291                 }
 292             else
 293                 {
 294                 //printfd(__FILE__, "NO lastUserUpdateTime\n");
 295                 }
 296             }
 297         ++attr;
 298         }
 299
 300     return 0;
 301     }
 302 return -1;
 303 }
 304 //-----------------------------------------------------------------------------
 305 int PARSER_GET_USERS::ParseEnd(void *, const char *el)
 306 {
 307 if (strcasecmp(el, "GetUsers") == 0)
 308     {
 309     CreateAnswer();
 310     return 0;
 311     }
 312 return -1;
 313 }
 314 //-----------------------------------------------------------------------------
 315 void PARSER_GET_USERS::CreateAnswer()
 316 {
 317 answer.clear();
 318
 319 int h = users->OpenSearch();
 320 if (!h)
 321     {
 322     printfd(__FILE__, "users->OpenSearch() error\n");
 323     users->CloseSearch(h);
 324     return;
 325     }
 326
 327 if (lastUpdateFound)
 328     answer += "<Users LastUpdate=\"" + x2str(time(NULL)) + "\">";
 329 else
 330     answer += "<Users>";
 331
 332 USER_PTR u;
 333
 334 while (users->SearchNext(h, &u) == 0)
 335     answer += UserToXML(*u, true, currAdmin->GetPriv()->userConf || currAdmin->GetPriv()->userPasswd, lastUserUpdateTime);
 336
 337 users->CloseSearch(h);
 338
 339 answer += "</Users>";
 340 }
 341 //-----------------------------------------------------------------------------
 342 //  ADD USER
 343 //-----------------------------------------------------------------------------
 344 int PARSER_ADD_USER::ParseStart(void *, const char *el, const char **attr)
 345 {
 346 depth++;
 347
 348 if (depth == 1)
 349     {
 350     if (strcasecmp(el, "AddUser") == 0)
 351         {
 352         return 0;
 353         }
 354     }
 355 else
 356     {
 357     if (strcasecmp(el, "login") == 0)
 358         {
 359         login = attr[1];
 360         return 0;
 361         }
 362     }
 363 return -1;
 364 }
 365 //-----------------------------------------------------------------------------
 366 int PARSER_ADD_USER::ParseEnd(void *, const char *el)
 367 {
 368 if (depth == 1)
 369     {
 370     if (strcasecmp(el, "AddUser") == 0)
 371         {
 372         CreateAnswer();
 373         depth--;
 374         return 0;
 375         }
 376     }
 377
 378 depth--;
 379 return -1;
 380 }
 381 //-----------------------------------------------------------------------------
 382 void PARSER_ADD_USER::Reset()
 383 {
 384 BASE_PARSER::Reset();
 385 depth = 0;
 386 }
 387 //-----------------------------------------------------------------------------
 388 void PARSER_ADD_USER::CreateAnswer()
 389 {
 390 if (CheckUserData() == 0)
 391     answer = "<AddUser result=\"ok\"/>";
 392 else
 393     answer = "<AddUser result=\"error\" reason=\"Access denied\"/>";
 394 }
 395 //-----------------------------------------------------------------------------
 396 int PARSER_ADD_USER::CheckUserData()
 397 {
 398 USER_PTR u;
 399 if (users->FindByName(login, &u))
 400     {
 401     return users->Add(login, currAdmin);
 402     }
 403 return -1;
 404 }
 405 //-----------------------------------------------------------------------------
 406 //  PARSER CHG USER
 407 //-----------------------------------------------------------------------------
 408 PARSER_CHG_USER::PARSER_CHG_USER()
 409     : BASE_PARSER(),
 410       usr(NULL),
 411       ucr(NULL),
 412       upr(NULL),
 413       downr(NULL),
 414       cashMsg(),
 415       login(),
 416       cashMustBeAdded(false),
 417       res(0)
 418 {
 419 Reset();
 420 }
 421 //-----------------------------------------------------------------------------
 422 PARSER_CHG_USER::~PARSER_CHG_USER()
 423 {
 424 delete usr;
 425 delete ucr;
 426 delete[] upr;
 427 delete[] downr;
 428 }
 429 //-----------------------------------------------------------------------------
 430 void PARSER_CHG_USER::Reset()
 431 {
 432 depth = 0;
 433 delete usr;
 434
 435 delete ucr;
 436
 437 delete[] upr;
 438
 439 delete[] downr;
 440
 441 usr = new USER_STAT_RES;
 442 ucr = new USER_CONF_RES;
 443
 444 upr = new RESETABLE<uint64_t>[DIR_NUM];
 445 downr = new RESETABLE<uint64_t>[DIR_NUM];
 446 }
 447 //-----------------------------------------------------------------------------
 448 std::string PARSER_CHG_USER::EncChar2String(const char * strEnc)
 449 {
 450 std::string str;
 451 Decode21str(str, strEnc);
 452 return str;
 453 }
 454 //-----------------------------------------------------------------------------
 455 int PARSER_CHG_USER::ParseStart(void *, const char *el, const char **attr)
 456 {
 457 depth++;
 458
 459 if (depth == 1)
 460     {
 461     if (strcasecmp(el, "SetUser") == 0)
 462         {
 463         return 0;
 464         }
 465     }
 466 else
 467     {
 468     //printfd(__FILE__, "el=%s\n", el);
 469     if (strcasecmp(el, "login") == 0)
 470         {
 471         login = attr[1];
 472         return 0;
 473         }
 474
 475     if (strcasecmp(el, "ip") == 0)
 476         {
 477         try
 478             {
 479             ucr->ips = StrToIPS(attr[1]);
 480             }
 481         catch (...)
 482             {
 483             printfd(__FILE__, "StrToIPS Error!\n");
 484             }
 485         }
 486
 487     if (strcasecmp(el, "password") == 0)
 488         {
 489         ucr->password = attr[1];
 490         return 0;
 491         }
 492
 493     if (strcasecmp(el, "address") == 0)
 494         {
 495         ucr->address = EncChar2String(attr[1]);
 496         return 0;
 497         }
 498
 499     if (strcasecmp(el, "aonline") == 0)
 500         {
 501         ucr->alwaysOnline = (*(attr[1]) != '0');
 502         return 0;
 503         }
 504
 505     if (strcasecmp(el, "cash") == 0)
 506         {
 507         if (attr[2] && (strcasecmp(attr[2], "msg") == 0))
 508             {
 509             cashMsg = EncChar2String(attr[3]);
 510             }
 511
 512         double cash;
 513         if (strtodouble2(attr[1], cash) == 0)
 514             usr->cash = cash;
 515
 516         if (strcasecmp(attr[0], "set") == 0)
 517             cashMustBeAdded = false;
 518
 519         if (strcasecmp(attr[0], "add") == 0)
 520             cashMustBeAdded = true;
 521
 522         return 0;
 523         }
 524
 525     if (strcasecmp(el, "CreditExpire") == 0)
 526         {
 527         long int creditExpire = 0;
 528         if (str2x(attr[1], creditExpire) == 0)
 529             ucr->creditExpire = (time_t)creditExpire;
 530
 531         return 0;
 532         }
 533
 534     if (strcasecmp(el, "credit") == 0)
 535         {
 536         double credit;
 537         if (strtodouble2(attr[1], credit) == 0)
 538             ucr->credit = credit;
 539         return 0;
 540         }
 541
 542     if (strcasecmp(el, "freemb") == 0)
 543         {
 544         double freeMb;
 545         if (strtodouble2(attr[1], freeMb) == 0)
 546             usr->freeMb = freeMb;
 547         return 0;
 548         }
 549
 550     if (strcasecmp(el, "down") == 0)
 551         {
 552         int down = 0;
 553         if (str2x(attr[1], down) == 0)
 554             ucr->disabled = down;
 555         return 0;
 556         }
 557
 558     if (strcasecmp(el, "DisableDetailStat") == 0)
 559         {
 560         int disabledDetailStat = 0;
 561         if (str2x(attr[1], disabledDetailStat) == 0)
 562             ucr->disabledDetailStat = disabledDetailStat;
 563         return 0;
 564         }
 565
 566     if (strcasecmp(el, "email") == 0)
 567         {
 568         ucr->email = EncChar2String(attr[1]);
 569         return 0;
 570         }
 571
 572     for (int i = 0; i < USERDATA_NUM; i++)
 573         {
 574         char name[15];
 575         sprintf(name, "userdata%d", i);
 576         if (strcasecmp(el, name) == 0)
 577             {
 578             ucr->userdata[i] = EncChar2String(attr[1]);
 579             return 0;
 580             }
 581         }
 582
 583     if (strcasecmp(el, "group") == 0)
 584         {
 585         ucr->group = EncChar2String(attr[1]);
 586         return 0;
 587         }
 588
 589     if (strcasecmp(el, "note") == 0)
 590         {
 591         ucr->note = EncChar2String(attr[1]);
 592         return 0;
 593         }
 594
 595     if (strcasecmp(el, "passive") == 0)
 596         {
 597         int passive = 0;
 598         if (str2x(attr[1], passive) == 0)
 599             ucr->passive = passive;
 600         return 0;
 601         }
 602
 603     if (strcasecmp(el, "phone") == 0)
 604         {
 605         ucr->phone = EncChar2String(attr[1]);
 606         return 0;
 607         }
 608
 609     if (strcasecmp(el, "Name") == 0)
 610         {
 611         ucr->realName = EncChar2String(attr[1]);
 612         return 0;
 613         }
 614
 615     if (strcasecmp(el, "traff") == 0)
 616         {
 617         int j = 0;
 618         DIR_TRAFF dtu;
 619         DIR_TRAFF dtd;
 620         uint64_t t = 0;
 621         while (attr[j])
 622             {
 623             int dir = attr[j][2] - '0';
 624
 625             if (strncasecmp(attr[j], "md", 2) == 0)
 626                 {
 627                 str2x(attr[j+1], t);
 628                 dtd[dir] = t;
 629                 downr[dir] = t;
 630                 }
 631             if (strncasecmp(attr[j], "mu", 2) == 0)
 632                 {
 633                 str2x(attr[j+1], t);
 634                 dtu[dir] = t;
 635                 upr[dir] = t;
 636                 }
 637             j+=2;
 638             }
 639         return 0;
 640         }
 641
 642     if (strcasecmp(el, "tariff") == 0)
 643         {
 644         if (strcasecmp(attr[0], "now") == 0)
 645             ucr->tariffName = attr[1];
 646
 647         if (strcasecmp(attr[0], "delayed") == 0)
 648             ucr->nextTariff = attr[1];
 649
 650         return 0;
 651         }
 652     }
 653 return -1;
 654 }
 655 //-----------------------------------------------------------------------------
 656 int PARSER_CHG_USER::ParseEnd(void *, const char *el)
 657 {
 658 if (depth == 1)
 659     {
 660     if (strcasecmp(el, "SetUser") == 0)
 661         {
 662         AplayChanges();
 663         CreateAnswer();
 664         depth--;
 665         return 0;
 666         }
 667     }
 668
 669 depth--;
 670 return -1;
 671 }
 672 //-----------------------------------------------------------------------------
 673 void PARSER_CHG_USER::CreateAnswer()
 674 {
 675 switch (res)
 676     {
 677     case 0:
 678         answer = "<SetUser result=\"ok\"/>";
 679         break;
 680     case -1:
 681         answer = "<SetUser result=\"error\"/>";
 682         break;
 683     case -2:
 684         answer = "<SetUser result=\"error\"/>";
 685         break;
 686     default:
 687         answer = "<SetUser result=\"error\"/>";
 688         break;
 689     }
 690
 691 }
 692 //-----------------------------------------------------------------------------
 693 int PARSER_CHG_USER::AplayChanges()
 694 {
 695 printfd(__FILE__, "PARSER_CHG_USER::AplayChanges()\n");
 696 USER_PTR u;
 697
 698 res = 0;
 699 if (users->FindByName(login, &u))
 700     {
 701     res = -1;
 702     return -1;
 703     }
 704
 705 bool check = false;
 706 bool alwaysOnline = u->GetProperty().alwaysOnline;
 707 if (!ucr->alwaysOnline.empty())
 708     {
 709     check = true;
 710     alwaysOnline = ucr->alwaysOnline.const_data();
 711     }
 712 bool onlyOneIP = u->GetProperty().ips.ConstData().OnlyOneIP();
 713 if (!ucr->ips.empty())
 714     {
 715     check = true;
 716     onlyOneIP = ucr->ips.const_data().OnlyOneIP();
 717     }
 718
 719 if (check && alwaysOnline && !onlyOneIP)
 720     {
 721     printfd(__FILE__, "Requested change leads to a forbidden state: AlwaysOnline with multiple IP's\n");
 722     GetStgLogger()("%s Requested change leads to a forbidden state: AlwaysOnline with multiple IP's", currAdmin->GetLogStr().c_str());
 723     res = -1;
 724     return -1;
 725     }
 726
 727 for (size_t i = 0; i < ucr->ips.const_data().Count(); ++i)
 728     {
 729     CONST_USER_PTR user;
 730     uint32_t ip = ucr->ips.const_data().operator[](i).ip;
 731     if (users->IsIPInUse(ip, login, &user))
 732         {
 733         printfd(__FILE__, "Trying to assign an IP %s to '%s' that is already in use by '%s'\n", inet_ntostring(ip).c_str(), login.c_str(), user->GetLogin().c_str());
 734         GetStgLogger()("%s trying to assign an IP %s to '%s' that is currently in use by '%s'", currAdmin->GetLogStr().c_str(), inet_ntostring(ip).c_str(), login.c_str(), user->GetLogin().c_str());
 735         res = -1;
 736         return -1;
 737         }
 738     }
 739
 740 if (!ucr->ips.empty())
 741     if (!u->GetProperty().ips.Set(ucr->ips.const_data(), currAdmin, login, store))
 742         res = -1;
 743
 744 if (!ucr->alwaysOnline.empty())
 745     if (!u->GetProperty().alwaysOnline.Set(ucr->alwaysOnline.const_data(),
 746                                       currAdmin, login, store))
 747         res = -1;
 748
 749 if (!ucr->address.empty())
 750     if (!u->GetProperty().address.Set(ucr->address.const_data(), currAdmin, login, store))
 751         res = -1;
 752
 753 if (!ucr->creditExpire.empty())
 754     if (!u->GetProperty().creditExpire.Set(ucr->creditExpire.const_data(),
 755                                       currAdmin, login, store))
 756         res = -1;
 757
 758 if (!ucr->credit.empty())
 759     if (!u->GetProperty().credit.Set(ucr->credit.const_data(), currAdmin, login, store))
 760         res = -1;
 761
 762 if (!usr->freeMb.empty())
 763     if (!u->GetProperty().freeMb.Set(usr->freeMb.const_data(), currAdmin, login, store))
 764         res = -1;
 765
 766 if (!ucr->disabled.empty())
 767     if (!u->GetProperty().disabled.Set(ucr->disabled.const_data(), currAdmin, login, store))
 768         res = -1;
 769
 770 if (!ucr->disabledDetailStat.empty())
 771     if (!u->GetProperty().disabledDetailStat.Set(ucr->disabledDetailStat.const_data(), currAdmin, login, store))
 772         res = -1;
 773
 774 if (!ucr->email.empty())
 775     if (!u->GetProperty().email.Set(ucr->email.const_data(), currAdmin, login, store))
 776         res = -1;
 777
 778 if (!ucr->group.empty())
 779     if (!u->GetProperty().group.Set(ucr->group.const_data(), currAdmin, login, store))
 780         res = -1;
 781
 782 if (!ucr->note.empty())
 783     if (!u->GetProperty().note.Set(ucr->note.const_data(), currAdmin, login, store))
 784         res = -1;
 785
 786 std::vector<USER_PROPERTY_LOGGED<std::string> *> userdata;
 787 userdata.push_back(u->GetProperty().userdata0.GetPointer());
 788 userdata.push_back(u->GetProperty().userdata1.GetPointer());
 789 userdata.push_back(u->GetProperty().userdata2.GetPointer());
 790 userdata.push_back(u->GetProperty().userdata3.GetPointer());
 791 userdata.push_back(u->GetProperty().userdata4.GetPointer());
 792 userdata.push_back(u->GetProperty().userdata5.GetPointer());
 793 userdata.push_back(u->GetProperty().userdata6.GetPointer());
 794 userdata.push_back(u->GetProperty().userdata7.GetPointer());
 795 userdata.push_back(u->GetProperty().userdata8.GetPointer());
 796 userdata.push_back(u->GetProperty().userdata9.GetPointer());
 797
 798 for (int i = 0; i < (int)userdata.size(); i++)
 799     {
 800     if (!ucr->userdata[i].empty())
 801         {
 802         if(!userdata[i]->Set(ucr->userdata[i].const_data(), currAdmin, login, store))
 803             res = -1;
 804         }
 805     }
 806
 807 if (!ucr->passive.empty())
 808     if (!u->GetProperty().passive.Set(ucr->passive.const_data(), currAdmin, login, store))
 809         res = -1;
 810
 811 if (!ucr->password.empty())
 812     if (!u->GetProperty().password.Set(ucr->password.const_data(), currAdmin, login, store))
 813         res = -1;
 814
 815 if (!ucr->phone.empty())
 816     if (!u->GetProperty().phone.Set(ucr->phone.const_data(), currAdmin, login, store))
 817         res = -1;
 818
 819 if (!ucr->realName.empty())
 820     if (!u->GetProperty().realName.Set(ucr->realName.const_data(), currAdmin, login, store))
 821         res = -1;
 822
 823
 824 if (!usr->cash.empty())
 825     {
 826     //if (*currAdmin->GetPriv()->userCash)
 827         {
 828         if (cashMustBeAdded)
 829             {
 830             if (!u->GetProperty().cash.Set(usr->cash.const_data() + u->GetProperty().cash,
 831                                            currAdmin,
 832                                            login,
 833                                            store,
 834                                            cashMsg))
 835                 res = -1;
 836             }
 837         else
 838             {
 839             if (!u->GetProperty().cash.Set(usr->cash.const_data(), currAdmin, login, store, cashMsg))
 840                 res = -1;
 841             }
 842         }
 843     }
 844
 845
 846 if (!ucr->tariffName.empty())
 847     {
 848     if (tariffs->FindByName(ucr->tariffName.const_data()))
 849         {
 850         if (!u->GetProperty().tariffName.Set(ucr->tariffName.const_data(), currAdmin, login, store))
 851             res = -1;
 852         u->ResetNextTariff();
 853         }
 854     else
 855         {
 856         //WriteServLog("SetUser: Tariff %s not found", ud.conf.tariffName.c_str());
 857         res = -1;
 858         }
 859     }
 860
 861 if (!ucr->nextTariff.empty())
 862     {
 863     if (tariffs->FindByName(ucr->nextTariff.const_data()))
 864         {
 865         if (!u->GetProperty().nextTariff.Set(ucr->nextTariff.const_data(), currAdmin, login, store))
 866             res = -1;
 867         }
 868     else
 869         {
 870         //WriteServLog("SetUser: Tariff %s not found", ud.conf.tariffName.c_str());
 871         res = -1;
 872         }
 873     }
 874
 875 DIR_TRAFF up = u->GetProperty().up;
 876 DIR_TRAFF down = u->GetProperty().down;
 877 int upCount = 0;
 878 int downCount = 0;
 879 for (int i = 0; i < DIR_NUM; i++)
 880     {
 881     if (!upr[i].empty())
 882         {
 883         up[i] = upr[i].data();
 884         upCount++;
 885         }
 886     if (!downr[i].empty())
 887         {
 888         down[i] = downr[i].data();
 889         downCount++;
 890         }
 891     }
 892
 893 if (upCount)
 894     if (!u->GetProperty().up.Set(up, currAdmin, login, store))
 895         res = -1;
 896
 897 if (downCount)
 898     if (!u->GetProperty().down.Set(down, currAdmin, login, store))
 899         res = -1;
 900
 901 u->WriteConf();
 902 u->WriteStat();
 903
 904 return 0;
 905 }
 906 //-----------------------------------------------------------------------------
 907 //      SEND MESSAGE
 908 //-----------------------------------------------------------------------------
 909 int PARSER_SEND_MESSAGE::ParseStart(void *, const char *el, const char **attr)
 910 {
 911 if (strcasecmp(el, "Message") == 0)
 912     {
 913     for (int i = 0; i < 14; i++)
 914         {
 915         if (attr[i] == NULL)
 916             {
 917             result = res_params_error;
 918             CreateAnswer();
 919             printfd(__FILE__, "To few parameters\n");
 920             return 0;
 921             }
 922         }
 923
 924     for (int i = 0; i < 14; i+=2)
 925         {
 926         if (strcasecmp(attr[i], "login") == 0)
 927             {
 928             ParseLogins(attr[i+1]);
 929             /*if (users->FindByName(login, &u))
 930                 {
 931                 result = res_unknown;
 932                 break;
 933                 }*/
 934             }
 935
 936         if (strcasecmp(attr[i], "MsgVer") == 0)
 937             {
 938             str2x(attr[i+1], msg.header.ver);
 939             if (msg.header.ver != 1)
 940                 result = res_params_error;
 941             }
 942
 943         if (strcasecmp(attr[i], "MsgType") == 0)
 944             {
 945             str2x(attr[i+1], msg.header.type);
 946             if (msg.header.type != 1)
 947                 result = res_params_error;
 948             }
 949
 950         if (strcasecmp(attr[i], "Repeat") == 0)
 951             {
 952             str2x(attr[i+1], msg.header.repeat);
 953             if (msg.header.repeat < 0)
 954                 result = res_params_error;
 955             }
 956
 957         if (strcasecmp(attr[i], "RepeatPeriod") == 0)
 958             {
 959             str2x(attr[i+1], msg.header.repeatPeriod);
 960             }
 961
 962         if (strcasecmp(attr[i], "ShowTime") == 0)
 963             {
 964             str2x(attr[i+1], msg.header.showTime);
 965             }
 966
 967         if (strcasecmp(attr[i], "Text") == 0)
 968             {
 969             Decode21str(msg.text, attr[i+1]);
 970             result = res_ok;
 971             }
 972         }
 973     return 0;
 974     }
 975 return -1;
 976 }
 977 //-----------------------------------------------------------------------------
 978 int PARSER_SEND_MESSAGE::ParseEnd(void *, const char *el)
 979 {
 980 //MSG msg;
 981 if (strcasecmp(el, "Message") == 0)
 982     {
 983     result = res_unknown;
 984     for (unsigned i = 0; i < logins.size(); i++)
 985         {
 986         if (users->FindByName(logins[i], &u))
 987             {
 988             printfd(__FILE__, "User not found. %s\n", logins[i].c_str());
 989             continue;
 990             }
 991         msg.header.creationTime = static_cast<unsigned int>(stgTime);
 992         u->AddMessage(&msg);
 993         result = res_ok;
 994         }
 995     /*if (result == res_ok)
 996         {
 997         if (strcmp(login, "*") == 0)
 998             {
 999             msg.text = text;
1000             msg.prio = pri;
1001             printfd(__FILE__, "SendMsg text: %s\n", text);
1002             users->GetAllUsers(SendMessageAllUsers, &msg);
1003             }
1004         else
1005             {
1006             u->AddMessage(pri, text);
1007             }
1008         }*/
1009     CreateAnswer();
1010     return 0;
1011     }
1012 return -1;
1013 }
1014 //-----------------------------------------------------------------------------
1015 int PARSER_SEND_MESSAGE::ParseLogins(const char * login)
1016 {
1017 char * p;
1018 char * l = new char[strlen(login) + 1];
1019 strcpy(l, login);
1020 p = strtok(l, ":");
1021 logins.clear();
1022 while(p)
1023     {
1024     logins.push_back(p);
1025     p = strtok(NULL, ":");
1026     }
1027
1028 delete[] l;
1029 return 0;
1030 }
1031 //-----------------------------------------------------------------------------
1032 void PARSER_SEND_MESSAGE::CreateAnswer()
1033 {
1034 switch (result)
1035     {
1036     case res_ok:
1037         answer = "<SendMessageResult value=\"ok\"/>";
1038         break;
1039     case res_params_error:
1040         printfd(__FILE__, "res_params_error\n");
1041         answer = "<SendMessageResult value=\"Parameters error.\"/>";
1042         break;
1043     case res_unknown:
1044         printfd(__FILE__, "res_unknown\n");
1045         answer = "<SendMessageResult value=\"Unknown user.\"/>";
1046         break;
1047     default:
1048         printfd(__FILE__, "res_default\n");
1049     }
1050
1051 }
1052 //-----------------------------------------------------------------------------
1053 //      DEL USER
1054 //-----------------------------------------------------------------------------
1055 int PARSER_DEL_USER::ParseStart(void *, const char *el, const char **attr)
1056 {
1057 res = 0;
1058 if (strcasecmp(el, "DelUser") == 0)
1059     {
1060     if (attr[0] == NULL || attr[1] == NULL)
1061         {
1062         //CreateAnswer("Parameters error!");
1063         CreateAnswer();
1064         return 0;
1065         }
1066
1067     if (users->FindByName(attr[1], &u))
1068         {
1069         res = 1;
1070         CreateAnswer();
1071         return 0;
1072         }
1073     CreateAnswer();
1074     return 0;
1075     }
1076 return -1;
1077 }
1078 //-----------------------------------------------------------------------------
1079 int PARSER_DEL_USER::ParseEnd(void *, const char *el)
1080 {
1081 if (strcasecmp(el, "DelUser") == 0)
1082     {
1083     if (!res)
1084         users->Del(u->GetLogin(), currAdmin);
1085
1086     return 0;
1087     }
1088 return -1;
1089 }
1090 //-----------------------------------------------------------------------------
1091 void PARSER_DEL_USER::CreateAnswer()
1092 {
1093 if (res)
1094     answer = "<DelUser value=\"error\" reason=\"User not found\"/>";
1095 else
1096     answer = "<DelUser value=\"ok\"/>";
1097 }
1098 //-----------------------------------------------------------------------------
1099 /*void PARSERDELUSER::CreateAnswer(char * mes)
1100 {
1101 //answerList->clear();
1102 answerList->erase(answerList->begin(), answerList->end());
1103
1104 char str[255];
1105 sprintf(str, "<DelUser value=\"%s\"/>", mes);
1106 answerList->push_back(str);
1107 }*/
1108 //-----------------------------------------------------------------------------
1109 //  CHECK USER
1110 // <checkuser login="vasya" password=\"123456\"/>
1111 //-----------------------------------------------------------------------------
1112 int PARSER_CHECK_USER::ParseStart(void *, const char *el, const char **attr)
1113 {
1114 result = false;
1115
1116 if (strcasecmp(el, "CheckUser") == 0)
1117     {
1118     if (attr[0] == NULL || attr[1] == NULL
1119      || attr[2] == NULL || attr[3] == NULL)
1120         {
1121         result = false;
1122         CreateAnswer();
1123         printfd(__FILE__, "PARSER_CHECK_USER - attr err\n");
1124         return 0;
1125         }
1126
1127     USER_PTR user;
1128     if (users->FindByName(attr[1], &user))
1129         {
1130         result = false;
1131         CreateAnswer();
1132         printfd(__FILE__, "PARSER_CHECK_USER - login err\n");
1133         return 0;
1134         }
1135
1136     if (strcmp(user->GetProperty().password.Get().c_str(), attr[3]))
1137         {
1138         result = false;
1139         CreateAnswer();
1140         printfd(__FILE__, "PARSER_CHECK_USER - passwd err\n");
1141         return 0;
1142         }
1143
1144     result = true;
1145     CreateAnswer();
1146     return 0;
1147     }
1148 return -1;
1149 }
1150 //-----------------------------------------------------------------------------
1151 int PARSER_CHECK_USER::ParseEnd(void *, const char *el)
1152 {
1153 if (strcasecmp(el, "CheckUser") == 0)
1154     {
1155     return 0;
1156     }
1157 return -1;
1158 }
1159 //-----------------------------------------------------------------------------
1160 void PARSER_CHECK_USER::CreateAnswer()
1161 {
1162 if (error)
1163     answer = std::string("<CheckUser value=\"Err\" reason=\"") + error + "\"/>";
1164 else
1165     answer = "<CheckUser value=\"Ok\"/>";
1166 }
1167 //-----------------------------------------------------------------------------
1168 //-----------------------------------------------------------------------------
1169 //-----------------------------------------------------------------------------