tcp_address.cpp 19.2 KB
Newer Older
1
/*
2
    Copyright (c) 2007-2015 Contributors as noted in the AUTHORS file
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

    This file is part of 0MQ.

    0MQ is free software; you can redistribute it and/or modify it under
    the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    0MQ is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <string>
21
#include <sstream>
22 23 24

#include "tcp_address.hpp"
#include "platform.hpp"
Martin Sustrik's avatar
Martin Sustrik committed
25
#include "stdint.hpp"
26
#include "err.hpp"
27
#include "ip.hpp"
28 29 30 31 32 33 34 35 36 37

#ifdef ZMQ_HAVE_WINDOWS
#include "windows.hpp"
#else
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <netdb.h>
#endif

Martin Hurton's avatar
Martin Hurton committed
38
#ifdef ZMQ_HAVE_SOLARIS
39 40 41 42

#include <sys/sockio.h>
#include <net/if.h>
#include <unistd.h>
43
#include <stdlib.h>
44 45

//  On Solaris platform, network interface name can be queried by ioctl.
46
int zmq::tcp_address_t::resolve_nic_name (const char *nic_, bool ipv6_, bool is_src_)
47 48
{
    //  TODO: Unused parameter, IPv6 support not implemented for Solaris.
Pieter Hintjens's avatar
Pieter Hintjens committed
49
    (void) ipv6_;
50 51

    //  Create a socket.
Martin Hurton's avatar
Martin Hurton committed
52
    const int fd = open_socket (AF_INET, SOCK_DGRAM, 0);
53
    errno_assert (fd != -1);
54 55 56 57 58 59

    //  Retrieve number of interfaces.
    lifnum ifn;
    ifn.lifn_family = AF_INET;
    ifn.lifn_flags = 0;
    int rc = ioctl (fd, SIOCGLIFNUM, (char*) &ifn);
60
    errno_assert (rc != -1);
61 62

    //  Allocate memory to get interface names.
Martin Hurton's avatar
Martin Hurton committed
63
    const size_t ifr_size = sizeof (struct lifreq) * ifn.lifn_count;
64 65
    char *ifr = (char*) malloc (ifr_size);
    alloc_assert (ifr);
66

67 68 69 70 71 72 73
    //  Retrieve interface names.
    lifconf ifc;
    ifc.lifc_family = AF_INET;
    ifc.lifc_flags = 0;
    ifc.lifc_len = ifr_size;
    ifc.lifc_buf = ifr;
    rc = ioctl (fd, SIOCGLIFCONF, (char*) &ifc);
74
    errno_assert (rc != -1);
75 76 77 78

    //  Find the interface with the specified name and AF_INET family.
    bool found = false;
    lifreq *ifrp = ifc.lifc_req;
Martin Hurton's avatar
Martin Hurton committed
79
    for (int n = 0; n < (int) (ifc.lifc_len / sizeof lifreq);
80
          n ++, ifrp ++) {
81
        if (!strcmp (nic_, ifrp->lifr_name)) {
82
            rc = ioctl (fd, SIOCGLIFADDR, (char*) ifrp);
83
            errno_assert (rc != -1);
84
            if (ifrp->lifr_addr.ss_family == AF_INET) {
Martin Hurton's avatar
Martin Hurton committed
85
                if (is_src_)
86
                    source_address.ipv4 = *(sockaddr_in*) &ifrp->lifr_addr;
Martin Hurton's avatar
Martin Hurton committed
87 88
                else
                    address.ipv4 = *(sockaddr_in*) &ifrp->lifr_addr;
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
                found = true;
                break;
            }
        }
    }

    //  Clean-up.
    free (ifr);
    close (fd);

    if (!found) {
        errno = ENODEV;
        return -1;
    }
    return 0;
}

106
#elif defined ZMQ_HAVE_AIX || defined ZMQ_HAVE_HPUX || defined ZMQ_HAVE_ANDROID
107 108 109 110 111 112

#include <sys/types.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <net/if.h>

113
int zmq::tcp_address_t::resolve_nic_name (const char *nic_, bool ipv6_, bool is_src_)
114 115
{
    //  TODO: Unused parameter, IPv6 support not implemented for AIX or HP/UX.
Pieter Hintjens's avatar
Pieter Hintjens committed
116
    (void) ipv6_;
117 118

    //  Create a socket.
Martin Hurton's avatar
Martin Hurton committed
119
    const int sd = open_socket (AF_INET, SOCK_DGRAM, 0);
120
    errno_assert (sd != -1);
121

122
    struct ifreq ifr;
123 124

    //  Copy interface name for ioctl get.
Martin Hurton's avatar
Martin Hurton committed
125
    strncpy (ifr.ifr_name, nic_, sizeof ifr.ifr_name);
126 127

    //  Fetch interface address.
Martin Hurton's avatar
Martin Hurton committed
128
    const int rc = ioctl (sd, SIOCGIFADDR, (caddr_t) &ifr, sizeof ifr);
129 130 131 132 133 134 135 136

    //  Clean up.
    close (sd);

    if (rc == -1) {
        errno = ENODEV;
        return -1;
    }
Martin Hurton's avatar
Martin Hurton committed
137
    if (is_src_)
Martin Hurton's avatar
Martin Hurton committed
138
        memcpy (&source_address.ipv4.sin_addr,
139
            &((sockaddr_in*) &ifr.ifr_addr)->sin_addr, sizeof (struct in_addr));
Martin Hurton's avatar
Martin Hurton committed
140
    else
Martin Hurton's avatar
Martin Hurton committed
141
       memcpy (&address.ipv4.sin_addr,
142
            &((sockaddr_in*) &ifr.ifr_addr)->sin_addr, sizeof (struct in_addr));
143

144
    return 0;
145 146 147 148 149 150 151 152 153 154 155
}

#elif ((defined ZMQ_HAVE_LINUX || defined ZMQ_HAVE_FREEBSD ||\
    defined ZMQ_HAVE_OSX || defined ZMQ_HAVE_OPENBSD ||\
    defined ZMQ_HAVE_QNXNTO || defined ZMQ_HAVE_NETBSD)\
    && defined ZMQ_HAVE_IFADDRS)

#include <ifaddrs.h>

//  On these platforms, network interface name can be queried
//  using getifaddrs function.
156
int zmq::tcp_address_t::resolve_nic_name (const char *nic_, bool ipv6_, bool is_src_)
157 158
{
    //  Get the addresses.
Pieter Hintjens's avatar
Pieter Hintjens committed
159
    ifaddrs *ifa = NULL;
Martin Hurton's avatar
Martin Hurton committed
160
    const int rc = getifaddrs (&ifa);
161
    errno_assert (rc == 0);
162 163 164 165
    zmq_assert (ifa != NULL);

    //  Find the corresponding network interface.
    bool found = false;
Martin Hurton's avatar
Martin Hurton committed
166
    for (ifaddrs *ifp = ifa; ifp != NULL; ifp = ifp->ifa_next) {
167 168 169
        if (ifp->ifa_addr == NULL)
            continue;

Martin Hurton's avatar
Martin Hurton committed
170
        const int family = ifp->ifa_addr->sa_family;
Pieter Hintjens's avatar
Pieter Hintjens committed
171 172
        if ((family == AF_INET || (ipv6_ && family == AF_INET6))
        && !strcmp (nic_, ifp->ifa_name)) {
Martin Hurton's avatar
Martin Hurton committed
173
            if (is_src_)
174 175 176
                memcpy (&source_address, ifp->ifa_addr,
                        (family == AF_INET) ? sizeof (struct sockaddr_in)
                                            : sizeof (struct sockaddr_in6));
Martin Hurton's avatar
Martin Hurton committed
177
            else
178 179 180
                memcpy (&address, ifp->ifa_addr,
                        (family == AF_INET) ? sizeof (struct sockaddr_in)
                                            : sizeof (struct sockaddr_in6));
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
            found = true;
            break;
        }
    }

    //  Clean-up;
    freeifaddrs (ifa);

    if (!found) {
        errno = ENODEV;
        return -1;
    }
    return 0;
}

#else

//  On other platforms we assume there are no sane interface names.
//  This is true especially of Windows.
200
int zmq::tcp_address_t::resolve_nic_name (const char *nic_, bool ipv6_, bool is_src_)
201 202
{
    //  All unused parameters.
203
    (void) nic_;
Pieter Hintjens's avatar
Pieter Hintjens committed
204
    (void) ipv6_;
205 206 207 208 209 210 211

    errno = ENODEV;
    return -1;
}

#endif

212
int zmq::tcp_address_t::resolve_interface (const char *interface_, bool ipv6_, bool is_src_)
213 214 215
{
    //  Initialize temporary output pointers with storage address.
    sockaddr_storage ss;
216 217
    sockaddr *out_addr = (sockaddr*) &ss;
    size_t out_addrlen;
218 219 220

    //  Initialise IP-format family/port and populate temporary output pointers
    //  with the address.
Pieter Hintjens's avatar
Pieter Hintjens committed
221
    if (ipv6_) {
222
        sockaddr_in6 ip6_addr;
Martin Hurton's avatar
Martin Hurton committed
223
        memset (&ip6_addr, 0, sizeof ip6_addr);
224
        ip6_addr.sin6_family = AF_INET6;
Martin Hurton's avatar
Martin Hurton committed
225
        memcpy (&ip6_addr.sin6_addr, &in6addr_any, sizeof in6addr_any);
226
        out_addrlen = sizeof ip6_addr;
227 228
        memcpy (out_addr, &ip6_addr, out_addrlen);
    }
Pieter Hintjens's avatar
Pieter Hintjens committed
229 230
    else {
        sockaddr_in ip4_addr;
Martin Hurton's avatar
Martin Hurton committed
231
        memset (&ip4_addr, 0, sizeof ip4_addr);
Pieter Hintjens's avatar
Pieter Hintjens committed
232 233 234 235 236 237
        ip4_addr.sin_family = AF_INET;
        ip4_addr.sin_addr.s_addr = htonl (INADDR_ANY);
        out_addrlen = sizeof ip4_addr;
        memcpy (out_addr, &ip4_addr, out_addrlen);
    }
    //  "*" resolves to INADDR_ANY or in6addr_any.
238
    if (strcmp (interface_, "*") == 0) {
239
        zmq_assert (out_addrlen <= sizeof address);
Martin Hurton's avatar
Martin Hurton committed
240
        if (is_src_)
241
            memcpy (&source_address, out_addr, out_addrlen);
Martin Hurton's avatar
Martin Hurton committed
242
        else
243
            memcpy (&address, out_addr, out_addrlen);
244 245 246 247
        return 0;
    }

    //  Try to resolve the string as a NIC name.
248
    int rc = resolve_nic_name (interface_, ipv6_, is_src_);
Martin Hurton's avatar
Martin Hurton committed
249
    if (rc == 0 || errno != ENODEV)
250 251 252 253 254 255 256 257 258 259
        return rc;

    //  There's no such interface name. Assume literal address.
#if defined ZMQ_HAVE_OPENVMS && defined __ia64
    __addrinfo64 *res = NULL;
    __addrinfo64 req;
#else
    addrinfo *res = NULL;
    addrinfo req;
#endif
Martin Hurton's avatar
Martin Hurton committed
260
    memset (&req, 0, sizeof req);
261 262 263

    //  Choose IPv4 or IPv6 protocol family. Note that IPv6 allows for
    //  IPv4-in-IPv6 addresses.
Pieter Hintjens's avatar
Pieter Hintjens committed
264
    req.ai_family = ipv6_? AF_INET6: AF_INET;
265 266 267 268 269 270 271 272

    //  Arbitrary, not used in the output, but avoids duplicate results.
    req.ai_socktype = SOCK_STREAM;

    //  Restrict hostname/service to literals to avoid any DNS lookups or
    //  service-name irregularity due to indeterminate socktype.
    req.ai_flags = AI_PASSIVE | AI_NUMERICHOST;

273 274 275 276 277 278
#if defined AI_V4MAPPED && !defined ZMQ_HAVE_FREEBSD
    //  In this API we only require IPv4-mapped addresses when
    //  no native IPv6 interfaces are available (~AI_ALL).
    //  This saves an additional DNS roundtrip for IPv4 addresses.
    //  Note: While the AI_V4MAPPED flag is defined on FreeBSD system,
    //  it is not supported here. See libzmq issue #331.
279 280 281 282 283 284 285 286 287 288 289 290 291
    if (req.ai_family == AF_INET6)
        req.ai_flags |= AI_V4MAPPED;
#endif

    //  Resolve the literal address. Some of the error info is lost in case
    //  of error, however, there's no way to report EAI errors via errno.
    rc = getaddrinfo (interface_, NULL, &req, &res);
    if (rc) {
        errno = ENODEV;
        return -1;
    }

    //  Use the first result.
292
    zmq_assert (res != NULL);
Martin Hurton's avatar
Martin Hurton committed
293 294
    zmq_assert ((size_t) res->ai_addrlen <= sizeof address);
    if (is_src_)
295
        memcpy (&source_address, res->ai_addr, res->ai_addrlen);
Martin Hurton's avatar
Martin Hurton committed
296
    else
297
        memcpy (&address, res->ai_addr, res->ai_addrlen);
298 299

    //  Cleanup getaddrinfo after copying the possibly referenced result.
300
    freeaddrinfo (res);
301 302 303 304

    return 0;
}

305
int zmq::tcp_address_t::resolve_hostname (const char *hostname_, bool ipv6_, bool is_src_)
306 307
{
    //  Set up the query.
308 309 310
#if defined ZMQ_HAVE_OPENVMS && defined __ia64 && __INITIAL_POINTER_SIZE == 64
    __addrinfo64 req;
#else
311
    addrinfo req;
312
#endif
Martin Hurton's avatar
Martin Hurton committed
313
    memset (&req, 0, sizeof req);
314 315 316

    //  Choose IPv4 or IPv6 protocol family. Note that IPv6 allows for
    //  IPv4-in-IPv6 addresses.
Pieter Hintjens's avatar
Pieter Hintjens committed
317
    req.ai_family = ipv6_? AF_INET6: AF_INET;
318 319 320 321

    //  Need to choose one to avoid duplicate results from getaddrinfo() - this
    //  doesn't really matter, since it's not included in the addr-output.
    req.ai_socktype = SOCK_STREAM;
322 323 324 325 326 327 328

#if defined AI_V4MAPPED && !defined ZMQ_HAVE_FREEBSD
    //  In this API we only require IPv4-mapped addresses when
    //  no native IPv6 interfaces are available.
    //  This saves an additional DNS roundtrip for IPv4 addresses.
    //  Note: While the AI_V4MAPPED flag is defined on FreeBSD system,
    //  it is not supported here. See libzmq issue #331.
329 330 331 332 333 334
    if (req.ai_family == AF_INET6)
        req.ai_flags |= AI_V4MAPPED;
#endif

    //  Resolve host name. Some of the error info is lost in case of error,
    //  however, there's no way to report EAI errors via errno.
335 336 337
#if defined ZMQ_HAVE_OPENVMS && defined __ia64 && __INITIAL_POINTER_SIZE == 64
    __addrinfo64 *res;
#else
338
    addrinfo *res;
339
#endif
Martin Hurton's avatar
Martin Hurton committed
340
    const int rc = getaddrinfo (hostname_, NULL, &req, &res);
341 342 343 344 345 346 347 348 349 350 351 352 353
    if (rc) {
        switch (rc) {
        case EAI_MEMORY:
            errno = ENOMEM;
            break;
        default:
            errno = EINVAL;
            break;
        }
        return -1;
    }

    //  Copy first result to output addr with hostname and service.
Martin Hurton's avatar
Martin Hurton committed
354 355
    zmq_assert ((size_t) res->ai_addrlen <= sizeof address);
    if (is_src_)
356
        memcpy (&source_address, res->ai_addr, res->ai_addrlen);
Martin Hurton's avatar
Martin Hurton committed
357
    else
358
        memcpy (&address, res->ai_addr, res->ai_addrlen);
359

360
    freeaddrinfo (res);
361

362 363 364
    return 0;
}

365 366
zmq::tcp_address_t::tcp_address_t () :
    _has_src_addr (false)
367
{
Martin Hurton's avatar
Martin Hurton committed
368 369
    memset (&address, 0, sizeof address);
    memset (&source_address, 0, sizeof source_address);
370 371
}

372 373
zmq::tcp_address_t::tcp_address_t (const sockaddr *sa, socklen_t sa_len) :
    _has_src_addr (false)
374
{
Martin Hurton's avatar
Martin Hurton committed
375 376 377 378 379 380 381 382 383
    zmq_assert (sa && sa_len > 0);

    memset (&address, 0, sizeof address);
    memset (&source_address, 0, sizeof source_address);
    if (sa->sa_family == AF_INET && sa_len >= (socklen_t) sizeof address.ipv4)
        memcpy (&address.ipv4, sa, sizeof address.ipv4);
    else
    if (sa->sa_family == AF_INET6 && sa_len >= (socklen_t) sizeof address.ipv6)
        memcpy (&address.ipv6, sa, sizeof address.ipv6);
384 385
}

386 387 388 389
zmq::tcp_address_t::~tcp_address_t ()
{
}

390
int zmq::tcp_address_t::resolve (const char *name_, bool local_, bool ipv6_, bool is_src_)
391
{
392 393 394 395 396
    if (!is_src_) {
        // Test the ';' to know if we have a source address in name_
        const char *src_delimiter = strrchr (name_, ';');
        if (src_delimiter) {
            std::string src_name (name_, src_delimiter - name_);
Martin Hurton's avatar
Martin Hurton committed
397
            const int rc = resolve (src_name.c_str (), local_, ipv6_, true);
398 399 400 401 402 403 404
            if (rc != 0)
                return -1;
            name_ = src_delimiter + 1;
            _has_src_addr = true;
        }
    }

405 406 407 408 409 410
    //  Find the ':' at end that separates address from the port number.
    const char *delimiter = strrchr (name_, ':');
    if (!delimiter) {
        errno = EINVAL;
        return -1;
    }
411

412 413 414 415
    //  Separate the address/port.
    std::string addr_str (name_, delimiter - name_);
    std::string port_str (delimiter + 1);

416
    //  Remove square brackets around the address, if any, as used in IPv6
417 418 419 420
    if (addr_str.size () >= 2 && addr_str [0] == '[' &&
          addr_str [addr_str.size () - 1] == ']')
        addr_str = addr_str.substr (1, addr_str.size () - 2);

421
    //  Allow 0 specifically, to detect invalid port error in atoi if not
Pieter Hintjens's avatar
Pieter Hintjens committed
422
    uint16_t port;
423
    if (port_str == "*" || port_str == "0")
424
        //  Resolve wildcard to 0 to allow autoselection of port
425
        port = 0;
426
    else {
427
        //  Parse the port number (0 is not a valid port).
428
        port = (uint16_t) atoi (port_str.c_str ());
429 430 431 432
        if (port == 0) {
            errno = EINVAL;
            return -1;
        }
433 434 435 436 437
    }

    //  Resolve the IP address.
    int rc;
    if (local_)
438
        rc = resolve_interface (addr_str.c_str (), ipv6_, is_src_);
439
    else
440
        rc = resolve_hostname (addr_str.c_str (), ipv6_, is_src_);
441 442 443 444
    if (rc != 0)
        return -1;

    //  Set the port into the address structure.
445 446 447 448 449
    if (is_src_) {
        if (source_address.generic.sa_family == AF_INET6)
            source_address.ipv6.sin6_port = htons (port);
        else
            source_address.ipv4.sin_port = htons (port);
Martin Hurton's avatar
Martin Hurton committed
450 451
    }
    else {
452 453 454 455 456 457
        if (address.generic.sa_family == AF_INET6)
            address.ipv6.sin6_port = htons (port);
        else
            address.ipv4.sin_port = htons (port);
    }

458 459 460
    return 0;
}

461 462
int zmq::tcp_address_t::to_string (std::string &addr_)
{
Pieter Hintjens's avatar
Pieter Hintjens committed
463 464
    if (address.generic.sa_family != AF_INET
    &&  address.generic.sa_family != AF_INET6) {
465 466 467 468
        addr_.clear ();
        return -1;
    }

469 470
    //  Not using service resolv because of
    //  https://github.com/zeromq/libzmq/commit/1824574f9b5a8ce786853320e3ea09fe1f822bc4
Martin Hurton's avatar
Martin Hurton committed
471 472
    char hbuf [NI_MAXHOST];
    int rc = getnameinfo (addr (), addrlen (), hbuf, sizeof hbuf, NULL, 0, NI_NUMERICHOST);
473 474 475 476 477 478 479 480 481 482 483 484 485 486
    if (rc != 0) {
        addr_.clear ();
        return rc;
    }

    if (address.generic.sa_family == AF_INET6) {
        std::stringstream s;
        s << "tcp://[" << hbuf << "]:" << ntohs (address.ipv6.sin6_port);
        addr_ = s.str ();
    }
    else {
        std::stringstream s;
        s << "tcp://" << hbuf << ":" << ntohs (address.ipv4.sin_port);
        addr_ = s.str ();
Martin Hurton's avatar
Martin Hurton committed
487
    }
488 489 490
    return 0;
}

491
const sockaddr *zmq::tcp_address_t::addr () const
492 493 494 495
{
    return &address.generic;
}

496
socklen_t zmq::tcp_address_t::addrlen () const
497 498
{
    if (address.generic.sa_family == AF_INET6)
Martin Hurton's avatar
Martin Hurton committed
499
        return (socklen_t) sizeof address.ipv6;
500
    else
Martin Hurton's avatar
Martin Hurton committed
501
        return (socklen_t) sizeof address.ipv4;
502 503
}

504 505 506 507 508 509 510 511
const sockaddr *zmq::tcp_address_t::src_addr () const
{
    return &source_address.generic;
}

socklen_t zmq::tcp_address_t::src_addrlen () const
{
    if (address.generic.sa_family == AF_INET6)
Martin Hurton's avatar
Martin Hurton committed
512
        return (socklen_t) sizeof source_address.ipv6;
513
    else
Martin Hurton's avatar
Martin Hurton committed
514
        return (socklen_t) sizeof source_address.ipv4;
515 516
}

Martin Hurton's avatar
Martin Hurton committed
517
bool zmq::tcp_address_t::has_src_addr () const
518 519 520 521
{
    return _has_src_addr;
}

Martin Sustrik's avatar
Martin Sustrik committed
522
#if defined ZMQ_HAVE_WINDOWS
523
unsigned short zmq::tcp_address_t::family () const
Martin Sustrik's avatar
Martin Sustrik committed
524
#else
525
sa_family_t zmq::tcp_address_t::family () const
Martin Sustrik's avatar
Martin Sustrik committed
526
#endif
527 528 529 530
{
    return address.generic.sa_family;
}

531
zmq::tcp_address_mask_t::tcp_address_mask_t () :
Martin Hurton's avatar
Martin Hurton committed
532 533
    tcp_address_t (),
    address_mask (-1)
534 535 536
{
}

537
int zmq::tcp_address_mask_t::mask () const
538 539 540 541
{
    return address_mask;
}

Pieter Hintjens's avatar
Pieter Hintjens committed
542
int zmq::tcp_address_mask_t::resolve (const char *name_, bool ipv6_)
543 544
{
    // Find '/' at the end that separates address from the cidr mask number.
Martin Hurton's avatar
Martin Hurton committed
545
    // Allow empty mask clause and treat it like '/32' for ipv4 or '/128' for ipv6.
546
    std::string addr_str, mask_str;
547 548 549 550 551 552 553 554 555
    const char *delimiter = strrchr (name_, '/');
    if (delimiter != NULL) {
        addr_str.assign (name_, delimiter - name_);
        mask_str.assign (delimiter + 1);
        if (mask_str.empty ()) {
            errno = EINVAL;
            return -1;
        }
    }
Pieter Hintjens's avatar
Pieter Hintjens committed
556
    else
557 558 559
        addr_str.assign (name_);

    // Parse address part using standard routines.
Martin Hurton's avatar
Martin Hurton committed
560 561
    const int rc =
        tcp_address_t::resolve_hostname (addr_str.c_str (), ipv6_);
562 563 564 565 566 567 568 569 570 571 572
    if (rc != 0)
        return rc;

    // Parse the cidr mask number.
    if (mask_str.empty ()) {
        if (address.generic.sa_family == AF_INET6)
            address_mask = 128;
        else
            address_mask = 32;
    }
    else
Martin Hurton's avatar
Martin Hurton committed
573
    if (mask_str == "0")
574 575
        address_mask = 0;
    else {
Martin Hurton's avatar
Martin Hurton committed
576
        const int mask = atoi (mask_str.c_str ());
577 578 579 580 581 582 583 584 585 586 587 588 589 590
        if (
            (mask < 1) ||
            (address.generic.sa_family == AF_INET6 && mask > 128) ||
            (address.generic.sa_family != AF_INET6 && mask > 32)
        ) {
            errno = EINVAL;
            return -1;
        }
        address_mask = mask;
    }

    return 0;
}

591 592
int zmq::tcp_address_mask_t::to_string (std::string &addr_)
{
Martin Hurton's avatar
Martin Hurton committed
593 594
    if (address.generic.sa_family != AF_INET
    &&  address.generic.sa_family != AF_INET6) {
595 596 597 598 599 600 601 602
        addr_.clear ();
        return -1;
    }
    if (address_mask == -1) {
        addr_.clear ();
        return -1;
    }

Martin Hurton's avatar
Martin Hurton committed
603 604
    char hbuf [NI_MAXHOST];
    int rc = getnameinfo (addr (), addrlen (), hbuf, sizeof hbuf, NULL, 0, NI_NUMERICHOST);
605 606 607 608 609 610 611 612 613 614 615 616 617 618
    if (rc != 0) {
        addr_.clear ();
        return rc;
    }

    if (address.generic.sa_family == AF_INET6) {
        std::stringstream s;
        s << "[" << hbuf << "]/" << address_mask;
        addr_ = s.str ();
    }
    else {
        std::stringstream s;
        s << hbuf << "/" << address_mask;
        addr_ = s.str ();
Martin Hurton's avatar
Martin Hurton committed
619
    }
620 621 622
    return 0;
}

623
bool zmq::tcp_address_mask_t::match_address (const struct sockaddr *ss, const socklen_t ss_len) const
624
{
Martin Hurton's avatar
Martin Hurton committed
625 626 627
    zmq_assert (address_mask != -1
             && ss != NULL
             && ss_len >= (socklen_t) sizeof (struct sockaddr));
628 629 630 631 632 633

    if (ss->sa_family != address.generic.sa_family)
        return false;

    if (address_mask > 0) {
        int mask;
634
        const uint8_t *our_bytes, *their_bytes;
635 636
        if (ss->sa_family == AF_INET6) {
            zmq_assert (ss_len == sizeof (struct sockaddr_in6));
637 638
            their_bytes = (const uint8_t *) &(((const struct sockaddr_in6 *) ss)->sin6_addr);
            our_bytes = (const uint8_t *) &address.ipv6.sin6_addr;
639 640 641 642
            mask = sizeof (struct in6_addr) * 8;
        }
        else {
            zmq_assert (ss_len == sizeof (struct sockaddr_in));
643 644
            their_bytes = (const uint8_t *) &(((const struct sockaddr_in *) ss)->sin_addr);
            our_bytes = (const uint8_t *) &address.ipv4.sin_addr;
645 646
            mask = sizeof (struct in_addr) * 8;
        }
Martin Hurton's avatar
Martin Hurton committed
647 648
        if (address_mask < mask)
            mask = address_mask;
649

Martin Hurton's avatar
Martin Hurton committed
650 651
        const size_t full_bytes = mask / 8;
        if (memcmp (our_bytes, their_bytes, full_bytes))
652
            return false;
653

Martin Hurton's avatar
Martin Hurton committed
654
        const uint8_t last_byte_bits = 0xffU << (8 - mask % 8);
655
        if (last_byte_bits) {
Martin Hurton's avatar
Martin Hurton committed
656
            if ((their_bytes [full_bytes] & last_byte_bits) != (our_bytes [full_bytes] & last_byte_bits))
657 658 659 660 661 662
                return false;
        }
    }

    return true;
}