]> git.stg.codes - stg.git/blob - stglibs/srvconf.lib/servconf.cpp
Ticket 37. '../stglibs/common.lib/strptime.cpp' added in the
[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 "stg/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       error(0),
96       RecvUserDataCb(NULL),
97       RecvGetUserDataCb(NULL),
98       RecvServerInfoDataCb(NULL),
99       RecvChgUserCb(NULL),
100       RecvCheckUserCb(NULL),
101       RecvSendMessageCb(NULL),
102       getUserDataDataCb(NULL),
103       getUserAuthByDataCb(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 SERVCONF::~SERVCONF()
114 {
115 XML_ParserFree(parser);
116 }
117 //-----------------------------------------------------------------------------
118 void SERVCONF::SetServer(const char * server)
119 {
120 nt.SetServer(server);
121 }
122 //-----------------------------------------------------------------------------
123 void SERVCONF::SetPort(uint16_t port)
124 {
125 nt.SetServerPort(port);
126 }
127 //-----------------------------------------------------------------------------
128 void SERVCONF::SetAdmLogin(const char * login)
129 {
130 nt.SetLogin(login);
131 }
132 //-----------------------------------------------------------------------------
133 void SERVCONF::SetAdmPassword(const char * password)
134 {
135 nt.SetPassword(password);
136 }
137 //-----------------------------------------------------------------------------
138 int SERVCONF::GetUser(const char * l)
139 {
140 char request[255];
141 snprintf(request, 255, "<GetUser login=\"%s\"/>", l);
142 int ret;
143
144 currParser = &parserGetUser;
145 ((PARSER_GET_USER*)currParser)->SetUserDataRecvCb(RecvGetUserDataCb, getUserDataDataCb);
146
147 nt.Reset();
148 nt.SetRxCallback(this, AnsRecv);
149
150 if ((ret = nt.Connect()) != st_ok)
151     {
152     errorMsg = nt.GetError();
153     return ret;
154     }
155 if ((ret = nt.Transact(request)) != st_ok)
156     {
157     errorMsg = nt.GetError();
158     return ret;
159     }
160 if ((ret = nt.Disconnect()) != st_ok)
161     {
162     errorMsg = nt.GetError();
163     return ret;
164     }
165
166 return st_ok;
167 }
168 //-----------------------------------------------------------------------------
169 int SERVCONF::GetUserAuthBy(const char * l)
170 {
171 char request[255];
172 snprintf(request, 255, "<GetUserAuthBy login=\"%s\"/>", l);
173 int ret;
174
175 currParser = &parserAuthBy;
176 ((PARSER_AUTH_BY*)currParser)->SetRecvCb(RecvAuthByCb, getUserAuthByDataCb);
177
178 nt.Reset();
179 nt.SetRxCallback(this, AnsRecv);
180
181 if ((ret = nt.Connect()) != st_ok)
182     {
183     errorMsg = nt.GetError();
184     return ret;
185     }
186 if ((ret = nt.Transact(request)) != st_ok)
187     {
188     errorMsg = nt.GetError();
189     return ret;
190     }
191 if ((ret = nt.Disconnect()) != st_ok)
192     {
193     errorMsg = nt.GetError();
194     return ret;
195     }
196
197 return st_ok;
198 }
199 //-----------------------------------------------------------------------------
200 int SERVCONF::GetUsers()
201 {
202 char request[] = "<GetUsers/>";
203 int ret;
204
205 currParser = &parserGetUsers;
206 ((PARSER_GET_USERS*)currParser)->SetUserDataRecvCb(RecvUserDataCb, getUsersDataDataCb);
207
208 nt.Reset();
209 nt.SetRxCallback(this, AnsRecv);
210
211 if ((ret = nt.Connect()) != st_ok)
212     {
213     errorMsg = nt.GetError();
214     return ret;
215     }
216 if ((ret = nt.Transact(request)) != st_ok)
217     {
218     errorMsg = nt.GetError();
219     return ret;
220     }
221 if ((ret = nt.Disconnect()) != st_ok)
222     {
223     errorMsg = nt.GetError();
224     return ret;
225     }
226
227 return st_ok;
228 }
229 //-----------------------------------------------------------------------------
230 int SERVCONF::SendMessage(const char * login, const char * message, int prio)
231 {
232 char request[1000];
233 char msg[500];
234 Encode12(msg, message, strlen(message));
235 snprintf(request, 1000, "<Message login=\"%s\" priority=\"%d\" text=\"%s\"/>", login, prio, msg);
236 int ret;
237
238 currParser = &parserSendMessage;
239 parserSendMessage.SetSendMessageRecvCb(RecvSendMessageCb, sendMessageDataCb);
240
241 nt.Reset();
242 nt.SetRxCallback(this, AnsRecv);
243
244 if ((ret = nt.Connect()) != st_ok)
245     {
246     errorMsg = nt.GetError();
247     return ret;
248     }
249 if ((ret = nt.Transact(request)) != st_ok)
250     {
251     errorMsg = nt.GetError();
252     return ret;
253     }
254 if ((ret = nt.Disconnect()) != st_ok)
255     {
256     errorMsg = nt.GetError();
257     return ret;
258     }
259
260 return st_ok;
261 }
262 //-----------------------------------------------------------------------------
263 int SERVCONF::GetServerInfo()
264 {
265 char request[] = "<GetServerInfo/>";
266 int ret;
267
268 currParser = &parserServerInfo;
269 ((PARSER_GET_SERVER_INFO*)currParser)->SetServerInfoRecvCb(RecvServerInfoDataCb, getServerInfoDataCb);
270
271 nt.Reset();
272 nt.SetRxCallback(this, AnsRecv);
273
274 if ((ret = nt.Connect()) != st_ok)
275     {
276     errorMsg = nt.GetError();
277     return ret;
278     }
279 if ((ret = nt.Transact(request)) != st_ok)
280     {
281     errorMsg = nt.GetError();
282     return ret;
283     }
284 if ((ret = nt.Disconnect()) != st_ok)
285     {
286     errorMsg = nt.GetError();
287     return ret;
288     }
289
290 return st_ok;
291 }
292 //-----------------------------------------------------------------------------
293 int SERVCONF::ChgUser(const char * request)
294 {
295 int ret;
296
297 currParser = &parserChgUser;
298 ((PARSER_CHG_USER*)currParser)->SetChgUserRecvCb(RecvChgUserCb, chgUserDataCb);
299
300 nt.Reset();
301 nt.SetRxCallback(this, AnsRecv);
302
303 if ((ret = nt.Connect()) != st_ok)
304     {
305     errorMsg = nt.GetError();
306     return ret;
307     }
308 if ((ret = nt.Transact(request)) != st_ok)
309     {
310     errorMsg = nt.GetError();
311     return ret;
312     }
313 if ((ret = nt.Disconnect()) != st_ok)
314     {
315     errorMsg = nt.GetError();
316     return ret;
317     }
318
319 return st_ok;
320 }
321 //-----------------------------------------------------------------------------
322 //  TODO: remove this shit!
323 //-----------------------------------------------------------------------------
324 int SERVCONF::MsgUser(const char * request)
325 {
326 int ret;
327
328 currParser = &parserSendMessage;
329 parserSendMessage.SetSendMessageRecvCb(RecvSendMessageCb, sendMessageDataCb);
330
331 nt.Reset();
332 nt.SetRxCallback(this, AnsRecv);
333
334 if ((ret = nt.Connect()) != st_ok)
335     {
336     errorMsg = nt.GetError();
337     return ret;
338     }
339 if ((ret = nt.Transact(request)) != st_ok)
340     {
341     errorMsg = nt.GetError();
342     return ret;
343     }
344 if ((ret = nt.Disconnect()) != st_ok)
345     {
346     errorMsg = nt.GetError();
347     return ret;
348     }
349
350 return st_ok;
351 }
352 //-----------------------------------------------------------------------------
353 int SERVCONF::CheckUser(const char * login, const char * password)
354 {
355 char request[255];
356 snprintf(request, 255, "<CheckUser login=\"%s\" password=\"%s\"/>", login, password);
357 int ret;
358
359 currParser = &parserCheckUser;
360 ((PARSER_CHECK_USER*)currParser)->SetCheckUserRecvCb(RecvCheckUserCb, checkUserDataCb);
361
362 nt.Reset();
363 nt.SetRxCallback(this, AnsRecv);
364
365 if ((ret = nt.Connect()) != st_ok)
366     {
367     errorMsg = nt.GetError();
368     return ret;
369     }
370 if ((ret = nt.Transact(request)) != st_ok)
371     {
372     errorMsg = nt.GetError();
373     return ret;
374     }
375 if ((ret = nt.Disconnect()) != st_ok)
376     {
377     errorMsg = nt.GetError();
378     return ret;
379     }
380
381 return st_ok;
382 }
383 //-----------------------------------------------------------------------------
384 int SERVCONF::Start(const char *el, const char **attr)
385 {
386 currParser->ParseStart(el, attr);
387 return 0;
388 }
389 //-----------------------------------------------------------------------------
390 void SERVCONF::End(const char *el)
391 {
392 currParser->ParseEnd(el);
393 }
394 //-----------------------------------------------------------------------------
395 void SERVCONF::SetUserDataRecvCb(RecvUserDataCb_t f, void * data)
396 {
397 RecvUserDataCb = f;
398 getUsersDataDataCb = data;
399 }
400 //-----------------------------------------------------------------------------
401 void SERVCONF::SetGetUserDataRecvCb(RecvUserDataCb_t f, void * data)
402 {
403 RecvGetUserDataCb = f;            //GET_USER
404 getUserDataDataCb = data;
405 }
406 //-----------------------------------------------------------------------------
407 void SERVCONF::SetGetUserAuthByRecvCb(RecvAuthByDataCb_t f, void * data)
408 {
409 RecvAuthByCb = f;
410 getUserAuthByDataCb = data;
411 }
412 //-----------------------------------------------------------------------------
413 void SERVCONF::SetServerInfoRecvCb(RecvServerInfoDataCb_t f, void * data)
414 {
415 RecvServerInfoDataCb = f;
416 getServerInfoDataCb = data;
417 }
418 //-----------------------------------------------------------------------------
419 void SERVCONF::SetChgUserCb(RecvChgUserCb_t f, void * data)
420 {
421 RecvChgUserCb = f;
422 chgUserDataCb = data;
423 }
424 //-----------------------------------------------------------------------------
425 void SERVCONF::SetCheckUserCb(RecvCheckUserCb_t f, void * data)
426 {
427 RecvCheckUserCb = f;
428 checkUserDataCb = data;
429 }
430 //-----------------------------------------------------------------------------
431 void SERVCONF::SetSendMessageCb(RecvSendMessageCb_t f, void * data)
432 {
433 RecvSendMessageCb = f;
434 sendMessageDataCb = data;
435 }
436 //-----------------------------------------------------------------------------
437 const std::string & SERVCONF::GetStrError() const
438 {
439 return errorMsg;
440 }
441 //-----------------------------------------------------------------------------
442 int SERVCONF::GetError()
443 {
444 int e = error;
445 error = 0;
446 return e;
447 }
448 //-----------------------------------------------------------------------------