laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/src/ziflist.c

@@ -0,0 +1,517 @@
+/*  =========================================================================
+    ziflist - list of network interfaces available on system
+
+    Copyright (c) the Contributors as noted in the AUTHORS file.
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    =========================================================================
+*/
+
+/*
+@header
+    The ziflist class takes a snapshot of the network interfaces that the
+    system currently supports (this can change arbitrarily, especially on
+    mobile devices). The caller can then access the network interface
+    information using an iterator that works like zlistx. Only stores those
+    interfaces with broadcast capability, and ignores the loopback interface.
+@discuss
+@end
+*/
+
+#include "czmq_classes.h"
+
+//  Structure of an interface
+typedef struct {
+    char *name;
+    char *address;
+    char *netmask;
+    char *broadcast;
+    bool is_ipv6;
+} interface_t;
+
+
+//  --------------------------------------------------------------------------
+//  interface destructor
+
+static void
+s_interface_destroy (interface_t **self_p)
+{
+    assert (self_p);
+    interface_t *self = *self_p;
+    if (self) {
+        freen (self->name);
+        freen (self->address);
+        freen (self->netmask);
+        freen (self->broadcast);
+        freen (self);
+        *self_p = NULL;
+    }
+}
+
+
+//  --------------------------------------------------------------------------
+//  interface constructor
+
+static interface_t *
+s_interface_new (char *name, struct sockaddr *address, struct sockaddr *netmask,
+        struct sockaddr *broadcast)
+{
+    char hbuf[NI_MAXHOST];
+    int rc;
+
+    interface_t *self = (interface_t *) zmalloc (sizeof (interface_t));
+    assert (self);
+    self->name = strdup (name);
+    assert (self->name);
+
+    rc = getnameinfo (address, address->sa_family == AF_INET ?
+            sizeof (struct sockaddr_in) : sizeof (struct sockaddr_in6),
+            hbuf, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+    assert (rc == 0);
+    //  Some platform's getnameinfo, like Solaris, appear not to append the
+    //  interface name when parsing a link-local IPv6 address. These addresses
+    //  cannot be used without the interface, so we must append it manually.
+    if (address->sa_family == AF_INET6 &&
+            IN6_IS_ADDR_LINKLOCAL (&((struct sockaddr_in6 *)address)->sin6_addr) &&
+            !strchr (hbuf, '%')) {
+        strcat (hbuf, "%");
+        strcat (hbuf, name);
+    }
+    self->address = strdup (hbuf);
+    assert (self->address);
+
+    rc = getnameinfo (netmask, netmask->sa_family == AF_INET ?
+            sizeof (struct sockaddr_in) : sizeof (struct sockaddr_in6),
+            hbuf, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+    assert (rc == 0);
+    self->netmask = strdup (hbuf);
+    assert (self->netmask);
+
+    if (address->sa_family == AF_INET) {
+        //  If the returned broadcast address is the same as source
+        //  address, build the broadcast address from the source
+        //  address and netmask.
+        if (((inaddr_t *)address)->sin_addr.s_addr == ((inaddr_t *)broadcast)->sin_addr.s_addr)
+            ((inaddr_t *)broadcast)->sin_addr.s_addr |= ~(((inaddr_t *)netmask)->sin_addr.s_addr);
+
+        rc = getnameinfo (broadcast, sizeof (struct sockaddr_in), hbuf, NI_MAXHOST,
+                NULL, 0, NI_NUMERICHOST);
+        assert (rc == 0);
+        self->broadcast = strdup (hbuf);
+        assert (self->broadcast);
+    } else {
+        //  The default is link-local all-node multicast group fe02::1
+        self->broadcast = strdup (zsys_ipv6_mcast_address ());
+        assert (self->broadcast);
+    }
+
+    self->is_ipv6 = address->sa_family == AF_INET6 ? true : false;
+
+    return self;
+}
+
+//  Structure of our class
+struct _ziflist_t;
+
+//  --------------------------------------------------------------------------
+//  Get a list of network interfaces currently defined on the system
+
+ziflist_t *
+ziflist_new (void)
+{
+    ziflist_t *self = (ziflist_t *) zlistx_new ();
+    assert (self);
+    zlistx_set_destructor ((zlistx_t *) self, (czmq_destructor *) s_interface_destroy);
+    ziflist_reload (self);
+    return self;
+}
+
+//  --------------------------------------------------------------------------
+//  Get a list of network interfaces currently defined on the system
+//  Includes IPv6 interfaces
+
+ziflist_t *
+ziflist_new_ipv6 (void)
+{
+    ziflist_t *self = (ziflist_t *) zlistx_new ();
+    assert (self);
+    zlistx_set_destructor ((zlistx_t *) self, (czmq_destructor *) s_interface_destroy);
+    ziflist_reload_ipv6 (self);
+    return self;
+}
+
+
+//  Print properties of the ziflist object.
+//  --------------------------------------------------------------------------
+
+void
+ziflist_print (ziflist_t *self)
+{
+    interface_t *iface;
+    for (iface = (interface_t *) zlistx_first ((zlistx_t *) self);
+         iface != NULL;
+         iface = (interface_t *) zlistx_next ((zlistx_t *) self)) {
+        zsys_info (" - interface name : %s", iface->name);
+        zsys_info (" - interface address : %s", iface->address);
+        zsys_info (" - interface netmask : %s", iface->netmask);
+        zsys_info (" - interface broadcast : %s", iface->broadcast);
+    }
+}
+
+
+//  --------------------------------------------------------------------------
+//  Destroy a ziflist instance
+
+void
+ziflist_destroy (ziflist_t **self_p)
+{
+    zlistx_destroy ((zlistx_t **) self_p);
+}
+
+
+#ifdef __UNIX__
+//  --------------------------------------------------------------------------
+//  Helper function to verify if one interface's flags are what we want.
+
+static bool
+s_valid_flags (short flags, bool ipv6)
+{
+    return (flags & IFF_UP)             //  Only use interfaces that are running
+           && !(flags & IFF_LOOPBACK)   //  Ignore loopback interface
+           && ((ipv6 || (flags & IFF_BROADCAST))  //  Only use interfaces that have BROADCAST
+                   && (!ipv6 || (flags & IFF_MULTICAST))) //  or IPv6 and MULTICAST
+#   if defined (IFF_SLAVE)
+           && !(flags & IFF_SLAVE)      //  Ignore devices that are bonding slaves.
+#   endif
+           && !(flags & IFF_POINTOPOINT); //  Ignore point to point interfaces.
+}
+#endif
+
+
+//  --------------------------------------------------------------------------
+//  Helper to reload network interfaces from system
+
+static void
+s_reload (ziflist_t *self, bool ipv6)
+{
+    assert (self);
+    zlistx_t *list = (zlistx_t *) self;
+    zlistx_purge (list);
+
+#if defined (HAVE_GETIFADDRS)
+    struct ifaddrs *interfaces;
+    if (getifaddrs (&interfaces) == 0) {
+        struct ifaddrs *interface = interfaces;
+        while (interface) {
+            //  On Solaris, loopback interfaces have a NULL in ifa_broadaddr
+            if (interface->ifa_addr
+            && (interface->ifa_broadaddr
+                    || (ipv6 && (interface->ifa_addr->sa_family == AF_INET6)))
+            &&(interface->ifa_addr->sa_family == AF_INET
+                    || (ipv6 && (interface->ifa_addr->sa_family == AF_INET6)))
+            // Seems to be needed for running VirtualBox VMs on MacOS (see #1802)
+            &&(interface->ifa_netmask->sa_family == AF_INET
+                    || (ipv6 && (interface->ifa_netmask->sa_family == AF_INET6)))
+            &&  s_valid_flags (interface->ifa_flags,
+                    ipv6 && (interface->ifa_addr->sa_family == AF_INET6))) {
+                interface_t *item = s_interface_new (interface->ifa_name,
+                        interface->ifa_addr, interface->ifa_netmask,
+                        interface->ifa_broadaddr);
+                if (item)
+                    zlistx_add_end (list, item);
+            }
+            interface = interface->ifa_next;
+        }
+    }
+    freeifaddrs (interfaces);
+
+#   elif defined (__UNIX__)
+    int sock = socket (AF_INET, SOCK_DGRAM, 0);
+    if (sock != -1) {
+        int num_interfaces = 0;
+        struct ifconf ifconfig = { 0 };
+        //  First ioctl call gets us length of buffer; second call gets us contents
+        if (!ioctl (sock, SIOCGIFCONF, (caddr_t) &ifconfig, sizeof (struct ifconf))) {
+            ifconfig.ifc_buf = (char *) zmalloc (ifconfig.ifc_len);
+            if (!ioctl (sock, SIOCGIFCONF, (caddr_t) &ifconfig, sizeof (struct ifconf)))
+                num_interfaces = ifconfig.ifc_len / sizeof (struct ifreq);
+        }
+        int index;
+        for (index = 0; index < num_interfaces; index++) {
+            struct ifreq *ifr = &ifconfig.ifc_req [index];
+            //  Check interface flags
+            bool is_valid = false;
+
+            //  Get interface properties
+            inaddr_t address = { 0 };
+            if (!ioctl (sock, SIOCGIFADDR, (caddr_t) ifr, sizeof (struct ifreq)))
+                address = *((inaddr_t *) &ifr->ifr_addr);
+            else
+                is_valid = false;
+
+            if (!ioctl (sock, SIOCGIFFLAGS, (caddr_t) ifr, sizeof (struct ifreq)))
+                is_valid = s_valid_flags (ifr->ifr_flags,
+                        ipv6 && (address.sin_family == AF_INET6));
+
+            inaddr_t broadcast = { 0 };
+            if (!ioctl (sock, SIOCGIFBRDADDR, (caddr_t) ifr, sizeof (struct ifreq)))
+                broadcast = *((inaddr_t *) &ifr->ifr_addr);
+            else
+                is_valid = false;
+
+            inaddr_t netmask = { 0 };
+            if (!ioctl (sock, SIOCGIFNETMASK, (caddr_t) ifr, sizeof (struct ifreq)))
+                netmask = *((inaddr_t *) &ifr->ifr_addr);
+            else
+                is_valid = false;
+
+            if (is_valid) {
+                interface_t *item = s_interface_new (ifr->ifr_name,
+                        (struct sockaddr *)&address, (struct sockaddr *)&netmask,
+                        (struct sockaddr *)&broadcast);
+                if (item)
+                    zlistx_add_end (list, item);
+            }
+        }
+        freen (ifconfig.ifc_buf);
+        close (sock);
+    }
+
+#   elif defined (__WINDOWS__)
+    // TODO: IPv6 support
+    ULONG addr_size = 0;
+    DWORD rc = GetAdaptersAddresses (AF_INET, GAA_FLAG_INCLUDE_PREFIX, NULL, NULL, &addr_size);
+    assert (rc == ERROR_BUFFER_OVERFLOW);
+
+    static const int maxTries = 3;
+    int iterations = 0;
+
+    PIP_ADAPTER_ADDRESSES pip_addresses = NULL;
+
+    do {
+        pip_addresses = (PIP_ADAPTER_ADDRESSES) zmalloc (addr_size);
+        rc = GetAdaptersAddresses (AF_INET,
+                                   GAA_FLAG_INCLUDE_PREFIX, NULL, pip_addresses, &addr_size);
+        
+        if (rc == ERROR_BUFFER_OVERFLOW) {
+            freen (pip_addresses);
+            pip_addresses = NULL;
+        } 
+        else {
+            break;
+        }
+        
+        ++iterations;
+    }
+    while ((rc == ERROR_BUFFER_OVERFLOW) && (iterations < maxTries));
+
+    assert (rc == NO_ERROR);
+
+    PIP_ADAPTER_ADDRESSES cur_address = pip_addresses;
+    while (cur_address) {
+        PIP_ADAPTER_UNICAST_ADDRESS pUnicast = cur_address->FirstUnicastAddress;
+        PIP_ADAPTER_PREFIX pPrefix = cur_address->FirstPrefix;
+
+        PWCHAR friendlyName = cur_address->FriendlyName;
+        size_t asciiSize = wcstombs (0, friendlyName, 0) + 1;
+        char *asciiFriendlyName = (char *) zmalloc (asciiSize);
+        wcstombs (asciiFriendlyName, friendlyName, asciiSize);
+
+        bool valid = (cur_address->OperStatus == IfOperStatusUp)
+                     && (pUnicast && pPrefix)
+                     && (pUnicast->Address.lpSockaddr->sa_family == AF_INET)
+                     && (pPrefix->PrefixLength <= 32);
+
+        if (valid) {
+            struct sockaddr_in address, netmask, broadcast;
+            address = *(struct sockaddr_in *)pUnicast->Address.lpSockaddr;
+            address.sin_family = AF_INET;
+            netmask.sin_addr.s_addr = htonl ((0xffffffffU) << (32 - pPrefix->PrefixLength));
+            netmask.sin_family = AF_INET;
+            broadcast = address;
+            broadcast.sin_addr.s_addr |= ~(netmask.sin_addr.s_addr);
+            interface_t *item = s_interface_new (asciiFriendlyName,
+                    (struct sockaddr *)&address, (struct sockaddr *)&netmask,
+                    (struct sockaddr *)&broadcast);
+            if (item)
+                zlistx_add_end (list, item);
+        }
+        freen (asciiFriendlyName);
+        cur_address = cur_address->Next;
+    }
+    freen (pip_addresses);
+
+#   else
+#       error "Interface detection TBD on this operating system"
+#   endif
+}
+
+
+//  --------------------------------------------------------------------------
+//  Reload network interfaces from system
+
+void
+ziflist_reload (ziflist_t *self)
+{
+    s_reload (self, false);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Reload network interfaces from system, including IPv6
+
+void
+ziflist_reload_ipv6 (ziflist_t *self)
+{
+    s_reload (self, true);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return the number of network interfaces on system
+
+size_t
+ziflist_size (ziflist_t *self)
+{
+    assert (self);
+    return zlistx_size ((zlistx_t *) self);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Get first network interface, return NULL if there are none
+
+const char *
+ziflist_first (ziflist_t *self)
+{
+    assert (self);
+    interface_t *iface = (interface_t *) zlistx_first ((zlistx_t *) self);
+    if (iface)
+        return iface->name;
+    else
+        return NULL;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Get next network interface, return NULL if we hit the last one
+
+const char *
+ziflist_next (ziflist_t *self)
+{
+    assert (self);
+    interface_t *iface = (interface_t *) zlistx_next ((zlistx_t *) self);
+    if (iface)
+        return iface->name;
+    else
+        return NULL;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return the current interface IP address as a printable string
+
+const char *
+ziflist_address (ziflist_t *self)
+{
+    assert (self);
+    interface_t *iface = (interface_t *) zlistx_item ((zlistx_t *) self);
+    if (iface)
+        return iface->address;
+    else
+        return NULL;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return the current interface broadcast address as a printable string
+
+const char *
+ziflist_broadcast (ziflist_t *self)
+{
+    assert (self);
+    interface_t *iface = (interface_t *) zlistx_item ((zlistx_t *) self);
+    if (iface)
+        return iface->broadcast;
+    else
+        return NULL;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return the current interface network mask as a printable string
+
+const char *
+ziflist_netmask (ziflist_t *self)
+{
+    assert (self);
+    interface_t *iface = (interface_t *) zlistx_item ((zlistx_t *) self);
+    if (iface)
+        return iface->netmask;
+    else
+        return NULL;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return true if the current interface uses IPv6
+
+bool
+ziflist_is_ipv6 (ziflist_t *self)
+{
+    assert (self);
+    interface_t *iface = (interface_t *) zlistx_item ((zlistx_t *) self);
+    return iface->is_ipv6;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Selftest for this class
+
+void
+ziflist_test (bool verbose)
+{
+    printf (" * ziflist: ");
+    if (verbose)
+        printf ("\n");
+
+    // TODO: for any Windows dev, any alternative to this?
+#if defined (__WINDOWS__)
+    WORD version_requested = MAKEWORD (2, 2);
+    WSADATA wsa_data;
+    int rc = WSAStartup (version_requested, &wsa_data);
+    assert (rc == 0);
+    assert (LOBYTE (wsa_data.wVersion) == 2 &&
+        HIBYTE (wsa_data.wVersion) == 2);
+#endif
+
+    //  @selftest
+    ziflist_t *iflist = ziflist_new ();
+    assert (iflist);
+
+    size_t items = ziflist_size (iflist);
+
+    if (verbose) {
+        printf ("ziflist: interfaces=%zu\n", ziflist_size (iflist));
+        const char *name = ziflist_first (iflist);
+        while (name) {
+            printf (" - name=%s address=%s netmask=%s broadcast=%s\n",
+                    name, ziflist_address (iflist), ziflist_netmask (iflist), ziflist_broadcast (iflist));
+            name = ziflist_next (iflist);
+        }
+    }
+    ziflist_reload (iflist);
+    assert (items == ziflist_size (iflist));
+    ziflist_destroy (&iflist);
+
+#if defined (__WINDOWS__)
+    zsys_shutdown();
+#endif
+    //  @end
+    
+    printf ("OK\n");
+}