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