chef 18.6.2-universal-mingw-ucrt

data/lib/chef/win32/file/version_info.rb

@@ -0,0 +1,94 @@
+#
+# Author:: Matt Wrock (<matt@mattwrock.com>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../file"
+
+class Chef
+  module ReservedNames::Win32
+    class File
+
+      class VersionInfo
+
+        include Chef::ReservedNames::Win32::API::File
+
+        def initialize(file_name)
+          raise Errno::ENOENT, file_name unless ::File.exist?(file_name)
+
+          @file_version_info = retrieve_file_version_info(file_name)
+        end
+
+        # defining method for each predefined version resource string
+        # see https://msdn.microsoft.com/en-us/library/windows/desktop/ms647464(v=vs.85).aspx
+        %i{
+          Comments
+          CompanyName
+          FileDescription
+          FileVersion
+          InternalName
+          LegalCopyright
+          LegalTrademarks
+          OriginalFilename
+          ProductName
+          ProductVersion
+          PrivateBuild
+          SpecialBuild
+        }.each do |method|
+          define_method method do
+
+            get_version_info_string(method.to_s)
+          rescue Chef::Exceptions::Win32APIError
+            return nil
+
+          end
+        end
+
+        private
+
+        def translation
+          @translation ||= begin
+            info_ptr = FFI::MemoryPointer.new(:pointer)
+            unless VerQueryValueW(@file_version_info, "\\VarFileInfo\\Translation".to_wstring, info_ptr, FFI::MemoryPointer.new(:int))
+              Chef::ReservedNames::Win32::Error.raise!
+            end
+
+            # there can potentially be multiple translations but most installers just have one
+            # we use the first because we use this for the version strings which are language
+            # agnostic. If/when we need other fields, we should we should add logic to find
+            # the "best" translation
+            trans = Translation.new(info_ptr.read_pointer)
+            to_hex(trans[:w_lang]) + to_hex(trans[:w_code_page])
+          end
+        end
+
+        def to_hex(integer)
+          integer.to_s(16).rjust(4, "0")
+        end
+
+        def get_version_info_string(string_key)
+          info_ptr = FFI::MemoryPointer.new(:pointer)
+          size_ptr = FFI::MemoryPointer.new(:int)
+          unless VerQueryValueW(@file_version_info, "\\StringFileInfo\\#{translation}\\#{string_key}".to_wstring, info_ptr, size_ptr)
+            Chef::ReservedNames::Win32::Error.raise!
+          end
+
+          info_ptr.read_pointer.read_wstring(size_ptr.read_uint)
+        end
+      end
+    end
+  end
+end

data/lib/chef/win32/file.rb

@@ -0,0 +1,221 @@
+#
+# Author:: Seth Chisamore (<schisamo@chef.io>)
+# Author:: Mark Mzyk (<mmzyk@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../mixin/wide_string"
+require_relative "api/file"
+require_relative "api/security"
+require_relative "error"
+require_relative "unicode"
+require_relative "version"
+
+class Chef
+  module ReservedNames::Win32
+    class File
+      include Chef::ReservedNames::Win32::API::File
+      extend Chef::ReservedNames::Win32::API::File
+
+      include Chef::Mixin::WideString
+      extend Chef::Mixin::WideString
+
+      # Creates a symbolic link called +new_name+ for the file or directory
+      # +old_name+.
+      #
+      # This method requires Windows Vista or later to work. Otherwise, it
+      # returns nil as per MRI.
+      #
+      def self.link(old_name, new_name)
+        raise Errno::ENOENT, "(#{old_name}, #{new_name})" unless ::File.exist?(old_name) || ::File.symlink?(old_name)
+
+        # TODO do a check for CreateHardLinkW and
+        # raise NotImplemented exception on older Windows
+        old_name = encode_path(old_name)
+        new_name = encode_path(new_name)
+        unless CreateHardLinkW(new_name, old_name, nil)
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+      # Creates a symbolic link called +new_name+ for the file or directory
+      # +old_name+.
+      #
+      # This method requires Windows Vista or later to work. Otherwise, it
+      # returns nil as per MRI.
+      #
+      def self.symlink(old_name, new_name)
+        # raise Errno::ENOENT, "(#{old_name}, #{new_name})" unless ::File.exist?(old_name) || ::File.symlink?(old_name)
+        # TODO do a check for CreateSymbolicLinkW and
+        # raise NotImplemented exception on older Windows
+        flags = ::File.directory?(old_name) ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0
+        flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE if Chef::ReservedNames::Win32::Version.new.win_10_creators_or_higher?
+        old_name = encode_path(old_name)
+        new_name = encode_path(new_name)
+        unless CreateSymbolicLinkW(new_name, old_name, flags)
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+      # Return true if the named file is a symbolic link, false otherwise.
+      #
+      # This method requires Windows Vista or later to work. Otherwise, it
+      # always returns false as per MRI.
+      #
+      def self.symlink?(file_name)
+        is_symlink = false
+        path = encode_path(file_name)
+        if ::File.exist?(file_name) || ::File.symlink?(file_name)
+          if (GetFileAttributesW(path) & FILE_ATTRIBUTE_REPARSE_POINT) > 0
+            file_search_handle(file_name) do |handle, find_data|
+              if find_data[:dw_reserved_0] == IO_REPARSE_TAG_SYMLINK
+                is_symlink = true
+              end
+            end
+          end
+        end
+        is_symlink
+      end
+
+      def self.realpath(file_name)
+        if symlink?(file_name)
+          readlink(file_name)
+        else
+          file_name
+        end
+      end
+
+      # Returns the path of the of the symbolic link referred to by +file+.
+      #
+      # Requires Windows Vista or later. On older versions of Windows it
+      # will raise a NotImplementedError, as per MRI.
+      #
+      def self.readlink(link_name)
+        raise Errno::ENOENT, link_name unless ::File.exist?(link_name) || ::File.symlink?(link_name)
+
+        symlink_file_handle(link_name) do |handle|
+          # Go to DeviceIoControl to get the symlink information
+          # http://msdn.microsoft.com/en-us/library/windows/desktop/aa364571(v=vs.85).aspx
+          reparse_buffer = FFI::MemoryPointer.new(MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
+          parsed_size = FFI::Buffer.new(:long).write_long(0)
+          if DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, nil, 0, reparse_buffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE, parsed_size, nil) == 0
+            Chef::ReservedNames::Win32::Error.raise!
+          end
+
+          # Ensure it's a symbolic link
+          reparse_buffer = REPARSE_DATA_BUFFER.new(reparse_buffer)
+          if reparse_buffer[:ReparseTag] != IO_REPARSE_TAG_SYMLINK
+            raise Errno::EACCES, "#{link_name} is not a symlink"
+          end
+
+          # Return the link destination (strip off \??\ at the beginning, which is a local filesystem thing)
+          link_dest = reparse_buffer.reparse_buffer.substitute_name
+          if /^\\\?\?\\/.match?(link_dest)
+            link_dest = link_dest[4..]
+          end
+          link_dest
+        end
+      end
+
+      # Gets the short form of a path (Administrator -> ADMINI~1)
+      def self.get_short_path_name(path)
+        path = path.to_wstring
+        size = GetShortPathNameW(path, nil, 0)
+        if size == 0
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        result = FFI::MemoryPointer.new :char, (size + 1) * 2
+        if GetShortPathNameW(path, result, size + 1) == 0
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        result.read_wstring(size)
+      end
+
+      # Gets the long form of a path (ADMINI~1 -> Administrator)
+      def self.get_long_path_name(path)
+        path = path.to_wstring
+        size = GetLongPathNameW(path, nil, 0)
+        if size == 0
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        result = FFI::MemoryPointer.new :char, (size + 1) * 2
+        if GetLongPathNameW(path, result, size + 1) == 0
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        result.read_wstring(size)
+      end
+
+      def self.info(file_name)
+        Info.new(file_name)
+      end
+
+      def self.version_info(file_name)
+        VersionInfo.new(file_name)
+      end
+
+      def self.file_access_check(path, desired_access)
+        security_descriptor = Chef::ReservedNames::Win32::Security.get_file_security(path)
+        token_rights = Chef::ReservedNames::Win32::Security::TOKEN_IMPERSONATE |
+          Chef::ReservedNames::Win32::Security::TOKEN_QUERY |
+          Chef::ReservedNames::Win32::Security::TOKEN_DUPLICATE |
+          Chef::ReservedNames::Win32::Security::STANDARD_RIGHTS_READ
+        token = Chef::ReservedNames::Win32::Security.open_process_token(
+          Chef::ReservedNames::Win32::Process.get_current_process,
+          token_rights
+        )
+        duplicate_token = token.duplicate_token(:SecurityImpersonation)
+
+        mapping = Chef::ReservedNames::Win32::Security::GENERIC_MAPPING.new
+        mapping[:GenericRead] = Chef::ReservedNames::Win32::Security::FILE_GENERIC_READ
+        mapping[:GenericWrite] = Chef::ReservedNames::Win32::Security::FILE_GENERIC_WRITE
+        mapping[:GenericExecute] = Chef::ReservedNames::Win32::Security::FILE_GENERIC_EXECUTE
+        mapping[:GenericAll] = Chef::ReservedNames::Win32::Security::FILE_ALL_ACCESS
+
+        Chef::ReservedNames::Win32::Security.access_check(security_descriptor, duplicate_token,
+          desired_access, mapping)
+      end
+
+      def self.delete_volume_mount_point(mount_point)
+        unless DeleteVolumeMountPointW(wstring(mount_point))
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+      def self.set_volume_mount_point(mount_point, name)
+        unless SetVolumeMountPointW(wstring(mount_point), wstring(name))
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+      def self.get_volume_name_for_volume_mount_point(mount_point)
+        buffer = FFI::MemoryPointer.new(2, 128)
+        unless GetVolumeNameForVolumeMountPointW(wstring(mount_point), buffer, buffer.size / buffer.type_size)
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        buffer.read_wstring
+      end
+
+      # ::File compat
+      class << self
+        alias :stat :info
+      end
+
+    end
+  end
+end
+
+require_relative "file/info"
+require_relative "file/version_info"

data/lib/chef/win32/handle.rb

@@ -0,0 +1,54 @@
+#
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "api/process"
+require_relative "api/psapi"
+require_relative "api/system"
+require_relative "error"
+
+class Chef
+  module ReservedNames::Win32
+    class Handle
+      extend Chef::ReservedNames::Win32::API::Process
+
+      def initialize(handle)
+        @handle = handle
+        ObjectSpace.define_finalizer(self, Handle.close_handle_finalizer(handle))
+      end
+
+      attr_reader :handle
+
+      def self.close_handle_finalizer(handle)
+        proc { close_handle(handle) }
+      end
+
+      def self.close_handle(handle)
+        # According to http://msdn.microsoft.com/en-us/library/windows/desktop/ms683179(v=vs.85).aspx, it is not necessary
+        # to close the pseudo handle returned by the GetCurrentProcess function.  The docs also say that it doesn't hurt to call
+        # CloseHandle on it. However, doing so from inside of Ruby always seems to produce an invalid handle error.
+        # The recommendation is to use GetCurrentProcess instead of the const (HANDLE)-1, to ensure we're making the correct comparison.
+        return if handle == GetCurrentProcess()
+
+        unless CloseHandle(handle)
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/win32/memory.rb

@@ -0,0 +1,101 @@
+#
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "error"
+require_relative "api/memory"
+
+class Chef
+  module ReservedNames::Win32
+    class Memory
+      include Chef::ReservedNames::Win32::API::Memory
+      extend Chef::ReservedNames::Win32::API::Memory
+
+      # local_alloc(length[, flags]) [BLOCK]
+      # Allocates memory using LocalAlloc
+      # If BLOCK is specified, the memory will be passed
+      # to the block and freed afterwards.
+      def self.local_alloc(length, flags = LPTR, &block)
+        result = LocalAlloc(flags, length)
+        if result.null?
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        # If a block is passed, handle freeing the memory at the end
+        if !block.nil?
+          begin
+            yield result
+          ensure
+            local_free(result)
+          end
+        else
+          result
+        end
+      end
+
+      # local_discard(pointer)
+      # Discard memory.  Equivalent to local_realloc(pointer, 0)
+      def self.local_discard(pointer)
+        local_realloc(pointer, 0, LMEM_MOVEABLE)
+      end
+
+      # local_flags(pointer)
+      # Get lock count and Windows flags for local_alloc allocated memory.
+      # Use: flags, lock_count = local_flags(pointer)
+      def self.local_flags(pointer)
+        result = LocalFlags(pointer)
+        if result == LMEM_INVALID_HANDLE
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        [ result & ~LMEM_LOCKCOUNT, result & LMEM_LOCKCOUNT ]
+      end
+
+      # local_free(pointer)
+      # Free memory allocated using local_alloc
+      def self.local_free(pointer)
+        result = LocalFree(pointer)
+        unless result.null?
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+      # local_realloc(pointer, size[, flags])
+      # Resizes memory allocated using LocalAlloc.
+      def self.local_realloc(pointer, size, flags = LMEM_MOVEABLE | LMEM_ZEROINIT)
+        result = LocalReAlloc(pointer, size, flags)
+        if result.null?
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        result
+      end
+
+      # local_size(pointer)
+      # Gets the size of memory allocated using LocalAlloc.
+      def self.local_size(pointer)
+        result = LocalSize(pointer)
+        if result == 0
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        result
+      end
+
+      def self.local_free_finalizer(pointer)
+        proc { local_free(pointer) }
+      end
+
+    end
+  end
+end

data/lib/chef/win32/mutex.rb

@@ -0,0 +1,116 @@
+#
+# Author:: Serdar Sutay (<serdar@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "api/synchronization"
+require_relative "unicode"
+
+class Chef
+  module ReservedNames::Win32
+    class Mutex
+      include Chef::ReservedNames::Win32::API::Synchronization
+
+      def initialize(name)
+        @name = name
+        create_system_mutex
+      end
+
+      attr_reader :handle
+      attr_reader :name
+
+      #####################################################
+      # Attempts to grab the mutex.
+      # Returns true if the mutex is grabbed or if it's already
+      # owned; false otherwise.
+      def test
+        WaitForSingleObject(handle, 0) == WAIT_OBJECT_0
+      end
+
+      #####################################################
+      # Attempts to grab the mutex and waits until it is acquired.
+      def wait
+        loop do
+          wait_result = WaitForSingleObject(handle, 1000)
+          case wait_result
+          when WAIT_TIMEOUT
+            # We are periodically waking up in order to give ruby a
+            # chance to process any signal it got while we were
+            # sleeping. This condition shouldn't contain any logic
+            # other than sleeping.
+            sleep 0.1
+          when WAIT_ABANDONED
+            # Previous owner of the mutex died before it can release the
+            # mutex. Log a warning and continue.
+            Chef::Log.trace "Existing owner of the mutex exited prematurely."
+            break
+          when WAIT_OBJECT_0
+            # Mutex is successfully acquired.
+            break
+          else
+            Chef::Log.error("Failed to acquire system mutex '#{name}'. Return code: #{wait_result}")
+            Chef::ReservedNames::Win32::Error.raise!
+          end
+        end
+      end
+
+      #####################################################
+      # Releases the mutex
+      def release
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms685066(v=vs.85).aspx
+        # Note that release method needs to be called more than once
+        # if mutex is acquired more than once.
+        unless ReleaseMutex(handle)
+          # Don't fail things in here if we can't release the mutex.
+          # Because it will be automatically released when the owner
+          # of the process goes away and this class is only being used
+          # to synchronize chef-clients runs on a node.
+          Chef::Log.error("Can not release mutex '#{name}'. This might cause issues \
+if other threads attempt to acquire the mutex.")
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+      private
+
+      def create_system_mutex
+        # First check if there exists a mutex in the system with the
+        # given name. We need only synchronize rights if a mutex is
+        # already created.
+        # InheritHandle is set to true so that subprocesses can
+        # inherit the ownership of the mutex.
+        @handle = OpenMutexW(SYNCHRONIZE, true, name.to_wstring)
+
+        if @handle == 0
+          # Mutex doesn't exist so create one.
+          # In the initial creation of the mutex initial_owner is set to
+          # false so that mutex will not be acquired until someone calls
+          # acquire.
+          # In order to call "*W" windows apis, strings needs to be
+          # encoded as wide strings.
+          @handle = CreateMutexW(nil, false, name.to_wstring)
+
+          # Looks like we can't create the mutex for some reason.
+          # Fail early.
+          if @handle == 0
+            Chef::Log.error("Failed to create system mutex with name'#{name}'")
+            Chef::ReservedNames::Win32::Error.raise!
+          end
+        end
+      end
+    end
+  end
+end