puppet 3.7.0-x64-mingw32

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

@@ -0,0 +1,224 @@
+require 'ffi'
+
+module Puppet::Util::Windows::COM
+  extend FFI::Library
+
+  ffi_convention :stdcall
+
+  S_OK = 0
+  S_FALSE = 1
+
+  def SUCCEEDED(hr) hr >= 0 end
+  def FAILED(hr) hr < 0 end
+
+  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)})."
+
+    result
+  ensure
+    yield failed if block_given?
+  end
+
+  module_function :raise_if_hresult_failed
+
+  CLSCTX_INPROC_SERVER = 0x1
+  CLSCTX_INPROC_HANDLER = 0x2
+  CLSCTX_LOCAL_SERVER = 0x4
+  CLSCTX_INPROC_SERVER16 = 0x8
+  CLSCTX_REMOTE_SERVER = 0x10
+  CLSCTX_INPROC_HANDLER16 = 0x20
+  CLSCTX_RESERVED1 = 0x40
+  CLSCTX_RESERVED2 = 0x80
+  CLSCTX_RESERVED3 = 0x100
+  CLSCTX_RESERVED4 = 0x200
+  CLSCTX_NO_CODE_DOWNLOAD = 0x400
+  CLSCTX_RESERVED5 = 0x800
+  CLSCTX_NO_CUSTOM_MARSHAL = 0x1000
+  CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000
+  CLSCTX_NO_FAILURE_LOG = 0x4000
+  CLSCTX_DISABLE_AAA = 0x8000
+  CLSCTX_ENABLE_AAA = 0x10000
+  CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000
+  CLSCTX_ACTIVATE_32_BIT_SERVER = 0x40000
+  CLSCTX_ACTIVATE_64_BIT_SERVER = 0x80000
+  CLSCTX_ENABLE_CLOAKING = 0x100000
+  CLSCTX_PS_DLL = -0x80000000
+  CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER
+  CLSCTX_ALL = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
+  CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/ms686615(v=vs.85).aspx
+  # HRESULT CoCreateInstance(
+  #   _In_   REFCLSID rclsid,
+  #   _In_   LPUNKNOWN pUnkOuter,
+  #   _In_   DWORD dwClsContext,
+  #   _In_   REFIID riid,
+  #   _Out_  LPVOID *ppv
+  # );
+  ffi_lib :ole32
+  attach_function_private :CoCreateInstance,
+    [:pointer, :lpunknown, :dword, :pointer, :lpvoid], :hresult
+
+  # code modified from Unknownr project https://github.com/rpeev/Unknownr
+  # licensed under MIT
+  module Interface
+    def self.[](*args)
+      spec, iid, *ifaces = args.reverse
+
+      spec.each { |name, signature| signature[0].unshift(:pointer) }
+
+      Class.new(FFI::Struct) do
+        const_set(:IID, iid)
+
+        vtable = Class.new(FFI::Struct) do
+          vtable_hash = Hash[(ifaces.map { |iface| iface::VTBL::SPEC.to_a } << spec.to_a).flatten(1)]
+          const_set(:SPEC, vtable_hash)
+
+          layout \
+            *self::SPEC.map { |name, signature| [name, callback(*signature)] }.flatten
+        end
+
+        const_set(:VTBL, vtable)
+
+        layout \
+          :lpVtbl, :pointer
+      end
+    end
+  end
+
+  module Helpers
+    def QueryInstance(klass)
+      instance = nil
+
+      FFI::MemoryPointer.new(:pointer) do |ppv|
+        QueryInterface(klass::IID, ppv)
+
+        instance = klass.new(ppv.read_pointer)
+      end
+
+      begin
+        yield instance
+        return self
+      ensure
+        instance.Release
+      end if block_given?
+
+      instance
+    end
+
+    def UseInstance(klass, name, *args)
+      instance = nil
+
+      FFI::MemoryPointer.new(:pointer) do |ppv|
+        send(name, *args, ppv)
+
+        yield instance = klass.new(ppv.read_pointer)
+      end
+
+      self
+    ensure
+      instance.Release if instance && ! instance.null?
+    end
+  end
+
+  module Instance
+    def self.[](iface)
+      Class.new(iface) do
+        send(:include, Helpers)
+
+        def initialize(pointer)
+          self.pointer = pointer
+
+          @vtbl = self.class::VTBL.new(self[:lpVtbl])
+        end
+
+        attr_reader :vtbl
+
+        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)
+            end
+            result
+          end
+        end
+
+        layout \
+          :lpVtbl, :pointer
+      end
+    end
+  end
+
+  module Factory
+    def self.[](iface, clsid)
+      Class.new(iface) do
+        send(:include, Helpers)
+
+        const_set(:CLSID, clsid)
+
+        def initialize(opts = {})
+          @opts = opts
+
+          @opts[:clsctx] ||= CLSCTX_INPROC_SERVER
+
+          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})."
+            end
+
+            self.pointer = ppv.read_pointer
+          end
+
+          @vtbl = self.class::VTBL.new(self[:lpVtbl])
+        end
+
+        attr_reader :vtbl
+
+        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)
+            end
+            result
+          end
+        end
+
+        layout \
+          :lpVtbl, :pointer
+      end
+    end
+  end
+
+  IUnknown = Interface[
+    FFI::WIN32::GUID['00000000-0000-0000-C000-000000000046'],
+
+    QueryInterface: [[:pointer, :pointer], :hresult],
+    AddRef: [[], :win32_ulong],
+    Release: [[], :win32_ulong]
+  ]
+
+  Unknown = Instance[IUnknown]
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/ms678543(v=vs.85).aspx
+  # HRESULT CoInitialize(
+  #   _In_opt_  LPVOID pvReserved
+  # );
+  ffi_lib :ole32
+  attach_function_private :CoInitialize, [:lpvoid], :hresult
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/ms688715(v=vs.85).aspx
+  # void CoUninitialize(void);
+  ffi_lib :ole32
+  attach_function_private :CoUninitialize, [], :void
+
+  def InitializeCom
+    raise_if_hresult_failed(:CoInitialize, FFI::Pointer::NULL)
+
+    at_exit { CoUninitialize() }
+  end
+
+  module_function :InitializeCom
+end

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

@@ -0,0 +1,83 @@
+require 'puppet/util/windows'
+
+# represents an error resulting from a Win32 error code
+class Puppet::Util::Windows::Error < Puppet::Error
+  require 'ffi'
+  extend FFI::Library
+
+  attr_reader :code
+
+  # 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)
+    super(message + ":  #{self.class.format_error_code(code)}", original)
+
+    @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 == FFI::WIN32_FALSE
+        # can't raise same error type here or potentially recurse infinitely
+        raise Puppet::Error.new("FormatMessageW could not format 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}")
+        end
+
+        error_string = wide_string_ptr.read_wide_string(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
+
+  ffi_convention :stdcall
+
+  # http://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_private :FormatMessageW,
+    [:dword, :lpcvoid, :dword, :dword, :pointer, :dword, :pointer], :dword
+end

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

@@ -0,0 +1,401 @@
+require 'puppet/util/windows'
+
+module Puppet::Util::Windows::File
+  require 'ffi'
+  extend FFI::Library
+  extend Puppet::Util::Windows::String
+
+  FILE_ATTRIBUTE_READONLY      = 0x00000001
+
+  SYNCHRONIZE                 = 0x100000
+  STANDARD_RIGHTS_REQUIRED    = 0xf0000
+  STANDARD_RIGHTS_READ        = 0x20000
+  STANDARD_RIGHTS_WRITE       = 0x20000
+  STANDARD_RIGHTS_EXECUTE     = 0x20000
+  STANDARD_RIGHTS_ALL         = 0x1F0000
+  SPECIFIC_RIGHTS_ALL         = 0xFFFF
+
+  FILE_READ_DATA               = 1
+  FILE_WRITE_DATA              = 2
+  FILE_APPEND_DATA             = 4
+  FILE_READ_EA                 = 8
+  FILE_WRITE_EA                = 16
+  FILE_EXECUTE                 = 32
+  FILE_DELETE_CHILD            = 64
+  FILE_READ_ATTRIBUTES         = 128
+  FILE_WRITE_ATTRIBUTES        = 256
+
+  FILE_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF
+
+  FILE_GENERIC_READ =
+     STANDARD_RIGHTS_READ |
+     FILE_READ_DATA |
+     FILE_READ_ATTRIBUTES |
+     FILE_READ_EA |
+     SYNCHRONIZE
+
+  FILE_GENERIC_WRITE =
+     STANDARD_RIGHTS_WRITE |
+     FILE_WRITE_DATA |
+     FILE_WRITE_ATTRIBUTES |
+     FILE_WRITE_EA |
+     FILE_APPEND_DATA |
+     SYNCHRONIZE
+
+  FILE_GENERIC_EXECUTE =
+     STANDARD_RIGHTS_EXECUTE |
+     FILE_READ_ATTRIBUTES |
+     FILE_EXECUTE |
+     SYNCHRONIZE
+
+  def replace_file(target, source)
+    target_encoded = wide_string(target.to_s)
+    source_encoded = wide_string(source.to_s)
+
+    flags = 0x1
+    backup_file = nil
+    result = ReplaceFileW(
+      target_encoded,
+      source_encoded,
+      backup_file,
+      flags,
+      FFI::Pointer::NULL,
+      FFI::Pointer::NULL
+    )
+
+    return true if result != FFI::WIN32_FALSE
+    raise Puppet::Util::Windows::Error.new("ReplaceFile(#{target}, #{source})")
+  end
+  module_function :replace_file
+
+  def move_file_ex(source, target, flags = 0)
+    result = MoveFileExW(wide_string(source.to_s),
+                         wide_string(target.to_s),
+                         flags)
+
+    return true if result != FFI::WIN32_FALSE
+    raise Puppet::Util::Windows::Error.
+      new("MoveFileEx(#{source}, #{target}, #{flags.to_s(8)})")
+  end
+  module_function :move_file_ex
+
+  def symlink(target, symlink)
+    flags = File.directory?(target) ? 0x1 : 0x0
+    result = CreateSymbolicLinkW(wide_string(symlink.to_s),
+      wide_string(target.to_s), flags)
+    return true if result != FFI::WIN32_FALSE
+    raise Puppet::Util::Windows::Error.new(
+      "CreateSymbolicLink(#{symlink}, #{target}, #{flags.to_s(8)})")
+  end
+  module_function :symlink
+
+  INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF #define INVALID_FILE_ATTRIBUTES (DWORD (-1))
+
+  def get_file_attributes(file_name)
+    Puppet.deprecation_warning('Puppet::Util::Windows::File.get_file_attributes is deprecated; please use Puppet::Util::Windows::File.get_attributes')
+    get_attributes(file_name)
+  end
+  module_function :get_file_attributes
+
+  def get_attributes(file_name)
+    result = GetFileAttributesW(wide_string(file_name.to_s))
+    return result unless result == INVALID_FILE_ATTRIBUTES
+    raise Puppet::Util::Windows::Error.new("GetFileAttributes(#{file_name})")
+  end
+  module_function :get_attributes
+
+  def add_attributes(path, flags)
+    oldattrs = get_attributes(path)
+
+    if (oldattrs | flags) != oldattrs
+      set_attributes(path, oldattrs | flags)
+    end
+  end
+  module_function :add_attributes
+
+  def remove_attributes(path, flags)
+    oldattrs = get_attributes(path)
+
+    if (oldattrs & ~flags) != oldattrs
+      set_attributes(path, oldattrs & ~flags)
+    end
+  end
+  module_function :remove_attributes
+
+  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
+
+    success
+  end
+  module_function :set_attributes
+
+  #define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
+  INVALID_HANDLE_VALUE = FFI::Pointer.new(-1).address
+  def self.create_file(file_name, desired_access, share_mode, security_attributes,
+    creation_disposition, flags_and_attributes, template_file_handle)
+
+    result = CreateFileW(wide_string(file_name.to_s),
+      desired_access, share_mode, security_attributes, creation_disposition,
+      flags_and_attributes, template_file_handle)
+
+    return result unless result == INVALID_HANDLE_VALUE
+    raise Puppet::Util::Windows::Error.new(
+      "CreateFile(#{file_name}, #{desired_access.to_s(8)}, #{share_mode.to_s(8)}, " +
+        "#{security_attributes}, #{creation_disposition.to_s(8)}, " +
+        "#{flags_and_attributes.to_s(8)}, #{template_file_handle})")
+  end
+
+  def self.get_reparse_point_data(handle, &block)
+    # must be multiple of 1024, min 10240
+    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)
+      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.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")
+    end
+
+    FFI::MemoryPointer.new(:dword, 1) do |bytes_returned_ptr|
+      result = DeviceIoControl(
+        handle,
+        io_control_code,
+        in_buffer, in_buffer.nil? ? 0 : in_buffer.size,
+        out_buffer, out_buffer.size,
+        bytes_returned_ptr,
+        nil
+      )
+
+      if result == FFI::WIN32_FALSE
+        raise Puppet::Util::Windows::Error.new(
+          "DeviceIoControl(#{handle}, #{io_control_code}, " +
+          "#{in_buffer}, #{in_buffer ? in_buffer.size : ''}, " +
+          "#{out_buffer}, #{out_buffer ? out_buffer.size : ''}")
+      end
+    end
+
+    out_buffer
+  end
+
+  FILE_ATTRIBUTE_REPARSE_POINT = 0x400
+  def symlink?(file_name)
+    begin
+      attributes = get_attributes(file_name)
+      (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
+    rescue
+      # raised INVALID_FILE_ATTRIBUTES is equivalent to file not found
+      false
+    end
+  end
+  module_function :symlink?
+
+  GENERIC_READ                  = 0x80000000
+  GENERIC_WRITE                 = 0x40000000
+  GENERIC_EXECUTE               = 0x20000000
+  GENERIC_ALL                   = 0x10000000
+  FILE_SHARE_READ               = 1
+  FILE_SHARE_WRITE              = 2
+  OPEN_EXISTING                 = 3
+  FILE_FLAG_OPEN_REPARSE_POINT  = 0x00200000
+  FILE_FLAG_BACKUP_SEMANTICS    = 0x02000000
+
+  def self.open_symlink(link_name)
+    begin
+      yield handle = create_file(
+      link_name,
+      GENERIC_READ,
+      FILE_SHARE_READ,
+      nil, # security_attributes
+      OPEN_EXISTING,
+      FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
+      0) # template_file
+    ensure
+      FFI::WIN32.CloseHandle(handle) if handle
+    end
+
+    # handle has had CloseHandle called against it, so nothing to return
+    nil
+  end
+
+  def readlink(link_name)
+    link = nil
+    open_symlink(link_name) do |handle|
+      link = resolve_symlink(handle)
+    end
+
+    link
+  end
+  module_function :readlink
+
+  def stat(file_name)
+    file_name = file_name.to_s # accomodate PathName or String
+    stat = File.stat(file_name)
+    singleton_class = class << stat; self; end
+    target_path = file_name
+
+    if symlink?(file_name)
+      target_path = readlink(file_name)
+      link_ftype = File.stat(target_path).ftype
+
+      # sigh, monkey patch instance method for instance, and close over link_ftype
+      singleton_class.send(:define_method, :ftype) do
+        link_ftype
+      end
+    end
+
+    singleton_class.send(:define_method, :mode) do
+      Puppet::Util::Windows::Security.get_mode(target_path)
+    end
+
+    stat
+  end
+  module_function :stat
+
+  def lstat(file_name)
+    file_name = file_name.to_s # accomodate PathName or String
+    # monkey'ing around!
+    stat = File.lstat(file_name)
+
+    singleton_class = class << stat; self; end
+    singleton_class.send(:define_method, :mode) do
+      Puppet::Util::Windows::Security.get_mode(file_name)
+    end
+
+    if symlink?(file_name)
+      def stat.ftype
+        "link"
+      end
+    end
+    stat
+  end
+  module_function :lstat
+
+  private
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa364571(v=vs.85).aspx
+  FSCTL_GET_REPARSE_POINT = 0x900a8
+
+  def self.resolve_symlink(handle)
+    path = nil
+    get_reparse_point_data(handle) do |reparse_data|
+      offset = reparse_data[:PrintNameOffset]
+      length = reparse_data[:PrintNameLength]
+
+      ptr = reparse_data.pointer + reparse_data.offset_of(:PathBuffer) + offset
+      path = ptr.read_wide_string(length / 2) # length is bytes, need UTF-16 wchars
+    end
+
+    path
+  end
+
+  ffi_convention :stdcall
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365512(v=vs.85).aspx
+  # BOOL WINAPI ReplaceFile(
+  #   _In_        LPCTSTR lpReplacedFileName,
+  #   _In_        LPCTSTR lpReplacementFileName,
+  #   _In_opt_    LPCTSTR lpBackupFileName,
+  #   _In_        DWORD dwReplaceFlags - 0x1 REPLACEFILE_WRITE_THROUGH,
+  #                                      0x2 REPLACEFILE_IGNORE_MERGE_ERRORS,
+  #                                      0x4 REPLACEFILE_IGNORE_ACL_ERRORS
+  #   _Reserved_  LPVOID lpExclude,
+  #   _Reserved_  LPVOID lpReserved
+  # );
+  ffi_lib :kernel32
+  attach_function_private :ReplaceFileW,
+    [:lpcwstr, :lpcwstr, :lpcwstr, :dword, :lpvoid, :lpvoid], :win32_bool
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365240(v=vs.85).aspx
+  # BOOL WINAPI MoveFileEx(
+  #   _In_      LPCTSTR lpExistingFileName,
+  #   _In_opt_  LPCTSTR lpNewFileName,
+  #   _In_      DWORD dwFlags
+  # );
+  ffi_lib :kernel32
+  attach_function_private :MoveFileExW,
+    [:lpcwstr, :lpcwstr, :dword], :win32_bool
+
+  # BOOLEAN WINAPI CreateSymbolicLink(
+  #   _In_  LPTSTR lpSymlinkFileName, - symbolic link to be created
+  #   _In_  LPTSTR lpTargetFileName, - name of target for symbolic link
+  #   _In_  DWORD dwFlags - 0x0 target is a file, 0x1 target is a directory
+  # );
+  # rescue on Windows < 6.0 so that code doesn't explode
+  begin
+    ffi_lib :kernel32
+    attach_function_private :CreateSymbolicLinkW,
+      [:lpwstr, :lpwstr, :dword], :win32_bool
+  rescue LoadError
+  end
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa364944(v=vs.85).aspx
+  # DWORD WINAPI GetFileAttributes(
+  #   _In_  LPCTSTR lpFileName
+  # );
+  ffi_lib :kernel32
+  attach_function_private :GetFileAttributesW,
+    [:lpcwstr], :dword
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365535(v=vs.85).aspx
+  # BOOL WINAPI SetFileAttributes(
+  #   _In_  LPCTSTR lpFileName,
+  #   _In_  DWORD dwFileAttributes
+  # );
+  ffi_lib :kernel32
+  attach_function_private :SetFileAttributesW,
+    [:lpcwstr, :dword], :win32_bool
+
+  # HANDLE WINAPI CreateFile(
+  #   _In_      LPCTSTR lpFileName,
+  #   _In_      DWORD dwDesiredAccess,
+  #   _In_      DWORD dwShareMode,
+  #   _In_opt_  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+  #   _In_      DWORD dwCreationDisposition,
+  #   _In_      DWORD dwFlagsAndAttributes,
+  #   _In_opt_  HANDLE hTemplateFile
+  # );
+  ffi_lib :kernel32
+  attach_function_private :CreateFileW,
+    [:lpcwstr, :dword, :dword, :pointer, :dword, :dword, :handle], :handle
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa363216(v=vs.85).aspx
+  # BOOL WINAPI DeviceIoControl(
+  #   _In_         HANDLE hDevice,
+  #   _In_         DWORD dwIoControlCode,
+  #   _In_opt_     LPVOID lpInBuffer,
+  #   _In_         DWORD nInBufferSize,
+  #   _Out_opt_    LPVOID lpOutBuffer,
+  #   _In_         DWORD nOutBufferSize,
+  #   _Out_opt_    LPDWORD lpBytesReturned,
+  #   _Inout_opt_  LPOVERLAPPED lpOverlapped
+  # );
+  ffi_lib :kernel32
+  attach_function_private :DeviceIoControl,
+    [:handle, :dword, :lpvoid, :dword, :lpvoid, :dword, :lpdword, :pointer], :win32_bool
+
+  MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16384
+
+  # REPARSE_DATA_BUFFER
+  # http://msdn.microsoft.com/en-us/library/cc232006.aspx
+  # http://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
+  # struct is always MAXIMUM_REPARSE_DATA_BUFFER_SIZE bytes
+  class REPARSE_DATA_BUFFER < FFI::Struct
+    layout :ReparseTag, :win32_ulong,
+           :ReparseDataLength, :ushort,
+           :Reserved, :ushort,
+           :SubstituteNameOffset, :ushort,
+           :SubstituteNameLength, :ushort,
+           :PrintNameOffset, :ushort,
+           :PrintNameLength, :ushort,
+           :Flags, :win32_ulong,
+           # 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 - 20]
+  end
+end