[Refactor] use cb::net::getIpAddresses()

Moved the implementation to cb::net and allow for getting
the loopback addresses so that it may be used from
other test programs

Change-Id: If184bfbb47d9a73be02d0042419546c25e605191
Reviewed-on: http://review.couchbase.org/c/kv_engine/+/141230
Tested-by: Build Bot <[email protected]>
Reviewed-by: Dave Rigby <[email protected]>

Author: trondn

cluster_framework/bucket.cc

@@ -79,7 +79,7 @@ Bucket::Bucket(const Cluster& cluster,
 
     };
 
-    auto [ipv4, ipv6] = cb::test::Cluster::getIpAddresses();
+    auto [ipv4, ipv6] = cb::net::getIpAddresses(true);
     (void)ipv6; // currently not used
     const auto& hostname = ipv4.front();
     cluster.iterateNodes([this, &hostname](const cb::test::Node& node) {

cluster_framework/cluster.cc

@@ -19,21 +19,9 @@
 #include "bucket.h"
 #include "node.h"
 
-#ifdef WIN32
-#include <winsock2.h>
-
-#include <iphlpapi.h>
-#pragma comment(lib, "IPHLPAPI.lib")
-#else
-#include <arpa/inet.h>
-#include <ifaddrs.h>
-#include <netinet/in.h>
-#endif
-
 #include <platform/dirutils.h>
 #include <platform/uuid.h>
 #include <protocol/connection/client_mcbp_commands.h>
-#include <array>
 #include <iostream>
 #include <string>
 #include <system_error>
@@ -55,7 +43,7 @@ class ClusterImpl : public Cluster {
         manifest = {{"rev", 0},
                     {"clusterCapabilities", nlohmann::json::object()},
                     {"clusterCapabilitiesVer", {1, 0}}};
-        auto [ipv4, ipv6] = cb::test::Cluster::getIpAddresses();
+        auto [ipv4, ipv6] = cb::net::getIpAddresses(true);
         (void)ipv6; // currently not used
         const auto& hostname = ipv4.front();
         for (const auto& n : nodes) {
@@ -409,104 +397,4 @@ nlohmann::json Cluster::getUninitializedJson() {
     return ret;
 }
 
-std::pair<std::vector<std::string>, std::vector<std::string>>
-Cluster::getIpAddresses() {
-    std::array<char, 1024> buffer;
-    std::pair<std::vector<std::string>, std::vector<std::string>> ret;
-
-#ifdef WIN32
-    std::vector<char> blob(1024 * 1024);
-    auto* addresses = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(blob.data());
-    ULONG dataSize = blob.size();
-    auto rw = GetAdaptersAddresses(
-            AF_UNSPEC,
-            GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
-                    GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME,
-            nullptr,
-            addresses,
-            &dataSize);
-    if (rw != ERROR_SUCCESS) {
-        throw std::system_error(
-                rw, std::system_category(), "GetAdaptersAddresses()");
-    }
-    for (auto* iff = addresses; iff != nullptr; iff = iff->Next) {
-        for (auto* addr = iff->FirstUnicastAddress; addr != nullptr;
-             addr = addr->Next) {
-            auto family = addr->Address.lpSockaddr->sa_family;
-            if (family == AF_INET) {
-                inet_ntop(AF_INET,
-                          &reinterpret_cast<sockaddr_in*>(
-                                   addr->Address.lpSockaddr)
-                                   ->sin_addr,
-                          buffer.data(),
-                          buffer.size());
-                std::string address(buffer.data());
-                if (address != "127.0.0.1") {
-                    // Ignore localhost address
-                    ret.first.emplace_back(std::move(address));
-                }
-            } else if (family == AF_INET6) {
-                inet_ntop(AF_INET6,
-                          &reinterpret_cast<sockaddr_in6*>(
-                                   addr->Address.lpSockaddr)
-                                   ->sin6_addr,
-                          buffer.data(),
-                          buffer.size());
-                std::string address(buffer.data());
-                if (address != "::1") {
-                    // Ignore localhost address
-                    ret.second.emplace_back(std::move(address));
-                }
-            } else {
-                // Skip all other types of addresses
-                continue;
-            }
-        }
-    }
-#else
-    ifaddrs* interfaces;
-    if (getifaddrs(&interfaces) != 0) {
-        throw std::system_error(errno, std::system_category(), "getifaddrs()");
-    }
-
-    if (interfaces == nullptr) {
-        return {};
-    }
-
-    // Iterate over all the interfaces and pick out the IPv4 and IPv6 addresses
-    for (auto* ifa = interfaces; ifa != nullptr; ifa = ifa->ifa_next) {
-        if (!ifa->ifa_addr) {
-            continue;
-        }
-
-        if (ifa->ifa_addr->sa_family == AF_INET) {
-            inet_ntop(AF_INET,
-                      &reinterpret_cast<sockaddr_in*>(ifa->ifa_addr)->sin_addr,
-                      buffer.data(),
-                      buffer.size());
-            std::string address(buffer.data());
-            if (address != "127.0.0.1") {
-                // Ignore localhost address
-                ret.first.emplace_back(std::move(address));
-            }
-        } else if (ifa->ifa_addr->sa_family == AF_INET6) {
-            inet_ntop(
-                    AF_INET6,
-                    &reinterpret_cast<sockaddr_in6*>(ifa->ifa_addr)->sin6_addr,
-                    buffer.data(),
-                    buffer.size());
-            std::string address(buffer.data());
-            if (address != "::1") {
-                // Ignore localhost address
-                ret.second.emplace_back(std::move(address));
-            }
-        }
-    }
-
-    freeifaddrs(interfaces);
-#endif
-
-    return ret;
-}
-
 } // namespace cb::test

cluster_framework/cluster.h

@@ -122,17 +122,6 @@ class Cluster {
     static std::unique_ptr<Cluster> create(
             size_t nodes, std::optional<std::string> directory = {});
 
-    /**
-     * Get all IPv4 and IPv6 addresses configured on this machine (skipping
-     * loopback interface such as 127.0.0.1 and ::1)
-     *
-     * @return the first vector contains IPv4 addresses, the second Iv6
-     * addresses
-     * @throws std::system_error if we fail to get the interface description
-     */
-    static std::pair<std::vector<std::string>, std::vector<std::string>>
-    getIpAddresses();
-
     /// Get a JSON representation for the cluster before the
     /// cluster is initialized
     static nlohmann::json getUninitializedJson();