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