Fixed problems with connect/disconnect notification.

diff --git a/projects/stargazer/plugins/other/rscript/rscript.cpp b/projects/stargazer/plugins/other/rscript/rscript.cpp
index ebe2556df282c2f007ad6b54fe9f6500cb3fd393..82ca4f5d557c4ec90b22047cf3b237da563bfbfb 100644 (file)
--- a/projects/stargazer/plugins/other/rscript/rscript.cpp
+++ b/projects/stargazer/plugins/other/rscript/rscript.cpp
@@ -44,6 +44,19 @@ extern volatile const 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;
+};
+
+} // namespace anonymous
+

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


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


@@ -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(),


@@ -371,16 +357,16 @@ while (it != authorizedUsers.end())
     {
     if (difftime(stgTime, it->second.lastSentTime) - (rand() % halfPeriod) > sendPeriod)
         {
     {
     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 +378,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 +386,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;


@@ -446,13 +441,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;


@@ -467,11 +462,11 @@ std::for_each(
 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;


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

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

     }
 
 users->CloseSearch(h);
     }
 
 users->CloseSearch(h);


@@ -516,8 +511,8 @@ void REMOTE_SCRIPT::ChangedIP(USER_PTR u, uint32_t oldIP, uint32_t newIP)
  */
 if (newIP)
     {
  */
 if (newIP)
     {

-    RS::USER rsu(IP2Routers(newIP), u, *this);
-    Send(newIP, rsu);
+    RS::USER rsu(IP2Routers(newIP), u);
+    Send(rsu);

 
     STG_LOCKER lock(&mutex, __FILE__, __LINE__);
     authorizedUsers.insert(std::make_pair(newIP, rsu));
 
     STG_LOCKER lock(&mutex, __FILE__, __LINE__);
     authorizedUsers.insert(std::make_pair(newIP, rsu));


@@ -530,7 +525,7 @@ else
             );
     if (it != authorizedUsers.end())
         {
             );
     if (it != authorizedUsers.end())
         {

-        Send(oldIP, it->second, true);
+        Send(it->second, true);

         authorizedUsers.erase(it);
         }
     }
         authorizedUsers.erase(it);
         }
     }


@@ -629,44 +624,62 @@ 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));

-
-u->AddCurrIPAfterNotifier(&(*ipNotifierList.begin()));
+connNotifierList.push_front(RS::CONNECTED_NOTIFIER(*this, u));

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

-void REMOTE_SCRIPT::UnSetUserNotifier(USER_PTR u)
+void REMOTE_SCRIPT::UnSetUserNotifiers(USER_PTR u)

 {
 {

-list<RS::IP_NOTIFIER>::iterator  ipAIter;
-std::list<list<RS::IP_NOTIFIER>::iterator> toErase;
+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());

 
 

-for (ipAIter = ipNotifierList.begin(); ipAIter != ipNotifierList.end(); ++ipAIter)
-    {
-    if (ipAIter->GetUser() == u)
-        {
-        u->DelCurrIPAfterNotifier(&(*ipAIter));
-        toErase.push_back(ipAIter);
-        }
-    }
-
-std::list<list<RS::IP_NOTIFIER>::iterator>::iterator eIter;
+}
+//-----------------------------------------------------------------------------
+void REMOTE_SCRIPT::AddRSU(USER_PTR user)
+{
+RS::USER rsu(IP2Routers(user->GetCurrIP()), user);
+Send(rsu);

 
 

-for (eIter = toErase.begin(); eIter != toErase.end(); ++eIter)
+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__);
+const 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);
+//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 string & password) const

diff --git a/projects/stargazer/plugins/other/rscript/rscript.h b/projects/stargazer/plugins/other/rscript/rscript.h
index 001d65e1295f26bed2f4b0c9ef50c49606f88dea..e0118638a8d5ac21f0c5966c4ba79fcf7f2f22aa 100644 (file)
--- a/projects/stargazer/plugins/other/rscript/rscript.h
+++ b/projects/stargazer/plugins/other/rscript/rscript.h
@@ -89,47 +89,65 @@ private:
 class IP_NOTIFIER: public PROPERTY_NOTIFIER_BASE<uint32_t> {
 public:
     IP_NOTIFIER(REMOTE_SCRIPT & r, USER_PTR u)
 class IP_NOTIFIER: public PROPERTY_NOTIFIER_BASE<uint32_t> {
 public:
     IP_NOTIFIER(REMOTE_SCRIPT & r, USER_PTR u)

-        : PROPERTY_NOTIFIER_BASE<uint32_t>(), user(u), rs(r) {}
+        : PROPERTY_NOTIFIER_BASE<uint32_t>(), user(u), rs(r) { user->AddCurrIPAfterNotifier(this); }

     IP_NOTIFIER(const IP_NOTIFIER & rhs)
     IP_NOTIFIER(const IP_NOTIFIER & rhs)

-        : PROPERTY_NOTIFIER_BASE<uint32_t>(), user(rhs.user), rs(rhs.rs) {}
+        : PROPERTY_NOTIFIER_BASE<uint32_t>(), user(rhs.user), rs(rhs.rs) { user->AddCurrIPAfterNotifier(this); }
+    ~IP_NOTIFIER() { user->DelCurrIPAfterNotifier(this); }
+
+    IP_NOTIFIER & operator=(const IP_NOTIFIER & rhs)
+    {
+        user->DelCurrIPAfterNotifier(this);
+        user = rhs.user;
+        user->AddCurrIPAfterNotifier(this);
+        return *this;
+    }
+

     void Notify(const uint32_t & oldValue, const uint32_t & newValue);
     void Notify(const uint32_t & oldValue, const uint32_t & newValue);

-    USER_PTR GetUser() { return user; }
+    USER_PTR GetUser() const { return user; }

 
 private:
 
 private:

-    IP_NOTIFIER & operator=(const IP_NOTIFIER & rhs);

 
     USER_PTR user;
     REMOTE_SCRIPT & rs;
 };
 //-----------------------------------------------------------------------------
 
     USER_PTR user;
     REMOTE_SCRIPT & rs;
 };
 //-----------------------------------------------------------------------------

-class USER;
-//-----------------------------------------------------------------------------

 class CONNECTED_NOTIFIER: public PROPERTY_NOTIFIER_BASE<bool> {
 public:
 class CONNECTED_NOTIFIER: public PROPERTY_NOTIFIER_BASE<bool> {
 public:

-    CONNECTED_NOTIFIER(REMOTE_SCRIPT & r, USER & u)
-        : PROPERTY_NOTIFIER_BASE<bool>(), user(u), rs(r) {}
+    CONNECTED_NOTIFIER(REMOTE_SCRIPT & r, USER_PTR u)
+        : PROPERTY_NOTIFIER_BASE<bool>(), user(u), rs(r) { user->AddConnectedAfterNotifier(this); }

     CONNECTED_NOTIFIER(const CONNECTED_NOTIFIER & rhs)
     CONNECTED_NOTIFIER(const CONNECTED_NOTIFIER & rhs)

-        : PROPERTY_NOTIFIER_BASE<bool>(), user(rhs.user), rs(rhs.rs) {}
+        : PROPERTY_NOTIFIER_BASE<bool>(), user(rhs.user), rs(rhs.rs) { user->AddConnectedAfterNotifier(this); }
+    ~CONNECTED_NOTIFIER() { user->DelConnectedAfterNotifier(this); }
+
+    CONNECTED_NOTIFIER & operator=(const CONNECTED_NOTIFIER & rhs)
+    {
+        user->DelConnectedAfterNotifier(this);
+        user = rhs.user;
+        user->AddConnectedAfterNotifier(this);
+        return *this;
+    }
+

     void Notify(const bool & oldValue, const bool & newValue);
     void Notify(const bool & oldValue, const bool & newValue);

+    USER_PTR GetUser() const { return user; }

 
 private:
 
 private:

-    CONNECTED_NOTIFIER & operator=(const CONNECTED_NOTIFIER & rhs);

 
 

-    USER & user;
+    USER_PTR user;

     REMOTE_SCRIPT & rs;
 };
 //-----------------------------------------------------------------------------
 struct USER {
     REMOTE_SCRIPT & rs;
 };
 //-----------------------------------------------------------------------------
 struct USER {

-    USER(const std::vector<uint32_t> & r, USER_PTR it, REMOTE_SCRIPT & rs);
-    USER(const USER & rhs);
-    ~USER();
+    USER(const std::vector<uint32_t> & r, USER_PTR it)
+        : user(it),
+          routers(r),
+          ip(user->GetCurrIP())
+    {}

 
     time_t lastSentTime;
     USER_PTR user;
     std::vector<uint32_t> routers;
     int shortPacketsCount;
     uint32_t ip;
 
     time_t lastSentTime;
     USER_PTR user;
     std::vector<uint32_t> routers;
     int shortPacketsCount;
     uint32_t ip;

-    CONNECTED_NOTIFIER notifier;

 };
 //-----------------------------------------------------------------------------
 class SETTINGS {
 };
 //-----------------------------------------------------------------------------
 class SETTINGS {


@@ -174,10 +192,12 @@ public:
     uint16_t            GetStartPosition() const { return 10; }
     uint16_t            GetStopPosition() const { return 10; }
 
     uint16_t            GetStartPosition() const { return 10; }
     uint16_t            GetStopPosition() const { return 10; }
 

-    void                DelUser(USER_PTR u) { UnSetUserNotifier(u); }
-    void                AddUser(USER_PTR u) { SetUserNotifier(u); }
+    void                DelUser(USER_PTR u) { UnSetUserNotifiers(u); }
+    void                AddUser(USER_PTR u) { SetUserNotifiers(u); }

 
     void                ChangedIP(USER_PTR u, uint32_t oldIP, uint32_t newIP);
 
     void                ChangedIP(USER_PTR u, uint32_t oldIP, uint32_t newIP);

+    void                AddRSU(USER_PTR user);
+    void                DelRSU(USER_PTR user);

 
 private:
     REMOTE_SCRIPT(const REMOTE_SCRIPT & rhs);
 
 private:
     REMOTE_SCRIPT(const REMOTE_SCRIPT & rhs);


@@ -187,17 +207,17 @@ private:
     bool                PrepareNet();
     bool                FinalizeNet();
 
     bool                PrepareNet();
     bool                FinalizeNet();
 

-    bool                Send(uint32_t ip, USER & rsu, bool forceDisconnect = false) const;
-    bool                SendDirect(uint32_t ip, USER & rsu, uint32_t routerIP, bool forceDisconnect = false) const;
-    bool                PreparePacket(char * buf, size_t bufSize, uint32_t ip, USER &rsu, bool forceDisconnect = false) const;
+    bool                Send(USER & rsu, bool forceDisconnect = false) const;
+    bool                SendDirect(USER & rsu, uint32_t routerIP, bool forceDisconnect = false) const;
+    bool                PreparePacket(char * buf, size_t bufSize, USER &rsu, bool forceDisconnect = false) const;

     void                PeriodicSend();
 
     std::vector<uint32_t> IP2Routers(uint32_t ip);
     bool                GetUsers();
     std::string         GetUserParam(USER_PTR u, const std::string & paramName) const;
 
     void                PeriodicSend();
 
     std::vector<uint32_t> IP2Routers(uint32_t ip);
     bool                GetUsers();
     std::string         GetUserParam(USER_PTR u, const std::string & paramName) const;
 

-    void                SetUserNotifier(USER_PTR u);
-    void                UnSetUserNotifier(USER_PTR u);
+    void                SetUserNotifiers(USER_PTR u);
+    void                UnSetUserNotifiers(USER_PTR u);

 
     void                InitEncrypt(BLOWFISH_CTX * ctx, const string & password) const;
     void                Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, size_t len8) const;
 
     void                InitEncrypt(BLOWFISH_CTX * ctx, const string & password) const;
     void                Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, size_t len8) const;


@@ -205,6 +225,7 @@ private:
     mutable BLOWFISH_CTX ctx;
 
     std::list<IP_NOTIFIER> ipNotifierList;
     mutable BLOWFISH_CTX ctx;
 
     std::list<IP_NOTIFIER> ipNotifierList;

+    std::list<CONNECTED_NOTIFIER> connNotifierList;

     std::map<uint32_t, USER> authorizedUsers;
 
     mutable std::string errorStr;
     std::map<uint32_t, USER> authorizedUsers;
 
     mutable std::string errorStr;


@@ -240,7 +261,7 @@ class DisconnectUser : public std::unary_function<std::pair<const uint32_t, USER
         DisconnectUser(REMOTE_SCRIPT & rs) : rscript(rs) {}
         void operator()(std::pair<const uint32_t, USER> & p)
         {
         DisconnectUser(REMOTE_SCRIPT & rs) : rscript(rs) {}
         void operator()(std::pair<const uint32_t, USER> & p)
         {

-            rscript.Send(p.first, p.second, true);
+            rscript.Send(p.second, true);

         }
     private:
         REMOTE_SCRIPT & rscript;
         }
     private:
         REMOTE_SCRIPT & rscript;

diff --git a/projects/stargazer/plugins/other/rscript/ur_functor.h b/projects/stargazer/plugins/other/rscript/ur_functor.h
index c5752e870a7811c60629391b86499d86443b8677..5d02d9dc897bf76ada08d5ebcde250915f0b9910 100644 (file)
--- a/projects/stargazer/plugins/other/rscript/ur_functor.h
+++ b/projects/stargazer/plugins/other/rscript/ur_functor.h
@@ -41,7 +41,7 @@ public:
 
     void operator() (std::pair<const uint32_t, USER> & val)
         {
 
     void operator() (std::pair<const uint32_t, USER> & val)
         {

-        std::vector<uint32_t> newRouters = obj.IP2Routers(val.first);
+        std::vector<uint32_t> newRouters = obj.IP2Routers(val.second.ip);

         std::vector<uint32_t>::const_iterator oldIt(val.second.routers.begin());
         std::vector<uint32_t>::const_iterator newIt(newRouters.begin());
         val.second.shortPacketsCount = 0;
         std::vector<uint32_t>::const_iterator oldIt(val.second.routers.begin());
         std::vector<uint32_t>::const_iterator newIt(newRouters.begin());
         val.second.shortPacketsCount = 0;


@@ -52,23 +52,23 @@ public:
                 {
                 if (newIt != newRouters.end())
                     {
                 {
                 if (newIt != newRouters.end())
                     {

-                    obj.SendDirect(val.first, val.second, *newIt); // Connect on new router
+                    obj.SendDirect(val.second, *newIt); // Connect on new router

                     ++newIt;
                     }
                 }
             else if (newIt == newRouters.end())
                 {
                     ++newIt;
                     }
                 }
             else if (newIt == newRouters.end())
                 {

-                obj.SendDirect(val.first, val.second, *oldIt, true); // Disconnect on old router
+                obj.SendDirect(val.second, *oldIt, true); // Disconnect on old router

                 ++oldIt;
                 } 
             else if (*oldIt < *newIt)
                 {
                 ++oldIt;
                 } 
             else if (*oldIt < *newIt)
                 {

-                obj.SendDirect(val.first, val.second, *oldIt, true); // Disconnect on old router
+                obj.SendDirect(val.second, *oldIt, true); // Disconnect on old router

                 ++oldIt;
                 }
             else if (*oldIt > *newIt)
                 {
                 ++oldIt;
                 }
             else if (*oldIt > *newIt)
                 {

-                obj.SendDirect(val.first, val.second, *newIt); // Connect on new router
+                obj.SendDirect(val.second, *newIt); // Connect on new router

                 ++newIt;
                 }
             else
                 ++newIt;
                 }
             else