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