Added configuration checks.

[stg.git] / projects / stargazer / plugins / other / rscript / rscript.cpp

diff --git a/projects/stargazer/plugins/other/rscript/rscript.cpp b/projects/stargazer/plugins/other/rscript/rscript.cpp
index ebe2556df282c2f007ad6b54fe9f6500cb3fd393..3bc90792276152606e274fb5258b2554ff956198 100644 (file)
--- a/projects/stargazer/plugins/other/rscript/rscript.cpp
+++ b/projects/stargazer/plugins/other/rscript/rscript.cpp
@@ -38,16 +38,29 @@
 #include "ur_functor.h"
 #include "send_functor.h"
 
 #include "ur_functor.h"
 #include "send_functor.h"
 

-extern volatile const time_t stgTime;
-
-#define RS_MAX_ROUTERS  (100)
+extern volatile time_t stgTime;

 
 using RS::REMOTE_SCRIPT;
 
 
 using RS::REMOTE_SCRIPT;
 

+namespace {
+
+template<typename T>
+struct USER_IS
+{
+    USER_IS(USER_PTR u) : user(u) {}
+    bool operator()(const T & notifier) { return notifier.GetUser() == user; }
+
+    USER_PTR user;
+};
+
+PLUGIN_CREATOR<REMOTE_SCRIPT> rsc;
+
+} // namespace anonymous
+
+extern "C" PLUGIN * GetPlugin();

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-PLUGIN_CREATOR<REMOTE_SCRIPT> rsc;

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------


@@ -58,34 +71,6 @@ return rsc.GetPlugin();
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-RS::USER::USER(const std::vector<uint32_t> & r, USER_PTR it, REMOTE_SCRIPT & rs)
-    : lastSentTime(0),
-      user(it),
-      routers(r),
-      shortPacketsCount(0),
-      ip(user->GetCurrIP()),
-      notifier(rs, *this)
-{
-    user->AddConnectedAfterNotifier(&notifier);
-}
-//-----------------------------------------------------------------------------
-RS::USER::USER(const RS::USER & rhs)
-    : lastSentTime(rhs.lastSentTime),
-      user(rhs.user),
-      routers(rhs.routers),
-      shortPacketsCount(rhs.shortPacketsCount),
-      ip(rhs.ip),
-      notifier(rhs.notifier)
-{
-    user->DelConnectedAfterNotifier(&rhs.notifier);
-    user->AddConnectedAfterNotifier(&notifier);
-}
-//-----------------------------------------------------------------------------
-RS::USER::~USER()
-{
-    user->DelConnectedAfterNotifier(&notifier);
-}
-//-----------------------------------------------------------------------------

 RS::SETTINGS::SETTINGS()
     : sendPeriod(0),
       port(0),
 RS::SETTINGS::SETTINGS()
     : sendPeriod(0),
       port(0),


@@ -101,7 +86,7 @@ int RS::SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
 {
 int p;
 PARAM_VALUE pv;
 {
 int p;
 PARAM_VALUE pv;

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

 netRouters.clear();
 ///////////////////////////
 pv.param = "Port";
 netRouters.clear();
 ///////////////////////////
 pv.param = "Port";


@@ -118,7 +103,7 @@ if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
     return -1;
     }
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
     return -1;
     }

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

 ///////////////////////////
 pv.param = "SendPeriod";
 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 ///////////////////////////
 pv.param = "SendPeriod";
 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);


@@ -185,6 +170,7 @@ return 0;
 REMOTE_SCRIPT::REMOTE_SCRIPT()
     : ctx(),
       ipNotifierList(),
 REMOTE_SCRIPT::REMOTE_SCRIPT()
     : ctx(),
       ipNotifierList(),

+      connNotifierList(),

       authorizedUsers(),
       errorStr(),
       rsSettings(),
       authorizedUsers(),
       errorStr(),
       rsSettings(),


@@ -338,6 +324,9 @@ std::for_each(authorizedUsers.begin(),
               authorizedUsers.end(),
               UpdateRouter(*this));
 
               authorizedUsers.end(),
               UpdateRouter(*this));
 

+logger("%s reloaded successfully.", rsSettings.GetMapFileName().c_str());
+printfd(__FILE__, "REMOTE_SCRIPT::Reload() %s reloaded successfully.\n");
+

 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------


@@ -366,21 +355,21 @@ void REMOTE_SCRIPT::PeriodicSend()
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 

-map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());
+std::map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());

 while (it != authorizedUsers.end())
     {
     if (difftime(stgTime, it->second.lastSentTime) - (rand() % halfPeriod) > sendPeriod)
         {
 while (it != authorizedUsers.end())
     {
     if (difftime(stgTime, it->second.lastSentTime) - (rand() % halfPeriod) > sendPeriod)
         {

-        Send(it->first, it->second);
+        Send(it->second);

         }
     ++it;
     }
 }
 //-----------------------------------------------------------------------------
 #ifdef NDEBUG
         }
     ++it;
     }
 }
 //-----------------------------------------------------------------------------
 #ifdef NDEBUG

-bool REMOTE_SCRIPT::PreparePacket(char * buf, size_t, uint32_t ip, RS::USER & rsu, bool forceDisconnect) const
+bool REMOTE_SCRIPT::PreparePacket(char * buf, size_t, RS::USER & rsu, bool forceDisconnect) const

 #else
 #else

-bool REMOTE_SCRIPT::PreparePacket(char * buf, size_t bufSize, uint32_t ip, RS::USER & rsu, bool forceDisconnect) const
+bool REMOTE_SCRIPT::PreparePacket(char * buf, size_t bufSize, RS::USER & rsu, bool forceDisconnect) const

 #endif
 {
 RS::PACKET_HEADER packetHead;
 #endif
 {
 RS::PACKET_HEADER packetHead;


@@ -392,6 +381,7 @@ packetHead.protoVer[1] = '2';
 if (forceDisconnect)
     {
     packetHead.packetType = RS_DISCONNECT_PACKET;
 if (forceDisconnect)
     {
     packetHead.packetType = RS_DISCONNECT_PACKET;

+    printfd(__FILE__, "RSCRIPT: force disconnect for '%s'\n", rsu.user->GetLogin().c_str());

     }
 else
     {
     }
 else
     {


@@ -399,17 +389,25 @@ else
         {
         //SendLong
         packetHead.packetType = rsu.user->IsInetable() ? RS_CONNECT_PACKET : RS_DISCONNECT_PACKET;
         {
         //SendLong
         packetHead.packetType = rsu.user->IsInetable() ? RS_CONNECT_PACKET : RS_DISCONNECT_PACKET;

+        if (rsu.user->IsInetable())
+            printfd(__FILE__, "RSCRIPT: connect for '%s'\n", rsu.user->GetLogin().c_str());
+        else
+            printfd(__FILE__, "RSCRIPT: disconnect for '%s'\n", rsu.user->GetLogin().c_str());

         }
     else
         {
         //SendShort
         packetHead.packetType = rsu.user->IsInetable() ? RS_ALIVE_PACKET : RS_DISCONNECT_PACKET;
         }
     else
         {
         //SendShort
         packetHead.packetType = rsu.user->IsInetable() ? RS_ALIVE_PACKET : RS_DISCONNECT_PACKET;

+        if (rsu.user->IsInetable())
+            printfd(__FILE__, "RSCRIPT: alive for '%s'\n", rsu.user->GetLogin().c_str());
+        else
+            printfd(__FILE__, "RSCRIPT: disconnect for '%s'\n", rsu.user->GetLogin().c_str());

         }
     }
 rsu.shortPacketsCount++;
 rsu.lastSentTime = stgTime;
 
         }
     }
 rsu.shortPacketsCount++;
 rsu.lastSentTime = stgTime;
 

-packetHead.ip = htonl(ip);
+packetHead.ip = htonl(rsu.ip);

 packetHead.id = htonl(rsu.user->GetID());
 strncpy((char*)packetHead.login, rsu.user->GetLogin().c_str(), RS_LOGIN_LEN);
 packetHead.login[RS_LOGIN_LEN - 1] = 0;
 packetHead.id = htonl(rsu.user->GetID());
 strncpy((char*)packetHead.login, rsu.user->GetLogin().c_str(), RS_LOGIN_LEN);
 packetHead.login[RS_LOGIN_LEN - 1] = 0;


@@ -425,7 +423,7 @@ RS::PACKET_TAIL packetTail;
 
 memset(packetTail.padding, 0, sizeof(packetTail.padding));
 strcpy((char*)packetTail.magic, RS_ID);
 
 memset(packetTail.padding, 0, sizeof(packetTail.padding));
 strcpy((char*)packetTail.magic, RS_ID);

-vector<string>::const_iterator it;
+std::vector<std::string>::const_iterator it;

 std::string params;
 for(it = rsSettings.GetUserParams().begin();
     it != rsSettings.GetUserParams().end();
 std::string params;
 for(it = rsSettings.GetUserParams().begin();
     it != rsSettings.GetUserParams().end();


@@ -446,13 +444,13 @@ Encrypt(&ctx, buf + sizeof(packetHead), (char *)&packetTail, sizeof(packetTail)
 return false;
 }
 //-----------------------------------------------------------------------------
 return false;
 }
 //-----------------------------------------------------------------------------

-bool REMOTE_SCRIPT::Send(uint32_t ip, RS::USER & rsu, bool forceDisconnect) const
+bool REMOTE_SCRIPT::Send(RS::USER & rsu, bool forceDisconnect) const

 {
 char buffer[RS_MAX_PACKET_LEN];
 
 memset(buffer, 0, sizeof(buffer));
 
 {
 char buffer[RS_MAX_PACKET_LEN];
 
 memset(buffer, 0, sizeof(buffer));
 

-if (PreparePacket(buffer, sizeof(buffer), ip, rsu, forceDisconnect))
+if (PreparePacket(buffer, sizeof(buffer), rsu, forceDisconnect))

     {
     printfd(__FILE__, "REMOTE_SCRIPT::Send() - Invalid packet length!\n");
     return true;
     {
     printfd(__FILE__, "REMOTE_SCRIPT::Send() - Invalid packet length!\n");
     return true;


@@ -461,17 +459,17 @@ if (PreparePacket(buffer, sizeof(buffer), ip, rsu, forceDisconnect))
 std::for_each(
         rsu.routers.begin(),
         rsu.routers.end(),
 std::for_each(
         rsu.routers.begin(),
         rsu.routers.end(),

-        PacketSender(sock, buffer, sizeof(buffer), htons(rsSettings.GetPort()))
+        PacketSender(sock, buffer, sizeof(buffer), static_cast<uint16_t>(htons(rsSettings.GetPort())))

         );
 
 return false;
 }
 //-----------------------------------------------------------------------------
         );
 
 return false;
 }
 //-----------------------------------------------------------------------------

-bool REMOTE_SCRIPT::SendDirect(uint32_t ip, RS::USER & rsu, uint32_t routerIP, bool forceDisconnect) const
+bool REMOTE_SCRIPT::SendDirect(RS::USER & rsu, uint32_t routerIP, bool forceDisconnect) const

 {
 char buffer[RS_MAX_PACKET_LEN];
 
 {
 char buffer[RS_MAX_PACKET_LEN];
 

-if (PreparePacket(buffer, sizeof(buffer), ip, rsu, forceDisconnect))
+if (PreparePacket(buffer, sizeof(buffer), rsu, forceDisconnect))

     {
     printfd(__FILE__, "REMOTE_SCRIPT::SendDirect() - Invalid packet length!\n");
     return true;
     {
     printfd(__FILE__, "REMOTE_SCRIPT::SendDirect() - Invalid packet length!\n");
     return true;


@@ -480,10 +478,10 @@ if (PreparePacket(buffer, sizeof(buffer), ip, rsu, forceDisconnect))
 struct sockaddr_in sendAddr;
 
 sendAddr.sin_family = AF_INET;
 struct sockaddr_in sendAddr;
 
 sendAddr.sin_family = AF_INET;

-sendAddr.sin_port = htons(rsSettings.GetPort());
+sendAddr.sin_port = static_cast<uint16_t>(htons(rsSettings.GetPort()));

 sendAddr.sin_addr.s_addr = routerIP;
 
 sendAddr.sin_addr.s_addr = routerIP;
 

-int res = sendto(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&sendAddr, sizeof(sendAddr));
+ssize_t res = sendto(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&sendAddr, sizeof(sendAddr));

 
 if (res < 0)
     logger("sendto error: %s", strerror(errno));
 
 if (res < 0)
     logger("sendto error: %s", strerror(errno));


@@ -500,42 +498,13 @@ assert(h && "USERS::OpenSearch is always correct");
 
 while (!users->SearchNext(h, &u))
     {
 
 while (!users->SearchNext(h, &u))
     {

-    SetUserNotifier(u);
+    SetUserNotifiers(u);

     }
 
 users->CloseSearch(h);
 return false;
 }
 //-----------------------------------------------------------------------------
     }
 
 users->CloseSearch(h);
 return false;
 }
 //-----------------------------------------------------------------------------

-void REMOTE_SCRIPT::ChangedIP(USER_PTR u, uint32_t oldIP, uint32_t newIP)
-{
-/*
- * When ip changes process looks like:
- * old => 0, 0 => new
- *
- */
-if (newIP)
-    {
-    RS::USER rsu(IP2Routers(newIP), u, *this);
-    Send(newIP, rsu);
-
-    STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-    authorizedUsers.insert(std::make_pair(newIP, rsu));
-    }
-else
-    {
-    STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-    const map<uint32_t, RS::USER>::iterator it(
-            authorizedUsers.find(oldIP)
-            );
-    if (it != authorizedUsers.end())
-        {
-        Send(oldIP, it->second, true);
-        authorizedUsers.erase(it);
-        }
-    }
-}
-//-----------------------------------------------------------------------------

 std::vector<uint32_t> REMOTE_SCRIPT::IP2Routers(uint32_t ip)
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 std::vector<uint32_t> REMOTE_SCRIPT::IP2Routers(uint32_t ip)
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);


@@ -549,9 +518,9 @@ for (size_t i = 0; i < netRouters.size(); ++i)
 return std::vector<uint32_t>();
 }
 //-----------------------------------------------------------------------------
 return std::vector<uint32_t>();
 }
 //-----------------------------------------------------------------------------

-string REMOTE_SCRIPT::GetUserParam(USER_PTR u, const string & paramName) const
+std::string REMOTE_SCRIPT::GetUserParam(USER_PTR u, const std::string & paramName) const

 {
 {

-string value = "";
+std::string value = "";

 if (strcasecmp(paramName.c_str(), "cash") == 0)
     strprintf(&value, "%f", u->GetProperty().cash.Get());
 else
 if (strcasecmp(paramName.c_str(), "cash") == 0)
     strprintf(&value, "%f", u->GetProperty().cash.Get());
 else


@@ -629,47 +598,75 @@ else
 return value;
 }
 //-----------------------------------------------------------------------------
 return value;
 }
 //-----------------------------------------------------------------------------

-void REMOTE_SCRIPT::SetUserNotifier(USER_PTR u)
+void REMOTE_SCRIPT::SetUserNotifiers(USER_PTR u)

 {
 ipNotifierList.push_front(RS::IP_NOTIFIER(*this, u));
 {
 ipNotifierList.push_front(RS::IP_NOTIFIER(*this, u));

+connNotifierList.push_front(RS::CONNECTED_NOTIFIER(*this, u));
+}
+//-----------------------------------------------------------------------------
+void REMOTE_SCRIPT::UnSetUserNotifiers(USER_PTR u)
+{
+ipNotifierList.erase(std::remove_if(ipNotifierList.begin(),
+                                    ipNotifierList.end(),
+                                    USER_IS<IP_NOTIFIER>(u)),
+                     ipNotifierList.end());
+connNotifierList.erase(std::remove_if(connNotifierList.begin(),
+                                      connNotifierList.end(),
+                                      USER_IS<CONNECTED_NOTIFIER>(u)),
+                       connNotifierList.end());

 
 

-u->AddCurrIPAfterNotifier(&(*ipNotifierList.begin()));

 }
 //-----------------------------------------------------------------------------
 }
 //-----------------------------------------------------------------------------

-void REMOTE_SCRIPT::UnSetUserNotifier(USER_PTR u)
+void REMOTE_SCRIPT::AddRSU(USER_PTR user)

 {
 {

-list<RS::IP_NOTIFIER>::iterator  ipAIter;
-std::list<list<RS::IP_NOTIFIER>::iterator> toErase;
+RS::USER rsu(IP2Routers(user->GetCurrIP()), user);
+Send(rsu);

 
 

-for (ipAIter = ipNotifierList.begin(); ipAIter != ipNotifierList.end(); ++ipAIter)
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+authorizedUsers.insert(std::make_pair(user->GetCurrIP(), rsu));
+}
+//-----------------------------------------------------------------------------
+void REMOTE_SCRIPT::DelRSU(USER_PTR user)
+{
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+std::map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());
+while (it != authorizedUsers.end())

     {
     {

-    if (ipAIter->GetUser() == u)
+    if (it->second.user == user)

         {
         {

-        u->DelCurrIPAfterNotifier(&(*ipAIter));
-        toErase.push_back(ipAIter);
+        Send(it->second, true);
+        authorizedUsers.erase(it);
+        return;

         }
         }

+    ++it;

     }
     }

-
-std::list<list<RS::IP_NOTIFIER>::iterator>::iterator eIter;
-
-for (eIter = toErase.begin(); eIter != toErase.end(); ++eIter)
+/*const std::map<uint32_t, RS::USER>::iterator it(
+        authorizedUsers.find(user->GetCurrIP())
+        );
+if (it != authorizedUsers.end())

     {
     {

-    ipNotifierList.erase(*eIter);
-    }
+    Send(it->second, true);
+    authorizedUsers.erase(it);
+    }*/

 }
 //-----------------------------------------------------------------------------
 }
 //-----------------------------------------------------------------------------

-void RS::IP_NOTIFIER::Notify(const uint32_t & oldValue, const uint32_t & newValue)
+void RS::IP_NOTIFIER::Notify(const uint32_t & /*oldValue*/, const uint32_t & newValue)

 {
 {

-rs.ChangedIP(user, oldValue, newValue);
+if (newValue)
+    rs.AddRSU(user);
+else
+    rs.DelRSU(user);

 }
 //-----------------------------------------------------------------------------
 void RS::CONNECTED_NOTIFIER::Notify(const bool & /*oldValue*/, const bool & newValue)
 {
 }
 //-----------------------------------------------------------------------------
 void RS::CONNECTED_NOTIFIER::Notify(const bool & /*oldValue*/, const bool & newValue)
 {

-if (!newValue)
-    rs.Send(user.ip, user, true);
+if (newValue)
+    rs.AddRSU(user);
+else
+    rs.DelRSU(user);

 }
 //-----------------------------------------------------------------------------
 }
 //-----------------------------------------------------------------------------

-void REMOTE_SCRIPT::InitEncrypt(BLOWFISH_CTX * ctx, const string & password) const
+void REMOTE_SCRIPT::InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password) const

 {
 unsigned char keyL[PASSWD_LEN];  // Пароль для шифровки
 memset(keyL, 0, PASSWD_LEN);
 {
 unsigned char keyL[PASSWD_LEN];  // Пароль для шифровки
 memset(keyL, 0, PASSWD_LEN);


@@ -677,11 +674,11 @@ strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
 Blowfish_Init(ctx, keyL, PASSWD_LEN);
 }
 //-----------------------------------------------------------------------------
 Blowfish_Init(ctx, keyL, PASSWD_LEN);
 }
 //-----------------------------------------------------------------------------

-void REMOTE_SCRIPT::Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, size_t len8) const
+void REMOTE_SCRIPT::Encrypt(BLOWFISH_CTX * ctx, void * dst, const void * src, size_t len8) const

 {
 if (dst != src)
     memcpy(dst, src, len8 * 8);
 for (size_t i = 0; i < len8; ++i)
 {
 if (dst != src)
     memcpy(dst, src, len8 * 8);
 for (size_t i = 0; i < len8; ++i)

-    Blowfish_Encrypt(ctx, (uint32_t *)(dst + i * 8), (uint32_t *)(dst + i * 8 + 4));
+    Blowfish_Encrypt(ctx, static_cast<uint32_t *>(dst) + i * 2, static_cast<uint32_t *>(dst) + i * 2 + 1);

 }
 //-----------------------------------------------------------------------------
 }
 //-----------------------------------------------------------------------------