puppet 4.10.0 → 5.0.0

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

@@ -155,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
@@ -190,7 +190,7 @@ module Puppet::Util::Windows::File
 
   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|
@@ -271,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)
@@ -397,7 +397,7 @@ module Puppet::Util::Windows::File
   begin
     ffi_lib :kernel32
     attach_function_private :CreateSymbolicLinkW,
-      [:lpwstr, :lpwstr, :dword], :win32_bool
+      [:lpwstr, :lpwstr, :dword], :boolean
   rescue LoadError
   end
 

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

@@ -64,14 +64,14 @@ module Puppet::Util::Windows::SID
                 last_error = FFI.errno
 
                 if (success == FFI::WIN32_FALSE && last_error != ERROR_INSUFFICIENT_BUFFER)
-                  raise Puppet::Util::Windows::Error.new('Failed to call LookupAccountNameW', last_error)
+                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountNameW'), last_error)
                 end
 
                 FFI::MemoryPointer.new(:lpwstr, domain_length_ptr.read_dword) do |domain_ptr|
                   if LookupAccountNameW(system_name_ptr, account_name_ptr,
                       sid_ptr, sid_length_ptr,
                       domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
-                   raise Puppet::Util::Windows::Error.new('Failed to call LookupAccountNameW')
+                   raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountNameW'))
                   end
 
                   # with a SID returned, loop back through lookup_account_sid to retrieve official name
@@ -93,7 +93,8 @@ module Puppet::Util::Windows::SID
     def self.lookup_account_sid(system_name = nil, sid_bytes)
       system_name_ptr = FFI::Pointer::NULL
       if (sid_bytes.nil? || (!sid_bytes.is_a? Array) || (sid_bytes.length == 0))
-        raise Puppet::Util::Windows::Error.new('Byte array for lookup_account_sid must not be nil and must be at least 1 byte long')
+        #TRANSLATORS `lookup_account_sid` is a variable name and should not be translated
+        raise Puppet::Util::Windows::Error.new(_('Byte array for lookup_account_sid must not be nil and must be at least 1 byte long'))
       end
 
       begin
@@ -115,14 +116,14 @@ module Puppet::Util::Windows::SID
                 last_error = FFI.errno
 
                 if (success == FFI::WIN32_FALSE && last_error != ERROR_INSUFFICIENT_BUFFER)
-                  raise Puppet::Util::Windows::Error.new('Failed to call LookupAccountSidW', last_error)
+                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountSidW'), last_error)
                 end
 
                 FFI::MemoryPointer.new(:lpwstr, name_length_ptr.read_dword) do |name_ptr|
                   FFI::MemoryPointer.new(:lpwstr, domain_length_ptr.read_dword) do |domain_ptr|
                     if LookupAccountSidW(system_name_ptr, sid_ptr, name_ptr, name_length_ptr,
                         domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
-                     raise Puppet::Util::Windows::Error.new('Failed to call LookupAccountSidW')
+                     raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountSidW'))
                     end
 
                     return new(

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

@@ -21,7 +21,7 @@ module Puppet::Util::Windows::Process
     exit_status = -1
     FFI::MemoryPointer.new(:dword, 1) do |exit_status_ptr|
       if GetExitCodeProcess(handle, exit_status_ptr) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Failed to get child process exit code")
+        raise Puppet::Util::Windows::Error.new(_("Failed to get child process exit code"))
       end
       exit_status = exit_status_ptr.read_dword
 
@@ -214,7 +214,7 @@ module Puppet::Util::Windows::Process
       result = GetVersionExW(os_version_ptr)
 
       if result == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("GetVersionEx failed")
+        raise Puppet::Util::Windows::Error.new(_("GetVersionEx failed"))
       end
 
       ver = os_version[:dwMajorVersion]
@@ -251,17 +251,17 @@ module Puppet::Util::Windows::Process
   module_function :get_environment_strings
 
   def set_environment_variable(name, val)
-    raise Puppet::Util::Windows::Error('environment variable name must not be nil or empty') if ! name || name.empty?
+    raise Puppet::Util::Windows::Error(_('environment variable name must not be nil or empty')) if ! name || name.empty?
 
     FFI::MemoryPointer.from_string_to_wide_string(name) do |name_ptr|
       if (val.nil?)
         if SetEnvironmentVariableW(name_ptr, FFI::MemoryPointer::NULL) == FFI::WIN32_FALSE
-          raise Puppet::Util::Windows::Error.new("Failed to remove environment variable: #{name}")
+          raise Puppet::Util::Windows::Error.new(_("Failed to remove environment variable: %{name}") % { name: name })
         end
       else
         FFI::MemoryPointer.from_string_to_wide_string(val) do |val_ptr|
           if SetEnvironmentVariableW(name_ptr, val_ptr) == FFI::WIN32_FALSE
-            raise Puppet::Util::Windows::Error.new("Failed to set environment variable: #{name}")
+            raise Puppet::Util::Windows::Error.new(_("Failed to set environment variable: %{name}") % { name: name })
           end
         end
       end

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

@@ -18,7 +18,7 @@ module Puppet::Util::Windows
     def root(name)
       Win32::Registry.const_get(name)
     rescue NameError
-      raise Puppet::Error, "Invalid registry key '#{name}'", $!.backtrace
+      raise Puppet::Error, _("Invalid registry key '%{name}'") % { name: name }, $!.backtrace
     end
 
     def open(name, path, mode = KEY_READ | KEY64, &block)
@@ -28,7 +28,7 @@ module Puppet::Util::Windows
           return yield subkey
         end
       rescue Win32::Registry::Error => error
-        raise Puppet::Util::Windows::Error.new("Failed to open registry key '#{hkey.keyname}\\#{path}'", error.code, error)
+        raise Puppet::Util::Windows::Error.new(_("Failed to open registry key '%{key}\\%{path}'") % { key: hkey.keyname, path: path }, error.code, error)
       end
     end
 
@@ -103,7 +103,7 @@ module Puppet::Util::Windows
             break if result == ERROR_NO_MORE_ITEMS
 
             if result != FFI::ERROR_SUCCESS
-              msg = "Failed to enumerate #{key.keyname} registry keys at index #{index}"
+              msg = _("Failed to enumerate %{key} registry keys at index %{index}") % { key: key.keyname, index: index }
               raise Puppet::Util::Windows::Error.new(msg)
             end
 
@@ -134,7 +134,7 @@ module Puppet::Util::Windows
           break if result == ERROR_NO_MORE_ITEMS
 
           if result != FFI::ERROR_SUCCESS
-            msg = "Failed to enumerate #{key.keyname} registry values at index #{index}"
+            msg = _("Failed to enumerate %{key} registry values at index %{index}") % { key: key.keyname, index: index }
             raise Puppet::Util::Windows::Error.new(msg)
           end
 
@@ -164,7 +164,7 @@ module Puppet::Util::Windows
           )
 
           if status != FFI::ERROR_SUCCESS
-            msg = "Failed to query registry #{key.keyname} for sizes"
+            msg = _("Failed to query registry %{key} for sizes") % { key: key.keyname }
             raise Puppet::Util::Windows::Error.new(msg)
           end
 
@@ -200,7 +200,7 @@ module Puppet::Util::Windows
 
       query_value_ex(key, name_ptr) do |type, data_ptr, byte_length|
         unless rtype.empty? or rtype.include?(type)
-          raise TypeError, "Type mismatch (expect #{rtype.inspect} but #{type} present)"
+          raise TypeError, _("Type mismatch (expect %{rtype} but %{type} present)") % { rtype: rtype.inspect, type: type }
         end
 
         string_length = 0
@@ -222,12 +222,12 @@ module Puppet::Util::Windows
             when Win32::Registry::REG_QWORD
               result = [ type, data_ptr.read_qword ]
             else
-              raise TypeError, "Type #{type} is not supported."
+              raise TypeError, _("Type %{type} is not supported.") % { type: type }
           end
         rescue IndexError => ex
           raise if (ex.message !~ /^Memory access .* is out of bounds$/i)
           parent_key_name = key.parent ? "#{key.parent.keyname}\\" : ""
-          Puppet.warning "A value in the registry key #{parent_key_name}#{key.keyname} is corrupt or invalid"
+          Puppet.warning _("A value in the registry key %{parent_key_name}%{key} is corrupt or invalid") % { parent_key_name: parent_key_name, key: key.keyname }
         end
       end
 
@@ -247,7 +247,7 @@ module Puppet::Util::Windows
               buffer_ptr, length_ptr)
 
             if result != FFI::ERROR_SUCCESS
-              msg = "Failed to read registry value #{name_ptr.read_wide_string} at #{key.keyname}"
+              msg = _("Failed to read registry value %{value} at %{key}") % { value: name_ptr.read_wide_string, key: key.keyname }
               raise Puppet::Util::Windows::Error.new(msg)
             end
 
@@ -265,7 +265,7 @@ module Puppet::Util::Windows
         result = RegDeleteValueW(key.hkey, name_ptr)
 
         if result != FFI::ERROR_SUCCESS
-          msg = "Failed to delete registry value #{name} at #{key.keyname}"
+          msg = _("Failed to delete registry value %{name} at %{key}") % { name: name, key: key.keyname }
           raise Puppet::Util::Windows::Error.new(msg, result)
         end
       end
@@ -280,7 +280,7 @@ module Puppet::Util::Windows
         result = RegDeleteKeyExW(key.hkey, name_ptr, regsam, 0)
 
         if result != FFI::ERROR_SUCCESS
-          msg = "Failed to delete registry key #{name} at #{key.keyname}"
+          msg = _("Failed to delete registry key %{name} at %{key}") % { name: name, key: key.keyname }
           raise Puppet::Util::Windows::Error.new(msg, result)
         end
       end

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

@@ -44,7 +44,7 @@ class Puppet::Util::Windows::RootCerts
         begin
           certs << OpenSSL::X509::Certificate.new(cert_buf)
         rescue => detail
-          Puppet.warning("Failed to import root certificate: #{detail.inspect}")
+          Puppet.warning(_("Failed to import root certificate: %{detail}") % { detail: detail.inspect })
         end
       end
     ensure

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

@@ -170,7 +170,7 @@ module Puppet::Util::Windows::Security
       if GetVolumeInformationW(wide_string(root), FFI::Pointer::NULL, 0,
           FFI::Pointer::NULL, FFI::Pointer::NULL,
           flags_ptr, FFI::Pointer::NULL, 0) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Failed to get volume information")
+        raise Puppet::Util::Windows::Error.new(_("Failed to get volume information"))
       end
       supported = flags_ptr.read_dword & FILE_PERSISTENT_ACLS == FILE_PERSISTENT_ACLS
     end
@@ -380,11 +380,11 @@ module Puppet::Util::Windows::Security
 
     Puppet::Util::Windows::SID.string_to_sid_ptr(sid) do |sid_ptr|
       if Puppet::Util::Windows::SID.IsValidSid(sid_ptr) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Invalid SID")
+        raise Puppet::Util::Windows::Error.new(_("Invalid SID"))
       end
 
       if AddAccessAllowedAceEx(acl, ACL_REVISION, inherit, mask, sid_ptr) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Failed to add access control entry")
+        raise Puppet::Util::Windows::Error.new(_("Failed to add access control entry"))
       end
     end
 
@@ -397,11 +397,11 @@ module Puppet::Util::Windows::Security
 
     Puppet::Util::Windows::SID.string_to_sid_ptr(sid) do |sid_ptr|
       if Puppet::Util::Windows::SID.IsValidSid(sid_ptr) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Invalid SID")
+        raise Puppet::Util::Windows::Error.new(_("Invalid SID"))
       end
 
       if AddAccessDeniedAceEx(acl, ACL_REVISION, inherit, mask, sid_ptr) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Failed to add access control entry")
+        raise Puppet::Util::Windows::Error.new(_("Failed to add access control entry"))
       end
     end
 
@@ -412,7 +412,7 @@ module Puppet::Util::Windows::Security
   def parse_dacl(dacl_ptr)
     # REMIND: need to handle NULL DACL
     if IsValidAcl(dacl_ptr) == FFI::WIN32_FALSE
-      raise Puppet::Util::Windows::Error.new("Invalid DACL")
+      raise Puppet::Util::Windows::Error.new(_("Invalid DACL"))
     end
 
     dacl_struct = ACL.new(dacl_ptr)
@@ -435,7 +435,7 @@ module Puppet::Util::Windows::Security
         ace_type = ace[:Header][:AceType]
         if ace_type != Puppet::Util::Windows::AccessControlEntry::ACCESS_ALLOWED_ACE_TYPE &&
           ace_type != Puppet::Util::Windows::AccessControlEntry::ACCESS_DENIED_ACE_TYPE
-          Puppet.warning "Unsupported access control entry type: 0x#{ace_type.to_s(16)}"
+          Puppet.warning _("Unsupported access control entry type: 0x%{type}") % { type: ace_type.to_s(16) }
           next
         end
 
@@ -469,7 +469,7 @@ module Puppet::Util::Windows::Security
              FFI::Pointer::NULL_HANDLE) # template
 
     if handle == Puppet::Util::Windows::File::INVALID_HANDLE_VALUE
-      raise Puppet::Util::Windows::Error.new("Failed to open '#{path}'")
+      raise Puppet::Util::Windows::Error.new(_("Failed to open '%{path}'") % { path: path })
     end
 
     begin
@@ -516,7 +516,7 @@ module Puppet::Util::Windows::Security
             if AdjustTokenPrivileges(token, FFI::WIN32_FALSE,
                 token_privileges, token_privileges.size,
                 FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL) == FFI::WIN32_FALSE
-              raise Puppet::Util::Windows::Error.new("Failed to adjust process privileges")
+              raise Puppet::Util::Windows::Error.new(_("Failed to adjust process privileges"))
             end
           end
         end
@@ -546,7 +546,7 @@ module Puppet::Util::Windows::Security
                   dacl_ptr_ptr,
                   FFI::Pointer::NULL, #sacl
                   sd_ptr_ptr) #sec desc
-                raise Puppet::Util::Windows::Error.new("Failed to get security information") if rv != FFI::ERROR_SUCCESS
+                raise Puppet::Util::Windows::Error.new(_("Failed to get security information")) if rv != FFI::ERROR_SUCCESS
 
                 # these 2 convenience params are not freed since they point inside sd_ptr
                 owner = Puppet::Util::Windows::SID.sid_ptr_to_string(owner_sid_ptr_ptr.get_pointer(0))
@@ -557,7 +557,7 @@ module Puppet::Util::Windows::Security
                     sd_ptr_ptr.read_win32_local_pointer do |sd_ptr|
 
                       if GetSecurityDescriptorControl(sd_ptr, control, revision) == FFI::WIN32_FALSE
-                        raise Puppet::Util::Windows::Error.new("Failed to get security descriptor control")
+                        raise Puppet::Util::Windows::Error.new(_("Failed to get security descriptor control"))
                       end
 
                       protect = (control.read_word & SE_DACL_PROTECTED) == SE_DACL_PROTECTED
@@ -590,11 +590,11 @@ module Puppet::Util::Windows::Security
   def set_security_descriptor(path, sd)
     FFI::MemoryPointer.new(:byte, get_max_generic_acl_size(sd.dacl.count)) do |acl_ptr|
       if InitializeAcl(acl_ptr, acl_ptr.size, ACL_REVISION) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Failed to initialize ACL")
+        raise Puppet::Util::Windows::Error.new(_("Failed to initialize ACL"))
       end
 
       if IsValidAcl(acl_ptr) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Invalid DACL")
+        raise Puppet::Util::Windows::Error.new(_("Invalid DACL"))
       end
 
       with_privilege(SE_BACKUP_NAME) do
@@ -629,7 +629,7 @@ module Puppet::Util::Windows::Security
                                      FFI::MemoryPointer::NULL)
 
                 if rv != FFI::ERROR_SUCCESS
-                  raise Puppet::Util::Windows::Error.new("Failed to set security information")
+                  raise Puppet::Util::Windows::Error.new(_("Failed to set security information"))
                 end
               end
             end

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

@@ -90,7 +90,7 @@ module Puppet::Util::Windows
     # This method returns a SID::Principal with the account, domain, SID, etc
     def octet_string_to_sid_object(bytes)
       if !bytes || !bytes.respond_to?('pack') || bytes.empty?
-        raise Puppet::Util::Windows::Error.new("Octet string must be an array of bytes")
+        raise Puppet::Util::Windows::Error.new(_("Octet string must be an array of bytes"))
       end
 
       Principal.lookup_account_sid(bytes)
@@ -124,18 +124,18 @@ module Puppet::Util::Windows
     # Convert a SID pointer to a SID string, e.g. "S-1-5-32-544".
     def sid_ptr_to_string(psid)
       if ! psid.kind_of?(FFI::Pointer) || IsValidSid(psid) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Invalid SID")
+        raise Puppet::Util::Windows::Error.new(_("Invalid SID"))
       end
 
       sid_string = nil
       FFI::MemoryPointer.new(:pointer, 1) do |buffer_ptr|
         if ConvertSidToStringSidW(psid, buffer_ptr) == FFI::WIN32_FALSE
-          raise Puppet::Util::Windows::Error.new("Failed to convert binary SID")
+          raise Puppet::Util::Windows::Error.new(_("Failed to convert binary SID"))
         end
 
         buffer_ptr.read_win32_local_pointer do |wide_string_ptr|
           if wide_string_ptr.null?
-            raise Puppet::Error.new("ConvertSidToStringSidW failed to allocate buffer for sid")
+            raise Puppet::Error.new(_("ConvertSidToStringSidW failed to allocate buffer for sid"))
           end
 
           sid_string = wide_string_ptr.read_arbitrary_wide_string_up_to(MAXIMUM_SID_STRING_LENGTH)
@@ -155,7 +155,7 @@ module Puppet::Util::Windows
         FFI::MemoryPointer.new(:pointer, 1) do |sid_ptr_ptr|
 
           if ConvertStringSidToSidW(lpcwstr, sid_ptr_ptr) == FFI::WIN32_FALSE
-            raise Puppet::Util::Windows::Error.new("Failed to convert string SID: #{string_sid}")
+            raise Puppet::Util::Windows::Error.new(_("Failed to convert string SID: %{string_sid}") % { string_sid: string_sid })
           end
 
           sid_ptr_ptr.read_win32_local_pointer do |sid_ptr|
@@ -186,7 +186,7 @@ module Puppet::Util::Windows
     def get_length_sid(sid_ptr)
       # MSDN states IsValidSid should be called on pointer first
       if ! sid_ptr.kind_of?(FFI::Pointer) || IsValidSid(sid_ptr) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new("Invalid SID")
+        raise Puppet::Util::Windows::Error.new(_("Invalid SID"))
       end
 
       GetLengthSid(sid_ptr)