cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/src/facts/windows/kernel_resolver.cc

@@ -0,0 +1,78 @@
+#include <internal/facts/windows/kernel_resolver.hpp>
+#include <leatherman/windows/system_error.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <facter/facts/os.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/optional.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/format.hpp>
+#include <boost/nowide/convert.hpp>
+
+using namespace std;
+using namespace leatherman::windows;
+
+namespace facter { namespace facts { namespace windows {
+
+    static boost::optional<string> get_release()
+    {
+        // GetVersionEx requires the manifest is correct, and is essentially deprecated.
+        // Another method of getting the OS version can be found at
+        // http://msdn.microsoft.com/en-us/library/windows/desktop/ms724429(v=vs.85).aspx
+        // and is what we use here.
+        auto fileName = L"Kernel32.dll";
+        auto fileVerSize = GetFileVersionInfoSizeW(fileName, nullptr);
+        if (fileVerSize == 0) {
+            return boost::none;
+        }
+
+        vector<wchar_t> buffer(fileVerSize);
+        if (!GetFileVersionInfoW(fileName, 0, fileVerSize, buffer.data())) {
+            return boost::none;
+        }
+
+        struct LANGANDCODEPAGE {
+            WORD wLanguage, wCodePage;
+        } *lpTranslate;
+        UINT cbTranslate;
+
+        if (!VerQueryValueW(buffer.data(), L"\\VarFileinfo\\Translation",
+            reinterpret_cast<LPVOID*>(&lpTranslate), &cbTranslate)) {
+            return boost::none;
+        }
+
+        // Use the 1st language found, as ProductVersion should be language-independent.
+        wstring subBlock = str(boost::wformat(L"\\StringFileInfo\\%04x%04x\\ProductVersion")
+            % lpTranslate->wLanguage % lpTranslate->wCodePage);
+
+        wchar_t *version;
+        UINT versionLen;
+        if (!VerQueryValueW(buffer.data(), subBlock.c_str(), reinterpret_cast<LPVOID*>(&version), &versionLen)) {
+            return boost::none;
+        }
+
+        // Strip the last (file version) token to get just the OS version.
+        wstring versionStrW(version, versionLen);
+        auto versionStr = boost::nowide::narrow(versionStrW);
+        boost::trim_right_if(versionStr, [](char c) { return c != '.'; });  // Remove everything after '.'
+        boost::trim_right_if(versionStr, [](char c) { return c == '.'; });  // Remove '.'
+
+        return versionStr;
+    }
+
+    kernel_resolver::data kernel_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        auto release = get_release();
+        if (release) {
+            result.release = move(*release);
+            result.version = result.release;
+        } else {
+            LOG_DEBUG("failed to retrieve kernel facts: {1}", leatherman::windows::system_error());
+        }
+
+        result.name = os::windows;
+        return result;
+    }
+
+}}}  // namespace facter::facts::windows

data/ext/facter/facter/lib/src/facts/windows/memory_resolver.cc

@@ -0,0 +1,25 @@
+#include <internal/facts/windows/memory_resolver.hpp>
+#include <leatherman/windows/system_error.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <psapi.h>
+
+using namespace leatherman::windows;
+
+namespace facter { namespace facts { namespace windows {
+
+    memory_resolver::data memory_resolver::collect_data(collection& facts)
+    {
+        PERFORMANCE_INFORMATION statex;
+        if (!GetPerformanceInfo(&statex, sizeof(statex))) {
+            LOG_DEBUG("resolving memory facts failed: {1}", system_error());
+            return {};
+        }
+
+        data result;
+        result.mem_total = statex.PhysicalTotal*statex.PageSize;
+        result.mem_free = statex.PhysicalAvailable*statex.PageSize;
+        return result;
+    }
+
+}}}  // namespace facter::facts::windows

data/ext/facter/facter/lib/src/facts/windows/networking_resolver.cc

@@ -0,0 +1,227 @@
+#include <internal/facts/windows/networking_resolver.hpp>
+#include <leatherman/windows/registry.hpp>
+#include <leatherman/windows/system_error.hpp>
+#include <internal/util/windows/wsa.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/range/combine.hpp>
+#include <boost/nowide/convert.hpp>
+#include <iomanip>
+#include <Ws2tcpip.h>
+#include <iphlpapi.h>
+
+#ifdef interface
+  // Something's bleeding in and making it impossible to instantiate an interface object.
+  #undef interface
+#endif
+
+using namespace std;
+using namespace facter::util;
+using namespace facter::util::windows;
+using namespace leatherman::windows;
+
+namespace facter { namespace facts { namespace windows {
+
+    networking_resolver::networking_resolver()
+    {
+    }
+
+    static string get_computername(COMPUTER_NAME_FORMAT nameFormat)
+    {
+        DWORD size = 0u;
+        GetComputerNameExW(nameFormat, nullptr, &size);
+        if (GetLastError() != ERROR_MORE_DATA) {
+            LOG_DEBUG("failure resolving hostname: {1}", leatherman::windows::system_error());
+            return "";
+        }
+
+        wstring buffer(size, '\0');
+        if (!GetComputerNameExW(nameFormat, &buffer[0], &size)) {
+            LOG_DEBUG("failure resolving hostname: {1}", leatherman::windows::system_error());
+            return "";
+        }
+
+        buffer.resize(size);
+        return boost::nowide::narrow(buffer);
+    }
+
+    sockaddr_in networking_resolver::create_ipv4_mask(uint8_t masklen)
+    {
+        sockaddr_in mask = {AF_INET};
+        if (ConvertLengthToIpv4Mask(masklen, &mask.sin_addr.S_un.S_addr) != NO_ERROR) {
+            LOG_DEBUG("failed creating IPv4 mask of length {1}", masklen);
+        }
+        return mask;
+    }
+
+    sockaddr_in6 networking_resolver::create_ipv6_mask(uint8_t masklen)
+    {
+        sockaddr_in6 mask = {AF_INET6};
+        const uint8_t incr = 32u;
+        for (size_t i = 0; i < 16 && masklen > 0; i += 4, masklen -= min(masklen, incr)) {
+            if (ConvertLengthToIpv4Mask(min(masklen, incr), reinterpret_cast<PULONG>(&mask.sin6_addr.u.Byte[i])) != NO_ERROR) {
+                LOG_DEBUG("failed creating IPv6 mask with component of length {1}", incr);
+                break;
+            }
+        }
+        return mask;
+    }
+
+    sockaddr_in networking_resolver::mask_ipv4_address(sockaddr const* addr, sockaddr_in const& mask)
+    {
+        sockaddr_in masked = *reinterpret_cast<sockaddr_in const*>(addr);
+        masked.sin_addr.S_un.S_addr &= mask.sin_addr.S_un.S_addr;
+        return masked;
+    }
+
+    sockaddr_in6 networking_resolver::mask_ipv6_address(sockaddr const* addr, sockaddr_in6 const& mask)
+    {
+        sockaddr_in6 masked = *reinterpret_cast<sockaddr_in6 const*>(addr);
+        for (size_t i = 0; i < 8; ++i) {
+            masked.sin6_addr.u.Word[i] &= mask.sin6_addr.u.Word[i];
+        }
+        return masked;
+    }
+
+    networking_resolver::data networking_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        result.hostname = get_computername(ComputerNameDnsHostname);
+
+        try {
+            result.domain = registry::get_registry_string(registry::HKEY::LOCAL_MACHINE,
+                "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\", "Domain");
+        } catch (registry_exception &e) {
+            LOG_DEBUG("failure getting networking::domain fact: {1}", e.what());
+        }
+
+        // Get linked list of adapters.
+        ULONG family = AF_UNSPEC;
+        ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
+
+        // Pre-allocate and try several times, because the adapter configuration may change between calls.
+        ULONG outBufLen = 15000;
+        vector<char> pAddresses(outBufLen);
+        DWORD err;
+        for (int i = 0; i < 3; ++i) {
+            err = GetAdaptersAddresses(family, flags, nullptr,
+                reinterpret_cast<PIP_ADAPTER_ADDRESSES>(pAddresses.data()), &outBufLen);
+            if (err == ERROR_SUCCESS) {
+                break;
+            } else if (err == ERROR_BUFFER_OVERFLOW) {
+                pAddresses.resize(outBufLen);
+            } else {
+                LOG_DEBUG("failure resolving networking facts: {1}", leatherman::windows::system_error(err));
+                return result;
+            }
+        }
+
+        if (err != ERROR_SUCCESS) {
+            LOG_DEBUG("failure resolving networking facts: {1}", leatherman::windows::system_error(err));
+            return result;
+        }
+
+        facter::util::windows::wsa winsock;
+
+        for (auto pCurAddr = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(pAddresses.data());
+            pCurAddr; pCurAddr = pCurAddr->Next) {
+            if (pCurAddr->OperStatus != IfOperStatusUp ||
+                (pCurAddr->IfType != IF_TYPE_ETHERNET_CSMACD && pCurAddr->IfType != IF_TYPE_IEEE80211)) {
+                continue;
+            }
+
+            if (result.domain.empty()) {
+                // If domain isn't set in the registry, fall back to the first DnsDomain encountered in the adapters.
+                result.domain = boost::nowide::narrow(pCurAddr->DnsSuffix);
+            }
+
+            interface net_interface;
+            net_interface.name = boost::nowide::narrow(pCurAddr->FriendlyName);
+
+            // Only supported on platforms after Windows Server 2003.
+            if (pCurAddr->Flags & IP_ADAPTER_DHCP_ENABLED && pCurAddr->Length >= sizeof(IP_ADAPTER_ADDRESSES_LH)) {
+                auto adapter = reinterpret_cast<IP_ADAPTER_ADDRESSES_LH&>(*pCurAddr);
+                if (adapter.Flags & IP_ADAPTER_DHCP_ENABLED) {
+                    try {
+                        net_interface.dhcp_server = winsock.saddress_to_string(adapter.Dhcpv4Server);
+                    } catch (wsa_exception &e) {
+                        LOG_DEBUG("failed to retrieve dhcp v4 server address for {1}: {2}", net_interface.name, e.what());
+                    }
+                }
+            }
+
+            for (auto it = pCurAddr->FirstUnicastAddress; it; it = it->Next) {
+                string addr;
+                try {
+                    addr = winsock.saddress_to_string(it->Address);
+                } catch (wsa_exception &e) {
+                    string iptype =
+                        (it->Address.lpSockaddr->sa_family == AF_INET) ? " v4"
+                        : (it->Address.lpSockaddr->sa_family == AF_INET6) ? " v6"
+                        : "";
+                    LOG_DEBUG("failed to retrieve ip{1} address for {2}: {3}",
+                        iptype, net_interface.name, e.what());
+                }
+
+                if (addr.empty()) {
+                    continue;
+                }
+
+                if (it->Address.lpSockaddr->sa_family == AF_INET || it->Address.lpSockaddr->sa_family == AF_INET6) {
+                    bool ipv6 = it->Address.lpSockaddr->sa_family == AF_INET6;
+
+                    binding b;
+                    b.address = addr;
+
+                    // Need to do lookup based on the structure length.
+                    auto adapterAddr = reinterpret_cast<IP_ADAPTER_UNICAST_ADDRESS_LH&>(*it);
+                    if (ipv6) {
+                        auto mask = create_ipv6_mask(adapterAddr.OnLinkPrefixLength);
+                        auto masked = mask_ipv6_address(it->Address.lpSockaddr, mask);
+                        b.netmask = winsock.address_to_string(mask);
+                        b.network = winsock.address_to_string(masked);
+                    } else {
+                        auto mask = create_ipv4_mask(adapterAddr.OnLinkPrefixLength);
+                        auto masked = mask_ipv4_address(it->Address.lpSockaddr, mask);
+                        b.netmask = winsock.address_to_string(mask);
+                        b.network = winsock.address_to_string(masked);
+                    }
+
+                    if (ipv6) {
+                        net_interface.ipv6_bindings.emplace_back(std::move(b));
+                    } else {
+                        net_interface.ipv4_bindings.emplace_back(std::move(b));
+                    }
+
+                    // http://support.microsoft.com/kb/894564 talks about how binding order is determined.
+                    // GetAdaptersAddresses returns adapters in binding order. This way, the domain and primary_interface match.
+                    // The old facter behavior didn't make a lot of sense (it would pick the last in binding order, not 1st).
+                    // Only accept this as a primary interface if it has a non-link-local address.
+                    if (result.primary_interface.empty() && (
+                        (it->Address.lpSockaddr->sa_family == AF_INET && !ignored_ipv4_address(addr)) ||
+                        (it->Address.lpSockaddr->sa_family == AF_INET6 && !ignored_ipv6_address(addr)))) {
+                        result.primary_interface = net_interface.name;
+                    }
+                }
+            }
+
+            stringstream macaddr;
+            for (DWORD i = 0u; i < pCurAddr->PhysicalAddressLength; ++i) {
+                macaddr << setfill('0') << setw(2) << hex << uppercase <<
+                    static_cast<int>(pCurAddr->PhysicalAddress[i]) << ':';
+            }
+            net_interface.macaddress = macaddr.str();
+            if (!net_interface.macaddress.empty()) {
+                net_interface.macaddress.pop_back();
+            }
+
+            net_interface.mtu = pCurAddr->Mtu;
+
+            result.interfaces.emplace_back(move(net_interface));
+        }
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::windows

data/ext/facter/facter/lib/src/facts/windows/operating_system_resolver.cc

@@ -0,0 +1,125 @@
+#include <internal/facts/windows/operating_system_resolver.hpp>
+#include <leatherman/windows/system_error.hpp>
+#include <leatherman/windows/wmi.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/os_family.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/util/regex.hpp>
+#include <intrin.h>
+#include <winnt.h>
+#include <Shlobj.h>
+#include <map>
+#include <boost/filesystem.hpp>
+
+using namespace std;
+using namespace leatherman::util;
+using namespace leatherman::windows;
+using namespace boost::filesystem;
+
+namespace facter { namespace facts { namespace windows {
+
+    static string get_hardware()
+    {
+        SYSTEM_INFO sysInfo;
+        GetNativeSystemInfo(&sysInfo);
+
+        switch (sysInfo.wProcessorArchitecture) {
+            case PROCESSOR_ARCHITECTURE_AMD64:
+                return "x86_64";
+            case PROCESSOR_ARCHITECTURE_ARM:
+                return "arm";
+            case PROCESSOR_ARCHITECTURE_IA64:
+                return "ia64";
+            case PROCESSOR_ARCHITECTURE_INTEL:
+                return "i" + to_string((sysInfo.wProcessorLevel > 5) ? 6 : sysInfo.wProcessorLevel) + "86";
+            default:
+                return "unknown";
+        }
+    }
+
+    static string get_architecture(string const& hardware)
+    {
+        // Use "x86" for 32-bit systems
+        if (re_search(hardware, boost::regex("i[3456]86"))) {
+            return "x86";
+        } else if (hardware == "x86_64") {
+            return "x64";
+        }
+        return hardware;
+    }
+
+    static string get_system32()
+    {
+        // When facter is a 32-bit process running on 64-bit windows (such as in a 32-bit puppet installation that
+        // includes native facter), system32 points to 32-bit executables; Windows invisibly redirects it. It also
+        // provides a link at %SYSTEMROOT%\sysnative for the 64-bit versions. Return the system path where OS-native
+        // executables can be found.
+        TCHAR szPath[MAX_PATH];
+        if (!SUCCEEDED(SHGetFolderPath(NULL, CSIDL_WINDOWS, NULL, 0, szPath))) {
+            LOG_DEBUG("error finding SYSTEMROOT: {1}", leatherman::windows::system_error());
+        }
+
+        auto pathNative = path(szPath) / "sysnative";
+        boost::system::error_code ec;
+        if (is_directory(pathNative, ec)) {
+            return pathNative.string();
+        }
+
+        LOG_TRACE("sysnative path does not exist");
+        auto path32 = path(szPath) / "system32";
+        return path32.string();
+    }
+
+    operating_system_resolver::operating_system_resolver(shared_ptr<wmi> wmi_conn) :
+        resolvers::operating_system_resolver(),
+        _wmi(move(wmi_conn))
+    {
+    }
+
+    operating_system_resolver::data operating_system_resolver::collect_data(collection& facts)
+    {
+        // Default to the base implementation
+        data result = resolvers::operating_system_resolver::collect_data(facts);
+
+        result.family = os_family::windows;
+        result.hardware = get_hardware();
+        result.architecture = get_architecture(result.hardware);
+        result.win.system32 = get_system32();
+
+        auto lastDot = result.release.rfind('.');
+        if (lastDot == string::npos) {
+            return result;
+        }
+
+        auto vals = _wmi->query(wmi::operatingsystem, {wmi::producttype, wmi::othertypedescription});
+        if (vals.empty()) {
+            return result;
+        }
+
+        // Override default release with Windows release names
+        auto version = result.release.substr(0, lastDot);
+        bool consumerrel = (wmi::get(vals, wmi::producttype) == "1");
+        if (version == "10.0") {
+            result.release = consumerrel ? "10" : "2016";
+        } else if (version == "6.3") {
+            result.release = consumerrel ? "8.1" : "2012 R2";
+        } else if (version == "6.2") {
+            result.release = consumerrel ? "8" : "2012";
+        } else if (version == "6.1") {
+            result.release = consumerrel ? "7" : "2008 R2";
+        } else if (version == "6.0") {
+            result.release = consumerrel ? "Vista" : "2008";
+        } else if (version == "5.2") {
+            if (consumerrel) {
+                result.release = "XP";
+            } else {
+                result.release = (wmi::get(vals, wmi::othertypedescription) == "R2") ? "2003 R2" : "2003";
+            }
+        }
+        result.major = result.release;
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::windows