* ext/fiddle/handle.c: Make Fiddle independent of DL, copy DL::Handle

to Fiddle::Handle.
* ext/fiddle/pointer.c: Make Fiddle independent of DL, copy
  DL::Pointer to Fiddle::Pointer.
* test/fiddle/test_func.rb: relevent tests
* test/fiddle/test_handle.rb: ditto
* test/fiddle/test_pointer.rb: ditto
* ext/dl/lib/dl/struct.rb: use Fiddle::Pointer if available
* ext/fiddle/extconf.rb: check for dlfcn.h
* ext/fiddle/fiddle.c: add constants for sizeof() things
* ext/fiddle/fiddle.h: include dlfcn.h
* ext/fiddle/function.c: expose a C function for creating new
  Fiddle::Function objects.
* ext/fiddle/lib/fiddle.rb: include constants for dl backwards compat
* ext/fiddle/lib/fiddle/function.rb: read the pointer from the
  function for dl backwards compat.
* test/dl/test_callback.rb: check the addresses of the pointers rather
  than their types.
* test/fiddle/helper.rb: remove dependency on dl
* test/fiddle/test_closure.rb: ditto
* test/fiddle/test_fiddle.rb: ditto

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@37907 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

test/fiddle/test_handle.rb

@@ -0,0 +1,186 @@
+require_relative 'helper'
+
+module Fiddle
+  class TestHandle < TestCase
+    include Fiddle
+
+    def test_to_i
+      handle = Fiddle::Handle.new(LIBC_SO)
+      assert_kind_of Integer, handle.to_i
+    end
+
+    def test_static_sym_secure
+      assert_raises(SecurityError) do
+        Thread.new do
+          $SAFE = 2
+          Fiddle::Handle.sym('calloc')
+        end.join
+      end
+    end
+
+    def test_static_sym_unknown
+      assert_raises(DLError) { Fiddle::Handle.sym('fooo') }
+      assert_raises(DLError) { Fiddle::Handle['fooo'] }
+    end
+
+    def test_static_sym
+      skip "Fiddle::Handle.sym is not supported" if /mswin|mingw/ =~ RUBY_PLATFORM
+      begin
+        # Linux / Darwin / FreeBSD
+       refute_nil Fiddle::Handle.sym('dlopen')
+       assert_equal Fiddle::Handle.sym('dlopen'), Fiddle::Handle['dlopen']
+      rescue
+        # NetBSD
+        require 'objspace'
+       refute_nil Fiddle::Handle.sym('Init_objspace')
+       assert_equal Fiddle::Handle.sym('Init_objspace'), Fiddle::Handle['Init_objspace']
+      end
+    end
+
+    def test_sym_closed_handle
+      handle = Fiddle::Handle.new(LIBC_SO)
+      handle.close
+      assert_raises(DLError) { handle.sym("calloc") }
+      assert_raises(DLError) { handle["calloc"] }
+    end
+
+    def test_sym_unknown
+      handle = Fiddle::Handle.new(LIBC_SO)
+      assert_raises(DLError) { handle.sym('fooo') }
+      assert_raises(DLError) { handle['fooo'] }
+    end
+
+    def test_sym_with_bad_args
+      handle = Handle.new(LIBC_SO)
+      assert_raises(TypeError) { handle.sym(nil) }
+      assert_raises(TypeError) { handle[nil] }
+    end
+
+    def test_sym_secure
+      assert_raises(SecurityError) do
+        Thread.new do
+          $SAFE = 2
+          handle = Handle.new(LIBC_SO)
+          handle.sym('calloc')
+        end.join
+      end
+    end
+
+    def test_sym
+      handle = Handle.new(LIBC_SO)
+      refute_nil handle.sym('calloc')
+      refute_nil handle['calloc']
+    end
+
+    def test_handle_close
+      handle = Handle.new(LIBC_SO)
+      assert_equal 0, handle.close
+    end
+
+    def test_handle_close_twice
+      handle = Handle.new(LIBC_SO)
+      handle.close
+      assert_raises(DLError) do
+        handle.close
+      end
+    end
+
+    def test_dlopen_returns_handle
+      assert_instance_of Handle, dlopen(LIBC_SO)
+    end
+
+    def test_dlopen_safe
+      assert_raises(SecurityError) do
+        Thread.new do
+          $SAFE = 2
+          dlopen(LIBC_SO)
+        end.join
+      end
+    end
+
+    def test_initialize_safe
+      assert_raises(SecurityError) do
+        Thread.new do
+          $SAFE = 2
+          Handle.new(LIBC_SO)
+        end.join
+      end
+    end
+
+    def test_initialize_noargs
+      handle = Handle.new
+      refute_nil handle['rb_str_new']
+    end
+
+    def test_initialize_flags
+      handle = Handle.new(LIBC_SO, RTLD_LAZY | RTLD_GLOBAL)
+      refute_nil handle['calloc']
+    end
+
+    def test_enable_close
+      handle = Handle.new(LIBC_SO)
+      assert !handle.close_enabled?, 'close is enabled'
+
+      handle.enable_close
+      assert handle.close_enabled?, 'close is not enabled'
+    end
+
+    def test_disable_close
+      handle = Handle.new(LIBC_SO)
+
+      handle.enable_close
+      assert handle.close_enabled?, 'close is enabled'
+      handle.disable_close
+      assert !handle.close_enabled?, 'close is enabled'
+    end
+
+    def test_NEXT
+      begin
+        # Linux / Darwin
+        #
+        # There are two special pseudo-handles, RTLD_DEFAULT and RTLD_NEXT.  The  former  will  find
+        # the  first  occurrence  of the desired symbol using the default library search order.  The
+        # latter will find the next occurrence of a function in the search order after  the  current
+        # library.   This  allows  one  to  provide  a  wrapper  around a function in another shared
+        # library.
+        # --- Ubuntu Linux 8.04 dlsym(3)
+        handle = Handle::NEXT
+        refute_nil handle['malloc']
+      rescue
+        # BSD
+        #
+        # If dlsym() is called with the special handle RTLD_NEXT, then the search
+        # for the symbol is limited to the shared objects which were loaded after
+        # the one issuing the call to dlsym().  Thus, if the function is called
+        # from the main program, all the shared libraries are searched.  If it is
+        # called from a shared library, all subsequent shared libraries are
+        # searched.  RTLD_NEXT is useful for implementing wrappers around library
+        # functions.  For example, a wrapper function getpid() could access the
+        # "real" getpid() with dlsym(RTLD_NEXT, "getpid").  (Actually, the dlfunc()
+        # interface, below, should be used, since getpid() is a function and not a
+        # data object.)
+        # --- FreeBSD 8.0 dlsym(3)
+        require 'objspace'
+        handle = Handle::NEXT
+        refute_nil handle['Init_objspace']
+      end
+    end unless /mswin|mingw/ =~ RUBY_PLATFORM
+
+    def test_DEFAULT
+      skip "Handle::DEFAULT is not supported" if /mswin|mingw/ =~ RUBY_PLATFORM
+      handle = Handle::DEFAULT
+      refute_nil handle['malloc']
+    end unless /mswin|mingw/ =~ RUBY_PLATFORM
+
+    def test_dlerror
+      # FreeBSD (at least 7.2 to 7.2) calls nsdispatch(3) when it calls
+      # getaddrinfo(3). And nsdispatch(3) doesn't call dlerror(3) even if
+      # it calls _nss_cache_cycle_prevention_function with dlsym(3).
+      # So our Fiddle::Handle#sym must call dlerror(3) before call dlsym.
+      # In general uses of dlerror(3) should call it before use it.
+      require 'socket'
+      Socket.gethostbyname("localhost")
+      Fiddle.dlopen("/usr/lib/libc.so").sym('strcpy')
+    end if /freebsd/=~ RUBY_PLATFORM
+  end
+end