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