#include <iostream>
#include <sstream>
-#include "common.h"
+#include "stg/common.h"
#include "os_int.h"
-using namespace std;
-
//-------------------------------------------------------------------------
struct IP_MASK
{
//-------------------------------------------------------------------------
class USER_IPS
{
- friend std::ostream & operator<< (ostream & o, const USER_IPS & i);
+ friend std::ostream & operator<< (std::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 const USER_IPS StrToIPS(const std::string & ipsStr);
public:
+ typedef std::vector<IP_MASK> ContainerType;
+ typedef ContainerType::size_type IndexType;
+
USER_IPS();
USER_IPS(const USER_IPS &);
USER_IPS & operator=(const USER_IPS &);
- const IP_MASK & operator[](int idx) const;
+ const IP_MASK & operator[](IndexType idx) const;
std::string GetIpStr() const;
bool IsIPInIPS(uint32_t ip) const;
bool OnlyOneIP() const;
- int Count() const;
+ bool IsAnyIP() const;
+ size_t Count() const;
void Add(const IP_MASK &im);
void Erase();
private:
uint32_t CalcMask(unsigned int msk) const;
- std::vector<IP_MASK> ips;
+ ContainerType ips;
};
//-------------------------------------------------------------------------
}
//-----------------------------------------------------------------------------
inline
-const IP_MASK & USER_IPS::operator[](int idx) const
+const IP_MASK & USER_IPS::operator[](IndexType idx) const
{
return ips[idx];
}
return "*";
}
-std::vector<IP_MASK>::const_iterator it(ips.begin());
-std::stringstream s;
+ContainerType::const_iterator it(ips.begin());
+std::ostringstream s;
s << inet_ntostring(it->ip);
++it;
for (; it != ips.end(); ++it)
}
//-----------------------------------------------------------------------------
inline
-int USER_IPS::Count() const
+size_t USER_IPS::Count() const
{
return ips.size();
}
//-----------------------------------------------------------------------------
inline
+uint32_t USER_IPS::CalcMask(unsigned int msk) const
+{
+if (msk > 32)
+ return 0;
+return htonl(0xFFffFFff << (32 - msk));
+}
+//-----------------------------------------------------------------------------
+inline
bool USER_IPS::IsIPInIPS(uint32_t ip) const
{
if (ips.empty())
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))
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
-uint32_t USER_IPS::CalcMask(unsigned int msk) const
+bool USER_IPS::IsAnyIP() const
{
-if (msk > 32)
- return 0;
-return htonl(0xFFffFFff << (32 - msk));
+ return !ips.empty() && ips.front().ip == 0;
}
//-----------------------------------------------------------------------------
inline
}*/
//-----------------------------------------------------------------------------
inline
-const USER_IPS StrToIPS(const std::string & ipsStr) throw(std::string)
+const USER_IPS StrToIPS(const std::string & ipsStr)
{
USER_IPS ips;
char * paddr;
IP_MASK im;
std::vector<std::string> ipMask;
-std::string err;
if (ipsStr.empty())
{
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;
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;
strIp = strtok(str, "/");
if (strIp == NULL)
{
- err = "Incorrect IP address " + ipsStr;
return ips;
}
strMask = strtok(NULL, "/");
im.ip = inet_addr(strIp);
if (im.ip == INADDR_NONE)
{
- err = "Incorrect IP address: " + std::string(strIp);
return ips;
}
int m = 0;
if (str2x(strMask, m) != 0)
{
- err = "Incorrect mask: " + std::string(strMask);
return ips;
}
im.mask = m;
if (im.mask > 32)
{
- err = "Incorrect mask: " + std::string(strMask);
return ips;
}
if ((im.ip & ips.CalcMask(im.mask)) != im.ip)
{
- err = "Address does'n match mask: " + std::string(strIp) + "/" + std::string(strMask);
return ips;
}
}