]> git.stg.codes - stg.git/blob - stglibs/srvconf.lib/parser.cpp
Виправлено помилки компіляції unit-тесту test_raw_ip.cpp
[stg.git] / stglibs / srvconf.lib / 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  /*
22  $Revision: 1.18 $
23  $Date: 2010/08/04 00:40:00 $
24  $Author: faust $
25  */
26
27 #include <stdio.h>
28 #include <string.h>
29 #include <stdlib.h>
30 #include <sys/types.h>
31 #include <sys/socket.h>
32 #include <netinet/in.h>
33 #include <arpa/inet.h>
34 #include <string>
35
36 #include "common.h"
37 //#include "srvconf_common.h"
38 #include "stg_const.h"
39 #include "servconf.h"
40
41 using namespace std;
42
43 //-----------------------------------------------------------------------------
44 //-----------------------------------------------------------------------------
45 //-----------------------------------------------------------------------------
46 PARSER_GET_USERS::PARSER_GET_USERS()
47     : RecvUserDataCb(NULL),
48       userDataCb(NULL),
49       depth(0),
50       error(false)
51 {
52 }
53 //-----------------------------------------------------------------------------
54 int PARSER_GET_USERS::ParseStart(const char *el, const char **attr)
55 {
56 depth++;
57 if (depth == 1)
58     {
59     ParseUsers(el, attr);
60     }
61
62 if (depth == 2)
63     {
64     ParseUser(el, attr);
65     }
66
67 if (depth == 3)
68     {
69     ParseUserParams(el, attr);
70     }
71 return 0;
72 }
73 //-----------------------------------------------------------------------------
74 void PARSER_GET_USERS::ParseEnd(const char *)
75 {
76 depth--;
77 if (depth == 1)
78     {
79     if (RecvUserDataCb)
80         {
81         RecvUserDataCb(&user, userDataCb);
82         }
83     }
84 }
85 //-----------------------------------------------------------------------------
86 void PARSER_GET_USERS::ParseUsers(const char * el, const char ** attr)
87 {
88 if (strcasecmp(el, "users") == 0)
89     {
90     if (*attr != NULL)
91         return;
92     return;
93     }
94 }
95 //-----------------------------------------------------------------------------
96 void PARSER_GET_USERS::ParseUser(const char * el, const char ** attr)
97 {
98 if (el && attr[0])
99     {
100     if (strcasecmp(el, "user") != 0)
101         {
102         return;
103         }
104
105     if (strcasecmp(attr[0], "login") != 0)
106         {
107         return;
108         }
109     user.login = attr[1];
110     }
111 }
112 //-----------------------------------------------------------------------------
113 void PARSER_GET_USERS::ParseUserParams(const char * el, const char ** attr)
114 {
115 if (strcasecmp(el, "cash") == 0)
116     {
117     if (strtodouble2(attr[1], user.cash) < 0)
118         {
119         return;
120         }
121     }
122
123 /*if (strcasecmp(el, "LastCash") == 0)
124     {
125     if (strtodouble2(attr[1], user.lastCash) < 0)
126         {
127         MessageDlg("Error in answer", mtError, TMsgDlgButtons() << mbOK, 0);
128         return 0;
129         }
130     }*/
131
132 /*if (strcasecmp(el, "LastActivityTime") == 0)
133     {
134     if (strtol(attr[1], user.lastActivityTime) < 0)
135         {
136         MessageDlg("Error in answer", mtError, TMsgDlgButtons() << mbOK, 0);
137         return 0;
138         }
139     }*/
140
141
142 /*if (strcasecmp(el, "LastTimeCash") == 0)
143     {
144     if (strtol(attr[1], user.lastTimeCash) < 0)
145         {
146         MessageDlg("Error in answer", mtError, TMsgDlgButtons() << mbOK, 0);
147         return 0;
148         }
149     }*/
150
151 /*if (strcasecmp(el, "CashExpire") == 0)
152     {
153     if (strtol(attr[1], user.cashExpire) < 0)
154         {
155         MessageDlg("Error in answer", mtError, TMsgDlgButtons() << mbOK, 0);
156         return 0;
157         }
158     }*/
159
160 if (strcasecmp(el, "credit") == 0)
161     {
162     if (strtodouble2(attr[1], user.credit) < 0)
163         {
164         return;
165         }
166     }
167
168 /*if (strcasecmp(el, "freemb") == 0)
169     {
170     if (strtodouble2(attr[1], user.freeMb) < 0)
171         {
172         MessageDlg("Error in answer", mtError, TMsgDlgButtons() << mbOK, 0);
173         return 0;
174         }
175     }*/
176
177 if (strcasecmp(el, "down") == 0)
178     {
179     if (str2x(attr[1], user.down) < 0)
180         {
181         return;
182         }
183     }
184
185 if (strcasecmp(el, "passive") == 0)
186     {
187     if (str2x(attr[1], user.passive) < 0)
188         {
189         return;
190         }
191     }
192
193 if (strcasecmp(el, "disableDetailStat") == 0)
194     {
195     if (str2x(attr[1], user.disableDetailStat) < 0)
196         {
197         return;
198         }
199     }
200
201
202 if (strcasecmp(el, "status") == 0)
203     {
204     if (str2x(attr[1], user.connected) < 0)
205         {
206         return;
207         }
208     }
209
210 if (strcasecmp(el, "aonline") == 0)
211     {
212     if (str2x(attr[1], user.alwaysOnline) < 0)
213         {
214         return;
215         }
216     }
217
218 if (strcasecmp(el, "currip") == 0)
219     {
220     user.ip = inet_addr(attr[1]);
221     }
222
223 if (strcasecmp(el, "ip") == 0)
224     {
225     user.ips = attr[1];
226     }
227
228
229 if (strcasecmp(el, "tariff") == 0)
230     {
231     //KOIToWin(user.tariff, *(attr+1), TARIFF_LEN);
232     user.tariff = attr[1];
233     return;
234     }
235
236 if (strcasecmp(el, "password") == 0)
237     {
238     user.password = *(attr+1);
239     return;
240     }
241
242 if (strcasecmp(el, "iface") == 0)
243     {
244     user.iface = attr[1];
245     return;
246     }
247
248 /*if (strcasecmp(el, "name") == 0)
249     {
250     / *char nameEnc[REALNM_LEN * 2 + 1];
251     char name[REALNM_LEN];
252     strncpy(nameEnc, attr[1], REALNM_LEN * 2 + 1);
253     Decode21(name, nameEnc);
254     KOIToWin(user.realName, name, REALNM_LEN);* /
255     Decode21str(user.realName, attr[1]);
256     return;
257     }*/
258
259 if (strcasecmp(el, "address") == 0)
260     {
261     /*char addressEnc[ADDR_LEN * 2 + 1];
262     char address[ADDR_LEN];
263     strncpy(addressEnc, attr[1], ADDR_LEN * 2 + 1);
264     Decode21(address, addressEnc);
265     KOIToWin(user.address, address, ADDR_LEN);*/
266     Decode21str(user.address, attr[1]);
267     return;
268     }
269
270 if (strcasecmp(el, "phone") == 0)
271     {
272     /*char phoneEnc[PHONE_LEN * 2 + 1];
273     char phone[PHONE_LEN];
274     strncpy(phoneEnc, attr[1], PHONE_LEN * 2 + 1);
275     Decode21(phone, phoneEnc);
276     KOIToWin(user.phone, phone, PHONE_LEN);*/
277     Decode21str(user.phone, attr[1]);
278     return;
279     }
280
281 if (strcasecmp(el, "note") == 0)
282     {
283     /*char noteEnc[NOTE_LEN * 2 + 1];
284     char note[NOTE_LEN];
285     strncpy(noteEnc, attr[1], NOTE_LEN * 2 + 1);*/
286     //KOIToWin(user.note, note, NOTE_LEN);
287     //user.note = note;
288     Decode21str(user.note, attr[1]);
289     return;
290     }
291
292 if (strcasecmp(el, "email") == 0)
293     {
294     /*char emailEnc[EMAIL_LEN * 2 + 1];
295     char email[EMAIL_LEN];
296     strncpy(emailEnc, attr[1], EMAIL_LEN * 2 + 1);
297     Decode21(email, emailEnc);
298     //KOIToWin(user.email, email, EMAIL_LEN);
299     user.email = email;*/
300     Decode21str(user.email, attr[1]);
301     return;
302     }
303
304 if (strcasecmp(el, "group") == 0)
305     {
306     /*char groupEnc[GROUP_LEN * 2 + 1];
307     char group[GROUP_LEN];
308     strncpy(groupEnc, attr[1], GROUP_LEN * 2 + 1);
309     Decode21(group, groupEnc);
310     //KOIToWin(user.group, group, GROUP_LEN);
311     user.group = group;*/
312     Decode21str(user.group, attr[1]);
313     return;
314     }
315
316 if (strcasecmp(el, "traff") == 0)
317     {
318     ParseUserLoadStat(el, attr);
319     return;
320     }
321
322 }
323 //-----------------------------------------------------------------------------
324 void PARSER_GET_USERS::ParseUserLoadStat(const char *, const char ** attr)
325 {
326 int i = 0;
327 char dir[6];
328 while (attr[i])
329     {
330     for (int j = 0; j < DIR_NUM; j++)
331         {
332         sprintf(dir, "MU%d", j);
333         if (strcasecmp(dir, attr[i]) == 0)
334             {
335             str2x(attr[i+1], user.stat.mu[j]);
336             break;
337             }
338         }
339     for (int j = 0; j < DIR_NUM; j++)
340         {
341         sprintf(dir, "MD%d", j);
342         if (strcasecmp(dir, attr[i]) == 0)
343             {
344             str2x(attr[i+1], user.stat.md[j]);
345             break;
346             }
347         }
348     for (int j = 0; j < DIR_NUM; j++)
349         {
350         sprintf(dir, "SU%d", j);
351         if (strcasecmp(dir, attr[i]) == 0)
352             {
353             str2x(attr[i+1], user.stat.su[j]);
354             break;
355             }
356         }
357     for (int j = 0; j < DIR_NUM; j++)
358         {
359         sprintf(dir, "SD%d", j);
360         if (strcasecmp(dir, attr[i]) == 0)
361             {
362             str2x(attr[i+1], user.stat.sd[j]);
363             break;
364             }
365         }
366     i+=2;
367     }
368 return;
369 }
370 //-----------------------------------------------------------------------------
371 void PARSER_GET_USERS::SetUserDataRecvCb(RecvUserDataCb_t f, void * data)
372 {
373 RecvUserDataCb = f;
374 userDataCb = data;
375 }
376 //-----------------------------------------------------------------------------
377 //-----------------------------------------------------------------------------
378 //-----------------------------------------------------------------------------
379 PARSER_GET_USER::PARSER_GET_USER()
380     : RecvUserDataCb(NULL),
381       userDataCb(NULL),
382       depth(0),
383       error(false)
384 {
385 }
386 //-----------------------------------------------------------------------------
387 int PARSER_GET_USER::ParseStart(const char *el, const char **attr)
388 {
389 depth++;
390 if (depth == 1)
391     {
392     ParseUser(el, attr);
393     }
394
395 if (depth == 2)
396     {
397     ParseUserParams(el, attr);
398     }
399 return 0;
400 }
401 //-----------------------------------------------------------------------------
402 void PARSER_GET_USER::ParseEnd(const char *)
403 {
404 depth--;
405 if (depth == 0)
406     {
407     if (RecvUserDataCb)
408         {
409         RecvUserDataCb(&user, userDataCb);
410         }
411     }
412 }
413 //-----------------------------------------------------------------------------
414 void PARSER_GET_USER::ParseUser(const char * el, const char ** attr)
415 {
416 if (strcasecmp(el, "user") == 0)
417     {
418     if (strcasecmp(attr[1], "error") == 0)
419         user.login = "";
420     return;
421     }
422 }
423 //-----------------------------------------------------------------------------
424 struct ParsedStringParams
425 {
426 string    * param;
427 string      paramName;
428 };
429 //-----------------------------------------------------------------------------
430 struct ParsedDoubleParams
431 {
432 double    * param;
433 string      paramName;
434 };
435 //-----------------------------------------------------------------------------
436 void PARSER_GET_USER::ParseUserParams(const char * el, const char ** attr)
437 {
438 //printf("PARSER_GET_USER::ParseUserParams el=%s attr[1]=%s\n", el, attr[1]);
439
440 if (strcasecmp(el, "login") == 0)
441     {
442     user.login = attr[1];
443     }
444
445
446 /*if (strcasecmp(el, "LastActivityTime") == 0)
447     {
448     if (strtol(attr[1], user.lastActivityTime) < 0)
449         {
450         MessageDlg("Error in answer", mtError, TMsgDlgButtons() << mbOK, 0);
451         return 0;
452         }
453     }
454
455
456 if (strcasecmp(el, "LastTimeCash") == 0)
457     {
458     if (strtol(attr[1], user.lastTimeCash) < 0)
459         {
460         MessageDlg("Error in answer", mtError, TMsgDlgButtons() << mbOK, 0);
461         return 0;
462         }
463     }
464
465 if (strcasecmp(el, "CashExpire") == 0)
466     {
467     if (strtol(attr[1], user.cashExpire) < 0)
468         {
469         MessageDlg("Error in answer", mtError, TMsgDlgButtons() << mbOK, 0);
470         return 0;
471         }
472     }
473 */
474
475 if (strcasecmp(el, "down") == 0)
476     {
477     if (str2x(attr[1], user.down) < 0)
478         {
479         return;
480         }
481     }
482
483 if (strcasecmp(el, "passive") == 0)
484     {
485     if (str2x(attr[1], user.passive) < 0)
486         {
487         return;
488         }
489     }
490
491 if (strcasecmp(el, "disableDetailStat") == 0)
492     {
493     if (str2x(attr[1], user.disableDetailStat) < 0)
494         {
495         return;
496         }
497     }
498
499
500 if (strcasecmp(el, "status") == 0)
501     {
502     if (str2x(attr[1], user.connected) < 0)
503         {
504         return;
505         }
506     }
507
508 if (strcasecmp(el, "aonline") == 0)
509     {
510     if (str2x(attr[1], user.alwaysOnline) < 0)
511         {
512         return;
513         }
514     }
515
516 if (strcasecmp(el, "currip") == 0)
517     {
518     user.ip = inet_addr(attr[1]);
519     }
520
521 for (int i = 0; i < USERDATA_NUM; i++)
522     {
523     string num;
524     x2str(i, num);
525     string udName = "UserData" + num;
526     if (strcasecmp(el, udName.c_str()) == 0)
527         {
528         Decode21str(user.userData[i], attr[1]);
529         return;
530         }
531     }
532
533 ParsedStringParams psp[] =
534 {
535     {&user.ips,         "ip"},
536     {&user.tariff,      "tariff"},
537     {&user.password,    "password"},
538     {&user.iface,       "iface"},
539 };
540
541 for (unsigned i = 0; i < sizeof(psp)/sizeof(ParsedStringParams); i++)
542     {
543     if (strcasecmp(el, psp[i].paramName.c_str()) == 0)
544         {
545         *psp[i].param = attr[1];
546         return;
547         }
548     }
549
550 ParsedStringParams pspEnc[] =
551 {
552     {&user.note,    "note"},
553     {&user.email,   "email"},
554     {&user.group,   "group"},
555     {&user.name,    "name"},
556     {&user.address, "address"},
557     {&user.phone,   "phone"}
558 };
559
560 for (unsigned i = 0; i < sizeof(pspEnc)/sizeof(ParsedStringParams); i++)
561     {
562     if (strcasecmp(el, pspEnc[i].paramName.c_str()) == 0)
563         {
564         Decode21str(*pspEnc[i].param, attr[1]);
565         return;
566         }
567     }
568
569 ParsedDoubleParams pdp[] =
570 {
571     {&user.cash,            "cash"},
572     {&user.credit,          "credit"},
573     {&user.lastCash,        "lastCash"},
574     {&user.prepaidTraff,    "freemb"},
575 };
576
577 for (unsigned i = 0; i < sizeof(pdp)/sizeof(ParsedDoubleParams); i++)
578     {
579     if (strcasecmp(el, pdp[i].paramName.c_str()) == 0)
580         {
581         strtodouble2(attr[1], *pdp[i].param);
582         return;
583         }
584     }
585
586 if (strcasecmp(el, "traff") == 0)
587     {
588     ParseUserLoadStat(el, attr);
589     return;
590     }
591 }
592 //-----------------------------------------------------------------------------
593 void PARSER_GET_USER::ParseUserLoadStat(const char *, const char ** attr)
594 {
595 int i = 0;
596 char dir[6];
597 while (attr[i])
598     {
599     for (int j = 0; j < DIR_NUM; j++)
600         {
601         sprintf(dir, "MU%d", j);
602         if (strcasecmp(dir, attr[i]) == 0)
603             {
604             str2x(attr[i+1], user.stat.mu[j]);
605             break;
606             }
607         }
608     for (int j = 0; j < DIR_NUM; j++)
609         {
610         sprintf(dir, "MD%d", j);
611         if (strcasecmp(dir, attr[i]) == 0)
612             {
613             str2x(attr[i+1], user.stat.md[j]);
614             break;
615             }
616         }
617     for (int j = 0; j < DIR_NUM; j++)
618         {
619         sprintf(dir, "SU%d", j);
620         if (strcasecmp(dir, attr[i]) == 0)
621             {
622             str2x(attr[i+1], user.stat.su[j]);
623             break;
624             }
625         }
626     for (int j = 0; j < DIR_NUM; j++)
627         {
628         sprintf(dir, "SD%d", j);
629         if (strcasecmp(dir, attr[i]) == 0)
630             {
631             str2x(attr[i+1], user.stat.sd[j]);
632             break;
633             }
634         }
635     i+=2;
636     }
637 return;
638 }
639 //-----------------------------------------------------------------------------
640 void PARSER_GET_USER::SetUserDataRecvCb(RecvUserDataCb_t f, void * data)
641 {
642 RecvUserDataCb = f;
643 userDataCb = data;
644 }
645 //-----------------------------------------------------------------------------
646 //-----------------------------------------------------------------------------
647 //-----------------------------------------------------------------------------
648 PARSER_GET_SERVER_INFO::PARSER_GET_SERVER_INFO()
649     : RecvServerInfoDataCb(NULL),
650       serverInfoDataCb(NULL),
651       depth(0),
652       error(false)
653 {
654 }
655 //-----------------------------------------------------------------------------
656 int PARSER_GET_SERVER_INFO::ParseStart(const char *el, const char **attr)
657 {
658 depth++;
659 if (depth == 1)
660     {
661     if (strcasecmp(el, "ServerInfo") != 0)
662         {
663         //printf("%s\n", el);
664         }
665     }
666 else
667     {
668     if (depth == 2)
669         {
670         if (strcasecmp(el, "uname") == 0)
671             {
672             ParseUname(attr);
673             return 0;
674             }
675         if (strcasecmp(el, "version") == 0)
676             {
677             ParseServerVersion(attr);
678             return 0;
679             }
680         if (strcasecmp(el, "tariff") == 0)
681             {
682             ParseTariffType(attr);
683             return 0;
684             }
685         if (strcasecmp(el, "dir_num") == 0)
686             {
687             ParseDirNum(attr);
688             return 0;
689             }
690         if (strcasecmp(el, "users_num") == 0)
691             {
692             ParseUsersNum(attr);
693             return 0;
694             }
695         if (strcasecmp(el, "tariff_num") == 0)
696             {
697             ParseTariffsNum(attr);
698             return 0;
699             }
700
701         for (int j = 0; j < DIR_NUM; j++)
702             {
703             char str[16];
704             sprintf(str, "dir_name_%d", j);
705             if (strcasecmp(el, str) == 0)
706                 {
707                 ParseDirName(attr, j);
708                 }
709             }
710
711         }
712     }
713 return 0;
714 }
715 //-----------------------------------------------------------------------------
716 void PARSER_GET_SERVER_INFO::ParseEnd(const char *)
717 {
718 depth--;
719 if (depth == 0)
720     {
721     RecvServerInfoDataCb(&serverInfo, serverInfoDataCb);
722     }
723 }
724 //-----------------------------------------------------------------------------
725 /*void PARSER_GET_SERVER_INFO::ParseServerInfo(const char * el, const char ** attr)
726     {
727     }*/
728 //-----------------------------------------------------------------------------
729 void PARSER_GET_SERVER_INFO::SetServerInfoRecvCb(RecvServerInfoDataCb_t f, void * data)
730 {
731 RecvServerInfoDataCb = f;
732 serverInfoDataCb = data;
733 }
734 //-----------------------------------------------------------------------------
735 void PARSER_GET_SERVER_INFO::ParseUname(const char ** attr)
736 {
737 if (strcmp(*attr, "value") == 0)
738     serverInfo.uname = attr[1];
739 }
740 //-----------------------------------------------------------------------------
741 void PARSER_GET_SERVER_INFO::ParseServerVersion(const char ** attr)
742 {
743 if (strcmp(*attr, "value") == 0)
744     serverInfo.version = attr[1];
745 }
746 //-----------------------------------------------------------------------------
747 void PARSER_GET_SERVER_INFO::ParseUsersNum(const char ** attr)
748 {
749 if (strcmp(*attr, "value") == 0)
750     {
751     if (str2x(attr[1], serverInfo.usersNum) < 0)
752         {
753         serverInfo.usersNum = -1;
754         return;
755         }
756     }
757 }
758 //-----------------------------------------------------------------------------
759 void PARSER_GET_SERVER_INFO::ParseTariffsNum(const char ** attr)
760 {
761 if (strcmp(*attr, "value") == 0)
762     {
763     if (str2x(attr[1], serverInfo.tariffNum) < 0)
764         {
765         serverInfo.tariffNum = -1;
766         return;
767         }
768     }
769 }
770 //-----------------------------------------------------------------------------
771 void PARSER_GET_SERVER_INFO::ParseTariffType(const char ** attr)
772 {
773 if (strcmp(*attr, "value") == 0)
774     {
775     if (str2x(attr[1], serverInfo.tariffType) < 0)
776         {
777         serverInfo.tariffType = -1;
778         return;
779         }
780     }
781 }
782 //-----------------------------------------------------------------------------
783 void PARSER_GET_SERVER_INFO::ParseDirNum(const char **attr)
784 {
785 if (strcasecmp(*attr, "value") == 0)
786     {
787     if (str2x(attr[1], serverInfo.dirNum) < 0)
788         {
789         serverInfo.dirNum = -1;
790         return;
791         }
792     }
793 }
794 //-----------------------------------------------------------------------------
795 void PARSER_GET_SERVER_INFO::ParseDirName(const char **attr, int d)
796 {
797 if (strcmp(attr[0], "value") == 0)
798     {
799     char str[2*DIRNAME_LEN + 1];
800     Decode21(str, attr[1]);
801     serverInfo.dirName[d] = str;
802     }
803 }
804 //-----------------------------------------------------------------------------
805 //-----------------------------------------------------------------------------
806 //-----------------------------------------------------------------------------
807 PARSER_CHG_USER::PARSER_CHG_USER()
808     : RecvChgUserCb(NULL),
809       chgUserCbData(NULL),
810       depth(0),
811       error(false)
812 {
813 }
814 //-----------------------------------------------------------------------------
815 int PARSER_CHG_USER::ParseStart(const char *el, const char **attr)
816 {
817 depth++;
818 if (depth == 1)
819     {
820     if (strcasecmp(el, "SetUser") == 0)
821         {
822         ParseAnswer(el, attr);
823         }
824     else if (strcasecmp(el, "DelUser") == 0)
825         {
826         ParseAnswer(el, attr);
827         }
828     else if (strcasecmp(el, "AddUser") == 0)
829         {
830         ParseAnswer(el, attr);
831         }
832     }
833 return 0;
834 }
835 //-----------------------------------------------------------------------------
836 void PARSER_CHG_USER::ParseEnd(const char *)
837 {
838 depth--;
839 }
840 //-----------------------------------------------------------------------------
841 void PARSER_CHG_USER::ParseAnswer(const char *, const char **attr)
842 {
843 if (RecvChgUserCb)
844     {
845     RecvChgUserCb(attr[1], chgUserCbData);
846     }
847 }
848 //-----------------------------------------------------------------------------
849 void PARSER_CHG_USER::SetChgUserRecvCb(RecvChgUserCb_t f, void * data)
850 {
851 RecvChgUserCb = f;
852 chgUserCbData = data;
853 }
854 //-----------------------------------------------------------------------------
855 //-----------------------------------------------------------------------------
856 //-----------------------------------------------------------------------------
857 PARSER_CHECK_USER::PARSER_CHECK_USER()
858     : RecvCheckUserCb(NULL),
859       checkUserCbData(NULL),
860       depth(0),
861       error(false)
862 {
863 }
864 //-----------------------------------------------------------------------------
865 int PARSER_CHECK_USER::ParseStart(const char *el, const char **attr)
866 {
867 depth++;
868 if (depth == 1)
869     {
870     if (strcasecmp(el, "CheckUser") == 0)
871         {
872         //printf("el=%s attr[0]=%s attr[1]=%s\n", el, attr[0], attr[1]);
873         ParseAnswer(el, attr);
874         }
875     }
876 return 0;
877 }
878 //-----------------------------------------------------------------------------
879 void PARSER_CHECK_USER::ParseEnd(const char *)
880 {
881 depth--;
882 }
883 //-----------------------------------------------------------------------------
884 void PARSER_CHECK_USER::ParseAnswer(const char *, const char **attr)
885 {
886 if (RecvCheckUserCb)
887     {
888     RecvCheckUserCb(attr[1], checkUserCbData);
889     }
890 }
891 //-----------------------------------------------------------------------------
892 void PARSER_CHECK_USER::SetCheckUserRecvCb(RecvCheckUserCb_t f, void * data)
893 {
894 RecvCheckUserCb = f;
895 checkUserCbData = data;
896 }
897 //-----------------------------------------------------------------------------
898 //-----------------------------------------------------------------------------
899 //-----------------------------------------------------------------------------
900 PARSER_SEND_MESSAGE::PARSER_SEND_MESSAGE()
901     : RecvSendMessageCb(NULL),
902       sendMessageCbData(NULL),
903       depth(0),
904       error(false)
905 {
906 }
907 //-----------------------------------------------------------------------------
908 int  PARSER_SEND_MESSAGE::ParseStart(const char *el, const char **attr)
909 {
910 depth++;
911 if (depth == 1)
912     {
913     if (strcasecmp(el, "SendMessageResult") == 0)
914         {
915         ParseAnswer(el, attr);
916         }
917     }
918 return 0;
919 }
920 //-----------------------------------------------------------------------------
921 void PARSER_SEND_MESSAGE::ParseEnd(const char *)
922 {
923 depth--;
924 }
925 //-----------------------------------------------------------------------------
926 void PARSER_SEND_MESSAGE::ParseAnswer(const char *, const char **attr)
927 {
928 if (RecvSendMessageCb)
929     RecvSendMessageCb(attr[1], sendMessageCbData);
930 }
931 //-----------------------------------------------------------------------------
932 void PARSER_SEND_MESSAGE::SetSendMessageRecvCb(RecvSendMessageCb_t f, void * data)
933 {
934 RecvSendMessageCb = f;
935 sendMessageCbData = data;
936 }
937 //-----------------------------------------------------------------------------