win32ole-ffi 0.1.0

data/lib/win32ole/ffi/typelib.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+require 'win32ole/ffi/win32'
+require 'win32ole/ffi/typeinfo'
+require 'win32ole/ffi/type'
+
+class WIN32OLE
+  class TypeLib
+    W = Win32
+    TI = TypeInfo
+    private_constant :W, :TI
+
+    LIBFLAG_FRESTRICTED = 0x1
+    LIBFLAG_FHIDDEN = 0x4
+
+    # Mirrors ext/win32ole/win32ole_typelib.c's foletypelib_initialize:
+    # +typelib+ is tried, in order, as a registered typelib name
+    # (major/minor ignored if this matches), then as a typelib GUID
+    # (major/minor pick a specific version, else the highest registered),
+    # then as a literal file path.
+    def self.new(*args)
+      unless (1..3).cover?(args.size)
+        raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 1..3)"
+      end
+
+      typelib = check_string!(args[0])
+      file = file_from_name(typelib) || file_from_guid_and_version(typelib, args[1], args[2])
+      itypelib_ptr = load_typelib(file || typelib)
+      raise WIN32OLE::RuntimeError, "not found type library `#{typelib}`" if itypelib_ptr.nil?
+
+      allocate.tap { |tlib| tlib.send(:initialize, itypelib_ptr) }
+    end
+
+    def self.check_string!(val)
+      return val if val.is_a?(::String)
+      return val.to_str if val.respond_to?(:to_str)
+
+      raise TypeError, "no implicit conversion of #{val.class} into String"
+    end
+
+    def self.load_typelib(file)
+      out = ("\x00" * W::PTR_SIZE).b
+      hr = TI.load_type_lib_ex.call(W.wstr(file), TI::REGKIND_NONE, out)
+      return nil if W.failed?(hr)
+
+      out.unpack1(W::PACK_PTR)
+    end
+
+    # Mirrors oletypelib_search_registry2: +guid+ is a typelib GUID
+    # string (TypeLib\{guid} directly, not the CLSID\{clsid} root
+    # file_from_clsid uses). If major is given, only that exact version
+    # is accepted; otherwise the highest version with a registered name
+    # wins, same tie-break as file_from_name_under_guid.
+    def self.file_from_guid_and_version(guid, major, minor)
+      with_reg_subkey(TI::HKEY_CLASSES_ROOT, "TypeLib\\#{guid}") do |hguid|
+        version = version_string(major, minor)
+        if version
+          valid = with_reg_subkey(hguid, version) { |hversion| !reg_default_string_value(hversion).nil? }
+          version = nil unless valid
+        else
+          version = highest_named_version_under(hguid)
+        end
+        version && file_under_version_key(hguid, version)
+      end
+    end
+
+    def self.version_string(major, minor)
+      return nil if major.nil?
+
+      minor.nil? ? major.to_s : "#{major}.#{minor}"
+    end
+
+    def self.highest_named_version_under(hguid)
+      best_version = nil
+      best_fver = nil
+      i = 0
+      while (version = TI.reg_enum_key(hguid, i))
+        i += 1
+        fver = version.to_f
+        next if best_fver && fver <= best_fver
+
+        valid = with_reg_subkey(hguid, version) { |hversion| !reg_default_string_value(hversion).nil? }
+        if valid
+          best_fver = fver
+          best_version = version
+        end
+      end
+      best_version
+    end
+
+    def self.from_itypelib_ptr(itypelib_ptr)
+      allocate.tap { |tlib| tlib.send(:initialize, itypelib_ptr) }
+    end
+
+    def initialize(itypelib_ptr)
+      # As the C allocator does, so the finalizer's ole_initialized? check
+      # holds on the thread that made this object.
+      WIN32OLE.ole_initialize
+      @ptr = itypelib_ptr
+      # Install the finalizer before any call that could raise: the caller
+      # has already AddRef'd this pointer, so if GetLibAttr/read_documentation
+      # (or the vtable lookups they perform) raise, this Release must still
+      # happen -- otherwise the reference leaks permanently.
+      install_finalizer
+
+      lib_attr_out = ("\x00" * W::PTR_SIZE).b
+      hr = TI.lib_attr_fn(@ptr).call(@ptr, lib_attr_out)
+      if W.failed?(hr)
+        raise WIN32OLE::QueryInterfaceError, W.query_interface_error_message('GetLibAttr', W.hr_hex(hr))
+      end
+      attr_ptr = lib_attr_out.unpack1(W::PACK_PTR)
+      p = Fiddle::Pointer.new(attr_ptr)
+      @guid_bytes = p[0, 16]
+      @lcid = p[16, 4].unpack1('L')
+      @major = p[16 + 4 + 4, 2].unpack1('S') # skip lcid(4) + syskind(4, enum-sized)
+      @minor = p[16 + 4 + 4 + 2, 2].unpack1('S')
+      @lib_flags = p[16 + 4 + 4 + 2 + 2, 2].unpack1('S')
+      TI.release_tlib_attr_fn(@ptr).call(@ptr, attr_ptr)
+
+      @name, @helpstring, @help_context, @helpfile = read_documentation(@ptr, -1)
+    end
+
+    def guid
+      d1, d2, d3 = @guid_bytes.unpack('LSS')
+      d4 = @guid_bytes[8, 8].unpack('C8')
+      format('{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}', d1, d2, d3, *d4)
+    end
+
+    def name
+      @helpstring
+    end
+    alias to_s name
+
+    def version
+      "#{@major}.#{@minor}"
+    end
+
+    def major_version
+      @major
+    end
+
+    def minor_version
+      @minor
+    end
+
+    def visible?
+      !(@lib_flags.zero? || (@lib_flags & (LIBFLAG_FRESTRICTED | LIBFLAG_FHIDDEN)) != 0)
+    end
+
+    def library_name
+      @name
+    end
+
+    def path
+      reg_path_lookup(guid, version, @lcid)
+    end
+
+    def ole_types
+      count = TI.type_info_count_fn(@ptr).call(@ptr)
+      Array.new(count) do |i|
+        ti_out = ("\x00" * W::PTR_SIZE).b
+        hr = TI.type_info_fn(@ptr).call(@ptr, i, ti_out)
+        next nil if W.failed?(hr)
+
+        begin
+          WIN32OLE::Type.from_typeinfo_ptr(ti_out.unpack1(W::PACK_PTR))
+        rescue WIN32OLE::QueryInterfaceError
+          # Matches MRI (ext/win32ole/win32ole_typelib.c's ole_types_from_typelib),
+          # which skips entries it can't build a Type for rather than
+          # failing the whole array -- one unreadable type in a typelib
+          # shouldn't break every other type (and, transitively, every
+          # object's #ole_methods) from that same library.
+          nil
+        end
+      end.compact
+    end
+
+    def inspect
+      "#<WIN32OLE::TypeLib:#{name}>"
+    end
+
+    alias ole_classes ole_types
+
+    # ext/win32ole/win32ole_typelib.c's foletypelib_s_typelibs: every
+    # HKCR\TypeLib\{guid}\{version} with a registered name whose file
+    # LoadTypeLibEx can open.
+    def self.typelibs
+      tlibs = []
+      with_reg_subkey(TI::HKEY_CLASSES_ROOT, 'TypeLib') do |htypelib|
+        each_reg_subkey_name(htypelib) do |guid|
+          with_reg_subkey(htypelib, guid) do |hguid|
+            each_reg_subkey_name(hguid) do |version|
+              next unless with_reg_subkey(hguid, version) { |hversion| reg_default_string_value(hversion) }
+
+              file = file_under_version_key(hguid, version)
+              ptr = file && load_typelib(file)
+              next unless ptr
+
+              begin
+                tlibs << from_itypelib_ptr(ptr)
+              rescue WIN32OLE::QueryInterfaceError
+                # unreadable TLIBATTR; its finalizer still releases ptr
+              end
+            end
+          end
+        end
+      end
+      tlibs
+    end
+
+    def self.each_reg_subkey_name(hkey)
+      i = 0
+      while (name = TI.reg_enum_key(hkey, i))
+        i += 1
+        yield name
+      end
+    end
+
+    # Mirrors ext/win32ole/win32ole_typelib.c's typelib_file: resolves a
+    # typelib name (e.g. "Microsoft Shell Controls And Automation") or a
+    # CLSID string (e.g. a COM class's own CLSID, whose InprocServer32 DLL
+    # commonly embeds the same typelib) to the file LoadTypeLibEx needs.
+    # Used by WIN32OLE::Type.new's name-based lookup. Returns nil if
+    # neither resolves -- the caller then tries the original string
+    # itself as a literal file path, same as the C fallback.
+    def self.file_for(typelib)
+      file_from_clsid(typelib) || file_from_name(typelib)
+    end
+
+    def self.file_from_clsid(clsid_str)
+      with_reg_subkey(TI::HKEY_CLASSES_ROOT, "CLSID\\#{clsid_str}\\InprocServer32") do |hkey|
+        reg_default_string_value(hkey)
+      end
+    end
+
+    def self.file_from_name(name)
+      with_reg_subkey(TI::HKEY_CLASSES_ROOT, 'TypeLib') do |htypelib|
+        result = nil
+        i = 0
+        while (guid = TI.reg_enum_key(htypelib, i))
+          i += 1
+          result = file_from_name_under_guid(htypelib, guid, name)
+          break if result
+        end
+        result
+      end
+    end
+
+    def self.file_from_name_under_guid(htypelib, guid, name)
+      with_reg_subkey(htypelib, guid) do |hclsid|
+        best_version = nil
+        best_fver = nil
+        i = 0
+        while (version = TI.reg_enum_key(hclsid, i))
+          i += 1
+          fver = version.to_f
+          next if best_fver && fver <= best_fver
+
+          matched = with_reg_subkey(hclsid, version) { |hversion| reg_default_string_value(hversion) == name }
+          if matched
+            best_fver = fver
+            best_version = version
+          end
+        end
+
+        best_version && file_under_version_key(hclsid, best_version)
+      end
+    end
+
+    def self.file_under_version_key(hclsid, version)
+      with_reg_subkey(hclsid, version) do |hversion|
+        result = nil
+        i = 0
+        while (lang = TI.reg_enum_key(hversion, i))
+          i += 1
+          result = with_reg_subkey(hversion, lang) { |hlang| reg_typelib_file_path(hlang) }
+          break if result
+        end
+        result
+      end
+    end
+
+    # Under a TypeLib\{guid}\{version}\{lcid} key, the actual file path is
+    # the default value of whichever of these architecture subkeys exists.
+    def self.reg_typelib_file_path(hlang)
+      %w[win64 win32 win16].each do |arch|
+        path = with_reg_subkey(hlang, arch) { |hkey| reg_default_string_value(hkey) }
+        return path if path
+      end
+      nil
+    end
+
+    def self.reg_default_string_value(hkey)
+      empty_name = W.wstr('')
+      type_out = ("\x00" * 4).b
+      size_out = [520].pack('L')
+      data_out = ("\x00" * 520).b
+      err = TI.reg_query_value_ex.call(hkey, empty_name, nil, type_out, data_out, size_out)
+      type = type_out.unpack1('L')
+      return nil unless err.zero? && (type == TI::REG_SZ || type == TI::REG_EXPAND_SZ)
+
+      value = data_out[0, size_out.unpack1('L')].force_encoding('UTF-16LE').encode('UTF-8').delete("\x00")
+      type == TI::REG_EXPAND_SZ ? W.expand_environment_strings(value) : value
+    end
+
+    def self.with_reg_subkey(hkey, name)
+      out = ("\x00" * W::PTR_SIZE).b
+      err = TI.reg_open_key_ex.call(hkey, W.wstr(name), 0, TI::KEY_READ, out)
+      return nil unless err.zero?
+
+      sub = out.unpack1(W::PACK_PTR)
+      begin
+        yield sub
+      ensure
+        TI.reg_close_key.call(sub)
+      end
+    end
+
+    private
+
+    def read_documentation(itypelib_ptr, index)
+      name_out = ("\x00" * W::PTR_SIZE).b
+      docstring_out = ("\x00" * W::PTR_SIZE).b
+      helpcontext_out = ("\x00" * 4).b
+      helpfile_out = ("\x00" * W::PTR_SIZE).b
+      TI.documentation_fn_for_typelib(itypelib_ptr).call(
+        itypelib_ptr, index, name_out, docstring_out, helpcontext_out, helpfile_out
+      )
+      name_bstr = name_out.unpack1(W::PACK_PTR)
+      docstring_bstr = docstring_out.unpack1(W::PACK_PTR)
+      helpfile_bstr = helpfile_out.unpack1(W::PACK_PTR)
+      name = W.bstr_to_s(name_bstr)
+      helpstring = W.bstr_to_s(docstring_bstr) || '' # C's WC2VSTR(NULL) is '', not nil
+      helpfile = W.bstr_to_s(helpfile_bstr) || ''
+      [name_bstr, docstring_bstr, helpfile_bstr].each { |b| W.sys_free_string.call(b) unless b.zero? }
+      [name, helpstring, helpcontext_out.unpack1('L'), helpfile]
+    end
+
+    def reg_path_lookup(guid_str, version_str, lcid)
+      # HKEY_CLASSES_ROOT is itself the merged Classes root, so the subkey
+      # path must NOT be prefixed with "SOFTWARE\Classes\" (that prefix is
+      # only needed when opening under HKEY_LOCAL_MACHINE/HKEY_CURRENT_USER
+      # directly, as MRI's own clsid_from_remote does for the DCOM path).
+      %w[win64 win32 win16].each do |arch_key|
+        path = reg_path_lookup_one(guid_str, version_str, lcid, arch_key)
+        return path if path
+      end
+      nil
+    end
+
+    def reg_path_lookup_one(guid_str, version_str, lcid, arch_key)
+      key_path = W.wstr("TypeLib\\#{guid_str}\\#{version_str}\\#{lcid}\\#{arch_key}")
+      hkey_out = ("\x00" * W::PTR_SIZE).b
+      err = TI.reg_open_key_ex.call(TI::HKEY_CLASSES_ROOT, key_path, 0, TI::KEY_READ, hkey_out)
+      return nil unless err.zero?
+
+      hkey = hkey_out.unpack1(W::PACK_PTR)
+      begin
+        empty_name = W.wstr('')
+        type_out = ("\x00" * 4).b
+        size_out = [520].pack('L') # 260 WCHARs, generous for a MAX_PATH-style value
+        data_out = ("\x00" * 520).b
+        err = TI.reg_query_value_ex.call(hkey, empty_name, nil, type_out, data_out, size_out)
+        return nil unless err.zero? && type_out.unpack1('L') == TI::REG_SZ
+
+        data_out[0, size_out.unpack1('L')].force_encoding('UTF-16LE').encode('UTF-8').delete("\x00")
+      ensure
+        TI.reg_close_key.call(hkey)
+      end
+    end
+
+    def install_finalizer
+      ptr = @ptr
+      release_fn = W.vtable_function(ptr, 2, [W::VOIDP], W::DWORD)
+      ObjectSpace.define_finalizer(self, self.class.finalizer(ptr, release_fn))
+    end
+
+    # OLE_FREE, deferred on a thread without OLE (as on JRuby); see
+    # WIN32OLE.finalizer.
+    def self.finalizer(ptr, release_fn)
+      proc { W.release_on_ole_thread { release_fn.call(ptr) } unless ptr.zero? }
+    end
+  end
+end

data/lib/win32ole/ffi/variable.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'win32ole/ffi/win32'
+require 'win32ole/ffi/typeinfo'
+
+class WIN32OLE
+  class Variable
+    W = Win32
+    TI = TypeInfo
+    private_constant :W, :TI
+
+    VARFLAG_FRESTRICTED = 0x80
+    VARFLAG_FHIDDEN = 0x40
+    VARFLAG_FNONBROWSABLE = 0x400
+    VAR_CONST = 2
+
+    # ext/win32ole/win32ole_variable.c undefines the allocator, so a
+    # Variable can't be constructed directly -- only via Type#variables.
+    def self.new(*)
+      raise TypeError, "allocator undefined for #{self}"
+    end
+
+    def self.from_typeinfo_ptr(itypeinfo_ptr, index)
+      allocate.tap { |var| var.send(:initialize, itypeinfo_ptr, index) }
+    end
+
+    def initialize(itypeinfo_ptr, index)
+      vardesc_out = ("\x00" * W::PTR_SIZE).b
+      hr = TI.var_desc_fn(itypeinfo_ptr).call(itypeinfo_ptr, index, vardesc_out)
+      if W.failed?(hr)
+        raise WIN32OLE::QueryInterfaceError, W.query_interface_error_message('GetVarDesc', W.hr_hex(hr))
+      end
+      vardesc_ptr = vardesc_out.unpack1(W::PACK_PTR)
+      vardesc = TI::VARDESC.new(vardesc_ptr)
+
+      @memid = vardesc.memid
+      @type_detail = TI.typedesc_details(itypeinfo_ptr, vardesc_ptr + TI.offsetof(TI::VARDESC, 'tdesc_union_ptr'))
+      @var_flags = vardesc.wVarFlags
+      @varkind = vardesc.varkind
+      @value = read_const_value(vardesc, vardesc_ptr) if @varkind == VAR_CONST
+      @name = read_name(itypeinfo_ptr, @memid)
+
+      TI.release_var_desc_fn(itypeinfo_ptr).call(itypeinfo_ptr, vardesc_ptr)
+    end
+
+    def name
+      @name
+    end
+    alias to_s name
+
+    def ole_type
+      @type_detail.last
+    end
+
+    def ole_type_detail
+      @type_detail.dup
+    end
+
+    def value
+      @value
+    end
+
+    def visible?
+      (@var_flags & (VARFLAG_FRESTRICTED | VARFLAG_FHIDDEN | VARFLAG_FNONBROWSABLE)) == 0
+    end
+
+    def variable_kind
+      TI::VARKIND_NAMES.fetch(@varkind, 'UNKNOWN')
+    end
+
+    def varkind
+      @varkind
+    end
+
+    def inspect
+      "#<WIN32OLE::Variable:#{name}=#{value.inspect}>"
+    end
+
+    private
+
+    def read_const_value(vardesc, vardesc_ptr)
+      # VARDESC.union_oInst_or_lpvarValue holds a VARIANT* when varkind == VAR_CONST.
+      variant_ptr = vardesc.union_oInst_or_lpvarValue
+      return nil if variant_ptr.to_i.zero?
+
+      variant_bytes = Fiddle::Pointer.new(variant_ptr)[0, W::VARIANT_SIZE]
+      vt, payload = W.unpack_variant(variant_bytes)
+      type = W.variant_ruby_type(vt)
+      case type
+      when :i4 then W.unpack_i4(payload)
+      when :i8 then W.unpack_i8(payload)
+      when :r8 then W.unpack_r8(payload)
+      when :bool then W.unpack_bool(payload)
+      when :bstr then W.bstr_to_s(W.unpack_pointer(payload))
+      else nil
+      end
+    end
+
+    def read_name(itypeinfo_ptr, memid)
+      names_out = ("\x00" * W::PTR_SIZE).b
+      count_out = ("\x00" * 4).b
+      get_names_fn(itypeinfo_ptr).call(itypeinfo_ptr, memid, names_out, 1, count_out)
+      bstr = names_out.unpack1(W::PACK_PTR)
+      name = W.bstr_to_s(bstr)
+      W.sys_free_string.call(bstr) unless bstr.zero?
+      name
+    end
+
+    def get_names_fn(itypeinfo_ptr)
+      @@get_names_fns ||= {}
+      @@get_names_fns[W.vtable_address(itypeinfo_ptr)] ||= W.vtable_function(
+        itypeinfo_ptr, TI::ITYPEINFO_VTBL[:GetNames],
+        [W::VOIDP, W::LONG, W::VOIDP, W::DWORD, W::VOIDP], W::LONG
+      )
+    end
+  end
+end