Handle callback errors in bfstreams.

[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 82ca4f5d557c4ec90b22047cf3b237da563bfbfb..00114df4c501fa0cd4aa6e3d7fc2031d8e7dc3ed 100644 (file)
--- a/projects/stargazer/plugins/other/rscript/rscript.cpp
+++ b/projects/stargazer/plugins/other/rscript/rscript.cpp
@@ -38,9 +38,7 @@
 #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;
 


@@ -55,12 +53,14 @@ struct USER_IS
     USER_PTR user;
 };
 
     USER_PTR user;
 };
 

+PLUGIN_CREATOR<REMOTE_SCRIPT> rsc;
+

 } // namespace anonymous
 
 } // namespace anonymous
 

+extern "C" PLUGIN * GetPlugin();

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

-PLUGIN_CREATOR<REMOTE_SCRIPT> rsc;

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


@@ -86,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";


@@ -103,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);


@@ -313,7 +313,7 @@ if (nrMapParser.ReadFile(rsSettings.GetMapFileName()))
     }
 
     {
     }
 
     {

-    STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+    STG_LOCKER lock(&mutex);

 
     printfd(__FILE__, "REMOTE_SCRIPT::Reload()\n");
 
 
     printfd(__FILE__, "REMOTE_SCRIPT::Reload()\n");
 


@@ -324,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;
 }
 //-----------------------------------------------------------------------------


@@ -350,9 +353,9 @@ return false;
 //-----------------------------------------------------------------------------
 void REMOTE_SCRIPT::PeriodicSend()
 {
 //-----------------------------------------------------------------------------
 void REMOTE_SCRIPT::PeriodicSend()
 {

-STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+STG_LOCKER lock(&mutex);

 
 

-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)


@@ -420,15 +423,18 @@ 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();
     ++it)
     {
 std::string params;
 for(it = rsSettings.GetUserParams().begin();
     it != rsSettings.GetUserParams().end();
     ++it)
     {

-    std::string parameter(GetUserParam(rsu.user, *it));
+    std::string parameter(rsu.user->GetParamValue(it->c_str()));

     if (params.length() + parameter.length() > RS_PARAMS_LEN - 1)
     if (params.length() + parameter.length() > RS_PARAMS_LEN - 1)

+    {
+        logger("Script params string length %d exceeds the limit of %d symbols.", params.length() + parameter.length(), RS_PARAMS_LEN);

         break;
         break;

+    }

     params += parameter + " ";
     }
 strncpy((char *)packetTail.params, params.c_str(), RS_PARAMS_LEN);
     params += parameter + " ";
     }
 strncpy((char *)packetTail.params, params.c_str(), RS_PARAMS_LEN);


@@ -456,7 +462,7 @@ if (PreparePacket(buffer, sizeof(buffer), 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;


@@ -475,10 +481,10 @@ if (PreparePacket(buffer, sizeof(buffer), 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));


@@ -502,38 +508,9 @@ users->CloseSearch(h);
 return false;
 }
 //-----------------------------------------------------------------------------
 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);
-    Send(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(it->second, true);
-        authorizedUsers.erase(it);
-        }
-    }
-}
-//-----------------------------------------------------------------------------

 std::vector<uint32_t> REMOTE_SCRIPT::IP2Routers(uint32_t ip)
 {
 std::vector<uint32_t> REMOTE_SCRIPT::IP2Routers(uint32_t ip)
 {

-STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+STG_LOCKER lock(&mutex);

 for (size_t i = 0; i < netRouters.size(); ++i)
     {
     if ((ip & netRouters[i].subnetMask) == (netRouters[i].subnetIP & netRouters[i].subnetMask))
 for (size_t i = 0; i < netRouters.size(); ++i)
     {
     if ((ip & netRouters[i].subnetMask) == (netRouters[i].subnetIP & netRouters[i].subnetMask))


@@ -544,86 +521,6 @@ 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
-{
-string value = "";
-if (strcasecmp(paramName.c_str(), "cash") == 0)
-    strprintf(&value, "%f", u->GetProperty().cash.Get());
-else
-if (strcasecmp(paramName.c_str(), "freeMb") == 0)
-    strprintf(&value, "%f", u->GetProperty().freeMb.Get());
-else
-if (strcasecmp(paramName.c_str(), "passive") == 0)
-    strprintf(&value, "%d", u->GetProperty().passive.Get());
-else
-if (strcasecmp(paramName.c_str(), "disabled") == 0)
-    strprintf(&value, "%d", u->GetProperty().disabled.Get());
-else
-if (strcasecmp(paramName.c_str(), "alwaysOnline") == 0)
-    strprintf(&value, "%d", u->GetProperty().alwaysOnline.Get());
-else
-if (strcasecmp(paramName.c_str(), "tariffName") == 0 ||
-    strcasecmp(paramName.c_str(), "tariff") == 0)
-    value = "\"" + u->GetProperty().tariffName.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "nextTariff") == 0)
-    value = "\"" + u->GetProperty().nextTariff.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "address") == 0)
-    value = "\"" + u->GetProperty().address.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "note") == 0)
-    value = "\"" + u->GetProperty().note.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "group") == 0)
-    value = "\"" + u->GetProperty().group.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "email") == 0)
-    value = "\"" + u->GetProperty().email.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "realName") == 0)
-    value = "\"" + u->GetProperty().realName.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "credit") == 0)
-    strprintf(&value, "%f", u->GetProperty().credit.Get());
-else
-if (strcasecmp(paramName.c_str(), "userdata0") == 0)
-    value = "\"" + u->GetProperty().userdata0.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata1") == 0)
-    value = "\"" + u->GetProperty().userdata1.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata2") == 0)
-    value = "\"" + u->GetProperty().userdata2.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata3") == 0)
-    value = "\"" + u->GetProperty().userdata3.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata4") == 0)
-    value = "\"" + u->GetProperty().userdata4.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata5") == 0)
-    value = "\"" + u->GetProperty().userdata5.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata6") == 0)
-    value = "\"" + u->GetProperty().userdata6.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata7") == 0)
-    value = "\"" + u->GetProperty().userdata7.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata8") == 0)
-    value = "\"" + u->GetProperty().userdata8.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "userdata9") == 0)
-    value = "\"" + u->GetProperty().userdata9.Get() + "\"";
-else
-if (strcasecmp(paramName.c_str(), "enabledDirs") == 0)
-    value = u->GetEnabledDirs();
-else
-    printfd(__FILE__, "Unknown value name: %s\n", paramName.c_str());
-return value;
-}
-//-----------------------------------------------------------------------------

 void REMOTE_SCRIPT::SetUserNotifiers(USER_PTR u)
 {
 ipNotifierList.push_front(RS::IP_NOTIFIER(*this, u));
 void REMOTE_SCRIPT::SetUserNotifiers(USER_PTR u)
 {
 ipNotifierList.push_front(RS::IP_NOTIFIER(*this, u));


@@ -648,26 +545,36 @@ void REMOTE_SCRIPT::AddRSU(USER_PTR user)
 RS::USER rsu(IP2Routers(user->GetCurrIP()), user);
 Send(rsu);
 
 RS::USER rsu(IP2Routers(user->GetCurrIP()), user);
 Send(rsu);
 

-STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+STG_LOCKER lock(&mutex);

 authorizedUsers.insert(std::make_pair(user->GetCurrIP(), rsu));
 }
 //-----------------------------------------------------------------------------
 void REMOTE_SCRIPT::DelRSU(USER_PTR user)
 {
 authorizedUsers.insert(std::make_pair(user->GetCurrIP(), rsu));
 }
 //-----------------------------------------------------------------------------
 void REMOTE_SCRIPT::DelRSU(USER_PTR user)
 {

-STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-const map<uint32_t, RS::USER>::iterator it(
+STG_LOCKER lock(&mutex);
+std::map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());
+while (it != authorizedUsers.end())
+    {
+    if (it->second.user == user)
+        {
+        Send(it->second, true);
+        authorizedUsers.erase(it);
+        return;
+        }
+    ++it;
+    }
+/*const std::map<uint32_t, RS::USER>::iterator it(

         authorizedUsers.find(user->GetCurrIP())
         );
 if (it != authorizedUsers.end())
     {
     Send(it->second, true);
     authorizedUsers.erase(it);
         authorizedUsers.find(user->GetCurrIP())
         );
 if (it != authorizedUsers.end())
     {
     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
 if (newValue)
     rs.AddRSU(user);
 else


@@ -682,7 +589,7 @@ else
     rs.DelRSU(user);
 }
 //-----------------------------------------------------------------------------
     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);


@@ -690,11 +597,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);

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