puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

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

@@ -2,15 +2,82 @@ require 'puppet/util/windows'
 
 # represents an error resulting from a Win32 error code
 class Puppet::Util::Windows::Error < Puppet::Error
-  require 'windows/error'
-  include ::Windows::Error
+  require 'ffi'
+  extend FFI::Library
 
   attr_reader :code
 
-  def initialize(message, code = GetLastError.call, original = nil)
-    super(message + ":  #{get_last_error(code)}", 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)
+    super(message + ":  #{self.class.format_error_code(code)}", original)
 
     @code = code
   end
-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

@@ -2,149 +2,140 @@ require 'puppet/util/windows'
 
 module Puppet::Util::Windows::File
   require 'ffi'
-  require 'windows/api'
+  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 = Puppet::Util::Windows::String.wide_string(target.to_s)
-    source_encoded = Puppet::Util::Windows::String.wide_string(source.to_s)
+    target_encoded = wide_string(target.to_s)
+    source_encoded = wide_string(source.to_s)
 
     flags = 0x1
     backup_file = nil
-    result = API.replace_file(
+    result = ReplaceFileW(
       target_encoded,
       source_encoded,
       backup_file,
       flags,
-      0,
-      0
+      FFI::Pointer::NULL,
+      FFI::Pointer::NULL
     )
 
-    return true if result
+    return true if result != FFI::WIN32_FALSE
     raise Puppet::Util::Windows::Error.new("ReplaceFile(#{target}, #{source})")
   end
   module_function :replace_file
 
-  MoveFileEx = Windows::API.new('MoveFileExW', 'PPL', 'B')
   def move_file_ex(source, target, flags = 0)
-    result = MoveFileEx.call(Puppet::Util::Windows::String.wide_string(source.to_s),
-                             Puppet::Util::Windows::String.wide_string(target.to_s),
-                             flags)
-    return true unless result == 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
 
-  module API
-    extend FFI::Library
-    ffi_lib 'kernel32'
-    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
-    # );
-    attach_function :replace_file, :ReplaceFileW,
-      [:buffer_in, :buffer_in, :buffer_in, :uint, :uint, :uint], :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
-      attach_function :create_symbolic_link, :CreateSymbolicLinkW,
-        [:buffer_in, :buffer_in, :uint], :bool
-    rescue LoadError
-    end
-
-    # DWORD WINAPI GetFileAttributes(
-    #   _In_  LPCTSTR lpFileName
-    # );
-    attach_function :get_file_attributes, :GetFileAttributesW,
-      [:buffer_in], :uint
-
-    # 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
-    # );
-    attach_function :create_file, :CreateFileW,
-      [:buffer_in, :uint, :uint, :pointer, :uint, :uint, :uint], :uint
-
-    # 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
-    # );
-    attach_function :device_io_control, :DeviceIoControl,
-      [:uint, :uint, :pointer, :uint, :pointer, :uint, :pointer, :pointer], :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 ReparseDataBuffer < FFI::Struct
-      layout :reparse_tag, :uint,
-             :reparse_data_length, :ushort,
-             :reserved, :ushort,
-             :substitute_name_offset, :ushort,
-             :substitute_name_length, :ushort,
-             :print_name_offset, :ushort,
-             :print_name_length, :ushort,
-             :flags, :uint,
-             # max less above fields dword / uint 4 bytes, ushort 2 bytes
-             :path_buffer, [:uchar, MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 20]
-    end
-
-    # BOOL WINAPI CloseHandle(
-    #   _In_  HANDLE hObject
-    # );
-    attach_function :close_handle, :CloseHandle, [:uint], :bool
-  end
-
   def symlink(target, symlink)
     flags = File.directory?(target) ? 0x1 : 0x0
-    result = API.create_symbolic_link(Puppet::Util::Windows::String.wide_string(symlink.to_s),
-      Puppet::Util::Windows::String.wide_string(target.to_s), flags)
-    return true if result
+    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 self.get_file_attributes(file_name)
-    result = API.get_file_attributes(Puppet::Util::Windows::String.wide_string(file_name.to_s))
+
+  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
 
-  INVALID_HANDLE_VALUE = -1 #define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
+    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 = API.create_file(Puppet::Util::Windows::String.wide_string(file_name.to_s),
+    result = CreateFileW(wide_string(file_name.to_s),
       desired_access, share_mode, security_attributes, creation_disposition,
       flags_and_attributes, template_file_handle)
 
@@ -155,31 +146,47 @@ module Puppet::Util::Windows::File
         "#{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
 
-    result = API.device_io_control(
-      handle,
-      io_control_code,
-      in_buffer, in_buffer.nil? ? 0 : in_buffer.size,
-      out_buffer, out_buffer.size,
-      FFI::MemoryPointer.new(:uint, 1),
-      nil
-    )
+    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
 
-    return out_buffer if result
-    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 : ''}")
+    out_buffer
   end
 
   FILE_ATTRIBUTE_REPARSE_POINT = 0x400
   def symlink?(file_name)
     begin
-      attributes = get_file_attributes(file_name)
+      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
@@ -189,7 +196,11 @@ module Puppet::Util::Windows::File
   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
@@ -197,7 +208,7 @@ module Puppet::Util::Windows::File
   def self.open_symlink(link_name)
     begin
       yield handle = create_file(
-      Puppet::Util::Windows::String.wide_string(link_name.to_s),
+      link_name,
       GENERIC_READ,
       FILE_SHARE_READ,
       nil, # security_attributes
@@ -205,14 +216,20 @@ module Puppet::Util::Windows::File
       FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
       0) # template_file
     ensure
-      API.close_handle(handle) if handle
+      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|
-      resolve_symlink(handle)
+      link = resolve_symlink(handle)
     end
+
+    link
   end
   module_function :readlink
 
@@ -265,15 +282,120 @@ module Puppet::Util::Windows::File
   FSCTL_GET_REPARSE_POINT = 0x900a8
 
   def self.resolve_symlink(handle)
-    # must be multiple of 1024, min 10240
-    out_buffer = FFI::MemoryPointer.new(API::ReparseDataBuffer.size)
-    device_io_control(handle, FSCTL_GET_REPARSE_POINT, nil, out_buffer)
+    path = nil
+    get_reparse_point_data(handle) do |reparse_data|
+      offset = reparse_data[:PrintNameOffset]
+      length = reparse_data[:PrintNameLength]
 
-    reparse_data = API::ReparseDataBuffer.new(out_buffer)
-    offset = reparse_data[:print_name_offset]
-    length = reparse_data[:print_name_length]
+      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
 
-    result = reparse_data[:path_buffer].to_a[offset, length].pack('C*')
-    result.force_encoding('UTF-16LE').encode(Encoding.default_external)
+  # 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