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