cfacter 3.11.0.rc.20180314

data/ext/facter/leatherman/windows/inc/leatherman/windows/file_util.hpp

@@ -0,0 +1,23 @@
+/**
+ * @file
+ * Declares utility functions for working with files in Windows
+ */
+#pragma once
+
+#include <string>
+#include <stdexcept>
+
+namespace leatherman { namespace windows { namespace file_util {
+
+    struct unknown_folder_exception : public std::runtime_error {
+        explicit unknown_folder_exception(const std::string& msg) : std::runtime_error(msg) {}
+    };
+
+    /**
+     * Finds the ProgramData directory in a Windows-friendly way.
+     * @return The ProgramData directory, using the Windows function
+     * Throws unknown_folder_exception if SHGetKnownFolderPath fails.
+     */
+    std::string get_programdata_dir();
+
+}}}  // namespace leatherman::windows::file_util

data/ext/facter/leatherman/windows/inc/leatherman/windows/process.hpp

@@ -0,0 +1,22 @@
+/**
+ * @file
+ * Declares utility functions for querying process properties
+ */
+#pragma once
+
+namespace leatherman { namespace windows { namespace process {
+
+    /**
+     * Returns whether or not the OS has the ability to set elevated token information.
+     * @return True on Windows Vista or later, otherwise false.
+     */
+    bool supports_elevated_security();
+
+    /**
+     * Returns whether or not the owner of the current process is running with elevated security privileges.
+     * Only supported on Windows Vista or later.
+     * @return True if elevated, otherwise false.
+     */
+    bool has_elevated_security();
+
+}}}  // namespace leatherman::windows::process

data/ext/facter/leatherman/windows/inc/leatherman/windows/registry.hpp

@@ -0,0 +1,56 @@
+/**
+ * @file
+ * Declares utility functions for interacting with the Windows registry.
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+#include <stdexcept>
+
+namespace leatherman { namespace windows {
+
+    /**
+     * Exception thrown when registry lookupfails.
+     */
+    struct registry_exception : std::runtime_error
+    {
+        /**
+         * Constructs a registry_exception.
+         * @param message The exception message.
+         */
+        explicit registry_exception(std::string const& message);
+    };
+
+    namespace registry {
+        /**
+         * HKEY Classes, derived from
+         * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724868(v=vs.85).aspxs
+         */
+        enum class HKEY {
+            CLASSES_ROOT, CURRENT_CONFIG, CURRENT_USER, LOCAL_MACHINE,
+            PERFORMANCE_DATA, PERFORMANCE_NLSTEXT, PERFORMANCE_TEXT, USERS
+        };
+
+        /**
+         * Retrieve a string value from the registry.
+         * @param hkey The registry key handle.
+         * @param subkey The name of the registry key.
+         * @param value The name of the registry value.
+         * @return A string value corresponding to a REG_SZ or REG_EXPAND_SZ type.
+         *         Returns an empty string if the value doesn't exist or isn't a string type.
+         */
+        std::string get_registry_string(HKEY hkey, std::string const& subkey, std::string const& value);
+
+        /**
+         * Retrieve a vector of string values from the registry.
+         * @param hkey The registry key handle.
+         * @param subkey The name of the registry key.
+         * @param value The name of the registry value.
+         * @return An array of string values corresponding to the REG_MULTI_SZ type.
+         *         Returns an empty vector if the value doesn't exist or isn't a composite string type.
+         */
+        std::vector<std::string> get_registry_strings(HKEY hkey, std::string const& subkey, std::string const& value);
+    }
+
+}}  // namespace leatherman::windows

data/ext/facter/leatherman/windows/inc/leatherman/windows/system_error.hpp

@@ -0,0 +1,23 @@
+/**
+ * @file
+ * Declares utility functions for getting Windows error messages.
+ */
+#pragma once
+
+#include <string>
+
+namespace leatherman { namespace windows {
+    /**
+     * This is a wrapper for printing error messages on Windows.
+     * @param err The Windows error code.
+     * @return A formatted string "<error_message> (<error_code>)".
+     */
+    std::string system_error(unsigned long err);
+
+    /**
+     * This is a wrapper for printing error messages on Windows.
+     * It calls system_error with GetLastError as the argument.
+     * @return A formatted string "<error_message> (<error_code>)".
+     */
+    std::string system_error();
+}}  // namespace leatherman::windows

data/ext/facter/leatherman/windows/inc/leatherman/windows/user.hpp

@@ -0,0 +1,30 @@
+/**
+ * @file
+ * Declares utility functions for querying user properties
+ */
+#pragma once
+
+#include <string>
+
+namespace leatherman { namespace windows { namespace user {
+
+    /**
+     * Determines whether the current process has Administrator privileges and can be expected to succeed at
+     * tasks restricted to Administrators.
+     * @return True if the current process has Administrator privileges, otherwise false.
+     */
+    bool is_admin();
+
+    /**
+     * Query token membership to determine whether the current user is a member of the Administrators group.
+     * @return True if user is an Administrator, otherwise false.
+     */
+    bool check_token_membership();
+
+    /**
+     * Finds the user's home directory in a Ruby-compatible way.
+     * @return The home directory, trying %HOME% > %HOMEDRIVE%%HOMEPATH% > %USERPROFILE%
+     */
+    std::string home_dir();
+
+}}}  // namespace leatherman::windows::user

data/ext/facter/leatherman/windows/inc/leatherman/windows/windows.hpp

@@ -0,0 +1,10 @@
+/**
+ * @file
+ * Utility header for including Windows API headers.
+ */
+#pragma once
+
+// Windows has several header files with fixed dependency ordering. Include interdependent headers here,
+// and anywhere we need include this header.
+#include <winsock2.h>
+#include <windows.h>

data/ext/facter/leatherman/windows/inc/leatherman/windows/wmi.hpp

@@ -0,0 +1,188 @@
+/**
+ * @file
+ * Declares utility functions for interacting with Windows Management Instrumentation.
+ */
+#pragma once
+
+#include <leatherman/util/scoped_resource.hpp>
+#include <leatherman/util/strings.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <string>
+#include <map>
+#include <vector>
+
+// Forward declarations
+class IWbemLocator;
+class IWbemServices;
+
+namespace leatherman { namespace windows {
+
+    /**
+     * Exception thrown when wmi initialization fails.
+     */
+    struct wmi_exception : std::runtime_error
+    {
+        /**
+         * Constructs a wmi_exception.
+         * @param message The exception message.
+         */
+        explicit wmi_exception(std::string const& message);
+    };
+
+    /**
+     * A class for initiating a WMI connection over COM and querying it.
+     */
+    struct wmi {
+        /**
+         * Identifier for the WMI class Win32_ComputerSystem
+         */
+        constexpr static char const* computersystem = "Win32_ComputerSystem";
+
+        /**
+         * Identifier for the WMI class Win32_ComputerSystemProduct
+         */
+        constexpr static char const* computersystemproduct = "Win32_ComputerSystemProduct";
+
+        /**
+         * Identifier for the WMI class Win32_OperatingSystem
+         */
+        constexpr static char const* operatingsystem = "Win32_OperatingSystem";
+
+        /**
+         * Identifier for the WMI class Win32_BIOS
+         */
+        constexpr static char const* bios = "Win32_Bios";
+
+        /**
+         * Identifier for the WMI class Win32_Processor
+         */
+        constexpr static char const* processor = "Win32_Processor";
+
+        /**
+         * Identifier for the WMI property Architecture
+         */
+        constexpr static char const* architecture = "Architecture";
+
+        /**
+         * Identifier for the WMI property Name
+         */
+        constexpr static char const* name = "Name";
+
+        /**
+         * Identifier for the WMI property Manufacturer
+         */
+        constexpr static char const* manufacturer = "Manufacturer";
+
+        /**
+         * Identifier for the WMI property Model
+         */
+        constexpr static char const* model = "Model";
+
+        /**
+         * Identifier for the WMI property SerialNumber
+         */
+        constexpr static char const* serialnumber = "SerialNumber";
+
+        /**
+         * Identifier for the WMI property NumberOfLogicalProcessors
+         */
+        constexpr static char const* numberoflogicalprocessors = "NumberOfLogicalProcessors";
+
+        /**
+         * Identifier for the WMI property LastBootUpTime
+         */
+        constexpr static char const* lastbootuptime = "LastBootUpTime";
+
+        /**
+         * Identifier for the WMI property LocalDateTime
+         */
+        constexpr static char const* localdatetime = "LocalDateTime";
+
+        /**
+         * Identifier for the WMI property ProductType
+         */
+        constexpr static char const* producttype = "ProductType";
+
+        /**
+         * Identifier for the WMI property OtherTypeDescription
+         */
+        constexpr static char const* othertypedescription = "OtherTypeDescription";
+
+        /**
+         * Multi-map with case-insensitive lookup.
+         */
+        using imap = std::multimap<std::string, std::string, util::ciless>;
+
+        /**
+         * Vector of case-insensitive multi-maps.
+         */
+        using imaps = std::vector<imap>;
+
+        /**
+         * Range of values for an array type.
+         */
+        using kv_range = boost::iterator_range<imap::const_iterator>;
+
+        /**
+         * Initializes a COM connection for WMI queries. Throws a wmi_exception on failure.
+         */
+        wmi();
+
+        /**
+         * This is a utility for querying WMI classes. Windows queries are case-insensitive,
+         * so the returned keys aren't guaranteed to have the same case as the arguments.
+         * Returns a vector of case-insensitive maps so the argument keys can safely be used for lookup.
+         * Some groups can return multiple objects; in that case the returned vector will
+         * have a multi-map for each object. If a property returns an array, it will have
+         * multiple entries in the multimap.
+         * @param group The class alias to query
+         * @param keys A list of keys to query from the specified class
+         * @param extra Extra arguments to the WMI query, such as filters
+         * @return A vector of case-insensitive maps of the keys argument and their corresponding values
+         */
+        imaps query(std::string const& group, std::vector<std::string> const& keys, std::string const& extra = "") const;
+
+        /**
+         * A utility for retrieving a single entry from an imap. It should only be used if
+         * it's known that the requested property is not an array.
+         * To retrieve an array, use imap's equal_range.
+         * @param kvmap A case-insensitive multimap of keys and their values.
+         * @param key The key to lookup.
+         * @return Return the value matching the specified key.
+         */
+        static std::string const& get(imap const& kvmap, std::string const& key);
+
+        /**
+         * A utility for retrieving an array entry from an imap. If only one value exists
+         * it returns a range of one element.
+         * @param kvmap A case-insensitive multimap of keys and their values.
+         * @param key The key to lookup.
+         * @return An iterator range of key-value pairs matching the specified key.
+         */
+        static kv_range get_range(imap const& kvmap, std::string const& key);
+
+        /**
+         * A utility for retrieving a single entry from an imaps. It should only be used if
+         * it's known that the requested group will only return a single object.
+         * @param kvmaps A vector of case-insensitive multimap of keys and their values.
+         * @param key The key to lookup.
+         * @return Return the value matching the specified key.
+         */
+        static std::string const& get(imaps const& kvmaps, std::string const& key);
+
+        /**
+         * A utility for retrieving an array entry from an imaps. It should only be used if
+         * it's known that the requested group will only return a single object.
+         * @param kvmaps A vector of case-insensitive multimap of keys and their values.
+         * @param key The key to lookup.
+         * @return An iterator range of key-value pairs matching the specified key.
+         */
+        static kv_range get_range(imaps const& kvmaps, std::string const& key);
+
+     private:
+        util::scoped_resource<bool> _coInit;
+        util::scoped_resource<IWbemLocator *> _pLoc;
+        util::scoped_resource<IWbemServices *> _pSvc;
+    };
+
+}}  // namespace leatherman::windows

data/ext/facter/leatherman/windows/src/file_util.cc

@@ -0,0 +1,28 @@
+#include <leatherman/windows/file_util.hpp>
+#include <leatherman/windows/system_error.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <boost/filesystem.hpp>
+
+#include <shlobj.h>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+using namespace boost::filesystem;
+
+namespace leatherman { namespace windows { namespace file_util {
+
+    string get_programdata_dir() {
+        PWSTR pdir;
+        if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_ProgramData, 0, nullptr, &pdir))) {
+            auto p = path(pdir);
+            return p.string();
+        }
+        throw unknown_folder_exception(_("error finding FOLDERID_ProgramData: {1}",
+                    leatherman::windows::system_error()));
+    }
+
+}}}  // namespace leatherman::windows::file_util
+

data/ext/facter/leatherman/windows/src/process.cc

@@ -0,0 +1,42 @@
+#include <leatherman/windows/system_error.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <leatherman/util/scoped_resource.hpp>
+#include <leatherman/logging/logging.hpp>
+
+using namespace std;
+
+namespace leatherman { namespace windows { namespace process {
+
+    bool supports_elevated_security()
+    {
+        // In the future this can use IsWindowsVistaOrGreater, but as of the initial work versionhelpers.h is only in
+        // the master branch of MinGW-w64.
+        OSVERSIONINFOEXW vi = {sizeof(vi), HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA), 0, 0, {0}, 0};
+
+        return VerifyVersionInfoW(&vi, VER_MAJORVERSION|VER_MINORVERSION|VER_SERVICEPACKMAJOR,
+            VerSetConditionMask(VerSetConditionMask(VerSetConditionMask(0,
+                VER_MAJORVERSION, VER_GREATER_EQUAL),
+                VER_MINORVERSION, VER_GREATER_EQUAL),
+                VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL));
+    }
+
+    bool has_elevated_security()
+    {
+        HANDLE temp_token = INVALID_HANDLE_VALUE;
+        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &temp_token)) {
+            LOG_DEBUG("OpenProcessToken call failed: {1}", system_error());
+            return false;
+        }
+        util::scoped_resource<HANDLE> token(temp_token, CloseHandle);
+
+        TOKEN_ELEVATION token_elevation;
+        DWORD token_elevation_length;
+        if (!GetTokenInformation(token, TokenElevation, &token_elevation, sizeof(TOKEN_ELEVATION), &token_elevation_length)) {
+            LOG_DEBUG("GetTokenInformation call failed: {1}", system_error());
+            return false;
+        }
+
+        return token_elevation.TokenIsElevated;
+    }
+
+}}}  // namespace leatherman::windows::process

data/ext/facter/leatherman/windows/src/registry.cc

@@ -0,0 +1,96 @@
+#include <leatherman/windows/registry.hpp>
+#include <leatherman/windows/system_error.hpp>
+#include <leatherman/windows/windows.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/nowide/convert.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace leatherman { namespace windows {
+
+    registry_exception::registry_exception(string const& message) :
+        runtime_error(message)
+    {
+    }
+
+    static HKEY get_hkey(registry::HKEY hkey)
+    {
+        switch (hkey) {
+            case registry::HKEY::CLASSES_ROOT:        return HKEY_CLASSES_ROOT;
+            case registry::HKEY::CURRENT_CONFIG:      return HKEY_CURRENT_CONFIG;
+            case registry::HKEY::CURRENT_USER:        return HKEY_CURRENT_USER;
+            case registry::HKEY::LOCAL_MACHINE:       return HKEY_LOCAL_MACHINE;
+            case registry::HKEY::PERFORMANCE_DATA:    return HKEY_PERFORMANCE_DATA;
+            case registry::HKEY::PERFORMANCE_NLSTEXT: return HKEY_PERFORMANCE_NLSTEXT;
+            case registry::HKEY::PERFORMANCE_TEXT:    return HKEY_PERFORMANCE_TEXT;
+            case registry::HKEY::USERS:               return HKEY_USERS;
+            default:
+                throw registry_exception(_("invalid HKEY specified"));
+        }
+    }
+
+    // Returns the registry value as a wstring buffer. It's up to the caller to interpret it.
+    // This only really works for RRF_RT_REG_EXPAND_SZ, RRF_RT_REG_MULTI_SZ, and RRF_RT_REG_SZ.
+    static wstring get_regvalue(registry::HKEY hkey, string const& lpSubKey, string const& lpValue, DWORD flags)
+    {
+        auto hk = get_hkey(hkey);
+        auto lpSubKeyW = boost::nowide::widen(lpSubKey);
+        auto lpValueW = boost::nowide::widen(lpValue);
+
+        DWORD size = 0u;
+        auto err = RegGetValueW(hk, lpSubKeyW.c_str(), lpValueW.c_str(), flags, nullptr, nullptr, &size);
+        if (err != ERROR_SUCCESS) {
+            throw registry_exception(_("error reading registry key {1} {2}: {3}",
+                lpSubKey, lpValue, windows::system_error(err)));
+        }
+
+        // Size is the number of bytes needed.
+        wstring buffer((size*sizeof(char))/sizeof(wchar_t), '\0');
+        err = RegGetValueW(hk, lpSubKeyW.c_str(), lpValueW.c_str(), flags, nullptr, &buffer[0], &size);
+        if (err != ERROR_SUCCESS) {
+            throw registry_exception(_("error reading registry key {1} {2}: {3}",
+                lpSubKey, lpValue, windows::system_error(err)));
+        }
+
+        // Size now represents bytes copied (which can be less than we allocated). Resize, and also remove the
+        // extraneous null-terminator from RegGetValueW (wstring handles termination internally).
+        auto numwchars = (size*sizeof(char))/sizeof(wchar_t);
+        buffer.resize(numwchars > 0u ? numwchars - 1u : 0u);
+
+        return buffer;
+    }
+
+    string registry::get_registry_string(registry::HKEY hkey, string const& subkey, string const& value)
+    {
+        // From http://msdn.microsoft.com/en-us/library/windows/desktop/ms724868(v=vs.85).aspx
+        // "RRF_RT_REG_SZV automatically converts REG_EXPAND_SZ to REG_SZ unless RRF_NOEXPAND is specified."
+        // This seems like the desired behavior most of the time.
+        return boost::nowide::narrow(get_regvalue(hkey, subkey, value, RRF_RT_REG_SZ));
+    }
+
+    vector<string> registry::get_registry_strings(registry::HKEY hkey, string const& subkey, string const& value)
+    {
+        auto buffer = get_regvalue(hkey, subkey, value, RRF_RT_REG_MULTI_SZ);
+
+        vector<string> strings;
+
+        wstring accum;
+        for (auto c : buffer) {
+            if (c == L'\0') {
+                string val = boost::trim_copy(boost::nowide::narrow(accum));
+                if (!val.empty()) {
+                    strings.emplace_back(move(val));
+                }
+                accum.clear();
+            } else {
+                accum += c;
+            }
+        }
+        return strings;
+    }
+
+}}  // namespace leatherman::windows