ipaddress.cpp.svn-base

来自「很好用的网络封装库,不熟悉网络编程的人也可以使用。使用风格良好的标准c++编写。」· SVN-BASE 代码 · 共 802 行 · 第 1/2 页

	bool isWellKnownMC() const
	{
		const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
		return (words[0] & 0xFFF0) == 0xFF00;
	}
	
	bool isNodeLocalMC() const
	{
		const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
		return (words[0] & 0xFFEF) == 0xFF01;
	}
	
	bool isLinkLocalMC() const
	{
		const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
		return (words[0] & 0xFFEF) == 0xFF02;
	}
	
	bool isSiteLocalMC() const
	{
		const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
		return (words[0] & 0xFFEF) == 0xFF05;
	}
	
	bool isOrgLocalMC() const
	{
		const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
		return (words[0] & 0xFFEF) == 0xFF08;
	}
	
	bool isGlobalMC() const
	{
		const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
		return (words[0] & 0xFFEF) == 0xFF0F;
	}

	static IPv6AddressImpl* parse(const std::string& addr)
	{
		if (addr.empty()) return 0;
#if defined(_WIN32)
		struct addrinfo* pAI;
		struct addrinfo hints;
		std::memset(&hints, 0, sizeof(hints));
		hints.ai_flags = AI_NUMERICHOST;
		int rc = getaddrinfo(addr.c_str(), NULL, &hints, &pAI);
		if (rc == 0)
		{
			IPv6AddressImpl* pResult = new IPv6AddressImpl(&reinterpret_cast<struct sockaddr_in6*>(pAI->ai_addr)->sin6_addr);
			freeaddrinfo(pAI);
			return pResult;
		}
		else return 0;
#else
		struct in6_addr ia;
		if (inet_pton(AF_INET6, addr.c_str(), &ia) == 1)
			return new IPv6AddressImpl(&ia);
		else
			return 0;
#endif
	}
	
	void mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet)
	{
		throw Poco::NotImplementedException("mask() is only supported for IPv4 addresses");
	}

	IPAddressImpl* clone() const
	{
		return new IPv6AddressImpl(&_addr);
	}

private:
	struct in6_addr _addr;	
};


#endif // POCO_HAVE_IPv6


//
// IPAddress
//


IPAddress::IPAddress(): _pImpl(new IPv4AddressImpl)
{
}


IPAddress::IPAddress(const IPAddress& addr): _pImpl(addr._pImpl)
{
	_pImpl->duplicate();
}


IPAddress::IPAddress(Family family): _pImpl(0)
{
	if (family == IPv4)
		_pImpl = new IPv4AddressImpl();
#if defined(POCO_HAVE_IPv6)
	else if (family == IPv6)
		_pImpl = new IPv6AddressImpl();
#endif
	else Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
}


IPAddress::IPAddress(const std::string& addr)
{
	_pImpl = IPv4AddressImpl::parse(addr);
#if defined(POCO_HAVE_IPv6)
	if (!_pImpl)
		_pImpl = IPv6AddressImpl::parse(addr);
#endif
	if (!_pImpl) throw InvalidAddressException(addr);
}


IPAddress::IPAddress(const std::string& addr, Family family): _pImpl(0)
{
	if (family == IPv4)
		_pImpl = IPv4AddressImpl::parse(addr);
#if defined(POCO_HAVE_IPv6)
	else if (family == IPv6)
		_pImpl = IPv6AddressImpl::parse(addr);
#endif
	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
	if (!_pImpl) throw InvalidAddressException(addr);
}


IPAddress::IPAddress(const void* addr, poco_socklen_t length)
{
	if (length == sizeof(struct in_addr))
		_pImpl = new IPv4AddressImpl(addr);
#if defined(POCO_HAVE_IPv6)
	else if (length == sizeof(struct in6_addr))
		_pImpl = new IPv6AddressImpl(addr);
#endif
	else throw Poco::InvalidArgumentException("Invalid address length passed to IPAddress()");
}


IPAddress::~IPAddress()
{
	_pImpl->release();
}


IPAddress& IPAddress::operator = (const IPAddress& addr)
{
	if (&addr != this)
	{
		_pImpl->release();
		_pImpl = addr._pImpl;
		_pImpl->duplicate();
	}
	return *this;
}


void IPAddress::swap(IPAddress& address)
{
	std::swap(_pImpl, address._pImpl);
}

	
IPAddress::Family IPAddress::family() const
{
	return _pImpl->family();
}

	
std::string IPAddress::toString() const
{
	return _pImpl->toString();
}


bool IPAddress::isWildcard() const
{
	return _pImpl->isWildcard();
}
	
bool IPAddress::isBroadcast() const
{
	return _pImpl->isBroadcast();
}


bool IPAddress::isLoopback() const
{
	return _pImpl->isLoopback();
}


bool IPAddress::isMulticast() const
{
	return _pImpl->isMulticast();
}

	
bool IPAddress::isUnicast() const
{
	return !isWildcard() && !isBroadcast() && !isMulticast();
}

	
bool IPAddress::isLinkLocal() const
{
	return _pImpl->isLinkLocal();
}


bool IPAddress::isSiteLocal() const
{
	return _pImpl->isSiteLocal();
}


bool IPAddress::isIPv4Compatible() const
{
	return _pImpl->isIPv4Compatible();
}


bool IPAddress::isIPv4Mapped() const
{
	return _pImpl->isIPv4Mapped();
}


bool IPAddress::isWellKnownMC() const
{
	return _pImpl->isWellKnownMC();
}


bool IPAddress::isNodeLocalMC() const
{
	return _pImpl->isNodeLocalMC();
}


bool IPAddress::isLinkLocalMC() const
{
	return _pImpl->isLinkLocalMC();
}


bool IPAddress::isSiteLocalMC() const
{
	return _pImpl->isSiteLocalMC();
}


bool IPAddress::isOrgLocalMC() const
{
	return _pImpl->isOrgLocalMC();
}


bool IPAddress::isGlobalMC() const
{
	return _pImpl->isGlobalMC();
}


bool IPAddress::operator == (const IPAddress& a) const
{
	poco_socklen_t l1 = length();
	poco_socklen_t l2 = a.length();
	if (l1 == l2)
		return std::memcmp(addr(), a.addr(), l1) == 0;
	else
		return false;
}


bool IPAddress::operator != (const IPAddress& a) const
{
	poco_socklen_t l1 = length();
	poco_socklen_t l2 = a.length();
	if (l1 == l2)
		return std::memcmp(addr(), a.addr(), l1) != 0;
	else
		return true;
}


bool IPAddress::operator < (const IPAddress& a) const
{
	poco_socklen_t l1 = length();
	poco_socklen_t l2 = a.length();
	if (l1 == l2)
		return std::memcmp(addr(), a.addr(), l1) < 0;
	else
		return l1 < l2;
}


bool IPAddress::operator <= (const IPAddress& a) const
{
	poco_socklen_t l1 = length();
	poco_socklen_t l2 = a.length();
	if (l1 == l2)
		return std::memcmp(addr(), a.addr(), l1) <= 0;
	else
		return l1 < l2;
}


bool IPAddress::operator > (const IPAddress& a) const
{
	poco_socklen_t l1 = length();
	poco_socklen_t l2 = a.length();
	if (l1 == l2)
		return std::memcmp(addr(), a.addr(), l1) > 0;
	else
		return l1 > l2;
}


bool IPAddress::operator >= (const IPAddress& a) const
{
	poco_socklen_t l1 = length();
	poco_socklen_t l2 = a.length();
	if (l1 == l2)
		return std::memcmp(addr(), a.addr(), l1) >= 0;
	else
		return l1 > l2;
}


poco_socklen_t IPAddress::length() const
{
	return _pImpl->length();
}

	
const void* IPAddress::addr() const
{
	return _pImpl->addr();
}


int IPAddress::af() const
{
	return _pImpl->af();
}


void IPAddress::init(IPAddressImpl* pImpl)
{
	_pImpl->release();
	_pImpl = pImpl;
}


IPAddress IPAddress::parse(const std::string& addr)
{
	return IPAddress(addr);
}


bool IPAddress::tryParse(const std::string& addr, IPAddress& result)
{
	IPAddressImpl* pImpl = IPv4AddressImpl::parse(addr);
#if defined(POCO_HAVE_IPv6)
	if (!pImpl) pImpl = IPv6AddressImpl::parse(addr);
#endif
	if (pImpl)
	{
		result.init(pImpl);
		return true;
	}
	else return false;
}


void IPAddress::mask(const IPAddress& mask)
{
	IPAddressImpl* pClone = _pImpl->clone();
	_pImpl->release();
	_pImpl = pClone;
	IPAddress null;
	_pImpl->mask(mask._pImpl, null._pImpl);
}


void IPAddress::mask(const IPAddress& mask, const IPAddress& set)
{
	IPAddressImpl* pClone = _pImpl->clone();
	_pImpl->release();
	_pImpl = pClone;
	_pImpl->mask(mask._pImpl, set._pImpl);
}


} } // namespace Poco::Net