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