stargazer/plugins/configuration/rpcconfig/rpcconfig.cpp

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