stglibs/srvconf.lib/servconf.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.8 $
  23  $Date: 2010/08/04 00:40:38 $
  24  $Author: faust $
  25  */
  26
  27 #include <cstdio>
  28 #include <cstring>
  29
  30 #include "servconf.h"
  31
  32 using namespace std;
  33
  34 //-----------------------------------------------------------------------------
  35 int AnsRecv(void * data, list<string> * list1)
  36 {
  37 //NODE * node;
  38 SERVCONF * sc;
  39 char ans[ENC_MSG_LEN + 1];
  40 int len, done = 0;
  41
  42 sc = (SERVCONF*)data;
  43
  44 XML_ParserReset(sc->parser, NULL);
  45 XML_SetElementHandler(sc->parser, Start, End);
  46 XML_SetUserData(sc->parser, data);
  47
  48 //loop parsing
  49 list<string>::iterator node;
  50 node = list1->begin();
  51
  52 if (node == list1->end())
  53     {
  54     return st_ok;
  55     }
  56
  57 while (node != list1->end())
  58     {
  59     strncpy(ans, node->c_str(), ENC_MSG_LEN);
  60     ans[ENC_MSG_LEN] = 0;
  61        //printf("---> %s\n", ans);
  62     len = strlen(ans);
  63
  64     if (XML_Parse(sc->parser, ans, len, done) == XML_STATUS_ERROR)
  65         {
  66         strprintf(&sc->errorMsg, "XML parse error at line %d: %s",
  67                   static_cast<int>(XML_GetCurrentLineNumber(sc->parser)),
  68                   XML_ErrorString(XML_GetErrorCode(sc->parser)));
  69         return st_xml_parse_error;
  70         }
  71     ++node;
  72
  73     }
  74
  75 return 0;
  76 }
  77 //-----------------------------------------------------------------------------
  78 void Start(void *data, const char *el, const char **attr)
  79 {
  80 SERVCONF * sc;
  81 sc = (SERVCONF*)data;
  82 sc->Start(el, attr);
  83 }
  84 //-----------------------------------------------------------------------------
  85 void End(void *data, const char *el)
  86 {
  87 SERVCONF * sc;
  88 sc = (SERVCONF*)data;
  89 sc->End(el);
  90 }
  91 //-----------------------------------------------------------------------------
  92 SERVCONF::SERVCONF()
  93 {
  94 parser = XML_ParserCreate(NULL);
  95 parseDepth = 0;
  96 }
  97 //-----------------------------------------------------------------------------
  98 void SERVCONF::SetServer(const char * server)
  99 {
 100 nt.SetServer(server);
 101 }
 102 //-----------------------------------------------------------------------------
 103 void SERVCONF::SetPort(uint16_t port)
 104 {
 105 nt.SetServerPort(port);
 106 }
 107 //-----------------------------------------------------------------------------
 108 void SERVCONF::SetAdmLogin(const char * login)
 109 {
 110 nt.SetLogin(login);
 111 }
 112 //-----------------------------------------------------------------------------
 113 void SERVCONF::SetAdmPassword(const char * password)
 114 {
 115 nt.SetPassword(password);
 116 }
 117 //-----------------------------------------------------------------------------
 118 int SERVCONF::GetUser(const char * l)
 119 {
 120 char request[255];
 121 snprintf(request, 255, "<GetUser login=\"%s\"/>", l);
 122 int ret;
 123
 124 currParser = &parserGetUser;
 125 ((PARSER_GET_USER*)currParser)->SetUserDataRecvCb(RecvGetUserDataCb, getUserDataDataCb);
 126
 127 nt.Reset();
 128 nt.SetRxCallback(this, AnsRecv);
 129
 130 if ((ret = nt.Connect()) != st_ok)
 131     {
 132     errorMsg = nt.GetError();
 133     return ret;
 134     }
 135 if ((ret = nt.Transact(request)) != st_ok)
 136     {
 137     errorMsg = nt.GetError();
 138     return ret;
 139     }
 140 if ((ret = nt.Disconnect()) != st_ok)
 141     {
 142     errorMsg = nt.GetError();
 143     return ret;
 144     }
 145
 146 return st_ok;
 147 }
 148 //-----------------------------------------------------------------------------
 149 int SERVCONF::GetUsers()
 150 {
 151 char request[] = "<GetUsers/>";
 152 int ret;
 153
 154 currParser = &parserGetUsers;
 155 ((PARSER_GET_USERS*)currParser)->SetUserDataRecvCb(RecvUserDataCb, getUsersDataDataCb);
 156
 157 nt.Reset();
 158 nt.SetRxCallback(this, AnsRecv);
 159
 160 if ((ret = nt.Connect()) != st_ok)
 161     {
 162     errorMsg = nt.GetError();
 163     return ret;
 164     }
 165 if ((ret = nt.Transact(request)) != st_ok)
 166     {
 167     errorMsg = nt.GetError();
 168     return ret;
 169     }
 170 if ((ret = nt.Disconnect()) != st_ok)
 171     {
 172     errorMsg = nt.GetError();
 173     return ret;
 174     }
 175
 176 return st_ok;
 177 }
 178 //-----------------------------------------------------------------------------
 179 int SERVCONF::SendMessage(const char * login, const char * message, int prio)
 180 {
 181 char request[1000];
 182 char msg[500];
 183 Encode12(msg, message, strlen(message));
 184 snprintf(request, 1000, "<Message login=\"%s\" priority=\"%d\" text=\"%s\"/>", login, prio, msg);
 185 int ret;
 186
 187 currParser = &parserSendMessage;
 188 parserSendMessage.SetSendMessageRecvCb(RecvSendMessageCb, sendMessageDataCb);
 189
 190 nt.Reset();
 191 nt.SetRxCallback(this, AnsRecv);
 192
 193 if ((ret = nt.Connect()) != st_ok)
 194     {
 195     errorMsg = nt.GetError();
 196     return ret;
 197     }
 198 if ((ret = nt.Transact(request)) != st_ok)
 199     {
 200     errorMsg = nt.GetError();
 201     return ret;
 202     }
 203 if ((ret = nt.Disconnect()) != st_ok)
 204     {
 205     errorMsg = nt.GetError();
 206     return ret;
 207     }
 208
 209 return st_ok;
 210 }
 211 //-----------------------------------------------------------------------------
 212 int SERVCONF::GetServerInfo()
 213 {
 214 char request[] = "<GetServerInfo/>";
 215 int ret;
 216
 217 currParser = &parserServerInfo;
 218 ((PARSER_GET_SERVER_INFO*)currParser)->SetServerInfoRecvCb(RecvServerInfoDataCb, getServerInfoDataCb);
 219
 220 nt.Reset();
 221 nt.SetRxCallback(this, AnsRecv);
 222
 223 if ((ret = nt.Connect()) != st_ok)
 224     {
 225     errorMsg = nt.GetError();
 226     return ret;
 227     }
 228 if ((ret = nt.Transact(request)) != st_ok)
 229     {
 230     errorMsg = nt.GetError();
 231     return ret;
 232     }
 233 if ((ret = nt.Disconnect()) != st_ok)
 234     {
 235     errorMsg = nt.GetError();
 236     return ret;
 237     }
 238
 239 return st_ok;
 240 }
 241 //-----------------------------------------------------------------------------
 242 int SERVCONF::ChgUser(const char * request)
 243 {
 244 int ret;
 245
 246 currParser = &parserChgUser;
 247 ((PARSER_CHG_USER*)currParser)->SetChgUserRecvCb(RecvChgUserCb, chgUserDataCb);
 248
 249 nt.Reset();
 250 nt.SetRxCallback(this, AnsRecv);
 251
 252 if ((ret = nt.Connect()) != st_ok)
 253     {
 254     errorMsg = nt.GetError();
 255     return ret;
 256     }
 257 if ((ret = nt.Transact(request)) != st_ok)
 258     {
 259     errorMsg = nt.GetError();
 260     return ret;
 261     }
 262 if ((ret = nt.Disconnect()) != st_ok)
 263     {
 264     errorMsg = nt.GetError();
 265     return ret;
 266     }
 267
 268 return st_ok;
 269 }
 270 //-----------------------------------------------------------------------------
 271 //  TODO: remove this shit!
 272 //-----------------------------------------------------------------------------
 273 int SERVCONF::MsgUser(const char * request)
 274 {
 275 int ret;
 276
 277 currParser = &parserSendMessage;
 278 parserSendMessage.SetSendMessageRecvCb(RecvSendMessageCb, sendMessageDataCb);
 279
 280 nt.Reset();
 281 nt.SetRxCallback(this, AnsRecv);
 282
 283 if ((ret = nt.Connect()) != st_ok)
 284     {
 285     errorMsg = nt.GetError();
 286     return ret;
 287     }
 288 if ((ret = nt.Transact(request)) != st_ok)
 289     {
 290     errorMsg = nt.GetError();
 291     return ret;
 292     }
 293 if ((ret = nt.Disconnect()) != st_ok)
 294     {
 295     errorMsg = nt.GetError();
 296     return ret;
 297     }
 298
 299 return st_ok;
 300 }
 301 //-----------------------------------------------------------------------------
 302 int SERVCONF::CheckUser(const char * login, const char * password)
 303 {
 304 char request[255];
 305 snprintf(request, 255, "<CheckUser login=\"%s\" password=\"%s\"/>", login, password);
 306 int ret;
 307
 308 currParser = &parserCheckUser;
 309 ((PARSER_CHECK_USER*)currParser)->SetCheckUserRecvCb(RecvCheckUserCb, checkUserDataCb);
 310
 311 nt.Reset();
 312 nt.SetRxCallback(this, AnsRecv);
 313
 314 if ((ret = nt.Connect()) != st_ok)
 315     {
 316     errorMsg = nt.GetError();
 317     return ret;
 318     }
 319 if ((ret = nt.Transact(request)) != st_ok)
 320     {
 321     errorMsg = nt.GetError();
 322     return ret;
 323     }
 324 if ((ret = nt.Disconnect()) != st_ok)
 325     {
 326     errorMsg = nt.GetError();
 327     return ret;
 328     }
 329
 330 return st_ok;
 331 }
 332 //-----------------------------------------------------------------------------
 333 int SERVCONF::Start(const char *el, const char **attr)
 334 {
 335 currParser->ParseStart(el, attr);
 336 return 0;
 337 }
 338 //-----------------------------------------------------------------------------
 339 void SERVCONF::End(const char *el)
 340 {
 341 currParser->ParseEnd(el);
 342 }
 343 //-----------------------------------------------------------------------------
 344 void SERVCONF::SetUserDataRecvCb(RecvUserDataCb_t f, void * data)
 345 {
 346 RecvUserDataCb = f;
 347 getUsersDataDataCb = data;
 348 }
 349 //-----------------------------------------------------------------------------
 350 void SERVCONF::SetGetUserDataRecvCb(RecvUserDataCb_t f, void * data)
 351 {
 352 RecvGetUserDataCb = f;            //GET_USER
 353 getUserDataDataCb = data;
 354 }
 355 //-----------------------------------------------------------------------------
 356 void SERVCONF::SetServerInfoRecvCb(RecvServerInfoDataCb_t f, void * data)
 357 {
 358 RecvServerInfoDataCb = f;
 359 getServerInfoDataCb = data;
 360 }
 361 //-----------------------------------------------------------------------------
 362 void SERVCONF::SetChgUserCb(RecvChgUserCb_t f, void * data)
 363 {
 364 RecvChgUserCb = f;
 365 chgUserDataCb = data;
 366 }
 367 //-----------------------------------------------------------------------------
 368 void SERVCONF::SetCheckUserCb(RecvCheckUserCb_t f, void * data)
 369 {
 370 RecvCheckUserCb = f;
 371 checkUserDataCb = data;
 372 }
 373 //-----------------------------------------------------------------------------
 374 void SERVCONF::SetSendMessageCb(RecvSendMessageCb_t f, void * data)
 375 {
 376 RecvSendMessageCb = f;
 377 sendMessageDataCb = data;
 378 }
 379 //-----------------------------------------------------------------------------
 380 const std::string & SERVCONF::GetStrError() const
 381 {
 382 return errorMsg;
 383 }
 384 //-----------------------------------------------------------------------------
 385 int SERVCONF::GetError()
 386 {
 387 int e = error;
 388 error = 0;
 389 return e;
 390 }
 391 //-----------------------------------------------------------------------------