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