]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/configuration/sgconfig/parser.cpp
45ef82c8a4ee566d1605458d102b228181a729d0
[stg.git] / 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 //  CHECK USER
1100 // <checkuser login="vasya" password=\"123456\"/>
1101 //-----------------------------------------------------------------------------
1102 int PARSER_CHECK_USER::ParseStart(void *, const char *el, const char **attr)
1103 {
1104 if (strcasecmp(el, "CheckUser") == 0)
1105     {
1106     if (attr[0] == NULL || attr[1] == NULL
1107      || attr[2] == NULL || attr[3] == NULL)
1108         {
1109         CreateAnswer("Invalid parameters.");
1110         printfd(__FILE__, "PARSER_CHECK_USER - attr err\n");
1111         return 0;
1112         }
1113
1114     USER_PTR user;
1115     if (users->FindByName(attr[1], &user))
1116         {
1117         CreateAnswer("User not found.");
1118         printfd(__FILE__, "PARSER_CHECK_USER - login err\n");
1119         return 0;
1120         }
1121
1122     if (strcmp(user->GetProperty().password.Get().c_str(), attr[3]))
1123         {
1124         CreateAnswer("Wrong password.");
1125         printfd(__FILE__, "PARSER_CHECK_USER - passwd err\n");
1126         return 0;
1127         }
1128
1129     CreateAnswer(NULL);
1130     return 0;
1131     }
1132 return -1;
1133 }
1134 //-----------------------------------------------------------------------------
1135 int PARSER_CHECK_USER::ParseEnd(void *, const char *el)
1136 {
1137 if (strcasecmp(el, "CheckUser") == 0)
1138     {
1139     return 0;
1140     }
1141 return -1;
1142 }
1143 //-----------------------------------------------------------------------------
1144 void PARSER_CHECK_USER::CreateAnswer(const char * error)
1145 {
1146 if (error)
1147     answer = std::string("<CheckUser value=\"Err\" reason=\"") + error + "\"/>";
1148 else
1149     answer = "<CheckUser value=\"Ok\"/>";
1150 }
1151 //-----------------------------------------------------------------------------
1152 //-----------------------------------------------------------------------------
1153 //-----------------------------------------------------------------------------