34 #include <boost/algorithm/string.hpp> 35 #include <boost/lexical_cast.hpp> 36 #include <boost/mpl/vector.hpp> 37 #include <boost/mpl/for_each.hpp> 45 BOOST_CONCEPT_ASSERT((boost::EqualityComparable<FaceUri>));
55 BOOST_THROW_EXCEPTION(
Error(
"Malformed URI: " + uri));
73 static const std::regex protocolExp(
"(\\w+\\d?(\\+\\w+)?)://([^/]*)(\\/[^?]*)?");
74 std::smatch protocolMatch;
75 if (!std::regex_match(uri, protocolMatch, protocolExp)) {
78 m_scheme = protocolMatch[1];
79 std::string authority = protocolMatch[3];
80 m_path = protocolMatch[4];
83 static const std::regex v6LinkLocalExp(
"^\\[([a-fA-F0-9:]+)%([^\\s/:]+)\\](?:\\:(\\d+))?$");
85 static const std::regex v6Exp(
"^\\[([a-fA-F0-9:]+)\\](?:\\:(\\d+))?$");
87 static const std::regex etherExp(
"^\\[((?:[a-fA-F0-9]{1,2}\\:){5}(?:[a-fA-F0-9]{1,2}))\\]$");
89 static const std::regex v4MappedV6Exp(
"^\\[::ffff:(\\d+(?:\\.\\d+){3})\\](?:\\:(\\d+))?$");
91 static const std::regex v4HostExp(
"^([^:]+)(?:\\:(\\d+))?$");
93 if (authority.empty()) {
98 if (std::regex_match(authority, match, v6LinkLocalExp)) {
100 m_host = match[1].str() +
"%" + match[2].str();
105 m_isV6 = std::regex_match(authority, match, v6Exp);
107 std::regex_match(authority, match, etherExp) ||
108 std::regex_match(authority, match, v4MappedV6Exp) ||
109 std::regex_match(authority, match, v4HostExp)) {
123 m_isV6 = endpoint.address().is_v6();
124 m_scheme = m_isV6 ?
"udp6" :
"udp4";
125 m_host = endpoint.address().to_string();
131 m_isV6 = endpoint.address().is_v6();
132 m_scheme = m_isV6 ?
"tcp6" :
"tcp4";
133 m_host = endpoint.address().to_string();
137 FaceUri::FaceUri(
const boost::asio::ip::tcp::endpoint& endpoint,
const std::string& scheme)
139 m_isV6 = endpoint.address().is_v6();
141 m_host = endpoint.address().to_string();
145 #ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS 146 FaceUri::FaceUri(
const boost::asio::local::stream_protocol::endpoint& endpoint)
148 , m_path(endpoint.path())
152 #endif // BOOST_ASIO_HAS_LOCAL_SOCKETS 174 uri.m_scheme =
"dev";
183 uri.m_scheme = endpoint.address().is_v6() ?
"udp6+dev" :
"udp4+dev";
192 return m_isV6 == rhs.m_isV6 &&
193 m_scheme == rhs.m_scheme &&
194 m_host == rhs.m_host &&
195 m_port == rhs.m_port &&
196 m_path == rhs.m_path;
202 return !(*
this == rhs);
208 std::ostringstream os;
216 os << uri.m_scheme <<
"://";
218 os <<
"[" << uri.m_host <<
"]";
223 if (!uri.m_port.empty()) {
224 os <<
":" << uri.m_port;
233 class CanonizeProvider : noncopyable
237 ~CanonizeProvider() =
default;
239 virtual std::set<std::string>
240 getSchemes()
const = 0;
249 boost::asio::io_service& io, time::nanoseconds timeout)
const = 0;
252 template<
typename Protocol>
253 class IpHostCanonizeProvider :
public CanonizeProvider
256 std::set<std::string>
257 getSchemes()
const override 259 return {m_baseScheme, m_v4Scheme, m_v6Scheme};
265 if (faceUri.
getPort().empty()) {
268 if (!faceUri.
getPath().empty()) {
272 boost::system::error_code ec;
273 auto addr = boost::asio::ip::address::from_string(unescapeHost(faceUri.
getHost()), ec);
278 bool hasCorrectScheme = (faceUri.
getScheme() == m_v4Scheme && addr.is_v4()) ||
279 (faceUri.
getScheme() == m_v6Scheme && addr.is_v6());
280 if (!hasCorrectScheme) {
284 auto checkAddressWithUri = [] (
const boost::asio::ip::address& addr,
285 const FaceUri& faceUri) ->
bool {
286 if (addr.is_v4() || !addr.to_v6().is_link_local()) {
287 return addr.to_string() == faceUri.
getHost();
290 std::vector<std::string> addrFields, faceUriFields;
291 std::string addrString = addr.to_string();
292 std::string faceUriString = faceUri.
getHost();
294 boost::algorithm::split(addrFields, addrString, boost::is_any_of(
"%"));
295 boost::algorithm::split(faceUriFields, faceUriString, boost::is_any_of(
"%"));
296 if (addrFields.size() != 2 || faceUriFields.size() != 2) {
300 if (faceUriFields[1].size() > 2 && faceUriFields[1].compare(0, 2,
"25") == 0) {
305 return addrFields[0] == faceUriFields[0] &&
306 addrFields[1] == faceUriFields[1];
309 return checkAddressWithUri(addr, faceUri) && checkAddress(addr).first;
316 boost::asio::io_service& io, time::nanoseconds timeout)
const override 324 auto uri = make_shared<FaceUri>(faceUri);
325 boost::system::error_code ec;
326 auto ipAddress = boost::asio::ip::address::from_string(unescapeHost(faceUri.
getHost()), ec);
329 if ((faceUri.
getScheme() == m_v4Scheme && !ipAddress.is_v4()) ||
330 (faceUri.
getScheme() == m_v6Scheme && !ipAddress.is_v6())) {
331 return onFailure(
"IPv4/v6 mismatch");
334 onDnsSuccess(uri, onSuccess, onFailure, ipAddress);
341 else if (faceUri.
getScheme() == m_v6Scheme) {
345 BOOST_ASSERT(faceUri.
getScheme() == m_baseScheme);
350 bind(&IpHostCanonizeProvider<Protocol>::onDnsSuccess,
this, uri, onSuccess, onFailure, _1),
351 bind(&IpHostCanonizeProvider<Protocol>::onDnsFailure,
this, uri, onFailure, _1),
352 io, addressSelector, timeout);
358 IpHostCanonizeProvider(
const std::string& baseScheme,
359 uint16_t defaultUnicastPort = 6363,
360 uint16_t defaultMulticastPort = 56363)
361 : m_baseScheme(baseScheme)
362 , m_v4Scheme(baseScheme +
'4')
363 , m_v6Scheme(baseScheme +
'6')
364 , m_defaultUnicastPort(defaultUnicastPort)
365 , m_defaultMulticastPort(defaultMulticastPort)
371 onDnsSuccess(
const shared_ptr<FaceUri>& faceUri,
378 std::tie(isOk, reason) = this->checkAddress(ipAddress);
380 return onFailure(reason);
384 if (faceUri->getPort().empty()) {
385 port = ipAddress.is_multicast() ? m_defaultMulticastPort : m_defaultUnicastPort;
389 port = boost::lexical_cast<uint16_t>(faceUri->getPort());
391 catch (
const boost::bad_lexical_cast&) {
392 return onFailure(
"invalid port number '" + faceUri->getPort() +
"'");
396 FaceUri canonicalUri(
typename Protocol::endpoint(ipAddress, port));
397 BOOST_ASSERT(canonicalUri.isCanonical());
398 onSuccess(canonicalUri);
402 onDnsFailure(
const shared_ptr<FaceUri>& faceUri,
404 const std::string& reason)
const 413 virtual std::pair<bool, std::string>
420 unescapeHost(std::string host)
422 auto escapePos = host.find(
"%25");
423 if (escapePos != std::string::npos && escapePos < host.size() - 3) {
430 std::string m_baseScheme;
431 std::string m_v4Scheme;
432 std::string m_v6Scheme;
433 uint16_t m_defaultUnicastPort;
434 uint16_t m_defaultMulticastPort;
437 class UdpCanonizeProvider :
public IpHostCanonizeProvider<boost::asio::ip::udp>
440 UdpCanonizeProvider()
441 : IpHostCanonizeProvider(
"udp")
446 class TcpCanonizeProvider :
public IpHostCanonizeProvider<boost::asio::ip::tcp>
449 TcpCanonizeProvider()
450 : IpHostCanonizeProvider(
"tcp")
455 std::pair<bool, std::string>
458 if (ipAddress.is_multicast()) {
459 return {
false,
"cannot use multicast address"};
465 class EtherCanonizeProvider :
public CanonizeProvider
468 std::set<std::string>
469 getSchemes()
const override 477 if (!faceUri.
getPort().empty()) {
480 if (!faceUri.
getPath().empty()) {
492 boost::asio::io_service& io, time::nanoseconds timeout)
const override 496 return onFailure(
"invalid ethernet address '" + faceUri.
getHost() +
"'");
500 BOOST_ASSERT(canonicalUri.isCanonical());
501 onSuccess(canonicalUri);
505 class DevCanonizeProvider :
public CanonizeProvider
508 std::set<std::string>
509 getSchemes()
const override 524 boost::asio::io_service& io, time::nanoseconds timeout)
const override 526 if (faceUri.
getHost().empty()) {
527 onFailure(
"network interface name is missing");
530 if (!faceUri.
getPort().empty()) {
531 onFailure(
"port number is not allowed");
535 onFailure(
"path is not allowed");
541 onSuccess(canonicalUri);
545 class UdpDevCanonizeProvider :
public CanonizeProvider
548 std::set<std::string>
549 getSchemes()
const override 551 return {
"udp4+dev",
"udp6+dev"};
557 if (faceUri.
getPort().empty()) {
560 if (!faceUri.
getPath().empty()) {
570 boost::asio::io_service& io, time::nanoseconds timeout)
const override 576 onFailure(
"cannot canonize " + faceUri.
toString());
582 TcpCanonizeProvider*,
583 EtherCanonizeProvider*,
584 DevCanonizeProvider*,
585 UdpDevCanonizeProvider*>;
588 class CanonizeProviderTableInitializer
593 : m_providerTable(providerTable)
597 template<
typename CP>
601 shared_ptr<CanonizeProvider> cp = make_shared<CP>();
602 auto schemes = cp->getSchemes();
603 BOOST_ASSERT(!schemes.empty());
605 for (
const auto& scheme : schemes) {
606 BOOST_ASSERT(m_providerTable.count(scheme) == 0);
607 m_providerTable[scheme] = cp;
615 static const CanonizeProvider*
619 if (providerTable.empty()) {
620 boost::mpl::for_each<CanonizeProviders>(CanonizeProviderTableInitializer(providerTable));
621 BOOST_ASSERT(!providerTable.empty());
624 auto it = providerTable.find(scheme);
625 return it == providerTable.end() ?
nullptr : it->second.get();
643 return cp->isCanonical(*
this);
649 boost::asio::io_service& io, time::nanoseconds timeout)
const 654 onFailure(
"scheme not supported");
660 onSuccess ? onSuccess : [] (
auto&&) {},
661 onFailure ? onFailure : [] (
auto&&) {},
static Address fromString(const std::string &str)
Creates an Address from a string containing an Ethernet address in hexadecimal notation, with colons or hyphens as separators.
Copyright (c) 2013-2017 Regents of the University of California.
function< void(const std::string &reason)> CanonizeFailureCallback
static FaceUri fromFd(int fd)
create fd FaceUri from file descriptor
function< void(const FaceUri &)> CanonizeSuccessCallback
static bool canCanonize(const std::string &scheme)
static const CanonizeProvider * getCanonizeProvider(const std::string &scheme)
function< bool(const IpAddress &address)> AddressSelector
static FaceUri fromUdpDev(const boost::asio::ip::udp::endpoint &endpoint, const std::string &ifname)
create udp4 or udp6 NIC-associated FaceUri from endpoint and network device name
bool operator!=(const FaceUri &rhs) const
void canonize(const CanonizeSuccessCallback &onSuccess, const CanonizeFailureCallback &onFailure, boost::asio::io_service &io, time::nanoseconds timeout) const
asynchronously convert this FaceUri to canonical form
bool parse(const std::string &uri)
exception-safe parsing
std::string toString() const
write as a string
std::string unescape(const std::string &str)
Decode a percent-encoded string.
std::string toString(char sep= ':') const
Converts the address to a human-readable string.
represents the underlying protocol and address used by a Face
std::map< std::string, shared_ptr< CanonizeProvider >> CanonizeProviderTable
represents an Ethernet hardware address
bool isCanonical() const
determine whether this FaceUri is in canonical form
bool operator==(const FaceUri &rhs) const
const std::string & getScheme() const
get scheme (protocol)
boost::asio::ip::address IpAddress
std::string to_string(const V &v)
const std::string & getHost() const
get host (domain)
const std::string & getPort() const
get port
boost::mpl::vector< UdpCanonizeProvider *, TcpCanonizeProvider *, EtherCanonizeProvider *, DevCanonizeProvider *, UdpDevCanonizeProvider * > CanonizeProviders
void asyncResolve(const std::string &host, const SuccessCallback &onSuccess, const ErrorCallback &onError, boost::asio::io_service &ioService, const AddressSelector &addressSelector, time::nanoseconds timeout)
Asynchronously resolve host.
static FaceUri fromDev(const std::string &ifname)
create dev FaceUri from network device name
const std::string & getPath() const
get path
friend std::ostream & operator<<(std::ostream &os, const FaceUri &uri)