]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/configuration/rpcconfig/rpcconfig.cpp
Use std::lock_guard instead of STG_LOCKER.
[stg.git] / projects / 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       stopped(true),
90       dayFee(0),
91       logger(STG::PluginLogger::get("conf_rpc"))
92 {
93 }
94
95 RPC_CONFIG::~RPC_CONFIG()
96 {
97 // delete server
98 delete rpcServer;
99 }
100
101 int RPC_CONFIG::ParseSettings()
102 {
103 int ret = rpcConfigSettings.ParseSettings(settings);
104
105 if (ret)
106     errorStr = rpcConfigSettings.GetStrError();
107
108 return ret;
109 }
110
111 void RPC_CONFIG::SetStgSettings(const STG::Settings * s)
112 {
113     dayFee = s->GetDayFee();
114     dirNames.erase(dirNames.begin(), dirNames.end());
115     for (size_t i = 0; i < DIR_NUM; ++i) {
116         dirNames.push_back(s->GetDirName(i));
117     }
118 }
119
120 int RPC_CONFIG::Start()
121 {
122 InitiateRegistry();
123
124 fd = socket(AF_INET, SOCK_STREAM, 0);
125 if (fd < 0)
126     {
127     errorStr = "Failed to create socket";
128     logger("Cannot create a socket: %s", strerror(errno));
129     printfd(__FILE__, "Failed to create listening socket: %s\n", strerror(errno));
130     return -1;
131     }
132
133 int flag = 1;
134
135 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag)))
136     {
137     errorStr = "Setsockopt failed.";
138     logger("setsockopt error: %s", strerror(errno));
139     printfd(__FILE__, "Setsockopt failed: %s\n", strerror(errno));
140     return -1;
141     }
142
143 struct sockaddr_in addr;
144 addr.sin_family = AF_INET;
145 addr.sin_port = htons(rpcConfigSettings.GetPort());
146 addr.sin_addr.s_addr = inet_addr("0.0.0.0");
147
148 if (bind(fd, reinterpret_cast<sockaddr *>(&addr), sizeof(addr)))
149     {
150     logger("Cannot bind the socket: %s", strerror(errno));
151     errorStr = "Failed to bind socket";
152     printfd(__FILE__, "Failed to bind listening socket: %s\n", strerror(errno));
153     return -1;
154     }
155
156 if (listen(fd, 10))
157     {
158     logger("Cannot listen the socket: %s", strerror(errno));
159     errorStr = "Failed to listen socket";
160     printfd(__FILE__, "Failed to listen listening socket: %s\n", strerror(errno));
161     return -1;
162     }
163
164 rpcServer = new xmlrpc_c::serverAbyss(
165         xmlrpc_c::serverAbyss::constrOpt()
166         .registryP(&rpcRegistry)
167         .logFileName("/var/log/stargazer_rpc.log")
168         .socketFd(fd)
169         );
170
171 m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
172
173 return 0;
174 }
175
176 int RPC_CONFIG::Stop()
177 {
178 m_thread.request_stop();
179 for (int i = 0; i < 5 && !stopped; ++i)
180     {
181     struct timespec ts = {0, 200000000};
182     nanosleep(&ts, NULL);
183     }
184
185 if (!stopped)
186     {
187     m_thread.detach();
188     logger("Cannot stop RPC thread.");
189     printfd(__FILE__, "Failed to stop RPC thread\n");
190     errorStr = "Failed to stop RPC thread";
191     return -1;
192     }
193 else
194     m_thread.join();
195
196 close(fd);
197
198 return 0;
199 }
200
201 void RPC_CONFIG::Run(std::stop_token token)
202 {
203 sigset_t signalSet;
204 sigfillset(&signalSet);
205 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
206
207 stopped = false;
208 while (!token.stop_requested())
209     {
210     if (WaitPackets(fd))
211         rpcServer->runOnce();
212     }
213 stopped = true;
214 }
215
216 bool RPC_CONFIG::GetAdminInfo(const std::string & cookie,
217                               ADMIN_INFO * info)
218 {
219 std::map<std::string,
220          ADMIN_INFO>::iterator it;
221
222 it = cookies.find(cookie);
223
224 if (it == cookies.end())
225     {
226     return true;
227     }
228
229 if (difftime(it->second.accessTime, time(NULL)) >
230     rpcConfigSettings.GetCookieTimeout())
231     {
232     cookies.erase(it);
233     return true;
234     }
235
236 // Update access time
237 time(&it->second.accessTime);
238 *info = it->second;
239 return false;
240 }
241
242 bool RPC_CONFIG::CheckAdmin(const std::string & login,
243                             const std::string & password,
244                             std::string * cookie)
245 {
246 STG::Admin * admin = NULL;
247
248 if (!admins->correct(login, password, &admin))
249     {
250     logger("Attempt to connect with invalid credentials. Login: %s", login.c_str());
251     return true;
252     }
253
254 ADMIN_INFO info;
255 time(&info.accessTime);
256 info.admin = login;
257 info.priviledges = admin->priv();
258 *cookie = GetCookie();
259 cookies[*cookie] = info;
260
261 return false;
262 }
263
264 bool RPC_CONFIG::LogoutAdmin(const std::string & cookie)
265 {
266 std::map<std::string,
267          ADMIN_INFO>::iterator it;
268
269 it = cookies.find(cookie);
270
271 if (it == cookies.end())
272     {
273     return true;
274     }
275
276 cookies.erase(it);
277
278 return false;
279 }
280
281 std::string RPC_CONFIG::GetCookie() const
282 {
283 std::string charset("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890");
284 std::string cookie;
285
286 for (int i = 0; i < 64; ++i)
287     {
288     cookie += charset[rand() % charset.length()];
289     };
290
291 return cookie;
292 }
293
294 void RPC_CONFIG::InitiateRegistry()
295 {
296 // manage registry
297 xmlrpc_c::methodPtr const methodInfoPtr(new METHOD_INFO(
298             tariffs,
299             users,
300             dayFee,
301             dirNames
302             ));
303 rpcRegistry.addMethod("stargazer.info", methodInfoPtr);
304
305 xmlrpc_c::methodPtr const methodLoginPtr(new METHOD_LOGIN(
306             this
307             ));
308 rpcRegistry.addMethod("stargazer.login", methodLoginPtr);
309
310 xmlrpc_c::methodPtr const methodLogoutPtr(new METHOD_LOGOUT(
311             this
312             ));
313 rpcRegistry.addMethod("stargazer.logout", methodLogoutPtr);
314
315 xmlrpc_c::methodPtr const methodGetUserPtr(new METHOD_USER_GET(
316             this,
317             users
318             ));
319 rpcRegistry.addMethod("stargazer.get_user", methodGetUserPtr);
320
321 xmlrpc_c::methodPtr const methodAddUserPtr(new METHOD_USER_ADD(
322             this,
323             admins,
324             users
325             ));
326 rpcRegistry.addMethod("stargazer.add_user", methodAddUserPtr);
327
328 xmlrpc_c::methodPtr const methodDelUserPtr(new METHOD_USER_DEL(
329             this,
330             admins,
331             users
332             ));
333 rpcRegistry.addMethod("stargazer.del_user", methodDelUserPtr);
334
335 xmlrpc_c::methodPtr const methodGetUsersPtr(new METHOD_USERS_GET(
336             this,
337             users
338             ));
339 rpcRegistry.addMethod("stargazer.get_users", methodGetUsersPtr);
340
341 xmlrpc_c::methodPtr const methodChgUserPtr(new METHOD_USER_CHG(
342             this,
343             admins,
344             tariffs,
345             store,
346             users
347             ));
348 rpcRegistry.addMethod("stargazer.chg_user", methodChgUserPtr);
349
350 xmlrpc_c::methodPtr const methodAddCashPtr(new METHOD_USER_CASH_ADD(
351             this,
352             admins,
353             store,
354             users
355             ));
356 rpcRegistry.addMethod("stargazer.add_user_cash", methodAddCashPtr);
357
358 xmlrpc_c::methodPtr const methodSetCashPtr(new METHOD_USER_CASH_SET(
359             this,
360             admins,
361             store,
362             users
363             ));
364 rpcRegistry.addMethod("stargazer.set_user_cash", methodSetCashPtr);
365
366 xmlrpc_c::methodPtr const methodTariffChangePtr(new METHOD_USER_TARIFF_CHANGE(
367             this,
368             admins,
369             tariffs,
370             store,
371             users
372             ));
373 rpcRegistry.addMethod("stargazer.chg_user_tariff", methodTariffChangePtr);
374
375 xmlrpc_c::methodPtr const methodGetTariffPtr(new METHOD_TARIFF_GET(
376             this,
377             tariffs
378             ));
379 rpcRegistry.addMethod("stargazer.get_tariff", methodGetTariffPtr);
380
381 xmlrpc_c::methodPtr const methodChgTariffPtr(new METHOD_TARIFF_CHG(
382             this,
383             admins,
384             tariffs
385             ));
386 rpcRegistry.addMethod("stargazer.chg_tariff", methodChgTariffPtr);
387
388 xmlrpc_c::methodPtr const methodGetTariffsPtr(new METHOD_TARIFFS_GET(
389             this,
390             tariffs
391             ));
392 rpcRegistry.addMethod("stargazer.get_tariffs", methodGetTariffsPtr);
393
394 xmlrpc_c::methodPtr const methodAddTariffPtr(new METHOD_TARIFF_ADD(
395             this,
396             admins,
397             tariffs
398             ));
399 rpcRegistry.addMethod("stargazer.add_tariff", methodAddTariffPtr);
400
401 xmlrpc_c::methodPtr const methodDelTariffPtr(new METHOD_TARIFF_DEL(
402             this,
403             admins,
404             tariffs,
405             users
406             ));
407 rpcRegistry.addMethod("stargazer.del_tariff", methodDelTariffPtr);
408
409 xmlrpc_c::methodPtr const methodGetAdminPtr(new METHOD_ADMIN_GET(
410             this,
411             admins
412             ));
413 rpcRegistry.addMethod("stargazer.get_admin", methodGetAdminPtr);
414
415 xmlrpc_c::methodPtr const methodAddAdminPtr(new METHOD_ADMIN_ADD(
416             this,
417             admins
418             ));
419 rpcRegistry.addMethod("stargazer.add_admin", methodAddAdminPtr);
420
421 xmlrpc_c::methodPtr const methodDelAdminPtr(new METHOD_ADMIN_DEL(
422             this,
423             admins
424             ));
425 rpcRegistry.addMethod("stargazer.del_admin", methodDelAdminPtr);
426
427 xmlrpc_c::methodPtr const methodChgAdminPtr(new METHOD_ADMIN_CHG(
428             this,
429             admins
430             ));
431 rpcRegistry.addMethod("stargazer.chg_admin", methodChgAdminPtr);
432
433 xmlrpc_c::methodPtr const methodGetAdminsPtr(new METHOD_ADMINS_GET(
434             this,
435             admins
436             ));
437 rpcRegistry.addMethod("stargazer.get_admins", methodGetAdminsPtr);
438
439 xmlrpc_c::methodPtr const methodSendMessagePtr(new METHOD_MESSAGE_SEND(
440             this,
441             users
442             ));
443 rpcRegistry.addMethod("stargazer.send_user_message", methodSendMessagePtr);
444
445 xmlrpc_c::methodPtr const methodGetOnlinIPsPtr(new METHOD_GET_ONLINE_IPS(
446             this,
447             users
448             ));
449 rpcRegistry.addMethod("stargazer.get_online_ips", methodGetOnlinIPsPtr);
450
451 xmlrpc_c::methodPtr const methodGetUserAuthByPtr(new METHOD_GET_USER_AUTH_BY(
452             this,
453             users
454             ));
455 rpcRegistry.addMethod("stargazer.get_user_auth_by", methodGetUserAuthByPtr);
456 }
457