]> git.stg.codes - stg.git/commitdiff
Apply some Clang Tidy suggestions.
authorMaksym Mamontov <madf@madf.info>
Sat, 30 Jul 2022 21:16:44 +0000 (00:16 +0300)
committerMaksym Mamontov <madf@madf.info>
Sat, 30 Jul 2022 21:16:44 +0000 (00:16 +0300)
include/stg/users.h
projects/stargazer/plugins/configuration/sgconfig/stgconfig.cpp
projects/stargazer/plugins/other/ping/ping.cpp
projects/stargazer/plugins/other/ping/ping.h
projects/stargazer/plugins/other/rscript/rscript.cpp
projects/stargazer/plugins/other/rscript/rscript.h
projects/stargazer/plugins/other/smux/smux.cpp
projects/stargazer/traffcounter_impl.cpp
projects/stargazer/users_impl.cpp
projects/stargazer/users_impl.h
tests/testusers.h

index 04b156056e0dab9baf35fa329c3d6554aab53fd2..dfc60b64dcb5fb107c2af0c5abd8a311c1e6113b 100644 (file)
@@ -65,7 +65,7 @@ struct Users {
     virtual bool IsIPInIndex(uint32_t ip) const = 0;
     virtual bool IsIPInUse(uint32_t ip, const std::string & login, const User** user) const = 0;
 
     virtual bool IsIPInIndex(uint32_t ip) const = 0;
     virtual bool IsIPInUse(uint32_t ip, const std::string & login, const User** user) const = 0;
 
-    virtual int  OpenSearch() = 0;
+    virtual unsigned int  OpenSearch() = 0;
     virtual int  SearchNext(int handle, User** u) = 0;
     virtual int  CloseSearch(int handle) = 0;
 
     virtual int  SearchNext(int handle, User** u) = 0;
     virtual int  CloseSearch(int handle) = 0;
 
index 0896bb85f434cacb392166e4e55c12db19099ae8..4666575c1ec4c7191903f86a1e621653173bd122 100644 (file)
@@ -102,7 +102,7 @@ int STG_CONFIG::Start()
         return -1;
     }
 
         return -1;
     }
 
-    m_thread = std::jthread([this](auto token){ Run(token); });
+    m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
 
     return 0;
 }
 
     return 0;
 }
index 53f7b2f02b8bdf929d540f98358347ac69ffa6e2..260f4aefbc77c22efa303c41fb67630da6210883 100644 (file)
@@ -50,7 +50,7 @@ if (pvi == s.moduleParams.end() || pvi->value.empty())
     printfd(__FILE__, "Parameter 'PingDelay' not found\n");
     return -1;
     }
     printfd(__FILE__, "Parameter 'PingDelay' not found\n");
     return -1;
     }
-if (ParseIntInRange(pvi->value[0], 5, 3600, &pingDelay))
+if (ParseIntInRange(pvi->value[0], 5, 3600, &pingDelay) != 0)
     {
     errorStr = "Cannot parse parameter \'PingDelay\': " + errorStr;
     printfd(__FILE__, "Canot parse parameter 'PingDelay'\n");
     {
     errorStr = "Cannot parse parameter \'PingDelay\': " + errorStr;
     printfd(__FILE__, "Canot parse parameter 'PingDelay'\n");
@@ -61,7 +61,7 @@ return 0;
 }
 //-----------------------------------------------------------------------------
 PING::PING()
 }
 //-----------------------------------------------------------------------------
 PING::PING()
-    : users(NULL),
+    : users(nullptr),
       isRunning(false),
       onAddUserNotifier(*this),
       onDelUserNotifier(*this),
       isRunning(false),
       onAddUserNotifier(*this),
       onDelUserNotifier(*this),
@@ -69,14 +69,10 @@ PING::PING()
 {
 }
 //-----------------------------------------------------------------------------
 {
 }
 //-----------------------------------------------------------------------------
-PING::~PING()
-{
-}
-//-----------------------------------------------------------------------------
 int PING::ParseSettings()
 {
 int PING::ParseSettings()
 {
-int ret = pingSettings.ParseSettings(settings);
-if (ret)
+auto ret = pingSettings.ParseSettings(settings);
+if (ret != 0)
     errorStr = pingSettings.GetStrError();
 return ret;
 }
     errorStr = pingSettings.GetStrError();
 return ret;
 }
@@ -91,7 +87,7 @@ users->AddNotifierUserDel(&onDelUserNotifier);
 pinger.SetDelayTime(pingSettings.GetPingDelay());
 pinger.Start();
 
 pinger.SetDelayTime(pingSettings.GetPingDelay());
 pinger.Start();
 
-m_thread = std::jthread([this](auto token){ Run(token); });
+m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
 
 return 0;
 }
 
 return 0;
 }
@@ -112,7 +108,7 @@ for (int i = 0; i < 25; i++)
     if (!isRunning)
         break;
 
     if (!isRunning)
         break;
 
-    nanosleep(&ts, NULL);
+    nanosleep(&ts, nullptr);
     }
 
 users->DelNotifierUserAdd(&onAddUserNotifier);
     }
 
 users->DelNotifierUserAdd(&onAddUserNotifier);
@@ -143,7 +139,7 @@ void PING::Run(std::stop_token token)
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
-pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
+pthread_sigmask(SIG_BLOCK, &signalSet, nullptr);
 
 isRunning = true;
 
 
 isRunning = true;
 
@@ -151,7 +147,7 @@ long delay = (10000000 * pingSettings.GetPingDelay()) / 3 + 50000000;
 
 while (!token.stop_requested())
     {
 
 while (!token.stop_requested())
     {
-    std::list<UserPtr>::iterator iter = usersList.begin();
+    auto iter = usersList.begin();
         {
         std::lock_guard lock(m_mutex);
         while (iter != usersList.end())
         {
         std::lock_guard lock(m_mutex);
         while (iter != usersList.end())
@@ -162,19 +158,19 @@ while (!token.stop_requested())
                 time_t t;
                 if (pinger.GetIPTime(ip, &t) == 0)
                     {
                 time_t t;
                 if (pinger.GetIPTime(ip, &t) == 0)
                     {
-                    if (t)
+                    if (t != 0)
                         (*iter)->UpdatePingTime(t);
                     }
                 }
             else
                 {
                 uint32_t ip = (*iter)->GetCurrIP();
                         (*iter)->UpdatePingTime(t);
                     }
                 }
             else
                 {
                 uint32_t ip = (*iter)->GetCurrIP();
-                if (ip)
+                if (ip != 0)
                     {
                     time_t t;
                     if (pinger.GetIPTime(ip, &t) == 0)
                         {
                     {
                     time_t t;
                     if (pinger.GetIPTime(ip, &t) == 0)
                         {
-                        if (t)
+                        if (t != 0)
                             (*iter)->UpdatePingTime(t);
                         }
                     }
                             (*iter)->UpdatePingTime(t);
                         }
                     }
@@ -187,7 +183,7 @@ while (!token.stop_requested())
         {
         if (!token.stop_requested())
             {
         {
         if (!token.stop_requested())
             {
-            nanosleep(&ts, NULL);
+            nanosleep(&ts, nullptr);
             }
         }
     }
             }
         }
     }
@@ -259,7 +255,7 @@ while (users->SearchNext(h, &u) == 0)
     else
         {
         uint32_t ip = u->GetCurrIP();
     else
         {
         uint32_t ip = u->GetCurrIP();
-        if (ip)
+        if (ip != 0)
             pinger.AddIP(ip);
         }
     }
             pinger.AddIP(ip);
         }
     }
@@ -298,7 +294,7 @@ while (users_iter != usersList.end())
 void CHG_CURRIP_NOTIFIER_PING::Notify(const uint32_t & oldIP, const uint32_t & newIP)
 {
 ping.pinger.DelIP(oldIP);
 void CHG_CURRIP_NOTIFIER_PING::Notify(const uint32_t & oldIP, const uint32_t & newIP)
 {
 ping.pinger.DelIP(oldIP);
-if (newIP)
+if (newIP != 0)
     ping.pinger.AddIP(newIP);
 }
 //-----------------------------------------------------------------------------
     ping.pinger.AddIP(newIP);
 }
 //-----------------------------------------------------------------------------
index 23874e37623da45d03fd35fb30a0919d1889af80..6a82811224b9886b1a24e6fc56911adb153dc96c 100644 (file)
@@ -95,7 +95,6 @@ friend class CHG_CURRIP_NOTIFIER_PING;
 friend class CHG_IPS_NOTIFIER_PING;
 public:
     PING();
 friend class CHG_IPS_NOTIFIER_PING;
 public:
     PING();
-    ~PING() override;
 
     void SetUsers(STG::Users * u) override { users = u; }
     void SetSettings(const STG::ModuleSettings & s) override { settings = s; }
 
     void SetUsers(STG::Users * u) override { users = u; }
     void SetSettings(const STG::ModuleSettings & s) override { settings = s; }
index 95699e1068cefd48f79669d1ecbb04a8b0f30cd7..e675d4886c56460ca234a3b78468f164f3c12dd4 100644 (file)
@@ -78,18 +78,17 @@ int RS::SETTINGS::ParseSettings(const STG::ModuleSettings & s)
 {
 int p;
 STG::ParamValue pv;
 {
 int p;
 STG::ParamValue pv;
-std::vector<STG::ParamValue>::const_iterator pvi;
 netRouters.clear();
 ///////////////////////////
 pv.param = "Port";
 netRouters.clear();
 ///////////////////////////
 pv.param = "Port";
-pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
+auto pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 if (pvi == s.moduleParams.end() || pvi->value.empty())
     {
     errorStr = "Parameter \'Port\' not found.";
     printfd(__FILE__, "Parameter 'Port' not found\n");
     return -1;
     }
 if (pvi == s.moduleParams.end() || pvi->value.empty())
     {
     errorStr = "Parameter \'Port\' not found.";
     printfd(__FILE__, "Parameter 'Port' not found\n");
     return -1;
     }
-if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
+if (ParseIntInRange(pvi->value[0], 2, 65535, &p) != 0)
     {
     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
     {
     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
@@ -106,7 +105,7 @@ if (pvi == s.moduleParams.end() || pvi->value.empty())
     return -1;
     }
 
     return -1;
     }
 
-if (ParseIntInRange(pvi->value[0], 5, 600, &sendPeriod))
+if (ParseIntInRange(pvi->value[0], 5, 600, &sendPeriod) != 0)
     {
     errorStr = "Cannot parse parameter \'SendPeriod\': " + errorStr;
     printfd(__FILE__, "Cannot parse parameter 'SendPeriod'\n");
     {
     errorStr = "Cannot parse parameter \'SendPeriod\': " + errorStr;
     printfd(__FILE__, "Cannot parse parameter 'SendPeriod'\n");
@@ -146,13 +145,9 @@ subnetFile = pvi->value[0];
 NRMapParser nrMapParser;
 
 if (!nrMapParser.ReadFile(subnetFile))
 NRMapParser nrMapParser;
 
 if (!nrMapParser.ReadFile(subnetFile))
-    {
     netRouters = nrMapParser.GetMap();
     netRouters = nrMapParser.GetMap();
-    }
 else
 else
-    {
-        STG::PluginLogger::get("rscript")("mod_rscript: error opening subnets file '%s'", subnetFile.c_str());
-    }
+    STG::PluginLogger::get("rscript")("mod_rscript: error opening subnets file '%s'", subnetFile.c_str());
 
 return 0;
 }
 
 return 0;
 }
@@ -163,7 +158,7 @@ REMOTE_SCRIPT::REMOTE_SCRIPT()
     : sendPeriod(15),
       halfPeriod(8),
       isRunning(false),
     : sendPeriod(15),
       halfPeriod(8),
       isRunning(false),
-      users(NULL),
+      users(nullptr),
       sock(0),
       onAddUserNotifier(*this),
       onDelUserNotifier(*this),
       sock(0),
       onAddUserNotifier(*this),
       onDelUserNotifier(*this),
@@ -171,15 +166,11 @@ REMOTE_SCRIPT::REMOTE_SCRIPT()
 {
 }
 //-----------------------------------------------------------------------------
 {
 }
 //-----------------------------------------------------------------------------
-REMOTE_SCRIPT::~REMOTE_SCRIPT()
-{
-}
-//-----------------------------------------------------------------------------
 void REMOTE_SCRIPT::Run(std::stop_token token)
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 void REMOTE_SCRIPT::Run(std::stop_token token)
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
-pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
+pthread_sigmask(SIG_BLOCK, &signalSet, nullptr);
 
 isRunning = true;
 
 
 isRunning = true;
 
@@ -194,8 +185,8 @@ isRunning = false;
 //-----------------------------------------------------------------------------
 int REMOTE_SCRIPT::ParseSettings()
 {
 //-----------------------------------------------------------------------------
 int REMOTE_SCRIPT::ParseSettings()
 {
-int ret = rsSettings.ParseSettings(settings);
-if (ret)
+auto ret = rsSettings.ParseSettings(settings);
+if (ret != 0)
     errorStr = rsSettings.GetStrError();
 
 sendPeriod = rsSettings.GetSendPeriod();
     errorStr = rsSettings.GetStrError();
 
 sendPeriod = rsSettings.GetSendPeriod();
@@ -214,19 +205,13 @@ users->AddNotifierUserAdd(&onAddUserNotifier);
 users->AddNotifierUserDel(&onDelUserNotifier);
 
 if (GetUsers())
 users->AddNotifierUserDel(&onDelUserNotifier);
 
 if (GetUsers())
-    {
     return -1;
     return -1;
-    }
 
 if (PrepareNet())
 
 if (PrepareNet())
-    {
     return -1;
     return -1;
-    }
 
 if (!isRunning)
 
 if (!isRunning)
-    {
-    m_thread = std::jthread([this](auto token){ Run(token); });
-    }
+    m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
 
 errorStr = "";
 return 0;
 
 errorStr = "";
 return 0;
@@ -253,7 +238,7 @@ if (isRunning)
     for (int i = 0; i < 25 && isRunning; i++)
         {
         struct timespec ts = {0, 200000000};
     for (int i = 0; i < 25 && isRunning; i++)
         {
         struct timespec ts = {0, 200000000};
-        nanosleep(&ts, NULL);
+        nanosleep(&ts, nullptr);
         }
     }
 
         }
     }
 
@@ -325,7 +310,7 @@ void REMOTE_SCRIPT::PeriodicSend()
 {
 std::lock_guard lock(m_mutex);
 
 {
 std::lock_guard lock(m_mutex);
 
-std::map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());
+auto 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)
@@ -393,19 +378,16 @@ RS::PACKET_TAIL packetTail;
 
 memset(packetTail.padding, 0, sizeof(packetTail.padding));
 memcpy(packetTail.magic, RS_ID, sizeof(RS_ID));
 
 memset(packetTail.padding, 0, sizeof(packetTail.padding));
 memcpy(packetTail.magic, RS_ID, sizeof(RS_ID));
-std::vector<std::string>::const_iterator it;
 std::string params;
 std::string params;
-for(it = rsSettings.GetUserParams().begin();
-    it != rsSettings.GetUserParams().end();
-    ++it)
+for (const auto& param : rsSettings.GetUserParams())
     {
     {
-    std::string parameter(rsu.user->GetParamValue(it->c_str()));
-    if (params.length() + parameter.length() > RS_PARAMS_LEN - 1)
+    auto value = rsu.user->GetParamValue(param);
+    if (params.length() + value.length() > RS_PARAMS_LEN - 1)
     {
     {
-        logger("Script params string length %d exceeds the limit of %d symbols.", params.length() + parameter.length(), RS_PARAMS_LEN);
+        logger("Script params string length %d exceeds the limit of %d symbols.", params.length() + value.length(), RS_PARAMS_LEN);
         break;
     }
         break;
     }
-    params += parameter + " ";
+    params += value + " ";
     }
 strncpy(reinterpret_cast<char*>(packetTail.params), params.c_str(), RS_PARAMS_LEN);
 packetTail.params[RS_PARAMS_LEN - 1] = 0;
     }
 strncpy(reinterpret_cast<char*>(packetTail.params), params.c_str(), RS_PARAMS_LEN);
 packetTail.params[RS_PARAMS_LEN - 1] = 0;
@@ -437,7 +419,7 @@ for (const auto& ip : rsu.routers)
     sendAddr.sin_port = htons(rsSettings.GetPort());
     sendAddr.sin_addr.s_addr = ip;
 
     sendAddr.sin_port = htons(rsSettings.GetPort());
     sendAddr.sin_addr.s_addr = ip;
 
-    return sendto(sock, buffer, sizeof(buffer), 0, reinterpret_cast<struct sockaddr*>(&sendAddr), sizeof(sendAddr));
+    return sendto(sock, buffer, sizeof(buffer), 0, reinterpret_cast<struct sockaddr*>(&sendAddr), sizeof(sendAddr)) > 0;
 }
 
 return false;
 }
 
 return false;
@@ -474,10 +456,8 @@ UserPtr u;
 int h = users->OpenSearch();
 assert(h && "USERS::OpenSearch is always correct");
 
 int h = users->OpenSearch();
 assert(h && "USERS::OpenSearch is always correct");
 
-while (!users->SearchNext(h, &u))
-    {
+while (users->SearchNext(h, &u) != 0)
     SetUserNotifiers(u);
     SetUserNotifiers(u);
-    }
 
 users->CloseSearch(h);
 return false;
 
 users->CloseSearch(h);
 return false;
@@ -486,14 +466,10 @@ return false;
 std::vector<uint32_t> REMOTE_SCRIPT::IP2Routers(uint32_t ip)
 {
 std::lock_guard lock(m_mutex);
 std::vector<uint32_t> REMOTE_SCRIPT::IP2Routers(uint32_t ip)
 {
 std::lock_guard lock(m_mutex);
-for (size_t i = 0; i < netRouters.size(); ++i)
-    {
-    if ((ip & netRouters[i].subnetMask) == (netRouters[i].subnetIP & netRouters[i].subnetMask))
-        {
-        return netRouters[i].routers;
-        }
-    }
-return std::vector<uint32_t>();
+for (auto& nr : netRouters)
+    if ((ip & nr.subnetMask) == (nr.subnetIP & nr.subnetMask))
+        return nr.routers;
+return {};
 }
 //-----------------------------------------------------------------------------
 void REMOTE_SCRIPT::SetUserNotifiers(UserPtr u)
 }
 //-----------------------------------------------------------------------------
 void REMOTE_SCRIPT::SetUserNotifiers(UserPtr u)
@@ -527,7 +503,7 @@ authorizedUsers.insert(std::make_pair(user->GetCurrIP(), rsu));
 void REMOTE_SCRIPT::DelRSU(UserPtr user)
 {
 std::lock_guard lock(m_mutex);
 void REMOTE_SCRIPT::DelRSU(UserPtr user)
 {
 std::lock_guard lock(m_mutex);
-std::map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());
+auto it = authorizedUsers.begin();
 while (it != authorizedUsers.end())
     {
     if (it->second.user == user)
 while (it != authorizedUsers.end())
     {
     if (it->second.user == user)
@@ -538,9 +514,7 @@ while (it != authorizedUsers.end())
         }
     ++it;
     }
         }
     ++it;
     }
-/*const std::map<uint32_t, RS::USER>::iterator it(
-        authorizedUsers.find(user->GetCurrIP())
-        );
+/*const auto it = authorizedUsers.find(user->GetCurrIP());
 if (it != authorizedUsers.end())
     {
     Send(it->second, true);
 if (it != authorizedUsers.end())
     {
     Send(it->second, true);
@@ -550,7 +524,7 @@ if (it != authorizedUsers.end())
 //-----------------------------------------------------------------------------
 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)
 {
-if (newValue)
+if (newValue != 0)
     rs.AddRSU(user);
 else
     rs.DelRSU(user);
     rs.AddRSU(user);
 else
     rs.DelRSU(user);
index 80fc86517e073efc09b149b9eb4ca023574433db..6c97b59883cb188392867ba847ee9911f83fd238 100644 (file)
@@ -177,7 +177,6 @@ private:
 class REMOTE_SCRIPT : public STG::Plugin {
 public:
                         REMOTE_SCRIPT();
 class REMOTE_SCRIPT : public STG::Plugin {
 public:
                         REMOTE_SCRIPT();
-                        ~REMOTE_SCRIPT() override;
 
     void                SetUsers(STG::Users * u) override { users = u; }
     void                SetSettings(const STG::ModuleSettings & s) override { settings = s; }
 
     void                SetUsers(STG::Users * u) override { users = u; }
     void                SetSettings(const STG::ModuleSettings & s) override { settings = s; }
index e0ddfffcb56e251fc84b0454fda065b6a9797930..f79085dff1250bc3978420ac35975a06cf05e0dd 100644 (file)
@@ -37,27 +37,24 @@ extern "C" STG::Plugin* GetPlugin()
 }
 
 SMUX_SETTINGS::SMUX_SETTINGS()
 }
 
 SMUX_SETTINGS::SMUX_SETTINGS()
-    : errorStr(),
-      ip(0),
-      port(0),
-      password()
+    : ip(0),
+      port(0)
 {}
 
 int SMUX_SETTINGS::ParseSettings(const STG::ModuleSettings & s)
 {
 STG::ParamValue pv;
 {}
 
 int SMUX_SETTINGS::ParseSettings(const STG::ModuleSettings & s)
 {
 STG::ParamValue pv;
-std::vector<STG::ParamValue>::const_iterator pvi;
 int p;
 
 pv.param = "Port";
 int p;
 
 pv.param = "Port";
-pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
+auto pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 if (pvi == s.moduleParams.end() || pvi->value.empty())
     {
     errorStr = "Parameter \'Port\' not found.";
     printfd(__FILE__, "Parameter 'Port' not found\n");
     return -1;
     }
 if (pvi == s.moduleParams.end() || pvi->value.empty())
     {
     errorStr = "Parameter \'Port\' not found.";
     printfd(__FILE__, "Parameter 'Port' not found\n");
     return -1;
     }
-if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
+if (ParseIntInRange(pvi->value[0], 2, 65535, &p) != 0)
     {
     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
     {
     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
@@ -92,12 +89,12 @@ return 0;
 }
 
 SMUX::SMUX()
 }
 
 SMUX::SMUX()
-    : users(NULL),
-      tariffs(NULL),
-      admins(NULL),
-      services(NULL),
-      corporations(NULL),
-      traffcounter(NULL),
+    : users(nullptr),
+      tariffs(nullptr),
+      admins(nullptr),
+      services(nullptr),
+      corporations(nullptr),
+      traffcounter(nullptr),
       stopped(true),
       needReconnect(false),
       lastReconnectTry(0),
       stopped(true),
       needReconnect(false),
       lastReconnectTry(0),
@@ -120,17 +117,11 @@ pdusHandlers[PDUs_PR_set_request] = &SMUX::SetRequestHandler;
 
 SMUX::~SMUX()
 {
 
 SMUX::~SMUX()
 {
-    {
-    Sensors::iterator it;
-    for (it = sensors.begin(); it != sensors.end(); ++it)
-        delete it->second;
-    }
-    {
-    Tables::iterator it;
-    for (it = tables.begin(); it != tables.end(); ++it)
-        delete it->second;
-    }
-printfd(__FILE__, "SMUX::~SMUX()\n");
+    for (auto& kv : sensors)
+        delete kv.second;
+    for (auto& kv : tables)
+        delete kv.second;
+    printfd(__FILE__, "SMUX::~SMUX()\n");
 }
 
 int SMUX::ParseSettings()
 }
 
 int SMUX::ParseSettings()
@@ -140,12 +131,12 @@ return smuxSettings.ParseSettings(settings);
 
 int SMUX::Start()
 {
 
 int SMUX::Start()
 {
-assert(users != NULL && "users must not be NULL");
-assert(tariffs != NULL && "tariffs must not be NULL");
-assert(admins != NULL && "admins must not be NULL");
-assert(services != NULL && "services must not be NULL");
-assert(corporations != NULL && "corporations must not be NULL");
-assert(traffcounter != NULL && "traffcounter must not be NULL");
+assert(users != nullptr && "users must not be NULL");
+assert(tariffs != nullptr && "tariffs must not be NULL");
+assert(admins != nullptr && "admins must not be NULL");
+assert(services != nullptr && "services must not be NULL");
+assert(corporations != nullptr && "corporations must not be NULL");
+assert(traffcounter != nullptr && "traffcounter must not be NULL");
 
 if (PrepareNet())
     needReconnect = true;
 
 if (PrepareNet())
     needReconnect = true;
@@ -181,7 +172,7 @@ UpdateTables();
 SetNotifiers();
 
 #ifdef SMUX_DEBUG
 SetNotifiers();
 
 #ifdef SMUX_DEBUG
-Sensors::const_iterator it(sensors.begin());
+auto it = sensors.begin();
 while (it != sensors.end())
     {
     printfd(__FILE__, "%s = %s\n",
 while (it != sensors.end())
     {
     printfd(__FILE__, "%s = %s\n",
@@ -192,7 +183,7 @@ while (it != sensors.end())
 #endif
 
 if (!m_thread.joinable())
 #endif
 
 if (!m_thread.joinable())
-    m_thread = std::jthread([this](auto token){ Run(token); });
+    m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
 
 return 0;
 }
 
 return 0;
 }
@@ -208,7 +199,7 @@ if (!stopped)
     for (int i = 0; i < 25 && !stopped; i++)
         {
         struct timespec ts = {0, 200000000};
     for (int i = 0; i < 25 && !stopped; i++)
         {
         struct timespec ts = {0, 200000000};
-        nanosleep(&ts, NULL);
+        nanosleep(&ts, nullptr);
         }
     }
 
         }
     }
 
@@ -219,16 +210,10 @@ else
 
 ResetNotifiers();
 
 
 ResetNotifiers();
 
-    {
-    Tables::iterator it;
-    for (it = tables.begin(); it != tables.end(); ++it)
-        delete it->second;
-    }
-    {
-    Sensors::iterator it;
-    for (it = sensors.begin(); it != sensors.end(); ++it)
-        delete it->second;
-    }
+for (auto& kv : sensors)
+    delete kv.second;
+for (auto& kv : tables)
+    delete kv.second;
 
 tables.erase(tables.begin(), tables.end());
 sensors.erase(sensors.begin(), sensors.end());
 
 tables.erase(tables.begin(), tables.end());
 sensors.erase(sensors.begin(), sensors.end());
@@ -246,9 +231,9 @@ return 0;
 
 int SMUX::Reload(const STG::ModuleSettings & /*ms*/)
 {
 
 int SMUX::Reload(const STG::ModuleSettings & /*ms*/)
 {
-if (Stop())
+if (Stop() != 0)
     return -1;
     return -1;
-if (Start())
+if (Start() != 0)
     return -1;
 if (!needReconnect)
     {
     return -1;
 if (!needReconnect)
     {
@@ -271,8 +256,8 @@ while (!token.stop_requested())
     {
     if (WaitPackets(sock) && !needReconnect)
         {
     {
     if (WaitPackets(sock) && !needReconnect)
         {
-        SMUX_PDUs_t * pdus = RecvSMUXPDUs(sock);
-        if (pdus)
+        auto* pdus = RecvSMUXPDUs(sock);
+        if (pdus != nullptr)
             {
             DispatchPDUs(pdus);
             ASN_STRUCT_FREE(asn_DEF_SMUX_PDUs, pdus);
             {
             DispatchPDUs(pdus);
             ASN_STRUCT_FREE(asn_DEF_SMUX_PDUs, pdus);
@@ -307,7 +292,7 @@ addr.sin_family = AF_INET;
 addr.sin_port = htons(smuxSettings.GetPort());
 addr.sin_addr.s_addr = smuxSettings.GetIP();
 
 addr.sin_port = htons(smuxSettings.GetPort());
 addr.sin_addr.s_addr = smuxSettings.GetIP();
 
-if (connect(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)))
+if (connect(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) != 0)
     {
     errorStr = "Cannot connect.";
     logger("Cannot connect the socket: %s", strerror(errno));
     {
     errorStr = "Cannot connect.";
     logger("Cannot connect the socket: %s", strerror(errno));
@@ -320,7 +305,7 @@ return false;
 
 bool SMUX::Reconnect()
 {
 
 bool SMUX::Reconnect()
 {
-if (needReconnect && difftime(time(NULL), lastReconnectTry) < reconnectTimeout)
+if (needReconnect && difftime(time(nullptr), lastReconnectTry) < reconnectTimeout)
     return true;
 
 time(&lastReconnectTry);
     return true;
 
 time(&lastReconnectTry);
@@ -347,11 +332,9 @@ return true;
 
 bool SMUX::DispatchPDUs(const SMUX_PDUs_t * pdus)
 {
 
 bool SMUX::DispatchPDUs(const SMUX_PDUs_t * pdus)
 {
-SMUXHandlers::iterator it(smuxHandlers.find(pdus->present));
+auto it = smuxHandlers.find(pdus->present);
 if (it != smuxHandlers.end())
 if (it != smuxHandlers.end())
-    {
     return (this->*(it->second))(pdus);
     return (this->*(it->second))(pdus);
-    }
 #ifdef SMUX_DEBUG
 else
     {
 #ifdef SMUX_DEBUG
 else
     {
@@ -379,7 +362,7 @@ bool SMUX::UpdateTables()
 {
 Sensors newSensors;
 bool done = true;
 {
 Sensors newSensors;
 bool done = true;
-Tables::iterator it(tables.begin());
+auto it = tables.begin();
 while (it != tables.end())
     {
     try
 while (it != tables.end())
     {
     try
@@ -398,7 +381,7 @@ while (it != tables.end())
     }
 if (!done)
     {
     }
 if (!done)
     {
-    Sensors::iterator sit(newSensors.begin());
+    auto sit = newSensors.begin();
     while (sit != newSensors.end())
         {
         delete sit->second;
     while (sit != newSensors.end())
         {
         delete sit->second;
@@ -410,12 +393,11 @@ if (!done)
 it = tables.begin();
 while (it != tables.end())
     {
 it = tables.begin();
 while (it != tables.end())
     {
-    std::pair<Sensors::iterator, Sensors::iterator> res;
-    res = std::equal_range(sensors.begin(),
-                           sensors.end(),
-                           std::pair<OID, Sensor *>(OID(it->first), NULL),
-                           SPrefixLess);
-    Sensors::iterator sit(res.first);
+    auto res = std::equal_range(sensors.begin(),
+                                sensors.end(),
+                                std::pair<OID, Sensor *>(OID(it->first), nullptr),
+                                SPrefixLess);
+    auto sit = res.first;
     while (sit != res.second)
         {
         delete sit->second;
     while (sit != res.second)
         {
         delete sit->second;
@@ -432,13 +414,13 @@ return true;
 
 void SMUX::SetNotifier(UserPtr userPtr)
 {
 
 void SMUX::SetNotifier(UserPtr userPtr)
 {
-notifiers.push_back(CHG_AFTER_NOTIFIER(*this, userPtr));
+notifiers.emplace_back(*this, userPtr);
 userPtr->GetProperties().tariffName.AddAfterNotifier(&notifiers.back());
 }
 
 void SMUX::UnsetNotifier(UserPtr userPtr)
 {
 userPtr->GetProperties().tariffName.AddAfterNotifier(&notifiers.back());
 }
 
 void SMUX::UnsetNotifier(UserPtr userPtr)
 {
-std::list<CHG_AFTER_NOTIFIER>::iterator it = notifiers.begin();
+auto it = notifiers.begin();
 while (it != notifiers.end())
     {
     if (it->GetUserPtr() == userPtr)
 while (it != notifiers.end())
     {
     if (it->GetUserPtr() == userPtr)
@@ -457,7 +439,7 @@ int h = users->OpenSearch();
 assert(h && "USERS::OpenSearch is always correct");
 
 UserPtr u;
 assert(h && "USERS::OpenSearch is always correct");
 
 UserPtr u;
-while (!users->SearchNext(h, &u))
+while (users->SearchNext(h, &u) == 0)
     SetNotifier(u);
 
 users->CloseSearch(h);
     SetNotifier(u);
 
 users->CloseSearch(h);
@@ -477,7 +459,7 @@ tariffs->DelNotifierAdd(&addDelTariffNotifier);
 users->DelNotifierUserDel(&delUserNotifier);
 users->DelNotifierUserAdd(&addUserNotifier);
 
 users->DelNotifierUserDel(&delUserNotifier);
 users->DelNotifierUserAdd(&addUserNotifier);
 
-std::list<CHG_AFTER_NOTIFIER>::iterator it(notifiers.begin());
+auto it = notifiers.begin();
 while (it != notifiers.end())
     {
     it->GetUserPtr()->GetProperties().tariffName.DelAfterNotifier(&(*it));
 while (it != notifiers.end())
     {
     it->GetUserPtr()->GetProperties().tariffName.DelAfterNotifier(&(*it));
index 9b0fd966d9a2732e456b60f176c8200e5bed6ccb..377e388902fd26cb493ee241ff54119d57efbe16 100644 (file)
@@ -106,7 +106,7 @@ while (users->SearchNext(h, &u) == 0)
     SetUserNotifiers(u);
 users->CloseSearch(h);
 
     SetUserNotifiers(u);
 users->CloseSearch(h);
 
-m_thread = std::jthread([this](auto token){ Run(token); });
+m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------
index ee25fb2cf90516159b348c7efd7f4fd92d3fd98b..8cb9bee5b0e8b723d9c89a8470605e159f70d8c9 100644 (file)
@@ -42,49 +42,45 @@ extern volatile time_t stgTime;
 using STG::UsersImpl;
 
 //-----------------------------------------------------------------------------
 using STG::UsersImpl;
 
 //-----------------------------------------------------------------------------
-UsersImpl::UsersImpl(SettingsImpl * s, Store * st,
-                    Tariffs * t, Services & svcs,
-                    const Admin& sa)
+UsersImpl::UsersImpl(SettingsImpl * s, Store * store,
+                    Tariffs * tariffs, Services & svcs,
+                    const Admin& sysAdmin)
     : settings(s),
     : settings(s),
-      tariffs(t),
+      m_tariffs(tariffs),
       m_services(svcs),
       m_services(svcs),
-      store(st),
-      sysAdmin(sa),
+      m_store(store),
+      m_sysAdmin(sysAdmin),
       WriteServLog(Logger::get()),
       isRunning(false),
       handle(0)
 {
 }
 //-----------------------------------------------------------------------------
       WriteServLog(Logger::get()),
       isRunning(false),
       handle(0)
 {
 }
 //-----------------------------------------------------------------------------
-UsersImpl::~UsersImpl()
+bool UsersImpl::FindByNameNonLock(const std::string & login, user_iter * user)
 {
 {
-}
-//-----------------------------------------------------------------------------
-int UsersImpl::FindByNameNonLock(const std::string & login, user_iter * user)
-{
-const std::map<std::string, user_iter>::const_iterator iter(loginIndex.find(login));
+const auto iter = loginIndex.find(login);
 if (iter == loginIndex.end())
 if (iter == loginIndex.end())
-    return -1;
-if (user)
+    return false;
+if (user != nullptr)
     *user = iter->second;
     *user = iter->second;
-return 0;
+return true;
 }
 //-----------------------------------------------------------------------------
 }
 //-----------------------------------------------------------------------------
-int UsersImpl::FindByNameNonLock(const std::string & login, const_user_iter * user) const
+bool UsersImpl::FindByNameNonLock(const std::string & login, const_user_iter * user) const
 {
 {
-const std::map<std::string, user_iter>::const_iterator iter(loginIndex.find(login));
+const auto iter = loginIndex.find(login);
 if (iter == loginIndex.end())
 if (iter == loginIndex.end())
-    return -1;
-if (user)
+    return false;
+if (user != nullptr)
     *user = iter->second;
     *user = iter->second;
-return 0;
+return true;
 }
 //-----------------------------------------------------------------------------
 int UsersImpl::FindByName(const std::string & login, UserPtr * user)
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 user_iter u;
 }
 //-----------------------------------------------------------------------------
 int UsersImpl::FindByName(const std::string & login, UserPtr * user)
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 user_iter u;
-if (FindByNameNonLock(login, &u))
+if (!FindByNameNonLock(login, &u))
     return -1;
 *user = &(*u);
 return 0;
     return -1;
 *user = &(*u);
 return 0;
@@ -94,7 +90,7 @@ int UsersImpl::FindByName(const std::string & login, ConstUserPtr * user) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 const_user_iter u;
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 const_user_iter u;
-if (FindByNameNonLock(login, &u))
+if (!FindByNameNonLock(login, &u))
     return -1;
 *user = &(*u);
 return 0;
     return -1;
 *user = &(*u);
 return 0;
@@ -103,15 +99,14 @@ return 0;
 bool UsersImpl::Exists(const std::string & login) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 bool UsersImpl::Exists(const std::string & login) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
-const std::map<std::string, user_iter>::const_iterator iter(loginIndex.find(login));
+const auto iter = loginIndex.find(login);
 return iter != loginIndex.end();
 }
 //-----------------------------------------------------------------------------
 bool UsersImpl::TariffInUse(const std::string & tariffName) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 return iter != loginIndex.end();
 }
 //-----------------------------------------------------------------------------
 bool UsersImpl::TariffInUse(const std::string & tariffName) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
-std::list<UserImpl>::const_iterator iter;
-iter = users.begin();
+auto iter = users.begin();
 while (iter != users.end())
     {
     if (iter->GetProperties().tariffName.Get() == tariffName)
 while (iter != users.end())
     {
     if (iter->GetProperties().tariffName.Get() == tariffName)
@@ -126,17 +121,17 @@ int UsersImpl::Add(const std::string & login, const Admin * admin)
 std::lock_guard<std::mutex> lock(m_mutex);
 const auto& priv = admin->priv();
 
 std::lock_guard<std::mutex> lock(m_mutex);
 const auto& priv = admin->priv();
 
-if (!priv.userAddDel)
+if (priv.userAddDel == 0)
     {
     WriteServLog("%s tried to add user \'%s\'. Access denied.",
                  admin->logStr().c_str(), login.c_str());
     return -1;
     }
 
     {
     WriteServLog("%s tried to add user \'%s\'. Access denied.",
                  admin->logStr().c_str(), login.c_str());
     return -1;
     }
 
-if (store->AddUser(login))
+if (m_store->AddUser(login) != 0)
     return -1;
 
     return -1;
 
-UserImpl u(settings, store, tariffs, &sysAdmin, this, m_services);
+UserImpl u(settings, m_store, m_tariffs, &m_sysAdmin, this, m_services);
 
 u.SetLogin(login);
 
 
 u.SetLogin(login);
 
@@ -156,7 +151,7 @@ AddUserIntoIndexes(users.begin());
 
     {
     // Fire all "on add" notifiers
 
     {
     // Fire all "on add" notifiers
-    std::set<NotifierBase<UserPtr> *>::iterator ni = onAddNotifiers.begin();
+    auto ni = onAddNotifiers.begin();
     while (ni != onAddNotifiers.end())
         {
         (*ni)->Notify(&users.front());
     while (ni != onAddNotifiers.end())
         {
         (*ni)->Notify(&users.front());
@@ -166,7 +161,7 @@ AddUserIntoIndexes(users.begin());
 
     {
     // Fire all "on add" implementation notifiers
 
     {
     // Fire all "on add" implementation notifiers
-    std::set<NotifierBase<UserImplPtr> *>::iterator ni = onAddNotifiersImpl.begin();
+    auto ni = onAddNotifiersImpl.begin();
     while (ni != onAddNotifiersImpl.end())
         {
         (*ni)->Notify(&users.front());
     while (ni != onAddNotifiersImpl.end())
         {
         (*ni)->Notify(&users.front());
@@ -182,7 +177,7 @@ void UsersImpl::Del(const std::string & login, const Admin * admin)
 const auto& priv = admin->priv();
 user_iter u;
 
 const auto& priv = admin->priv();
 user_iter u;
 
-if (!priv.userAddDel)
+if (priv.userAddDel == 0)
     {
     WriteServLog("%s tried to remove user \'%s\'. Access denied.",
                  admin->logStr().c_str(), login.c_str());
     {
     WriteServLog("%s tried to remove user \'%s\'. Access denied.",
                  admin->logStr().c_str(), login.c_str());
@@ -193,7 +188,7 @@ if (!priv.userAddDel)
     {
     std::lock_guard<std::mutex> lock(m_mutex);
 
     {
     std::lock_guard<std::mutex> lock(m_mutex);
 
-    if (FindByNameNonLock(login, &u))
+    if (!FindByNameNonLock(login, &u))
         {
         WriteServLog("%s tried to delete user \'%s\': not found.",
                      admin->logStr().c_str(),
         {
         WriteServLog("%s tried to delete user \'%s\': not found.",
                      admin->logStr().c_str(),
@@ -205,7 +200,7 @@ if (!priv.userAddDel)
     }
 
     {
     }
 
     {
-    std::set<NotifierBase<UserPtr> *>::iterator ni = onDelNotifiers.begin();
+    auto ni = onDelNotifiers.begin();
     while (ni != onDelNotifiers.end())
         {
         (*ni)->Notify(&(*u));
     while (ni != onDelNotifiers.end())
         {
         (*ni)->Notify(&(*u));
@@ -214,7 +209,7 @@ if (!priv.userAddDel)
     }
 
     {
     }
 
     {
-    std::set<NotifierBase<UserImplPtr> *>::iterator ni = onDelNotifiersImpl.begin();
+    auto ni = onDelNotifiersImpl.begin();
     while (ni != onDelNotifiersImpl.end())
         {
         (*ni)->Notify(&(*u));
     while (ni != onDelNotifiersImpl.end())
         {
         (*ni)->Notify(&(*u));
@@ -245,7 +240,7 @@ bool UsersImpl::Authorize(const std::string & login, uint32_t ip,
 {
 user_iter iter;
 std::lock_guard<std::mutex> lock(m_mutex);
 {
 user_iter iter;
 std::lock_guard<std::mutex> lock(m_mutex);
-if (FindByNameNonLock(login, &iter))
+if (!FindByNameNonLock(login, &iter))
     {
     WriteServLog("Attempt to authorize non-existant user '%s'", login.c_str());
     return false;
     {
     WriteServLog("Attempt to authorize non-existant user '%s'", login.c_str());
     return false;
@@ -260,12 +255,10 @@ if (FindByIPIdx(ip, iter))
                      iter->GetLogin().c_str());
         return false;
         }
                      iter->GetLogin().c_str());
         return false;
         }
-    if (iter->Authorize(ip, enabledDirs, auth))
-        return false;
-    return true;
+    return iter->Authorize(ip, enabledDirs, auth) == 0;
     }
 
     }
 
-if (iter->Authorize(ip, enabledDirs, auth))
+if (iter->Authorize(ip, enabledDirs, auth) != 0)
     return false;
 
 AddToIPIdx(iter);
     return false;
 
 AddToIPIdx(iter);
@@ -278,7 +271,7 @@ bool UsersImpl::Unauthorize(const std::string & login,
 {
 user_iter iter;
 std::lock_guard<std::mutex> lock(m_mutex);
 {
 user_iter iter;
 std::lock_guard<std::mutex> lock(m_mutex);
-if (FindByNameNonLock(login, &iter))
+if (!FindByNameNonLock(login, &iter))
     {
     WriteServLog("Attempt to unauthorize non-existant user '%s'", login.c_str());
     printfd(__FILE__, "Attempt to unauthorize non-existant user '%s'", login.c_str());
     {
     WriteServLog("Attempt to unauthorize non-existant user '%s'", login.c_str());
     printfd(__FILE__, "Attempt to unauthorize non-existant user '%s'", login.c_str());
@@ -289,7 +282,7 @@ uint32_t ip = iter->GetCurrIP();
 
 iter->Unauthorize(auth, reason);
 
 
 iter->Unauthorize(auth, reason);
 
-if (!iter->GetAuthorized())
+if (iter->GetAuthorized() == 0)
     DelFromIPIdx(ip);
 
 return true;
     DelFromIPIdx(ip);
 
 return true;
@@ -299,20 +292,20 @@ int UsersImpl::ReadUsers()
 {
 std::vector<std::string> usersList;
 usersList.clear();
 {
 std::vector<std::string> usersList;
 usersList.clear();
-if (store->GetUsersList(&usersList) < 0)
+if (m_store->GetUsersList(&usersList) < 0)
     {
     {
-    WriteServLog(store->GetStrError().c_str());
+    WriteServLog(m_store->GetStrError().c_str());
     return -1;
     }
 
 user_iter ui;
 
 unsigned errors = 0;
     return -1;
     }
 
 user_iter ui;
 
 unsigned errors = 0;
-for (unsigned int i = 0; i < usersList.size(); i++)
+for (const auto& user : usersList)
     {
     {
-    UserImpl u(settings, store, tariffs, &sysAdmin, this, m_services);
+    UserImpl u(settings, m_store, m_tariffs, &m_sysAdmin, this, m_services);
 
 
-    u.SetLogin(usersList[i]);
+    u.SetLogin(user);
     users.push_front(u);
     ui = users.begin();
 
     users.push_front(u);
     ui = users.begin();
 
@@ -345,7 +338,7 @@ void UsersImpl::Run(std::stop_token token)
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
-pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
+pthread_sigmask(SIG_BLOCK, &signalSet, nullptr);
 
 printfd(__FILE__, "=====================| pid: %d |===================== \n", getpid());
 
 
 printfd(__FILE__, "=====================| pid: %d |===================== \n", getpid());
 
@@ -400,7 +393,7 @@ while (!token.stop_requested())
     stgUsleep(100000);
     }
 
     stgUsleep(100000);
     }
 
-std::list<USER_TO_DEL>::iterator iter(usersToDelete.begin());
+auto iter = usersToDelete.begin();
 while (iter != usersToDelete.end())
     {
     iter->delTime -= 2 * userDeleteDelayTime;
 while (iter != usersToDelete.end())
     {
     iter->delTime -= 2 * userDeleteDelayTime;
@@ -426,8 +419,7 @@ if (TimeToWriteDetailStat(t))
     //printfd(__FILE__, "USER::WriteInetStat\n");
     int usersCnt = 0;
 
     //printfd(__FILE__, "USER::WriteInetStat\n");
     int usersCnt = 0;
 
-    // ðÉÛÅÍ ÀÚÅÒÏ× ÞÁÓÔÑÍÉ. ÷ ÐÅÒÅÒÙ×ÁÈ ×ÙÚÙ×ÁÅÍ USER::Run
-    std::list<UserImpl>::iterator usr = users.begin();
+    auto usr = users.begin();
     while (usr != users.end())
         {
         usersCnt++;
     while (usr != users.end())
         {
         usersCnt++;
@@ -488,7 +480,7 @@ if (settings->GetDayFeeIsLastDay())
 //-----------------------------------------------------------------------------
 void UsersImpl::DayResetTraff(const struct tm & t1)
 {
 //-----------------------------------------------------------------------------
 void UsersImpl::DayResetTraff(const struct tm & t1)
 {
-int dayResetTraff = settings->GetDayResetTraff();
+auto dayResetTraff = settings->GetDayResetTraff();
 if (dayResetTraff == 0)
     dayResetTraff = DaysInCurrentMonth();
 if (t1.tm_mday == dayResetTraff)
 if (dayResetTraff == 0)
     dayResetTraff = DaysInCurrentMonth();
 if (t1.tm_mday == dayResetTraff)
@@ -501,13 +493,13 @@ if (t1.tm_mday == dayResetTraff)
 //-----------------------------------------------------------------------------
 int UsersImpl::Start()
 {
 //-----------------------------------------------------------------------------
 int UsersImpl::Start()
 {
-if (ReadUsers())
+if (ReadUsers() != 0)
     {
     WriteServLog("USERS: Error: Cannot read users!");
     return -1;
     }
 
     {
     WriteServLog("USERS: Error: Cannot read users!");
     return -1;
     }
 
-m_thread = std::jthread([this](auto token){ Run(token); });
+m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------
@@ -524,7 +516,7 @@ for (size_t i = 0; i < 25 * (users.size() / 50 + 1); i++)
     if (!isRunning)
         break;
 
     if (!isRunning)
         break;
 
-    nanosleep(&ts, NULL);
+    nanosleep(&ts, nullptr);
     }
 
 //after 5 seconds waiting thread still running. now kill it
     }
 
 //after 5 seconds waiting thread still running. now kill it
@@ -540,11 +532,8 @@ else
 printfd(__FILE__, "Before USERS::Run()\n");
 for_each(users.begin(), users.end(), [](auto& user){ user.Run(); });
 
 printfd(__FILE__, "Before USERS::Run()\n");
 for_each(users.begin(), users.end(), [](auto& user){ user.Run(); });
 
-// 'cause bind2st accepts only constant first param
-for (std::list<UserImpl>::iterator it = users.begin();
-     it != users.end();
-     ++it)
-    it->WriteDetailStat(true);
+for (auto& user : users)
+    user.WriteDetailStat(true);
 
 for_each(users.begin(), users.end(), [](auto& user){ user.WriteStat(); });
 //for_each(users.begin(), users.end(), mem_fun_ref(&UserImpl::WriteConf));
 
 for_each(users.begin(), users.end(), [](auto& user){ user.WriteStat(); });
 //for_each(users.begin(), users.end(), mem_fun_ref(&UserImpl::WriteConf));
@@ -559,15 +548,14 @@ std::lock_guard<std::mutex> lock(m_mutex);
 
 printfd(__FILE__, "RealDelUser() users to del: %d\n", usersToDelete.size());
 
 
 printfd(__FILE__, "RealDelUser() users to del: %d\n", usersToDelete.size());
 
-std::list<USER_TO_DEL>::iterator iter;
-iter = usersToDelete.begin();
+auto iter = usersToDelete.begin();
 while (iter != usersToDelete.end())
     {
     printfd(__FILE__, "RealDelUser() user=%s\n", iter->iter->GetLogin().c_str());
     if (iter->delTime + userDeleteDelayTime < stgTime)
         {
         printfd(__FILE__, "RealDelUser() user=%s removed from DB\n", iter->iter->GetLogin().c_str());
 while (iter != usersToDelete.end())
     {
     printfd(__FILE__, "RealDelUser() user=%s\n", iter->iter->GetLogin().c_str());
     if (iter->delTime + userDeleteDelayTime < stgTime)
         {
         printfd(__FILE__, "RealDelUser() user=%s removed from DB\n", iter->iter->GetLogin().c_str());
-        if (store->DelUser(iter->iter->GetLogin()))
+        if (m_store->DelUser(iter->iter->GetLogin()) != 0)
             {
             WriteServLog("Error removing user \'%s\' from database.", iter->iter->GetLogin().c_str());
             }
             {
             WriteServLog("Error removing user \'%s\' from database.", iter->iter->GetLogin().c_str());
             }
@@ -579,7 +567,6 @@ while (iter != usersToDelete.end())
         ++iter;
         }
     }
         ++iter;
         }
     }
-return;
 }
 //-----------------------------------------------------------------------------
 void UsersImpl::AddToIPIdx(user_iter user)
 }
 //-----------------------------------------------------------------------------
 void UsersImpl::AddToIPIdx(user_iter user)
@@ -587,14 +574,12 @@ void UsersImpl::AddToIPIdx(user_iter user)
 printfd(__FILE__, "USERS: Add IP Idx\n");
 uint32_t ip = user->GetCurrIP();
 //assert(ip && "User has non-null ip");
 printfd(__FILE__, "USERS: Add IP Idx\n");
 uint32_t ip = user->GetCurrIP();
 //assert(ip && "User has non-null ip");
-if (!ip)
+if (ip == 0)
     return; // User has disconnected
 
 std::lock_guard<std::mutex> lock(m_mutex);
 
     return; // User has disconnected
 
 std::lock_guard<std::mutex> lock(m_mutex);
 
-const std::map<uint32_t, user_iter>::iterator it(
-        ipIndex.lower_bound(ip)
-);
+const auto it = ipIndex.lower_bound(ip);
 
 assert((it == ipIndex.end() || it->first != ip) && "User is not in index");
 
 
 assert((it == ipIndex.end() || it->first != ip) && "User is not in index");
 
@@ -608,9 +593,7 @@ assert(ip && "User has non-null ip");
 
 std::lock_guard<std::mutex> lock(m_mutex);
 
 
 std::lock_guard<std::mutex> lock(m_mutex);
 
-const std::map<uint32_t, user_iter>::iterator it(
-        ipIndex.find(ip)
-);
+const auto it = ipIndex.find(ip);
 
 if (it == ipIndex.end())
     return;
 
 if (it == ipIndex.end())
     return;
@@ -620,35 +603,35 @@ ipIndex.erase(it);
 //-----------------------------------------------------------------------------
 bool UsersImpl::FindByIPIdx(uint32_t ip, user_iter & iter) const
 {
 //-----------------------------------------------------------------------------
 bool UsersImpl::FindByIPIdx(uint32_t ip, user_iter & iter) const
 {
-std::map<uint32_t, user_iter>::const_iterator it(ipIndex.find(ip));
+auto it = ipIndex.find(ip);
 if (it == ipIndex.end())
     return false;
 iter = it->second;
 return true;
 }
 //-----------------------------------------------------------------------------
 if (it == ipIndex.end())
     return false;
 iter = it->second;
 return true;
 }
 //-----------------------------------------------------------------------------
-int UsersImpl::FindByIPIdx(uint32_t ip, UserPtr * usr) const
+int UsersImpl::FindByIPIdx(uint32_t ip, UserPtr * user) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 
 user_iter iter;
 if (FindByIPIdx(ip, iter))
     {
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 
 user_iter iter;
 if (FindByIPIdx(ip, iter))
     {
-    *usr = &(*iter);
+    *user = &(*iter);
     return 0;
     }
 
 return -1;
 }
 //-----------------------------------------------------------------------------
     return 0;
     }
 
 return -1;
 }
 //-----------------------------------------------------------------------------
-int UsersImpl::FindByIPIdx(uint32_t ip, UserImpl ** usr) const
+int UsersImpl::FindByIPIdx(uint32_t ip, UserImpl ** user) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 
 user_iter iter;
 if (FindByIPIdx(ip, iter))
     {
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 
 user_iter iter;
 if (FindByIPIdx(ip, iter))
     {
-    *usr = &(*iter);
+    *user = &(*iter);
     return 0;
     }
 
     return 0;
     }
 
@@ -659,23 +642,20 @@ bool UsersImpl::IsIPInIndex(uint32_t ip) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 
-std::map<uint32_t, user_iter>::const_iterator it(ipIndex.find(ip));
-
-return it != ipIndex.end();
+return ipIndex.find(ip) != ipIndex.end();
 }
 //-----------------------------------------------------------------------------
 bool UsersImpl::IsIPInUse(uint32_t ip, const std::string & login, ConstUserPtr * user) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 }
 //-----------------------------------------------------------------------------
 bool UsersImpl::IsIPInUse(uint32_t ip, const std::string & login, ConstUserPtr * user) const
 {
 std::lock_guard<std::mutex> lock(m_mutex);
-std::list<UserImpl>::const_iterator iter;
-iter = users.begin();
+auto iter = users.begin();
 while (iter != users.end())
     {
     if (iter->GetLogin() != login &&
         !iter->GetProperties().ips.Get().isAnyIP() &&
         iter->GetProperties().ips.Get().find(ip))
         {
 while (iter != users.end())
     {
     if (iter->GetLogin() != login &&
         !iter->GetProperties().ips.Get().isAnyIP() &&
         iter->GetProperties().ips.Get().find(ip))
         {
-        if (user != NULL)
+        if (user != nullptr)
             *user = &(*iter);
         return true;
         }
             *user = &(*iter);
         return true;
         }
@@ -732,7 +712,7 @@ std::lock_guard<std::mutex> lock(m_mutex);
 onDelNotifiersImpl.erase(n);
 }
 //-----------------------------------------------------------------------------
 onDelNotifiersImpl.erase(n);
 }
 //-----------------------------------------------------------------------------
-int UsersImpl::OpenSearch()
+unsigned int UsersImpl::OpenSearch()
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 handle++;
 {
 std::lock_guard<std::mutex> lock(m_mutex);
 handle++;
@@ -742,8 +722,8 @@ return handle;
 //-----------------------------------------------------------------------------
 int UsersImpl::SearchNext(int h, UserPtr * user)
 {
 //-----------------------------------------------------------------------------
 int UsersImpl::SearchNext(int h, UserPtr * user)
 {
-    UserImpl * ptr = NULL;
-    if (SearchNext(h, &ptr))
+    UserImpl * ptr = nullptr;
+    if (SearchNext(h, &ptr) != 0)
         return -1;
     *user = ptr;
     return 0;
         return -1;
     *user = ptr;
     return 0;
@@ -805,7 +785,7 @@ loginIndex.erase(user->GetLogin());
 //-----------------------------------------------------------------------------
 bool UsersImpl::TimeToWriteDetailStat(const struct tm & t)
 {
 //-----------------------------------------------------------------------------
 bool UsersImpl::TimeToWriteDetailStat(const struct tm & t)
 {
-int statTime = settings->GetDetailStatWritePeriod();
+auto statTime = settings->GetDetailStatWritePeriod();
 
 switch (statTime)
     {
 
 switch (statTime)
     {
index 5aa2a494a6e85f75d37117324a7edebc8647703c..bfb52fa17a521ce3832647ba42707a257effbce0 100644 (file)
@@ -76,7 +76,6 @@ public:
     UsersImpl(SettingsImpl * s, Store * store,
               Tariffs * tariffs, Services & svcs,
               const Admin& sysAdmin);
     UsersImpl(SettingsImpl * s, Store * store,
               Tariffs * tariffs, Services & svcs,
               const Admin& sysAdmin);
-    virtual ~UsersImpl();
 
     int             FindByName(const std::string & login, UserPtr * user) override;
     int             FindByName(const std::string & login, ConstUserPtr * user) const override;
 
     int             FindByName(const std::string & login, UserPtr * user) override;
     int             FindByName(const std::string & login, ConstUserPtr * user) const override;
@@ -113,7 +112,7 @@ public:
     bool            IsIPInIndex(uint32_t ip) const override;
     bool            IsIPInUse(uint32_t ip, const std::string & login, ConstUserPtr * user) const override;
 
     bool            IsIPInIndex(uint32_t ip) const override;
     bool            IsIPInUse(uint32_t ip, const std::string & login, ConstUserPtr * user) const override;
 
-    int             OpenSearch() override;
+    unsigned int    OpenSearch() override;
     int             SearchNext(int handler, UserPtr * user) override;
     int             SearchNext(int handler, UserImpl ** user);
     int             CloseSearch(int handler) override;
     int             SearchNext(int handler, UserPtr * user) override;
     int             SearchNext(int handler, UserImpl ** user);
     int             CloseSearch(int handler) override;
@@ -129,8 +128,8 @@ private:
     void            DelFromIPIdx(uint32_t ip);
     bool            FindByIPIdx(uint32_t ip, user_iter & iter) const;
 
     void            DelFromIPIdx(uint32_t ip);
     bool            FindByIPIdx(uint32_t ip, user_iter & iter) const;
 
-    int             FindByNameNonLock(const std::string & login, user_iter * user);
-    int             FindByNameNonLock(const std::string & login, const_user_iter * user) const;
+    bool            FindByNameNonLock(const std::string & login, user_iter * user);
+    bool            FindByNameNonLock(const std::string & login, const_user_iter * user) const;
 
     void            RealDelUser();
     void            ProcessActions();
 
     void            RealDelUser();
     void            ProcessActions();
@@ -152,10 +151,10 @@ private:
     std::map<std::string, user_iter>      loginIndex;
 
     SettingsImpl *     settings;
     std::map<std::string, user_iter>      loginIndex;
 
     SettingsImpl *     settings;
-    Tariffs *           tariffs;
+    Tariffs *           m_tariffs;
     Services &          m_services;
     Services &          m_services;
-    Store *             store;
-    const Admin&       sysAdmin;
+    Store *             m_store;
+    const Admin&        m_sysAdmin;
     Logger &        WriteServLog;
 
     bool                isRunning;
     Logger &        WriteServLog;
 
     bool                isRunning;
@@ -164,7 +163,7 @@ private:
     std::jthread            m_thread;
     mutable unsigned int    handle;
 
     std::jthread            m_thread;
     mutable unsigned int    handle;
 
-    mutable std::map<int, user_iter>  searchDescriptors;
+    mutable std::map<unsigned int, user_iter>  searchDescriptors;
 
     std::set<NotifierBase<UserPtr>*> onAddNotifiers;
     std::set<NotifierBase<UserPtr>*> onDelNotifiers;
 
     std::set<NotifierBase<UserPtr>*> onAddNotifiers;
     std::set<NotifierBase<UserPtr>*> onDelNotifiers;
index 492568dfac93c9cc1165199695f4d3c950501cfc..4fc141000e4193c164171d5e30add0ed6810fd00 100644 (file)
@@ -42,7 +42,7 @@ class TEST_USERS : public STG::Users {
         bool IsIPInUse(uint32_t, const std::string &, ConstUserPtr *) const override { return false; }
         bool Exists(const std::string &) const override { return false; }
 
         bool IsIPInUse(uint32_t, const std::string &, ConstUserPtr *) const override { return false; }
         bool Exists(const std::string &) const override { return false; }
 
-        int  OpenSearch() override { return 0; }
+        unsigned int  OpenSearch() override { return 0; }
         int  SearchNext(int /*handle*/, UserPtr * /*u*/) override { return -1; }
         int  CloseSearch(int /*handle*/) override { return 0; }
 
         int  SearchNext(int /*handle*/, UserPtr * /*u*/) override { return -1; }
         int  CloseSearch(int /*handle*/) override { return 0; }