udp_address.cpp

Go to the documentation of this file.

/* 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;
}