virtual bool
isCanonical(const FaceUri& faceUri) const
{
if (!faceUri.getPort().empty()) {
return false;
}
if (!faceUri.getPath().empty()) {
return false;
}
ethernet::Address addr = ethernet::Address::fromString(faceUri.getHost());
return addr.toString() == faceUri.getHost();
}
void
TcpFactory::createFace(const FaceUri& uri,
const FaceCreatedCallback& onCreated,
const FaceConnectFailedCallback& onConnectFailed)
{
resolver::AddressSelector addressSelector = resolver::AnyAddress();
if (uri.getScheme() == "tcp4")
addressSelector = resolver::Ipv4Address();
else if (uri.getScheme() == "tcp6")
addressSelector = resolver::Ipv6Address();
if (!uri.getPath().empty() && uri.getPath() != "/")
{
onConnectFailed("Invalid URI");
}
TcpResolver::asyncResolve(uri.getHost(),
uri.getPort().empty() ? m_defaultPort : uri.getPort(),
bind(&TcpFactory::continueCreateFaceAfterResolve, this, _1,
onCreated, onConnectFailed),
onConnectFailed,
addressSelector);
}
void
UdpFactory::createFace(const FaceUri& uri,
ndn::nfd::FacePersistency persistency,
const FaceCreatedCallback& onCreated,
const FaceConnectFailedCallback& onConnectFailed)
{
if (persistency == ndn::nfd::FacePersistency::FACE_PERSISTENCY_ON_DEMAND) {
BOOST_THROW_EXCEPTION(Error("UdpFactory::createFace does not support creating on-demand face"));
}
BOOST_ASSERT(uri.isCanonical());
boost::asio::ip::address ipAddress = boost::asio::ip::address::from_string(uri.getHost());
udp::Endpoint endpoint(ipAddress, boost::lexical_cast<uint16_t>(uri.getPort()));
if (endpoint.address().is_multicast()) {
onConnectFailed("The provided address is multicast. Please use createMulticastFace method");
return;
}
if (m_prohibitedEndpoints.find(endpoint) != m_prohibitedEndpoints.end()) {
onConnectFailed("Requested endpoint is prohibited "
"(reserved by this NFD or disallowed by face management protocol)");
return;
}
// very simple logic for now
for (ChannelMap::iterator channel = m_channels.begin();
channel != m_channels.end();
++channel)
{
if ((channel->first.address().is_v4() && endpoint.address().is_v4()) ||
(channel->first.address().is_v6() && endpoint.address().is_v6()))
{
channel->second->connect(endpoint, persistency, onCreated, onConnectFailed);
return;
}
}
onConnectFailed("No channels available to connect to " +
boost::lexical_cast<std::string>(endpoint));
}
virtual bool
isCanonical(const FaceUri& faceUri) const
{
if (faceUri.getPort().empty()) {
return false;
}
if (!faceUri.getPath().empty()) {
return false;
}
boost::system::error_code ec;
boost::asio::ip::address addr;
if (faceUri.getScheme() == m_v4Scheme) {
addr = boost::asio::ip::address_v4::from_string(faceUri.getHost(), ec);
}
else if (faceUri.getScheme() == m_v6Scheme) {
addr = boost::asio::ip::address_v6::from_string(faceUri.getHost(), ec);
}
else {
return false;
}
return !static_cast<bool>(ec) && addr.to_string() == faceUri.getHost() &&
this->checkAddress(addr).first;
}