puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

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

@@ -53,23 +53,19 @@ module Puppet::Util::Windows::APITypes
     alias_method :read_word,  :read_uint16
     alias_method :read_array_of_wchar, :read_array_of_uint16
 
-    def read_wide_string(char_length, dst_encoding = Encoding::UTF_8, encode_options = {})
+    def read_wide_string(char_length, dst_encoding = Encoding::UTF_8)
       # char_length is number of wide chars (typically excluding NULLs), *not* bytes
       str = get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
-      str.encode(dst_encoding, str.encoding, encode_options)
-    rescue Exception => e
-      Puppet.debug "Unable to convert value #{str.dump} to encoding #{dst_encoding} due to #{e.inspect}"
-      raise
+      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
-    # @param encode_options [Hash] Accepts the same option hash that may be passed to String#encode in Ruby
-    def read_arbitrary_wide_string_up_to(max_char_length = 512, null_terminator = :single_null, encode_options = {})
+    def read_arbitrary_wide_string_up_to(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"
+        raise _("Unable to read wide strings with %{null_terminator} terminal nulls") % { null_terminator: null_terminator }
       end
 
       terminator_width = null_terminator == :single_null ? 1 : 2
@@ -77,11 +73,11 @@ module Puppet::Util::Windows::APITypes
 
       # 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(i, Encoding::UTF_8, encode_options) if send(reader_method, (i * 2)) == 0
+        return read_wide_string(i) if send(reader_method, (i * 2)) == 0
       end
 
       # String is longer than the max; read just to the max
-      read_wide_string(max_char_length, Encoding::UTF_8, encode_options)
+      read_wide_string(max_char_length)
     end
 
     def read_win32_local_pointer(&block)
@@ -200,7 +196,7 @@ module Puppet::Util::Windows::APITypes
              :Data4, [:byte, 8]
 
       def self.[](s)
-        raise 'Bad GUID format.' unless s =~ /^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/i
+        raise _('Bad GUID format.') unless s =~ /^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/i
 
         new.tap do |guid|
           guid[:Data1] = s[0, 8].to_i(16)

data/lib/puppet/util/windows/com.rb

@@ -14,7 +14,7 @@ module Puppet::Util::Windows::COM
   module_function :SUCCEEDED, :FAILED
 
   def raise_if_hresult_failed(name, *args)
-    failed = FAILED(result = send(name, *args)) and raise "#{name} failed (hresult #{format('%#08x', result)})."
+    failed = FAILED(result = send(name, *args)) and raise _("%{name} failed (hresult %{result}).") % { name: name, result: format('%#08x', result) }
 
     result
   ensure
@@ -139,7 +139,7 @@ module Puppet::Util::Windows::COM
         self::VTBL.members.each do |name|
           define_method(name) do |*args|
             if Puppet::Util::Windows::COM.FAILED(result = @vtbl[name].call(self, *args))
-              raise Puppet::Util::Windows::Error.new("Failed to call #{self}::#{name} with HRESULT: #{result}.", result)
+              raise Puppet::Util::Windows::Error.new(_("Failed to call %{klass}::%{name} with HRESULT: %{result}.") % { klass: self, name: name, result: result }, result)
             end
             result
           end
@@ -166,7 +166,7 @@ module Puppet::Util::Windows::COM
           FFI::MemoryPointer.new(:pointer) do |ppv|
             hr = Puppet::Util::Windows::COM.CoCreateInstance(self.class::CLSID, FFI::Pointer::NULL, @opts[:clsctx], self.class::IID, ppv)
             if Puppet::Util::Windows::COM.FAILED(hr)
-              raise "CoCreateInstance failed (#{self.class})."
+              raise _("CoCreateInstance failed (%{klass}).") % { klass: self.class }
             end
 
             self.pointer = ppv.read_pointer
@@ -180,7 +180,7 @@ module Puppet::Util::Windows::COM
         self::VTBL.members.each do |name|
           define_method(name) do |*args|
             if Puppet::Util::Windows::COM.FAILED(result = @vtbl[name].call(self, *args))
-              raise Puppet::Util::Windows::Error.new("Failed to call #{self}::#{name} with HRESULT: #{result}.", result)
+              raise Puppet::Util::Windows::Error.new(_("Failed to call %{klass}::%{name} with HRESULT: %{result}.") % { klass: self, name: name, result: result }, result)
             end
             result
           end

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

@@ -39,13 +39,13 @@ class Puppet::Util::Windows::Error < Puppet::Error
 
       if length == FFI::WIN32_FALSE
         # can't raise same error type here or potentially recurse infinitely
-        raise Puppet::Error.new("FormatMessageW could not format code #{code}")
+        raise Puppet::Error.new(_("FormatMessageW could not format code %{code}") % { code: code })
       end
 
       # returns an FFI::Pointer with autorelease set to false, which is what we want
       buffer_ptr.read_win32_local_pointer do |wide_string_ptr|
         if wide_string_ptr.null?
-          raise Puppet::Error.new("FormatMessageW failed to allocate buffer for code #{code}")
+          raise Puppet::Error.new(_("FormatMessageW failed to allocate buffer for code %{code}") % { code: code })
         end
 
         error_string = wide_string_ptr.read_wide_string(length)

data/lib/puppet/util/windows/eventlog.rb

@@ -0,0 +1,192 @@
+require 'ffi'
+
+# Puppet::Util::Windows::EventLog needs to be requirable without having loaded
+# any other parts of Puppet so it can be leveraged independently by the code
+# that runs Puppet as a service on Windows.
+#
+# For this reason we:
+# - Define Puppet::Util::Windows
+# - Replicate logic that exists elsewhere in puppet/util/windows
+# - Raise generic RuntimeError instead of Puppet::Util::Windows::Error if its not defined
+module Puppet; module Util; module Windows ; end ; end ; end
+
+class Puppet::Util::Windows::EventLog
+  extend FFI::Library
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa363679(v=vs.85).aspx
+  EVENTLOG_ERROR_TYPE       = 0x0001
+  EVENTLOG_WARNING_TYPE     = 0x0002
+  EVENTLOG_INFORMATION_TYPE = 0x0004
+
+  # These are duplicate definitions from Puppet::Util::Windows::ApiTypes,
+  # established here so this class can be standalone from Puppet, and public so
+  # we can reference them in tests.
+  NULL_HANDLE = 0
+  WIN32_FALSE = 0
+
+  # Register an event log handle for the application
+  # @param source_name [String] the name of the event source to retrieve a handle for
+  # @return [void]
+  # @api public
+  def initialize(source_name = 'Puppet')
+    @eventlog_handle = RegisterEventSourceW(FFI::Pointer::NULL, wide_string(source_name))
+    if @eventlog_handle == NULL_HANDLE
+      raise EventLogError.new("RegisterEventSourceW failed to open Windows eventlog", FFI.errno)
+    end
+  end
+
+  # Close this instance's event log handle
+  # @return [void]
+  # @api public
+  def close
+    DeregisterEventSource(@eventlog_handle)
+  ensure
+    @eventlog_handle = nil
+  end
+
+  # Report an event to this instance's event log handle. Accepts a string to
+  #   report (:data => <string>) and event type (:event_type => FixNum) and id
+  # (:event_id => FixNum) as returned by #to_native. The additional arguments to
+  # ReportEventW seen in this method aren't exposed - though ReportEventW
+  # technically can accept multiple strings as well as raw binary data to log,
+  # we accept a single string from Puppet::Util::Log
+  #
+  # @param args [Hash{Symbol=>Object}] options to the associated log event
+  # @return [void]
+  # @api public
+  def report_event(args = {})
+    raise ArgumentError, "data must be a string, not #{args[:data].class}" unless args[:data].is_a?(String)
+    from_string_to_wide_string(args[:data]) do |message_ptr|
+      FFI::MemoryPointer.new(:pointer) do |message_array_ptr|
+        message_array_ptr.write_pointer(message_ptr)
+        user_sid = FFI::Pointer::NULL
+        raw_data = FFI::Pointer::NULL
+        raw_data_size = 0
+        num_strings = 1
+        eventlog_category = 0
+        report_result = ReportEventW(@eventlog_handle, args[:event_type],
+          eventlog_category, args[:event_id], user_sid,
+          num_strings, raw_data_size, message_array_ptr, raw_data)
+
+        if report_result == WIN32_FALSE
+          raise EventLogError.new("ReportEventW failed to report event to Windows eventlog", FFI.errno)
+        end
+      end
+    end
+  end
+
+  class << self
+    # Feels more natural to do Puppet::Util::Window::EventLog.open("MyApplication")
+    alias :open :new
+
+    # Query event identifier info for a given log level
+    # @param level [Symbol] an event log level
+    # @return [Array] Win API Event ID, Puppet Event ID
+    # @api public
+    def to_native(level)
+      case level
+      when :debug,:info,:notice
+        [EVENTLOG_INFORMATION_TYPE, 0x01]
+      when :warning
+        [EVENTLOG_WARNING_TYPE, 0x02]
+      when :err,:alert,:emerg,:crit
+        [EVENTLOG_ERROR_TYPE, 0x03]
+      else
+        raise ArgumentError, "Invalid log level #{level}"
+      end
+    end
+  end
+
+  private
+  # For the purposes of allowing this class to be standalone, the following are
+  # duplicate definitions from elsewhere in Puppet:
+
+  # If we're loaded via Puppet we should keep the previous behavior of raising
+  # Puppet::Util::Windows::Error on errors. If we aren't, at least concatenate
+  # the error code to the exception message to pass this information on to the
+  # user
+  if defined?(Puppet::Util::Windows::Error)
+    EventLogError = Puppet::Util::Windows::Error
+  else
+    class EventLogError < RuntimeError
+      def initialize(msg, code)
+        super(msg + " (Win32 error: #{code})")
+      end
+    end
+  end
+
+  # Private duplicate of Puppet::Util::Windows::String::wide_string
+  # Not for use outside of EventLog! - use Puppet::Util::Windows instead
+  # @api private
+  def wide_string(str)
+    # if given a nil string, assume caller wants to pass a nil pointer to win32
+    return nil if str.nil?
+    # ruby (< 2.1) does not respect multibyte terminators, so it is possible
+    # for a string to contain a single trailing null byte, followed by garbage
+    # causing buffer overruns.
+    #
+    # See http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?revision=41920&view=revision
+    newstr = str + "\0".encode(str.encoding)
+    newstr.encode!('UTF-16LE')
+  end
+
+  # Private duplicate of Puppet::Util::Windows::ApiTypes::from_string_to_wide_string
+  # Not for use outside of EventLog! - Use Puppet::Util::Windows instead
+  # @api private
+  def from_string_to_wide_string(str, &block)
+    str = wide_string(str)
+    FFI::MemoryPointer.new(:uchar, str.bytesize) do |ptr|
+      # uchar here is synonymous with byte
+      ptr.put_array_of_uchar(0, str.bytes.to_a)
+
+      yield ptr
+    end
+
+    # ptr has already had free called, so nothing to return
+    nil
+  end
+
+  ffi_convention :stdcall
+
+  # The following are typedefs in Puppet::Util::Winodws::ApiTypes, but here we
+  # use their original FFI counterparts:
+  # :uintptr_t for :handle
+  # :int32 for :win32_bool
+  # :uint16 for :word
+  # :uint32 for :dword
+  # :pointer for :lpvoid
+  # :uchar for :byte
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa363678(v=vs.85).aspx
+  # HANDLE RegisterEventSource(
+  # _In_ LPCTSTR lpUNCServerName,
+  # _In_ LPCTSTR lpSourceName
+  # );
+  ffi_lib :advapi32
+  attach_function :RegisterEventSourceW, [:buffer_in, :buffer_in], :uintptr_t
+  private :RegisterEventSourceW
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa363642(v=vs.85).aspx
+  # BOOL DeregisterEventSource(
+  # _Inout_ HANDLE hEventLog
+  # );
+  ffi_lib :advapi32
+  attach_function :DeregisterEventSource, [:uintptr_t], :int32
+  private :DeregisterEventSource
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa363679(v=vs.85).aspx
+  # BOOL ReportEvent(
+  #   _In_ HANDLE  hEventLog,
+  #   _In_ WORD    wType,
+  #   _In_ WORD    wCategory,
+  #   _In_ DWORD   dwEventID,
+  #   _In_ PSID    lpUserSid,
+  #   _In_ WORD    wNumStrings,
+  #   _In_ DWORD   dwDataSize,
+  #   _In_ LPCTSTR *lpStrings,
+  #   _In_ LPVOID  lpRawData
+  # );
+  ffi_lib :advapi32
+  attach_function :ReportEventW, [:uintptr_t, :uint16, :uint16, :uint32, :pointer, :uint16, :uint32, :pointer, :pointer], :int32
+  private :ReportEventW
+end

data/lib/puppet/util/windows/file.rb

@@ -111,15 +111,11 @@ module Puppet::Util::Windows::File
 
       # return true if path exists and it's not a symlink
       # Other file attributes are ignored. https://msdn.microsoft.com/en-us/library/windows/desktop/gg258117(v=vs.85).aspx
-      reparse_point = (result & FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
-      if reparse_point && symlink_reparse_point?(path)
-        # walk the symlink and try again...
-        seen_paths << path.downcase
-        path = readlink(path)
-      else
-        # file was found and its not a symlink
-        return true
-      end
+      return true if (result & FILE_ATTRIBUTE_REPARSE_POINT) != FILE_ATTRIBUTE_REPARSE_POINT
+
+      # walk the symlink and try again...
+      seen_paths << path.downcase
+      path = readlink(path)
     end
 
     false
@@ -159,7 +155,7 @@ module Puppet::Util::Windows::File
 
   def set_attributes(path, flags)
     success = SetFileAttributesW(wide_string(path), flags) != FFI::WIN32_FALSE
-    raise Puppet::Util::Windows::Error.new("Failed to set file attributes") if !success
+    raise Puppet::Util::Windows::Error.new(_("Failed to set file attributes")) if !success
 
     success
   end
@@ -181,60 +177,20 @@ module Puppet::Util::Windows::File
         "#{flags_and_attributes.to_s(8)}, #{template_file_handle})")
   end
 
-  IO_REPARSE_TAG_MOUNT_POINT  = 0xA0000003
-  IO_REPARSE_TAG_HSM          = 0xC0000004
-  IO_REPARSE_TAG_HSM2         = 0x80000006
-  IO_REPARSE_TAG_SIS          = 0x80000007
-  IO_REPARSE_TAG_WIM          = 0x80000008
-  IO_REPARSE_TAG_CSV          = 0x80000009
-  IO_REPARSE_TAG_DFS          = 0x8000000A
-  IO_REPARSE_TAG_SYMLINK      = 0xA000000C
-  IO_REPARSE_TAG_DFSR         = 0x80000012
-  IO_REPARSE_TAG_DEDUP        = 0x80000013
-  IO_REPARSE_TAG_NFS          = 0x80000014
-
   def self.get_reparse_point_data(handle, &block)
     # must be multiple of 1024, min 10240
-    FFI::MemoryPointer.new(MAXIMUM_REPARSE_DATA_BUFFER_SIZE) do |reparse_data_buffer_ptr|
+    FFI::MemoryPointer.new(REPARSE_DATA_BUFFER.size) do |reparse_data_buffer_ptr|
       device_io_control(handle, FSCTL_GET_REPARSE_POINT, nil, reparse_data_buffer_ptr)
-
-      reparse_tag = reparse_data_buffer_ptr.read_win32_ulong
-      buffer_type = case reparse_tag
-      when IO_REPARSE_TAG_SYMLINK
-        SYMLINK_REPARSE_DATA_BUFFER
-      when IO_REPARSE_TAG_MOUNT_POINT
-        MOUNT_POINT_REPARSE_DATA_BUFFER
-      when IO_REPARSE_TAG_NFS
-        raise Puppet::Util::Windows::Error.new("Retrieving NFS reparse point data is unsupported")
-      else
-        raise Puppet::Util::Windows::Error.new("DeviceIoControl(#{handle}, " +
-          "FSCTL_GET_REPARSE_POINT) returned unknown tag 0x#{reparse_tag.to_s(16).upcase}")
-      end
-
-      yield buffer_type.new(reparse_data_buffer_ptr)
+      yield REPARSE_DATA_BUFFER.new(reparse_data_buffer_ptr)
     end
 
     # underlying struct MemoryPointer has been cleaned up by this point, nothing to return
     nil
   end
 
-  def self.get_reparse_point_tag(handle)
-    reparse_tag = nil
-
-    # must be multiple of 1024, min 10240
-    FFI::MemoryPointer.new(MAXIMUM_REPARSE_DATA_BUFFER_SIZE) do |reparse_data_buffer_ptr|
-      device_io_control(handle, FSCTL_GET_REPARSE_POINT, nil, reparse_data_buffer_ptr)
-
-      # DWORD ReparseTag is the first member of the struct
-      reparse_tag = reparse_data_buffer_ptr.read_win32_ulong
-    end
-
-    reparse_tag
-  end
-
   def self.device_io_control(handle, io_control_code, in_buffer = nil, out_buffer = nil)
     if out_buffer.nil?
-      raise Puppet::Util::Windows::Error.new("out_buffer is required")
+      raise Puppet::Util::Windows::Error.new(_("out_buffer is required"))
     end
 
     FFI::MemoryPointer.new(:dword, 1) do |bytes_returned_ptr|
@@ -259,18 +215,12 @@ module Puppet::Util::Windows::File
   end
 
   FILE_ATTRIBUTE_REPARSE_POINT = 0x400
-  def reparse_point?(file_name)
+  def symlink?(file_name)
     attributes = get_attributes(file_name, false)
 
     return false if (attributes == INVALID_FILE_ATTRIBUTES)
     (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
   end
-  module_function :reparse_point?
-
-  def symlink?(file_name)
-    # Puppet currently only handles mount point and symlink reparse points, ignores others
-    reparse_point?(file_name) && symlink_reparse_point?(file_name)
-  end
   module_function :symlink?
 
   GENERIC_READ                  = 0x80000000
@@ -321,7 +271,7 @@ module Puppet::Util::Windows::File
       buffer_size = GetLongPathNameW(path_ptr, FFI::Pointer::NULL, 0)
       FFI::MemoryPointer.new(:wchar, buffer_size) do |converted_ptr|
         if GetLongPathNameW(path_ptr, converted_ptr, buffer_size) == FFI::WIN32_FALSE
-          raise Puppet::Util::Windows::Error.new("Failed to call GetLongPathName")
+          raise Puppet::Util::Windows::Error.new(_("Failed to call GetLongPathName"))
         end
 
         converted = converted_ptr.read_wide_string(buffer_size - 1)
@@ -411,22 +361,6 @@ module Puppet::Util::Windows::File
     path
   end
 
-  # these reparse point types are the only ones Puppet currently understands
-  # so rather than raising an exception in readlink, prefer to not consider
-  # the path a symlink when stat'ing later
-  def self.symlink_reparse_point?(path)
-    symlink = false
-
-    open_symlink(path) do |handle|
-      symlink = [
-        IO_REPARSE_TAG_SYMLINK,
-        IO_REPARSE_TAG_MOUNT_POINT
-      ].include?(get_reparse_point_tag(handle))
-    end
-
-    symlink
-  end
-
   ffi_convention :stdcall
 
   # https://msdn.microsoft.com/en-us/library/windows/desktop/aa365512(v=vs.85).aspx
@@ -514,11 +448,11 @@ module Puppet::Util::Windows::File
 
   MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16384
 
-  # SYMLINK_REPARSE_DATA_BUFFER
+  # REPARSE_DATA_BUFFER
   # https://msdn.microsoft.com/en-us/library/cc232006.aspx
   # https://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
   # struct is always MAXIMUM_REPARSE_DATA_BUFFER_SIZE bytes
-  class SYMLINK_REPARSE_DATA_BUFFER < FFI::Struct
+  class REPARSE_DATA_BUFFER < FFI::Struct
     layout :ReparseTag, :win32_ulong,
            :ReparseDataLength, :ushort,
            :Reserved, :ushort,
@@ -532,23 +466,6 @@ module Puppet::Util::Windows::File
            :PathBuffer, [:byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 20]
   end
 
-  # MOUNT_POINT_REPARSE_DATA_BUFFER
-  # https://msdn.microsoft.com/en-us/library/cc232007.aspx
-  # https://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
-  # struct is always MAXIMUM_REPARSE_DATA_BUFFER_SIZE bytes
-  class MOUNT_POINT_REPARSE_DATA_BUFFER < FFI::Struct
-    layout :ReparseTag, :win32_ulong,
-           :ReparseDataLength, :ushort,
-           :Reserved, :ushort,
-           :SubstituteNameOffset, :ushort,
-           :SubstituteNameLength, :ushort,
-           :PrintNameOffset, :ushort,
-           :PrintNameLength, :ushort,
-           # max less above fields dword / uint 4 bytes, ushort 2 bytes
-           # technically a WCHAR buffer, but we care about size in bytes here
-           :PathBuffer, [:byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 16]
-  end
-
   # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364980(v=vs.85).aspx
   # DWORD WINAPI GetLongPathName(
   #   _In_  LPCTSTR lpszShortPath,