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 //-----------------------------------------------------------------------------