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