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 #include "stg/servconf.h"
  22
  23 #include "stg/common.h"
  24
  25 #include <cstdio>
  26 #include <cstring>
  27
  28 //-----------------------------------------------------------------------------
  29 int AnsRecv(void * data, std::list<std::string> * list1)
  30 {
  31 SERVCONF * sc = static_cast<SERVCONF *>(data);
  32
  33 XML_ParserReset(sc->parser, NULL);
  34 XML_SetElementHandler(sc->parser, Start, End);
  35 XML_SetUserData(sc->parser, data);
  36
  37 char ans[ENC_MSG_LEN + 1];
  38 int len, done = 0;
  39
  40 //loop parsing
  41 std::list<std::string>::iterator node;
  42 node = list1->begin();
  43
  44 while (node != list1->end())
  45     {
  46     strncpy(ans, node->c_str(), ENC_MSG_LEN);
  47     ans[ENC_MSG_LEN] = 0;
  48     len = strlen(ans);
  49
  50     if (XML_Parse(sc->parser, ans, len, done) == XML_STATUS_ERROR)
  51         {
  52         strprintf(&sc->errorMsg, "XML parse error at line %d: %s",
  53                   static_cast<int>(XML_GetCurrentLineNumber(sc->parser)),
  54                   XML_ErrorString(XML_GetErrorCode(sc->parser)));
  55         printf("%s\n", sc->errorMsg.c_str());
  56         return st_xml_parse_error;
  57         }
  58     ++node;
  59     }
  60
  61 return st_ok;
  62 }
  63 //-----------------------------------------------------------------------------
  64 void Start(void *data, const char *el, const char **attr)
  65 {
  66 SERVCONF * sc = static_cast<SERVCONF *>(data);
  67 sc->Start(el, attr);
  68 }
  69 //-----------------------------------------------------------------------------
  70 void End(void * data, const char * el)
  71 {
  72 SERVCONF * sc = static_cast<SERVCONF *>(data);
  73 sc->End(el);
  74 }
  75 //-----------------------------------------------------------------------------
  76 SERVCONF::SERVCONF()
  77     : currParser(NULL)
  78 {
  79 parser = XML_ParserCreate(NULL);
  80 nt.SetRxCallback(this, AnsRecv);
  81 }
  82 //-----------------------------------------------------------------------------
  83 void SERVCONF::SetServer(const char * server)
  84 {
  85 nt.SetServer(server);
  86 }
  87 //-----------------------------------------------------------------------------
  88 void SERVCONF::SetPort(uint16_t port)
  89 {
  90 nt.SetServerPort(port);
  91 }
  92 //-----------------------------------------------------------------------------
  93 void SERVCONF::SetAdmLogin(const char * login)
  94 {
  95 nt.SetLogin(login);
  96 }
  97 //-----------------------------------------------------------------------------
  98 void SERVCONF::SetAdmPassword(const char * password)
  99 {
 100 nt.SetPassword(password);
 101 }
 102 //-----------------------------------------------------------------------------
 103 int SERVCONF::GetUser(const char * l)
 104 {
 105 char request[255];
 106 snprintf(request, 255, "<GetUser login=\"%s\"/>", l);
 107
 108 currParser = &parserGetUser;
 109
 110 return Exec(request);
 111 }
 112 //-----------------------------------------------------------------------------
 113 int SERVCONF::AuthBy(const char * l)
 114 {
 115 char request[255];
 116 snprintf(request, 255, "<GetUserAuthBy login=\"%s\"/>", l);
 117
 118 currParser = &parserAuthBy;
 119
 120 return Exec(request);
 121 }
 122 //-----------------------------------------------------------------------------
 123 int SERVCONF::GetUsers()
 124 {
 125 char request[] = "<GetUsers/>";
 126
 127 currParser = &parserGetUsers;
 128
 129 return Exec(request);
 130 }
 131 //-----------------------------------------------------------------------------
 132 int SERVCONF::ServerInfo()
 133 {
 134 char request[] = "<GetServerInfo/>";
 135
 136 currParser = &parserServerInfo;
 137
 138 return Exec(request);
 139 }
 140 //-----------------------------------------------------------------------------
 141 int SERVCONF::ChgUser(const char * request)
 142 {
 143 currParser = &parserChgUser;
 144
 145 return Exec(request);
 146 }
 147 //-----------------------------------------------------------------------------
 148 int SERVCONF::SendMessage(const char * request)
 149 {
 150 currParser = &parserSendMessage;
 151
 152 return Exec(request);
 153 }
 154 //-----------------------------------------------------------------------------
 155 int SERVCONF::CheckUser(const char * login, const char * password)
 156 {
 157 char request[255];
 158 snprintf(request, 255, "<CheckUser login=\"%s\" password=\"%s\"/>", login, password);
 159
 160 currParser = &parserCheckUser;
 161
 162 return Exec(request);
 163 }
 164 //-----------------------------------------------------------------------------
 165 int SERVCONF::Start(const char * el, const char ** attr)
 166 {
 167 currParser->ParseStart(el, attr);
 168 return 0;
 169 }
 170 //-----------------------------------------------------------------------------
 171 void SERVCONF::End(const char * el)
 172 {
 173 currParser->ParseEnd(el);
 174 }
 175 //-----------------------------------------------------------------------------
 176 void SERVCONF::SetGetUsersCallback(PARSER_GET_USERS::CALLBACK f, void * data)
 177 {
 178 parserGetUsers.SetCallback(f, data);
 179 }
 180 //-----------------------------------------------------------------------------
 181 void SERVCONF::SetGetUserCallback(PARSER_GET_USER::CALLBACK f, void * data)
 182 {
 183 parserGetUser.SetCallback(f, data);
 184 }
 185 //-----------------------------------------------------------------------------
 186 void SERVCONF::SetAuthByCallback(PARSER_AUTH_BY::CALLBACK f, void * data)
 187 {
 188 parserAuthBy.SetCallback(f, data);
 189 }
 190 //-----------------------------------------------------------------------------
 191 void SERVCONF::SetServerInfoCallback(PARSER_SERVER_INFO::CALLBACK f, void * data)
 192 {
 193 parserServerInfo.SetCallback(f, data);
 194 }
 195 //-----------------------------------------------------------------------------
 196 void SERVCONF::SetChgUserCallback(PARSER_CHG_USER::CALLBACK f, void * data)
 197 {
 198 parserChgUser.SetCallback(f, data);
 199 }
 200 //-----------------------------------------------------------------------------
 201 void SERVCONF::SetCheckUserCallback(PARSER_CHECK_USER::CALLBACK f, void * data)
 202 {
 203 parserCheckUser.SetCallback(f, data);
 204 }
 205 //-----------------------------------------------------------------------------
 206 void SERVCONF::SetSendMessageCallback(PARSER_SEND_MESSAGE::CALLBACK f, void * data)
 207 {
 208 parserSendMessage.SetCallback(f, data);
 209 }
 210 //-----------------------------------------------------------------------------
 211 const std::string & SERVCONF::GetStrError() const
 212 {
 213 return errorMsg;
 214 }
 215 //-----------------------------------------------------------------------------
 216 int SERVCONF::Exec(const char * request)
 217 {
 218 nt.Reset();
 219
 220 int ret = 0;
 221 if ((ret = nt.Connect()) != st_ok)
 222     {
 223     errorMsg = nt.GetError();
 224     return ret;
 225     }
 226 if ((ret = nt.Transact(request)) != st_ok)
 227     {
 228     errorMsg = nt.GetError();
 229     return ret;
 230     }
 231 if ((ret = nt.Disconnect()) != st_ok)
 232     {
 233     errorMsg = nt.GetError();
 234     return ret;
 235     }
 236
 237 return st_ok;
 238 }