]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/configuration/rpcconfig/rpcconfig.cpp
Fixed installation path for rlm_stg project.
[stg.git] / projects / stargazer / plugins / configuration / rpcconfig / rpcconfig.cpp
1 #include <sys/types.h>
2 #include <sys/socket.h>
3 #include <netinet/in.h>
4 #include <arpa/inet.h>
5 #include <unistd.h>
6
7 #include <cstdlib>
8 #include <csignal>
9 #include <cerrno>
10 #include <cstring>
11 #include <vector>
12 #include <algorithm>
13 #include <ostream> // xmlrpc-c devs have missed something :)
14
15 #include "stg/common.h"
16 #include "stg/admin.h"
17 #include "stg/module_settings.h"
18 #include "stg/settings.h"
19 #include "stg/plugin_creator.h"
20
21 #include "rpcconfig.h"
22 #include "info_methods.h"
23 #include "users_methods.h"
24 #include "tariffs_methods.h"
25 #include "admins_methods.h"
26 #include "messages_methods.h"
27
28 PLUGIN_CREATOR<RPC_CONFIG> rpcc;
29
30 RPC_CONFIG_SETTINGS::RPC_CONFIG_SETTINGS()
31     : errorStr(),
32       port(0),
33       cookieTimeout(0)
34 {
35 }
36
37 int RPC_CONFIG_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
38 {
39 int p;
40 PARAM_VALUE pv;
41 std::vector<PARAM_VALUE>::const_iterator pvi;
42
43 pv.param = "Port";
44 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
45 if (pvi == s.moduleParams.end())
46     {
47     errorStr = "Parameter \'Port\' not found.";
48     printfd(__FILE__, "Parameter 'Port' not found\n");
49     return -1;
50     }
51 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
52     {
53     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
54     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
55     return -1;
56     }
57 port = p;
58
59 pv.param = "CookieTimeout";
60 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
61 if (pvi == s.moduleParams.end())
62     {
63     cookieTimeout = 1800; // 30 * 60
64     }
65 else
66     {
67     if (str2x(pvi->value[0], cookieTimeout))
68         {
69         errorStr = "Incorrect value of CookieTimeout: \'" + pvi->value[0] + "\'";
70         printfd(__FILE__, "Incorrect value of 'CookieTimeout'\n");
71         return -1;
72         }
73     }
74
75 return 0;
76 }
77
78 PLUGIN * GetPlugin()
79 {
80 return rpcc.GetPlugin();
81 }
82
83 RPC_CONFIG::RPC_CONFIG()
84     : errorStr(),
85       rpcConfigSettings(),
86       users(NULL),
87       admins(NULL),
88       tariffs(NULL),
89       store(NULL),
90       settings(),
91       fd(-1),
92       rpcRegistry(),
93       rpcServer(NULL),
94       running(false),
95       stopped(true),
96       tid(),
97       cookies(),
98       dayFee(0),
99       dirNames(),
100       logger(GetPluginLogger(GetStgLogger(), "conf_rpc"))
101 {
102 }
103
104 RPC_CONFIG::~RPC_CONFIG()
105 {
106 // delete server
107 delete rpcServer;
108 }
109
110 int RPC_CONFIG::ParseSettings()
111 {
112 int ret = rpcConfigSettings.ParseSettings(settings);
113
114 if (ret)
115     errorStr = rpcConfigSettings.GetStrError();
116
117 return ret;
118 }
119
120 void RPC_CONFIG::SetStgSettings(const SETTINGS * settings)
121 {
122     dayFee = settings->GetDayFee();
123     dirNames.erase(dirNames.begin(), dirNames.end());
124     for (size_t i = 0; i < DIR_NUM; ++i) {
125         dirNames.push_back(settings->GetDirName(i));
126     }
127 }
128
129 int RPC_CONFIG::Start()
130 {
131 InitiateRegistry();
132 running = true;
133
134 fd = socket(AF_INET, SOCK_STREAM, 0);
135 if (fd < 0)
136     {
137     errorStr = "Failed to create socket";
138     logger("Cannot create a socket: %s", strerror(errno));
139     printfd(__FILE__, "Failed to create listening socket: %s\n", strerror(errno));
140     return -1;
141     }
142
143 int flag = 1;
144
145 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag)))
146     {
147     errorStr = "Setsockopt failed.";
148     logger("setsockopt error: %s", strerror(errno));
149     printfd(__FILE__, "Setsockopt failed: %s\n", strerror(errno));
150     return -1;
151     }
152
153 struct sockaddr_in addr;
154 addr.sin_family = AF_INET;
155 addr.sin_port = htons(rpcConfigSettings.GetPort());
156 addr.sin_addr.s_addr = inet_addr("0.0.0.0");
157
158 if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)))
159     {
160     logger("Cannot bind the socket: %s", strerror(errno));
161     errorStr = "Failed to bind socket";
162     printfd(__FILE__, "Failed to bind listening socket: %s\n", strerror(errno));
163     return -1;
164     }
165
166 if (listen(fd, 10))
167     {
168     logger("Cannot listen the socket: %s", strerror(errno));
169     errorStr = "Failed to listen socket";
170     printfd(__FILE__, "Failed to listen listening socket: %s\n", strerror(errno));
171     return -1;
172     }
173
174 rpcServer = new xmlrpc_c::serverAbyss(
175         xmlrpc_c::serverAbyss::constrOpt()
176         .registryP(&rpcRegistry)
177         .logFileName("/var/log/stargazer_rpc.log")
178         .socketFd(fd)
179         );
180
181 if (pthread_create(&tid, NULL, Run, this))
182     {
183     errorStr = "Failed to create RPC thread";
184     logger("Cannot create RPC thread.");
185     printfd(__FILE__, "Failed to crate RPC thread\n");
186     return -1;
187     }
188
189 return 0;
190 }
191
192 int RPC_CONFIG::Stop()
193 {
194 running = false;
195 for (int i = 0; i < 5 && !stopped; ++i)
196     {
197     struct timespec ts = {0, 200000000};
198     nanosleep(&ts, NULL);
199     }
200
201 if (!stopped)
202     {
203     running = true;
204     logger("Cannot stop RPC thread.");
205     printfd(__FILE__, "Failed to stop RPC thread\n");
206     errorStr = "Failed to stop RPC thread";
207     return -1;
208     }
209 else
210     {
211     pthread_join(tid, NULL);
212     }
213
214 close(fd);
215
216 return 0;
217 }
218
219 void * RPC_CONFIG::Run(void * rc)
220 {
221 sigset_t signalSet;
222 sigfillset(&signalSet);
223 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
224
225 RPC_CONFIG * config = static_cast<RPC_CONFIG *>(rc);
226
227 config->stopped = false;
228 while (config->running)
229     {
230     if (WaitPackets(config->fd))
231         config->rpcServer->runOnce();
232     }
233 config->stopped = true;
234
235 return NULL;
236 }
237
238 bool RPC_CONFIG::GetAdminInfo(const std::string & cookie,
239                               ADMIN_INFO * info)
240 {
241 std::map<std::string,
242          ADMIN_INFO>::iterator it;
243
244 it = cookies.find(cookie);
245
246 if (it == cookies.end())
247     {
248     return true;
249     }
250
251 if (difftime(it->second.accessTime, time(NULL)) >
252     rpcConfigSettings.GetCookieTimeout())
253     {
254     cookies.erase(it);
255     return true;
256     }
257
258 // Update access time
259 time(&it->second.accessTime);
260 *info = it->second;
261 return false;
262 }
263
264 bool RPC_CONFIG::CheckAdmin(const std::string & login,
265                             const std::string & password,
266                             std::string * cookie)
267 {
268 ADMIN * admin = NULL;
269
270 if (!admins->Correct(login, password, &admin))
271     {
272     logger("Attempt to connect with invalid credentials. Login: %s", login.c_str());
273     return true;
274     }
275
276 ADMIN_INFO info;
277 time(&info.accessTime);
278 info.admin = login;
279 info.priviledges = *admin->GetPriv();
280 *cookie = GetCookie();
281 cookies[*cookie] = info;
282
283 return false;
284 }
285
286 bool RPC_CONFIG::LogoutAdmin(const std::string & cookie)
287 {
288 std::map<std::string,
289          ADMIN_INFO>::iterator it;
290
291 it = cookies.find(cookie);
292
293 if (it == cookies.end())
294     {
295     return true;
296     }
297
298 cookies.erase(it);
299
300 return false;
301 }
302
303 std::string RPC_CONFIG::GetCookie() const
304 {
305 std::string charset("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890");
306 std::string cookie;
307
308 for (int i = 0; i < 64; ++i)
309     {
310     cookie += charset[rand() % charset.length()];
311     };
312
313 return cookie;
314 }
315
316 void RPC_CONFIG::InitiateRegistry()
317 {
318 // manage registry
319 xmlrpc_c::methodPtr const methodInfoPtr(new METHOD_INFO(
320             tariffs,
321             users,
322             dayFee,
323             dirNames
324             ));
325 rpcRegistry.addMethod("stargazer.info", methodInfoPtr);
326
327 xmlrpc_c::methodPtr const methodLoginPtr(new METHOD_LOGIN(
328             this
329             ));
330 rpcRegistry.addMethod("stargazer.login", methodLoginPtr);
331
332 xmlrpc_c::methodPtr const methodLogoutPtr(new METHOD_LOGOUT(
333             this
334             ));
335 rpcRegistry.addMethod("stargazer.logout", methodLogoutPtr);
336
337 xmlrpc_c::methodPtr const methodGetUserPtr(new METHOD_USER_GET(
338             this,
339             users
340             ));
341 rpcRegistry.addMethod("stargazer.get_user", methodGetUserPtr);
342
343 xmlrpc_c::methodPtr const methodAddUserPtr(new METHOD_USER_ADD(
344             this,
345             admins,
346             users
347             ));
348 rpcRegistry.addMethod("stargazer.add_user", methodAddUserPtr);
349
350 xmlrpc_c::methodPtr const methodDelUserPtr(new METHOD_USER_DEL(
351             this,
352             admins,
353             users
354             ));
355 rpcRegistry.addMethod("stargazer.del_user", methodDelUserPtr);
356
357 xmlrpc_c::methodPtr const methodGetUsersPtr(new METHOD_USERS_GET(
358             this,
359             users
360             ));
361 rpcRegistry.addMethod("stargazer.get_users", methodGetUsersPtr);
362
363 xmlrpc_c::methodPtr const methodChgUserPtr(new METHOD_USER_CHG(
364             this,
365             admins,
366             tariffs,
367             store,
368             users
369             ));
370 rpcRegistry.addMethod("stargazer.chg_user", methodChgUserPtr);
371
372 xmlrpc_c::methodPtr const methodAddCashPtr(new METHOD_USER_CASH_ADD(
373             this,
374             admins,
375             store,
376             users
377             ));
378 rpcRegistry.addMethod("stargazer.add_user_cash", methodAddCashPtr);
379
380 xmlrpc_c::methodPtr const methodSetCashPtr(new METHOD_USER_CASH_SET(
381             this,
382             admins,
383             store,
384             users
385             ));
386 rpcRegistry.addMethod("stargazer.set_user_cash", methodSetCashPtr);
387
388 xmlrpc_c::methodPtr const methodTariffChangePtr(new METHOD_USER_TARIFF_CHANGE(
389             this,
390             admins,
391             tariffs,
392             store,
393             users
394             ));
395 rpcRegistry.addMethod("stargazer.chg_user_tariff", methodTariffChangePtr);
396
397 xmlrpc_c::methodPtr const methodGetTariffPtr(new METHOD_TARIFF_GET(
398             this,
399             tariffs
400             ));
401 rpcRegistry.addMethod("stargazer.get_tariff", methodGetTariffPtr);
402
403 xmlrpc_c::methodPtr const methodChgTariffPtr(new METHOD_TARIFF_CHG(
404             this,
405             admins,
406             tariffs
407             ));
408 rpcRegistry.addMethod("stargazer.chg_tariff", methodChgTariffPtr);
409
410 xmlrpc_c::methodPtr const methodGetTariffsPtr(new METHOD_TARIFFS_GET(
411             this,
412             tariffs
413             ));
414 rpcRegistry.addMethod("stargazer.get_tariffs", methodGetTariffsPtr);
415
416 xmlrpc_c::methodPtr const methodAddTariffPtr(new METHOD_TARIFF_ADD(
417             this,
418             admins,
419             tariffs
420             ));
421 rpcRegistry.addMethod("stargazer.add_tariff", methodAddTariffPtr);
422
423 xmlrpc_c::methodPtr const methodDelTariffPtr(new METHOD_TARIFF_DEL(
424             this,
425             admins,
426             tariffs,
427             users
428             ));
429 rpcRegistry.addMethod("stargazer.del_tariff", methodDelTariffPtr);
430
431 xmlrpc_c::methodPtr const methodGetAdminPtr(new METHOD_ADMIN_GET(
432             this,
433             admins
434             ));
435 rpcRegistry.addMethod("stargazer.get_admin", methodGetAdminPtr);
436
437 xmlrpc_c::methodPtr const methodAddAdminPtr(new METHOD_ADMIN_ADD(
438             this,
439             admins
440             ));
441 rpcRegistry.addMethod("stargazer.add_admin", methodAddAdminPtr);
442
443 xmlrpc_c::methodPtr const methodDelAdminPtr(new METHOD_ADMIN_DEL(
444             this,
445             admins
446             ));
447 rpcRegistry.addMethod("stargazer.del_admin", methodDelAdminPtr);
448
449 xmlrpc_c::methodPtr const methodChgAdminPtr(new METHOD_ADMIN_CHG(
450             this,
451             admins
452             ));
453 rpcRegistry.addMethod("stargazer.chg_admin", methodChgAdminPtr);
454
455 xmlrpc_c::methodPtr const methodGetAdminsPtr(new METHOD_ADMINS_GET(
456             this,
457             admins
458             ));
459 rpcRegistry.addMethod("stargazer.get_admins", methodGetAdminsPtr);
460
461 xmlrpc_c::methodPtr const methodSendMessagePtr(new METHOD_MESSAGE_SEND(
462             this,
463             users
464             ));
465 rpcRegistry.addMethod("stargazer.send_user_message", methodSendMessagePtr);
466
467 xmlrpc_c::methodPtr const methodGetOnlinIPsPtr(new METHOD_GET_ONLINE_IPS(
468             this,
469             users
470             ));
471 rpcRegistry.addMethod("stargazer.get_online_ips", methodGetOnlinIPsPtr);
472 }
473