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