Minor changes.

[stg.git] / projects / stargazer / plugins / configuration / rpcconfig / rpcconfig.cpp

diff --git a/projects/stargazer/plugins/configuration/rpcconfig/rpcconfig.cpp b/projects/stargazer/plugins/configuration/rpcconfig/rpcconfig.cpp
index af7419854c4a64f7e255f46702415686af7a0514..3b28ddd809f1ac4cbc2d52c321fc1b97bbe9ccf8 100644 (file)
--- a/projects/stargazer/plugins/configuration/rpcconfig/rpcconfig.cpp
+++ b/projects/stargazer/plugins/configuration/rpcconfig/rpcconfig.cpp
@@ -1,94 +1,67 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+

 #include <cstdlib>
 #include <csignal>
 #include <cstdlib>
 #include <csignal>

-
+#include <cerrno>
+#include <cstring>

 #include <vector>
 #include <algorithm>
 #include <vector>
 #include <algorithm>

+#include <ostream> // xmlrpc-c devs have missed something :)

 
 

-#include "rpcconfig.h"
-
-#include "admin.h"
-#include "module_settings.h"
-#include "../../../settings.h"
-#include "common.h"
+#include "stg/common.h"
+#include "stg/admin.h"
+#include "stg/module_settings.h"
+#include "stg/settings.h"
+#include "stg/plugin_creator.h"

 
 

+#include "rpcconfig.h"

 #include "info_methods.h"
 #include "users_methods.h"
 #include "tariffs_methods.h"
 #include "admins_methods.h"
 #include "messages_methods.h"
 
 #include "info_methods.h"
 #include "users_methods.h"
 #include "tariffs_methods.h"
 #include "admins_methods.h"
 #include "messages_methods.h"
 

-class RPC_CONFIG_CREATOR {
-private:
-    RPC_CONFIG * rpcconfig;
-
-public:
-    RPC_CONFIG_CREATOR()
-        : rpcconfig(new RPC_CONFIG())
-        {
-        }
-    ~RPC_CONFIG_CREATOR()
-        {
-        delete rpcconfig;
-        }
-
-    RPC_CONFIG * GetPlugin()
-        {
-        return rpcconfig;
-        }
-};
+namespace
+{
+PLUGIN_CREATOR<RPC_CONFIG> rpcc;
+}

 
 

-RPC_CONFIG_CREATOR rpcc;
+extern "C" PLUGIN * GetPlugin();

 
 RPC_CONFIG_SETTINGS::RPC_CONFIG_SETTINGS()
 
 RPC_CONFIG_SETTINGS::RPC_CONFIG_SETTINGS()

-    : errorStr(),
-      port(0),
+    : port(0),

       cookieTimeout(0)
 {
 }
 
       cookieTimeout(0)
 {
 }
 

-int RPC_CONFIG_SETTINGS::ParseIntInRange(const std::string & str,
-                                         int min,
-                                         int max,
-                                         int * val)
-{
-if (str2x(str.c_str(), *val))
-    {
-    errorStr = "Incorrect value \'" + str + "\'.";
-    return -1;
-    }
-if (*val < min || *val > max)
-    {
-    errorStr = "Value \'" + str + "\' out of range.";
-    return -1;
-    }
-return 0;
-}
-

 int RPC_CONFIG_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
 {
 int RPC_CONFIG_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
 {

-int p;

 PARAM_VALUE pv;
 PARAM_VALUE pv;

-std::vector<PARAM_VALUE>::const_iterator pvi;
-

 pv.param = "Port";
 pv.param = "Port";

+std::vector<PARAM_VALUE>::const_iterator pvi;

 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);

-if (pvi == s.moduleParams.end())
+if (pvi == s.moduleParams.end() || pvi->value.empty())

     {
     errorStr = "Parameter \'Port\' not found.";
     printfd(__FILE__, "Parameter 'Port' not found\n");
     return -1;
     }
     {
     errorStr = "Parameter \'Port\' not found.";
     printfd(__FILE__, "Parameter 'Port' not found\n");
     return -1;
     }

+int p;

 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
     {
     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
     return -1;
     }
 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
     {
     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
     return -1;
     }

-port = p;
+port = static_cast<uint16_t>(p);

 
 pv.param = "CookieTimeout";
 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 
 pv.param = "CookieTimeout";
 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);

-if (pvi == s.moduleParams.end())
+if (pvi == s.moduleParams.end() || pvi->value.empty())

     {
     cookieTimeout = 1800; // 30 * 60
     }
     {
     cookieTimeout = 1800; // 30 * 60
     }


@@ -115,10 +88,12 @@ RPC_CONFIG::RPC_CONFIG()
       admins(NULL),
       tariffs(NULL),
       store(NULL),
       admins(NULL),
       tariffs(NULL),
       store(NULL),

+      fd(-1),

       rpcServer(NULL),
       running(false),
       stopped(true),
       rpcServer(NULL),
       running(false),
       stopped(true),

-      dayFee(0)
+      dayFee(0),
+      logger(GetPluginLogger(GetStgLogger(), "conf_rpc"))

 {
 }
 
 {
 }
 


@@ -138,12 +113,12 @@ if (ret)
 return ret;
 }
 
 return ret;
 }
 

-void RPC_CONFIG::SetStgSettings(const SETTINGS * settings)
+void RPC_CONFIG::SetStgSettings(const SETTINGS * s)

 {
 {

-    dayFee = settings->GetDayFee();
+    dayFee = s->GetDayFee();

     dirNames.erase(dirNames.begin(), dirNames.end());
     for (size_t i = 0; i < DIR_NUM; ++i) {
     dirNames.erase(dirNames.begin(), dirNames.end());
     for (size_t i = 0; i < DIR_NUM; ++i) {

-        dirNames.push_back(settings->GetDirName(i));
+        dirNames.push_back(s->GetDirName(i));

     }
 }
 
     }
 }
 


@@ -151,17 +126,62 @@ int RPC_CONFIG::Start()
 {
 InitiateRegistry();
 running = true;
 {
 InitiateRegistry();
 running = true;

+
+fd = socket(AF_INET, SOCK_STREAM, 0);
+if (fd < 0)
+    {
+    errorStr = "Failed to create socket";
+    logger("Cannot create a socket: %s", strerror(errno));
+    printfd(__FILE__, "Failed to create listening socket: %s\n", strerror(errno));
+    return -1;
+    }
+
+int flag = 1;
+
+if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag)))
+    {
+    errorStr = "Setsockopt failed.";
+    logger("setsockopt error: %s", strerror(errno));
+    printfd(__FILE__, "Setsockopt failed: %s\n", strerror(errno));
+    return -1;
+    }
+
+struct sockaddr_in addr;
+addr.sin_family = AF_INET;
+addr.sin_port = htons(rpcConfigSettings.GetPort());
+addr.sin_addr.s_addr = inet_addr("0.0.0.0");
+
+if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)))
+    {
+    logger("Cannot bind the socket: %s", strerror(errno));
+    errorStr = "Failed to bind socket";
+    printfd(__FILE__, "Failed to bind listening socket: %s\n", strerror(errno));
+    return -1;
+    }
+
+if (listen(fd, 10))
+    {
+    logger("Cannot listen the socket: %s", strerror(errno));
+    errorStr = "Failed to listen socket";
+    printfd(__FILE__, "Failed to listen listening socket: %s\n", strerror(errno));
+    return -1;
+    }
+

 rpcServer = new xmlrpc_c::serverAbyss(
 rpcServer = new xmlrpc_c::serverAbyss(

-        rpcRegistry,
-        rpcConfigSettings.GetPort(),
-        "/var/log/stargazer_rpc.log"
+        xmlrpc_c::serverAbyss::constrOpt()
+        .registryP(&rpcRegistry)
+        .logFileName("/var/log/stargazer_rpc.log")
+        .socketFd(fd)

         );
         );

+

 if (pthread_create(&tid, NULL, Run, this))
     {
     errorStr = "Failed to create RPC thread";
 if (pthread_create(&tid, NULL, Run, this))
     {
     errorStr = "Failed to create RPC thread";

+    logger("Cannot create RPC thread.");

     printfd(__FILE__, "Failed to crate RPC thread\n");
     return -1;
     }
     printfd(__FILE__, "Failed to crate RPC thread\n");
     return -1;
     }

+

 return 0;
 }
 
 return 0;
 }
 


@@ -169,39 +189,42 @@ int RPC_CONFIG::Stop()
 {
 running = false;
 for (int i = 0; i < 5 && !stopped; ++i)
 {
 running = false;
 for (int i = 0; i < 5 && !stopped; ++i)

-    usleep(200000);
-//rpcServer->terminate();
+    {
+    struct timespec ts = {0, 200000000};
+    nanosleep(&ts, NULL);
+    }
+

 if (!stopped)
     {
 if (!stopped)
     {

-    if (pthread_kill(tid, SIGTERM))
-        {
-        errorStr = "Failed to kill thread";
-        printfd(__FILE__, "Failed to kill thread\n");
-        }
-    for (int i = 0; i < 25 && !stopped; ++i)
-        usleep(200000);
-    if (!stopped)
-        {
-        printfd(__FILE__, "Failed to stop RPC thread\n");
-        errorStr = "Failed to stop RPC thread";
-        return -1;
-        }
-    else
-        {
-        pthread_join(tid, NULL);
-        }
+    running = true;
+    logger("Cannot stop RPC thread.");
+    printfd(__FILE__, "Failed to stop RPC thread\n");
+    errorStr = "Failed to stop RPC thread";
+    return -1;
+    }
+else
+    {
+    pthread_join(tid, NULL);

     }
     }

+
+close(fd);
+

 return 0;
 }
 
 void * RPC_CONFIG::Run(void * rc)
 {
 return 0;
 }
 
 void * RPC_CONFIG::Run(void * rc)
 {

+sigset_t signalSet;
+sigfillset(&signalSet);
+pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
+

 RPC_CONFIG * config = static_cast<RPC_CONFIG *>(rc);
 
 config->stopped = false;
 while (config->running)
     {
 RPC_CONFIG * config = static_cast<RPC_CONFIG *>(rc);
 
 config->stopped = false;
 while (config->running)
     {

-    config->rpcServer->runOnce();
+    if (WaitPackets(config->fd))
+        config->rpcServer->runOnce();

     }
 config->stopped = true;
 
     }
 config->stopped = true;
 


@@ -240,8 +263,9 @@ bool RPC_CONFIG::CheckAdmin(const std::string & login,
 {
 ADMIN * admin = NULL;
 
 {
 ADMIN * admin = NULL;
 

-if (!admins->AdminCorrect(login, password, &admin))
+if (!admins->Correct(login, password, &admin))

     {
     {

+    logger("Attempt to connect with invalid credentials. Login: %s", login.c_str());

     return true;
     }
 
     return true;
     }
 


@@ -347,7 +371,7 @@ xmlrpc_c::methodPtr const methodAddCashPtr(new METHOD_USER_CASH_ADD(
             store,
             users
             ));
             store,
             users
             ));

-rpcRegistry.addMethod("stargazer.add_cash", methodAddCashPtr);
+rpcRegistry.addMethod("stargazer.add_user_cash", methodAddCashPtr);

 
 xmlrpc_c::methodPtr const methodSetCashPtr(new METHOD_USER_CASH_SET(
             this,
 
 xmlrpc_c::methodPtr const methodSetCashPtr(new METHOD_USER_CASH_SET(
             this,


@@ -355,7 +379,7 @@ xmlrpc_c::methodPtr const methodSetCashPtr(new METHOD_USER_CASH_SET(
             store,
             users
             ));
             store,
             users
             ));

-rpcRegistry.addMethod("stargazer.set_cash", methodSetCashPtr);
+rpcRegistry.addMethod("stargazer.set_user_cash", methodSetCashPtr);

 
 xmlrpc_c::methodPtr const methodTariffChangePtr(new METHOD_USER_TARIFF_CHANGE(
             this,
 
 xmlrpc_c::methodPtr const methodTariffChangePtr(new METHOD_USER_TARIFF_CHANGE(
             this,


@@ -364,7 +388,7 @@ xmlrpc_c::methodPtr const methodTariffChangePtr(new METHOD_USER_TARIFF_CHANGE(
             store,
             users
             ));
             store,
             users
             ));

-rpcRegistry.addMethod("stargazer.tariff_change", methodTariffChangePtr);
+rpcRegistry.addMethod("stargazer.chg_user_tariff", methodTariffChangePtr);

 
 xmlrpc_c::methodPtr const methodGetTariffPtr(new METHOD_TARIFF_GET(
             this,
 
 xmlrpc_c::methodPtr const methodGetTariffPtr(new METHOD_TARIFF_GET(
             this,


@@ -434,12 +458,18 @@ xmlrpc_c::methodPtr const methodSendMessagePtr(new METHOD_MESSAGE_SEND(
             this,
             users
             ));
             this,
             users
             ));

-rpcRegistry.addMethod("stargazer.send_message", methodSendMessagePtr);
+rpcRegistry.addMethod("stargazer.send_user_message", methodSendMessagePtr);

 
 xmlrpc_c::methodPtr const methodGetOnlinIPsPtr(new METHOD_GET_ONLINE_IPS(
             this,
             users
             ));
 rpcRegistry.addMethod("stargazer.get_online_ips", methodGetOnlinIPsPtr);
 
 xmlrpc_c::methodPtr const methodGetOnlinIPsPtr(new METHOD_GET_ONLINE_IPS(
             this,
             users
             ));
 rpcRegistry.addMethod("stargazer.get_online_ips", methodGetOnlinIPsPtr);

+
+xmlrpc_c::methodPtr const methodGetUserAuthByPtr(new METHOD_GET_USER_AUTH_BY(
+            this,
+            users
+            ));
+rpcRegistry.addMethod("stargazer.get_user_auth_by", methodGetUserAuthByPtr);

 }
 
 }