libzmq/src/udp_address.cpp

183 lines
4.8 KiB
C++

/* SPDX-License-Identifier: MPL-2.0 */
#include "precompiled.hpp"
#include <string>
#include <sstream>
#include "macros.hpp"
#include "udp_address.hpp"
#include "stdint.hpp"
#include "err.hpp"
#include "ip.hpp"
#ifndef ZMQ_HAVE_WINDOWS
#include <sys/types.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <net/if.h>
#include <ctype.h>
#endif
zmq::udp_address_t::udp_address_t () :
_bind_interface (-1), _is_multicast (false)
{
_bind_address = ip_addr_t::any (AF_INET);
_target_address = ip_addr_t::any (AF_INET);
}
zmq::udp_address_t::~udp_address_t ()
{
}
int zmq::udp_address_t::resolve (const char *name_, bool bind_, bool ipv6_)
{
// No IPv6 support yet
bool has_interface = false;
_address = name_;
// If we have a semicolon then we should have an interface specifier in the
// URL
const char *src_delimiter = strrchr (name_, ';');
if (src_delimiter) {
const std::string src_name (name_, src_delimiter - name_);
ip_resolver_options_t src_resolver_opts;
src_resolver_opts
.bindable (true)
// Restrict hostname/service to literals to avoid any DNS
// lookups or service-name irregularity due to
// indeterminate socktype.
.allow_dns (false)
.allow_nic_name (true)
.ipv6 (ipv6_)
.expect_port (false);
ip_resolver_t src_resolver (src_resolver_opts);
const int rc = src_resolver.resolve (&_bind_address, src_name.c_str ());
if (rc != 0) {
return -1;
}
if (_bind_address.is_multicast ()) {
// It doesn't make sense to have a multicast address as a source
errno = EINVAL;
return -1;
}
// This is a hack because we need the interface index when binding
// multicast IPv6, we can't do it by address. Unfortunately for the
// time being we don't have a generic platform-independent function to
// resolve an interface index from an address, so we only support it
// when an actual interface name is provided.
if (src_name == "*") {
_bind_interface = 0;
} else {
#ifdef HAVE_IF_NAMETOINDEX
_bind_interface = if_nametoindex (src_name.c_str ());
if (_bind_interface == 0) {
// Error, probably not an interface name.
_bind_interface = -1;
}
#endif
}
has_interface = true;
name_ = src_delimiter + 1;
}
ip_resolver_options_t resolver_opts;
resolver_opts.bindable (bind_)
.allow_dns (true)
.allow_nic_name (bind_)
.expect_port (true)
.ipv6 (ipv6_);
ip_resolver_t resolver (resolver_opts);
const int rc = resolver.resolve (&_target_address, name_);
if (rc != 0) {
return -1;
}
_is_multicast = _target_address.is_multicast ();
const uint16_t port = _target_address.port ();
if (has_interface) {
// If we have an interface specifier then the target address must be a
// multicast address
if (!_is_multicast) {
errno = EINVAL;
return -1;
}
_bind_address.set_port (port);
} else {
// If we don't have an explicit interface specifier then the URL is
// ambiguous: if the target address is multicast then it's the
// destination address and the bind address is ANY, if it's unicast
// then it's the bind address when 'bind_' is true and the destination
// otherwise
if (_is_multicast || !bind_) {
_bind_address = ip_addr_t::any (_target_address.family ());
_bind_address.set_port (port);
_bind_interface = 0;
} else {
// If we were asked for a bind socket and the address
// provided was not multicast then it was really meant as
// a bind address and the target_address is useless.
_bind_address = _target_address;
}
}
if (_bind_address.family () != _target_address.family ()) {
errno = EINVAL;
return -1;
}
// For IPv6 multicast we *must* have an interface index since we can't
// bind by address.
if (ipv6_ && _is_multicast && _bind_interface < 0) {
errno = ENODEV;
return -1;
}
return 0;
}
int zmq::udp_address_t::family () const
{
return _bind_address.family ();
}
bool zmq::udp_address_t::is_mcast () const
{
return _is_multicast;
}
const zmq::ip_addr_t *zmq::udp_address_t::bind_addr () const
{
return &_bind_address;
}
int zmq::udp_address_t::bind_if () const
{
return _bind_interface;
}
const zmq::ip_addr_t *zmq::udp_address_t::target_addr () const
{
return &_target_address;
}
int zmq::udp_address_t::to_string (std::string &addr_)
{
// XXX what do (factor TCP code?)
addr_ = _address;
return 0;
}