facter 2.5.7-x64-mingw32 → 3.9.6.cfacter.20180412-x64-mingw32

data/lib/facter/util/vlans.rb

@@ -1,21 +0,0 @@
-# A module to gather vlan facts
-#
-module Facter::Util::Vlans
-  def self.get_vlan_config
-    if File.exist?('/proc/net/vlan/config') and File.readable?('/proc/net/vlan/config')
-      File.read('/proc/net/vlan/config')
-    end
-  end
-
-  def self.get_vlans
-    if (config = self.get_vlan_config)
-      vlans = []
-      config.each_line do |line|
-        if (match = line.match(/^([0-9A-Za-z]+)\.([0-9]+) /))
-          vlans << match[2] if match[2]
-        end
-      end
-      vlans.join(',') unless vlans.empty?
-    end
-  end
-end

data/lib/facter/util/windows.rb

@@ -1,10 +0,0 @@
-module Facter::Util::Windows
-  module Process; end
-
-  if Facter::Util::Config.is_windows?
-    require 'facter/util/windows/api_types'
-    require 'facter/util/windows/error'
-    require 'facter/util/windows/user'
-    require 'facter/util/windows/process'
-  end
-end

data/lib/facter/util/windows/api_types.rb

@@ -1,135 +0,0 @@
-require 'ffi'
-
-module Facter::Util::Windows::ApiTypes
-  class ::Facter::Util::Windows::FFI
-    # standard Win32 error codes
-    WIN32_FALSE = 0
-    ERROR_SUCCESS = 0
-
-    NULL_HANDLE = 0
-
-    def self.read_win32_bool(ffi_pointer)
-      # BOOL is always a 32-bit integer in Win32
-      # some Win32 APIs return 1 for true, while others are non-0
-      ffi_pointer.read_int32 != WIN32_FALSE
-    end
-
-    def self.read_dword(ffi_pointer)
-      ffi_pointer.read_uint32
-    end
-
-    def self.read_handle(ffi_pointer)
-      ffi_pointer.type_size == 4 ? ffi_pointer.read_uint32 : ffi_pointer.read_uint64
-    end
-
-    def self.read_wide_string(ffi_pointer, char_length, dst_encoding = Encoding::UTF_8)
-      # char_length is number of wide chars (typically excluding NULLs), *not* bytes
-      str = ffi_pointer.get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
-      str.encode(dst_encoding)
-    end
-
-    # @param max_char_length [Integer] Maximum number of wide chars to return (typically excluding NULLs), *not* bytes
-    # @param null_terminator [Symbol] Number of number of null wchar characters, *not* bytes, that determine the end of the string
-    #   null_terminator = :single_null, then the terminating sequence is two bytes of zero.   This is UNIT16 = 0
-    #   null_terminator = :double_null, then the terminating sequence is four bytes of zero.  This is UNIT32 = 0
-    def self.read_arbitrary_wide_string_up_to(ffi_pointer, max_char_length = 512, null_terminator = :single_null)
-      if null_terminator != :single_null && null_terminator != :double_null
-        raise _("Unable to read wide strings with %{null_terminator} terminal nulls") % { null_terminator: null_terminator }
-      end
-
-      terminator_width = null_terminator == :single_null ? 1 : 2
-      reader_method = null_terminator == :single_null ? :get_uint16 : :get_uint32
-
-      # Look for a null terminating characters; if found, read up to that null (exclusive)
-      (0...max_char_length - terminator_width).each do |i|
-        return read_wide_string(ffi_pointer, i) if ffi_pointer.send(reader_method, (i * 2)) == 0
-      end
-
-      # String is longer than the max; read just to the max
-      read_wide_string(ffi_pointer, max_char_length)
-    end
-
-    def self.read_win32_local_pointer(ffi_pointer, &block)
-      ptr = nil
-      begin
-        ptr = ffi_pointer.read_pointer
-        yield ptr
-      ensure
-        if ptr && ! ptr.null?
-          if WIN32.LocalFree(ptr.address) != NULL_HANDLE
-            Puppet.debug "LocalFree memory leak"
-          end
-        end
-      end
-
-      # ptr has already had LocalFree called, so nothing to return
-      nil
-    end
-  end
-  # FFI Types
-  # https://github.com/ffi/ffi/wiki/Types
-
-  # Windows - Common Data Types
-  # https://msdn.microsoft.com/en-us/library/cc230309.aspx
-
-  # Windows Data Types
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
-
-  FFI.typedef :uint32, :dword
-  FFI.typedef :uintptr_t, :handle
-
-  # buffer_inout is similar to pointer (platform specific), but optimized for buffers
-  FFI.typedef :buffer_inout, :lpwstr
-
-  # pointer in FFI is platform specific
-  # NOTE: for API calls with reserved lpvoid parameters, pass a FFI::Pointer::NULL
-  FFI.typedef :pointer, :lpcvoid
-  FFI.typedef :pointer, :lpvoid
-  FFI.typedef :pointer, :lpdword
-  FFI.typedef :pointer, :pdword
-  FFI.typedef :pointer, :phandle
-  FFI.typedef :pointer, :pbool
-
-  # any time LONG / ULONG is in a win32 API definition DO NOT USE platform specific width
-  # which is what FFI uses by default
-  # instead create new aliases for these very special cases
-  # NOTE: not a good idea to redefine FFI :ulong since other typedefs may rely on it
-  FFI.typedef :uint32, :win32_ulong
-  FFI.typedef :int32, :win32_long
-  # FFI bool can be only 1 byte at times,
-  # Win32 BOOL is a signed int, and is always 4 bytes, even on x64
-  # https://blogs.msdn.com/b/oldnewthing/archive/2011/03/28/10146459.aspx
-  FFI.typedef :int32, :win32_bool
-
-  # Same as a LONG, a 32-bit signed integer
-  FFI.typedef :int32, :hresult
-
-  # NOTE: FFI already defines (u)short as a 16-bit (un)signed like this:
-  # FFI.typedef :uint16, :ushort
-  # FFI.typedef :int16, :short
-
-  # 8 bits per byte
-  FFI.typedef :uchar, :byte
-  FFI.typedef :uint16, :wchar
-
-  module ::Facter::Util::Windows::FFI::WIN32
-    extend ::FFI::Library
-
-    ffi_convention :stdcall
-
-    private
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa366730(v=vs.85).aspx
-    # HLOCAL WINAPI LocalFree(
-    #   _In_  HLOCAL hMem
-    # );
-    ffi_lib :kernel32
-    attach_function :LocalFree, [:handle], :handle
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724211(v=vs.85).aspx
-    # BOOL WINAPI CloseHandle(
-    #   _In_  HANDLE hObject
-    # );
-    ffi_lib :kernel32
-    attach_function :CloseHandle, [:handle], :win32_bool
-  end
-end

data/lib/facter/util/windows/dir.rb

@@ -1,43 +0,0 @@
-require 'facter/util/windows'
-require 'ffi'
-
-module Facter::Util::Windows::Dir
-  extend FFI::Library
-
-  COMMON_APPDATA = 0x0023
-  S_OK           = 0x0
-  MAX_PATH       = 260;
-
-  def get_common_appdata
-    common_appdata = ''
-
-    # this pointer actually points to a :lpwstr (pointer) since we're letting Windows allocate for us
-    FFI::MemoryPointer.new(:pointer, ((MAX_PATH + 1) * 2)) do |buffer_ptr|
-      # hwndOwner, nFolder, hToken, dwFlags, pszPath
-      if SHGetFolderPathW(0, COMMON_APPDATA, 0, 0, buffer_ptr) != S_OK
-        raise Facter::Util::Windows::Error.new("Could not find COMMON_APPDATA path")
-      end
-
-      common_appdata = Facter::Util::Windows::FFI.read_arbitrary_wide_string_up_to(buffer_ptr, MAX_PATH + 1)
-    end
-
-    common_appdata
-  end
-  module_function :get_common_appdata
-
-  private
-
-  ffi_convention :stdcall
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/bb762181(v=vs.85).aspx
-  # HRESULT SHGetFolderPath(
-  #   _In_  HWND   hwndOwner,
-  #   _In_  int    nFolder,
-  #   _In_  HANDLE hToken,
-  #   _In_  DWORD  dwFlags,
-  #   _Out_ LPTSTR pszPath
-  # );
-  ffi_lib :shell32
-  attach_function :SHGetFolderPathW,
-    [:handle, :int32, :handle, :dword, :lpwstr], :hresult
-end

data/lib/facter/util/windows/error.rb

@@ -1,87 +0,0 @@
-require 'facter/util/windows'
-
-# represents an error resulting from a Win32 error code
-class Facter::Util::Windows::Error < RuntimeError
-  require 'ffi'
-  extend FFI::Library
-
-  attr_reader :code
-  attr_reader :original
-
-  # NOTE: FFI.errno only works properly when prior Win32 calls have been made
-  # through FFI bindings.  Calls made through Win32API do not have their error
-  # codes captured by FFI.errno
-  def initialize(message, code = FFI.errno, original = nil)
-    @original = original
-    super(message + ":  #{self.class.format_error_code(code)}")
-
-    @code = code
-  end
-
-  # Helper method that wraps FormatMessage that returns a human readable string.
-  def self.format_error_code(code)
-    # specifying 0 will look for LANGID in the following order
-    # 1.Language neutral
-    # 2.Thread LANGID, based on the thread's locale value
-    # 3.User default LANGID, based on the user's default locale value
-    # 4.System default LANGID, based on the system default locale value
-    # 5.US English
-    dwLanguageId = 0
-    flags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
-        FORMAT_MESSAGE_FROM_SYSTEM |
-        FORMAT_MESSAGE_ARGUMENT_ARRAY |
-        FORMAT_MESSAGE_IGNORE_INSERTS |
-        FORMAT_MESSAGE_MAX_WIDTH_MASK
-    error_string = ''
-
-    # this pointer actually points to a :lpwstr (pointer) since we're letting Windows allocate for us
-    FFI::MemoryPointer.new(:pointer, 1) do |buffer_ptr|
-      length = FormatMessageW(flags, FFI::Pointer::NULL, code, dwLanguageId,
-                              buffer_ptr, 0, FFI::Pointer::NULL)
-
-      if length == Facter::Util::Windows::FFI::WIN32_FALSE
-        # can't raise same error type here or potentially recurse infinitely
-        raise Facter::Error.new("FormatMessageW could not format code #{code}")
-      end
-
-      # returns an FFI::Pointer with autorelease set to false, which is what we want
-      Facter::Util::Windows::FFI.read_win32_local_pointer(buffer_ptr) do |wide_string_ptr|
-        if wide_string_ptr.null?
-          raise Facter::Error.new("FormatMessageW failed to allocate buffer for code #{code}")
-        end
-
-        error_string = Facter::Util::Windows::FFI.read_wide_string(wide_string_ptr, length)
-      end
-    end
-
-    error_string
-  end
-
-  ERROR_FILE_NOT_FOUND      = 2
-  ERROR_ACCESS_DENIED       = 5
-
-  FORMAT_MESSAGE_ALLOCATE_BUFFER   = 0x00000100
-  FORMAT_MESSAGE_IGNORE_INSERTS    = 0x00000200
-  FORMAT_MESSAGE_FROM_SYSTEM       = 0x00001000
-  FORMAT_MESSAGE_ARGUMENT_ARRAY    = 0x00002000
-  FORMAT_MESSAGE_MAX_WIDTH_MASK    = 0x000000FF
-
-  private
-
-  ffi_convention :stdcall
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms679351(v=vs.85).aspx
-  # DWORD WINAPI FormatMessage(
-  #   _In_      DWORD dwFlags,
-  #   _In_opt_  LPCVOID lpSource,
-  #   _In_      DWORD dwMessageId,
-  #   _In_      DWORD dwLanguageId,
-  #   _Out_     LPTSTR lpBuffer,
-  #   _In_      DWORD nSize,
-  #   _In_opt_  va_list *Arguments
-  # );
-  # NOTE: since we're not preallocating the buffer, use a :pointer for lpBuffer
-  ffi_lib :kernel32
-  attach_function :FormatMessageW,
-                  [:dword, :lpcvoid, :dword, :dword, :pointer, :dword, :pointer], :dword
-end

data/lib/facter/util/windows/process.rb

@@ -1,294 +0,0 @@
-require 'facter/util/windows'
-require 'ffi'
-
-module Facter::Util::Windows::Process
-  extend FFI::Library
-
-  def get_current_process
-    # this pseudo-handle does not require closing per MSDN docs
-    GetCurrentProcess()
-  end
-  module_function :get_current_process
-
-  def open_process_token(handle, desired_access, &block)
-    token_handle = nil
-    begin
-      FFI::MemoryPointer.new(:handle, 1) do |token_handle_ptr|
-        result = OpenProcessToken(handle, desired_access, token_handle_ptr)
-        if result == Facter::Util::Windows::FFI::WIN32_FALSE
-          raise Facter::Util::Windows::Error.new(
-              "OpenProcessToken(#{handle}, #{desired_access.to_s(8)}, #{token_handle_ptr})")
-        end
-
-        yield token_handle = Facter::Util::Windows::FFI.read_handle(token_handle_ptr)
-      end
-
-      token_handle
-    ensure
-      Facter::Util::Windows::FFI::WIN32.CloseHandle(token_handle) if token_handle
-    end
-
-    # token_handle has had CloseHandle called against it, so nothing to return
-    nil
-  end
-  module_function :open_process_token
-
-  def get_token_information(token_handle, token_information, &block)
-    # to determine buffer size
-    FFI::MemoryPointer.new(:dword, 1) do |return_length_ptr|
-      result = GetTokenInformation(token_handle, token_information, nil, 0, return_length_ptr)
-      return_length = Facter::Util::Windows::FFI.read_dword(return_length_ptr)
-
-      if return_length <= 0
-        raise Facter::Util::Windows::Error.new(
-            "GetTokenInformation(#{token_handle}, #{token_information}, nil, 0, #{return_length_ptr})")
-      end
-
-      # re-call API with properly sized buffer for all results
-      FFI::MemoryPointer.new(return_length) do |token_information_buf|
-        result = GetTokenInformation(token_handle, token_information,
-                                     token_information_buf, return_length, return_length_ptr)
-
-        if result == Facter::Util::Windows::FFI::WIN32_FALSE
-          raise Facter::Util::Windows::Error.new(
-              "GetTokenInformation(#{token_handle}, #{token_information}, #{token_information_buf}, " +
-                  "#{return_length}, #{return_length_ptr})")
-        end
-
-        yield token_information_buf
-      end
-    end
-
-    # GetTokenInformation buffer has been cleaned up by this point, nothing to return
-    nil
-  end
-  module_function :get_token_information
-
-  def parse_token_information_as_token_elevation(token_information_buf)
-    TOKEN_ELEVATION.new(token_information_buf)
-  end
-  module_function :parse_token_information_as_token_elevation
-
-  TOKEN_QUERY = 0x0008
-  # Returns whether or not the owner of the current process is running
-  # with elevated security privileges.
-  #
-  # Only supported on Windows Vista or later.
-  #
-  def elevated_security?
-    # default / pre-Vista
-    elevated = false
-    handle = nil
-
-    begin
-      handle = get_current_process
-      open_process_token(handle, TOKEN_QUERY) do |token_handle|
-        get_token_information(token_handle, :TokenElevation) do |token_info|
-          token_elevation = parse_token_information_as_token_elevation(token_info)
-          # TokenIsElevated member of the TOKEN_ELEVATION struct
-          elevated = token_elevation[:TokenIsElevated] != 0
-        end
-      end
-
-      elevated
-    rescue Facter::Util::Windows::Error => e
-      raise e if e.code != ERROR_NO_SUCH_PRIVILEGE
-    ensure
-      Facter::Util::Windows::FFI::WIN32.CloseHandle(handle) if handle
-    end
-  end
-  module_function :elevated_security?
-
-  STATUS_SUCCESS = 0
-
-  def os_version(&block)
-    FFI::MemoryPointer.new(OSVERSIONINFOEX.size) do |ver_ptr|
-      ver = OSVERSIONINFOEX.new(ver_ptr)
-      ver[:dwOSVersionInfoSize] = OSVERSIONINFOEX.size
-
-      result = RtlGetVersion(ver_ptr)
-
-      if result != STATUS_SUCCESS
-        raise RuntimeError, 'Calling Windows RtlGetVersion failed'
-      end
-
-      yield ver
-    end
-
-    # ver_ptr has already had free called, so nothing to return
-    nil
-  end
-  module_function :os_version
-
-  def windows_major_version
-    ver = 0
-
-    self.os_version do |version|
-      ver = version[:dwMajorVersion]
-    end
-
-    ver
-  end
-  module_function :windows_major_version
-
-  def os_version_string
-    ver = ''
-    self.os_version do |version|
-      ver = "#{version[:dwMajorVersion]}.#{version[:dwMinorVersion]}.#{version[:dwBuildNumber]}"
-    end
-
-    ver
-  end
-  module_function :os_version_string
-
-
-  SM_SERVERR2 = 89
-
-  def is_2003_r2?
-    # Peculiar API from user32 - the docs for SM_SERVER2 indicate
-    # The build number if the system is Windows Server 2003 R2; otherwise, 0.
-    GetSystemMetrics(SM_SERVERR2) != 0
-  end
-  module_function :is_2003_r2?
-
-  def supports_elevated_security?
-    windows_major_version >= 6
-  end
-  module_function :supports_elevated_security?
-
-  private
-
-  ffi_convention :stdcall
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683179(v=vs.85).aspx
-  # HANDLE WINAPI GetCurrentProcess(void);
-  ffi_lib :kernel32
-  attach_function :GetCurrentProcess, [], :handle
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379295(v=vs.85).aspx
-  # BOOL WINAPI OpenProcessToken(
-  #   _In_   HANDLE ProcessHandle,
-  #   _In_   DWORD DesiredAccess,
-  #   _Out_  PHANDLE TokenHandle
-  # );
-  ffi_lib :advapi32
-  attach_function :OpenProcessToken,
-                  [:handle, :dword, :phandle], :win32_bool
-
-  public
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379626(v=vs.85).aspx
-  TOKEN_INFORMATION_CLASS = enum(
-      :TokenUser, 1,
-      :TokenGroups,
-      :TokenPrivileges,
-      :TokenOwner,
-      :TokenPrimaryGroup,
-      :TokenDefaultDacl,
-      :TokenSource,
-      :TokenType,
-      :TokenImpersonationLevel,
-      :TokenStatistics,
-      :TokenRestrictedSids,
-      :TokenSessionId,
-      :TokenGroupsAndPrivileges,
-      :TokenSessionReference,
-      :TokenSandBoxInert,
-      :TokenAuditPolicy,
-      :TokenOrigin,
-      :TokenElevationType,
-      :TokenLinkedToken,
-      :TokenElevation,
-      :TokenHasRestrictions,
-      :TokenAccessInformation,
-      :TokenVirtualizationAllowed,
-      :TokenVirtualizationEnabled,
-      :TokenIntegrityLevel,
-      :TokenUIAccess,
-      :TokenMandatoryPolicy,
-      :TokenLogonSid,
-      :TokenIsAppContainer,
-      :TokenCapabilities,
-      :TokenAppContainerSid,
-      :TokenAppContainerNumber,
-      :TokenUserClaimAttributes,
-      :TokenDeviceClaimAttributes,
-      :TokenRestrictedUserClaimAttributes,
-      :TokenRestrictedDeviceClaimAttributes,
-      :TokenDeviceGroups,
-      :TokenRestrictedDeviceGroups,
-      :TokenSecurityAttributes,
-      :TokenIsRestricted,
-      :MaxTokenInfoClass
-  )
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/bb530717(v=vs.85).aspx
-  # typedef struct _TOKEN_ELEVATION {
-  #   DWORD TokenIsElevated;
-  # } TOKEN_ELEVATION, *PTOKEN_ELEVATION;
-  class TOKEN_ELEVATION < FFI::Struct
-    layout :TokenIsElevated, :dword
-  end
-
-  private
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa446671(v=vs.85).aspx
-  # BOOL WINAPI GetTokenInformation(
-  #   _In_       HANDLE TokenHandle,
-  #   _In_       TOKEN_INFORMATION_CLASS TokenInformationClass,
-  #   _Out_opt_  LPVOID TokenInformation,
-  #   _In_       DWORD TokenInformationLength,
-  #   _Out_      PDWORD ReturnLength
-  # );
-  ffi_lib :advapi32
-  attach_function :GetTokenInformation,
-                  [:handle, TOKEN_INFORMATION_CLASS, :lpvoid, :dword, :pdword ], :win32_bool
-
-  public
-
-  # https://msdn.microsoft.com/en-us/library/windows/hardware/ff563620(v=vs.85).aspx
-  # typedef struct _OSVERSIONINFOEXW {
-  #   ULONG  dwOSVersionInfoSize;
-  #   ULONG  dwMajorVersion;
-  #   ULONG  dwMinorVersion;
-  #   ULONG  dwBuildNumber;
-  #   ULONG  dwPlatformId;
-  #   WCHAR  szCSDVersion[128];
-  #   USHORT wServicePackMajor;
-  #   USHORT wServicePackMinor;
-  #   USHORT wSuiteMask;
-  #   UCHAR  wProductType;
-  #   UCHAR  wReserved;
-  # } RTL_OSVERSIONINFOEXW, *PRTL_OSVERSIONINFOEXW;
-  class OSVERSIONINFOEX < FFI::Struct
-    layout(
-      :dwOSVersionInfoSize, :win32_ulong,
-      :dwMajorVersion, :win32_ulong,
-      :dwMinorVersion, :win32_ulong,
-      :dwBuildNumber, :win32_ulong,
-      :dwPlatformId, :win32_ulong,
-      :szCSDVersion, [:wchar, 128],
-      :wServicePackMajor, :ushort,
-      :wServicePackMinor, :ushort,
-      :wSuiteMask, :ushort,
-      :wProductType, :uchar,
-      :wReserved, :uchar,
-    )
-  end
-
-  private
-
-  # NTSTATUS -> :int32 (defined in winerror.h / ntstatus.h)
-  # https://msdn.microsoft.com/en-us/library/windows/hardware/ff561910(v=vs.85).aspx
-  # NTSTATUS RtlGetVersion(
-  #   _Out_ PRTL_OSVERSIONINFOW lpVersionInformation
-  # );
-  ffi_lib [FFI::CURRENT_PROCESS, :ntdll]
-  attach_function :RtlGetVersion, [:pointer], :int32
-
-  # C++ int is a signed 32-bit integer
-  # int WINAPI GetSystemMetrics(
-  #   _In_ int nIndex
-  # );
-  ffi_lib :user32
-  attach_function :GetSystemMetrics, [:int32], :int32
-end