Remove std::list from actions.

[stg.git] / include / stg / user_ips.h

diff --git a/include/stg/user_ips.h b/include/stg/user_ips.h
index a29e28128c07f5a651df94e839128fe4bf2df70e..ee227e5d8c67a0ce3eef09990b246594a98e99b5 100644 (file)
--- a/include/stg/user_ips.h
+++ b/include/stg/user_ips.h
@@ -27,110 +27,68 @@
 #ifndef USER_IPS_H
 #define USER_IPS_H
 
 #ifndef USER_IPS_H
 #define USER_IPS_H
 

-#ifdef FREE_BSD
-#include <sys/types.h>
-#endif
-
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
+#include "stg/common.h"

 
 #include <cstring>
 
 #include <cstring>

+#include <cstdint>

 #include <vector>
 #include <string>
 #include <iostream>
 #include <vector>
 #include <string>
 #include <iostream>

-#include <sstream>

 
 

-#include "stg/common.h"
-#include "os_int.h"
+#ifdef FREE_BSD
+#include <sys/types.h>
+#endif

 
 

-using namespace std;
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>

 
 //-------------------------------------------------------------------------
 struct IP_MASK
 {
 IP_MASK() : ip(0), mask(0) {}
 
 //-------------------------------------------------------------------------
 struct IP_MASK
 {
 IP_MASK() : ip(0), mask(0) {}

-IP_MASK(const IP_MASK & ipm) : ip(ipm.ip), mask(ipm.mask)  {}

 uint32_t ip;
 uint32_t mask;
 };
 //-------------------------------------------------------------------------
 class USER_IPS
 {
 uint32_t ip;
 uint32_t mask;
 };
 //-------------------------------------------------------------------------
 class USER_IPS
 {

-    friend std::ostream & operator<< (ostream & o, const USER_IPS & i);
-    //friend stringstream & operator<< (stringstream & s, const USER_IPS & i);
-    friend const USER_IPS StrToIPS(const string & ipsStr) throw(string);
+    friend std::ostream & operator<< (std::ostream & o, const USER_IPS & i);
+    friend const USER_IPS StrToIPS(const std::string & ipsStr);

 
 public:
 
 public:

-    USER_IPS();
-    USER_IPS(const USER_IPS &);
-    USER_IPS & operator=(const USER_IPS &);
-    const IP_MASK & operator[](int idx) const;
+    typedef std::vector<IP_MASK> ContainerType;
+    typedef ContainerType::size_type IndexType;
+
+    const IP_MASK & operator[](IndexType idx) const { return ips[idx]; }

     std::string GetIpStr() const;
     bool IsIPInIPS(uint32_t ip) const;
     bool OnlyOneIP() const;
     std::string GetIpStr() const;
     bool IsIPInIPS(uint32_t ip) const;
     bool OnlyOneIP() const;

-    int  Count() const;
-    void Add(const IP_MASK &im);
-    void Erase();
+    bool IsAnyIP() const;
+    size_t Count() const { return ips.size(); }
+    void Add(const IP_MASK &im) { ips.push_back(im); }

 
 private:
     uint32_t CalcMask(unsigned int msk) const;
 
 private:
     uint32_t CalcMask(unsigned int msk) const;

-    std::vector<IP_MASK> ips;
+    ContainerType ips;

 };
 //-------------------------------------------------------------------------
 
 };
 //-------------------------------------------------------------------------
 

-//-----------------------------------------------------------------------------
-inline
-USER_IPS::USER_IPS()
-    : ips()
-{}
-//-----------------------------------------------------------------------------
-inline
-USER_IPS::USER_IPS(const USER_IPS & i)
-    : ips(i.ips)
-{}
-//-----------------------------------------------------------------------------
-inline
-USER_IPS & USER_IPS::operator=(const USER_IPS & i)
-{
-ips = i.ips;
-return *this;
-}
-//-----------------------------------------------------------------------------
-inline
-const IP_MASK & USER_IPS::operator[](int idx) const
-{
-return ips[idx];
-}
-//-----------------------------------------------------------------------------

 inline
 std::string USER_IPS::GetIpStr() const
 {
 if (ips.empty())
 inline
 std::string USER_IPS::GetIpStr() const
 {
 if (ips.empty())

-    {

     return "";
     return "";

-    }

 
 if (ips[0].ip == 0)
 
 if (ips[0].ip == 0)

-    {

     return "*";
     return "*";

-    }

 
 

-std::vector<IP_MASK>::const_iterator it(ips.begin());
-std::stringstream s;
-s << inet_ntostring(it->ip);
+ContainerType::const_iterator it(ips.begin());
+std::string res = inet_ntostring(it->ip);

 ++it;
 for (; it != ips.end(); ++it)
 ++it;
 for (; it != ips.end(); ++it)

-    {
-    s << "," << inet_ntostring(it->ip);
-    }
-return s.str();
-}
-//-----------------------------------------------------------------------------
-inline
-int USER_IPS::Count() const
-{
-return ips.size();
+    res += "," + inet_ntostring(it->ip);
+return res;

 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 inline


@@ -145,14 +103,12 @@ inline
 bool USER_IPS::IsIPInIPS(uint32_t ip) const
 {
 if (ips.empty())
 bool USER_IPS::IsIPInIPS(uint32_t ip) const
 {
 if (ips.empty())

-    {

     return false;
     return false;

-    }

 
 if (ips.front().ip == 0)
     return true;
 
 
 if (ips.front().ip == 0)
     return true;
 

-for (std::vector<IP_MASK>::const_iterator it(ips.begin()); it != ips.end(); ++it)
+for (ContainerType::const_iterator it(ips.begin()); it != ips.end(); ++it)

     {
     uint32_t mask(CalcMask(it->mask));
     if ((ip & mask) == (it->ip & mask))
     {
     uint32_t mask(CalcMask(it->mask));
     if ((ip & mask) == (it->ip & mask))


@@ -164,22 +120,16 @@ return false;
 inline
 bool USER_IPS::OnlyOneIP() const
 {
 inline
 bool USER_IPS::OnlyOneIP() const
 {

-if (ips.size() == 1 && ips.front().mask == 32)
+if (ips.size() == 1 && ips.front().mask == 32 && ips.front().ip != 0)

     return true;
 
 return false;
 }
 //-----------------------------------------------------------------------------
 inline
     return true;
 
 return false;
 }
 //-----------------------------------------------------------------------------
 inline

-void USER_IPS::Add(const IP_MASK &im)
+bool USER_IPS::IsAnyIP() const

 {
 {

-ips.push_back(im);
-}
-//-----------------------------------------------------------------------------
-inline
-void USER_IPS::Erase()
-{
-ips.erase(ips.begin(), ips.end());
+    return !ips.empty() && ips.front().ip == 0;

 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 inline


@@ -188,45 +138,33 @@ std::ostream & operator<<(std::ostream & o, const USER_IPS & i)
 return o << i.GetIpStr();
 }
 //-----------------------------------------------------------------------------
 return o << i.GetIpStr();
 }
 //-----------------------------------------------------------------------------

-/*inline
-stringstream & operator<<(std::stringstream & s, const USER_IPS & i)
-{
-s << i.GetIpStr();
-return s;
-}*/
-//-----------------------------------------------------------------------------

 inline
 inline

-const USER_IPS StrToIPS(const std::string & ipsStr) throw(std::string)
+const USER_IPS StrToIPS(const std::string & ipsStr)

 {
 USER_IPS ips;
 {
 USER_IPS ips;

-char * paddr;
-IP_MASK im;

 std::vector<std::string> ipMask;
 if (ipsStr.empty())
 std::vector<std::string> ipMask;
 if (ipsStr.empty())

-    {

     return ips;
     return ips;

-    }

 
 if (ipsStr[0] == '*' && ipsStr.size() == 1)
     {
 
 if (ipsStr[0] == '*' && ipsStr.size() == 1)
     {

-    im.ip = 0;
-    im.mask = 0;
-    ips.ips.push_back(im);
+    ips.ips.push_back(IP_MASK());

     return ips;
     }
 
     return ips;
     }
 

-char * str = new char[ipsStr.size() + 1];
-strcpy(str, ipsStr.c_str());
-char * pstr = str;
+char * tmp = new char[ipsStr.size() + 1];
+strcpy(tmp, ipsStr.c_str());
+char * pstr = tmp;
+char * paddr = NULL;

 while ((paddr = strtok(pstr, ",")))
     {
     pstr = NULL;
     ipMask.push_back(paddr);
     }
 
 while ((paddr = strtok(pstr, ",")))
     {
     pstr = NULL;
     ipMask.push_back(paddr);
     }
 

-delete[] str;
+delete[] tmp;

 
 

-for (unsigned int i = 0; i < ipMask.size(); i++)
+for (USER_IPS::IndexType i = 0; i < ipMask.size(); i++)

     {
     char str[128];
     char * strIp;
     {
     char str[128];
     char * strIp;


@@ -234,36 +172,28 @@ for (unsigned int i = 0; i < ipMask.size(); i++)
     strcpy(str, ipMask[i].c_str());
     strIp = strtok(str, "/");
     if (strIp == NULL)
     strcpy(str, ipMask[i].c_str());
     strIp = strtok(str, "/");
     if (strIp == NULL)

-        {

         return ips;
         return ips;

-        }

     strMask = strtok(NULL, "/");
 
     strMask = strtok(NULL, "/");
 

+    IP_MASK im;
+

     im.ip = inet_addr(strIp);
     if (im.ip == INADDR_NONE)
     im.ip = inet_addr(strIp);
     if (im.ip == INADDR_NONE)

-        {

         return ips;
         return ips;

-        }

 
     im.mask = 32;
     if (strMask != NULL)
         {
         int m = 0;
         if (str2x(strMask, m) != 0)
 
     im.mask = 32;
     if (strMask != NULL)
         {
         int m = 0;
         if (str2x(strMask, m) != 0)

-            {

             return ips;
             return ips;

-            }

         im.mask = m;
 
         if (im.mask > 32)
         im.mask = m;
 
         if (im.mask > 32)

-            {

             return ips;
             return ips;

-            }

 
         if ((im.ip & ips.CalcMask(im.mask)) != im.ip)
 
         if ((im.ip & ips.CalcMask(im.mask)) != im.ip)

-            {

             return ips;
             return ips;

-            }

         }
     ips.ips.push_back(im);
     }
         }
     ips.ips.push_back(im);
     }