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