class Fiddle::Handle - Documentation for Ruby 3.4
Description: class Fiddle::Handle: libc. so.
Keywords: ruby,class,Fiddle::Handle

# class Fiddle::Handle

The `Fiddle::Handle` is the manner to access the dynamic library

## Example¶ ↑

### Setup¶ ↑

    libc_so = "/lib64/libc.so.6"
    => "/lib64/libc.so.6"
    @handle = Fiddle::Handle.new(libc_so)
    => #<Fiddle::Handle:0x00000000d69ef8>

### Setup, with flags¶ ↑

    libc_so = "/lib64/libc.so.6"
    => "/lib64/libc.so.6"
    @handle = Fiddle::Handle.new(libc_so, Fiddle::RTLD_LAZY | Fiddle::RTLD_GLOBAL)
    => #<Fiddle::Handle:0x00000000d69ef8>

See `RTLD_LAZY` and `RTLD_GLOBAL`

### Addresses to symbols¶ ↑

    strcpy_addr = @handle['strcpy']
    => 140062278451968

or

    strcpy_addr = @handle.sym('strcpy')
    => 140062278451968

### Constants

DEFAULT

  `DEFAULT`

  A predefined pseudo-handle of RTLD_DEFAULT

  Which will find the first occurrence of the desired symbol using the default library search order

NEXT

  `NEXT`

  A predefined pseudo-handle of RTLD_NEXT

  Which will find the next occurrence of a function in the search order after the current library.

RTLD_GLOBAL

  `RTLD_GLOBAL`

  rtld `Fiddle::Handle` flag.

  The symbols defined by this library will be made available for symbol resolution of subsequently loaded libraries.

RTLD_LAZY

  `RTLD_LAZY`

  rtld `Fiddle::Handle` flag.

  Perform lazy binding. Only resolve symbols as the code that references them is executed. If the symbol is never referenced, then it is never resolved. (Lazy binding is only performed for function references; references to variables are always immediately bound when the library is loaded.)

RTLD_NOW

  `RTLD_NOW`

  rtld `Fiddle::Handle` flag.

  If this value is specified or the environment variable LD_BIND_NOW is set to a nonempty string, all undefined symbols in the library are resolved before `Fiddle.dlopen` returns. If this cannot be done an error is returned.

### Public Class Methods

sym(name)
Source

    static VALUE
    rb_fiddle_handle_s_sym(VALUE self, VALUE sym)
    {
        return fiddle_handle_sym(RTLD_NEXT, sym);
    }

Get the address as an `Integer` for the function named `name`. The function is searched via dlsym on RTLD_NEXT.

See man(3) dlsym() for more info.

new(library = nil, flags = Fiddle::RTLD_LAZY | Fiddle::RTLD_GLOBAL)
Source

    static VALUE
    rb_fiddle_handle_initialize(int argc, VALUE argv[], VALUE self)
    {
        void *ptr;
        struct dl_handle *fiddle_handle;
        VALUE lib, flag;
        char  *clib;
        int   cflag;
        const char *err;

        switch( rb_scan_args(argc, argv, "02", &lib, &flag) ){
          case 0:
            clib = NULL;
            cflag = RTLD_LAZY | RTLD_GLOBAL;
            break;
          case 1:
            clib = NIL_P(lib) ? NULL : StringValueCStr(lib);
            cflag = RTLD_LAZY | RTLD_GLOBAL;
            break;
          case 2:
            clib = NIL_P(lib) ? NULL : StringValueCStr(lib);
            cflag = NUM2INT(flag);
            break;
          default:
            rb_bug("rb_fiddle_handle_new");
        }

    #if defined(_WIN32)
        if( !clib ){
            HANDLE rb_libruby_handle(void);
            ptr = rb_libruby_handle();
        }
        else if( STRCASECMP(clib, "libc") == 0
    # ifdef RUBY_COREDLL
                 || STRCASECMP(clib, RUBY_COREDLL) == 0
                 || STRCASECMP(clib, RUBY_COREDLL".dll") == 0
    # endif
            ){
    # ifdef _WIN32_WCE
            ptr = dlopen("coredll.dll", cflag);
    # else
            (void)cflag;
            ptr = w32_coredll();
    # endif
        }
        else
    #endif
            ptr = dlopen(clib, cflag);
    #if defined(HAVE_DLERROR)
        if( !ptr && (err = dlerror()) ){
            rb_raise(rb_eFiddleDLError, "%s", err);
        }
    #else
        if( !ptr ){
            err = dlerror();
            rb_raise(rb_eFiddleDLError, "%s", err);
        }
    #endif
        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
        if( fiddle_handle->ptr && fiddle_handle->open && fiddle_handle->enable_close ){
            dlclose(fiddle_handle->ptr);
        }
        fiddle_handle->ptr = ptr;
        fiddle_handle->open = 1;
        fiddle_handle->enable_close = 0;

        if( rb_block_given_p() ){
            rb_ensure(rb_yield, self, rb_fiddle_handle_close, self);
        }

        return Qnil;
    }

Create a new handler that opens `library` with `flags`.

If no `library` is specified or `nil` is given, `DEFAULT` is used, which is the equivalent to RTLD_DEFAULT. See `man 3 dlopen` for more.

    lib = Fiddle::Handle.new

The default is dependent on OS, and provide a handle for all libraries already loaded. For example, in most cases you can use this to access `libc` functions, or ruby functions like `rb_str_new`.

new (libname = nil, flags = RTLD_LAZY | RTLD_GLOBAL) { |self| ... }
Source

    # File ext/fiddle/lib/fiddle/ffi_backend.rb, line 488
    def initialize(libname = nil, flags = RTLD_LAZY | RTLD_GLOBAL)
      begin
        @lib = FFI::DynamicLibrary.open(libname, flags)
      rescue LoadError, RuntimeError # LoadError for JRuby, RuntimeError for TruffleRuby
        raise DLError, "Could not open #{libname}"
      end

      @open = true

      begin
        yield(self)
      ensure
        self.close
      end if block_given?
    end

sym(name)
Source

    static VALUE
    rb_fiddle_handle_s_sym(VALUE self, VALUE sym)
    {
        return fiddle_handle_sym(RTLD_NEXT, sym);
    }

Get the address as an `Integer` for the function named `name`.

sym_defined? (p1)
Source

    static VALUE
    rb_fiddle_handle_s_sym_defined(VALUE self, VALUE sym)
    {
        fiddle_void_func func;

        func = fiddle_handle_find_func(RTLD_NEXT, sym);

        if( func ) {
            return PTR2NUM(func);
        }
        else {
            return Qnil;
        }
    }

### Public Instance Methods

[]
Alias for: sym
close
Source

    static VALUE
    rb_fiddle_handle_close(VALUE self)
    {
        struct dl_handle *fiddle_handle;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
        if(fiddle_handle->open) {
            int ret = dlclose(fiddle_handle->ptr);
            fiddle_handle->open = 0;

            /* Check dlclose for successful return value */
            if(ret) {
    #if defined(HAVE_DLERROR)
                rb_raise(rb_eFiddleDLError, "%s", dlerror());
    #else
                rb_raise(rb_eFiddleDLError, "could not close handle");
    #endif
            }
            return INT2NUM(ret);
        }
        rb_raise(rb_eFiddleDLError, "dlclose() called too many times");

        UNREACHABLE;
    }

Close this handle.

Calling close more than once will raise a `Fiddle::DLError` exception.

close_enabled?
Source

    static VALUE
    rb_fiddle_handle_close_enabled_p(VALUE self)
    {
        struct dl_handle *fiddle_handle;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);

        if(fiddle_handle->enable_close) return Qtrue;
        return Qfalse;
    }

Returns `true` if dlclose() will be called when this handle is garbage collected.

See man(3) dlclose() for more info.

disable_close
Source

    static VALUE
    rb_fiddle_handle_disable_close(VALUE self)
    {
        struct dl_handle *fiddle_handle;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
        fiddle_handle->enable_close = 0;
        return Qnil;
    }

Disable a call to dlclose() when this handle is garbage collected.

enable_close
Source

    static VALUE
    rb_fiddle_handle_enable_close(VALUE self)
    {
        struct dl_handle *fiddle_handle;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
        fiddle_handle->enable_close = 1;
        return Qnil;
    }

Enable a call to dlclose() when this handle is garbage collected.

file_name
Source

    static VALUE
    rb_fiddle_handle_file_name(VALUE self)
    {
        struct dl_handle *fiddle_handle;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);

    #if defined(HAVE_DLINFO) && defined(HAVE_CONST_RTLD_DI_LINKMAP)
        {
            struct link_map *lm = NULL;
            int res = dlinfo(fiddle_handle->ptr, RTLD_DI_LINKMAP, &lm);
            if (res == 0 && lm != NULL) {
                return rb_str_new_cstr(lm->l_name);
            }
            else {
    #if defined(HAVE_DLERROR)
                rb_raise(rb_eFiddleDLError, "could not get handle file name: %s", dlerror());
    #else
                rb_raise(rb_eFiddleDLError, "could not get handle file name");
    #endif
            }
        }
    #elif defined(HAVE_GETMODULEFILENAME)
        {
            char filename[MAX_PATH];
            DWORD res = GetModuleFileName(fiddle_handle->ptr, filename, MAX_PATH);
            if (res == 0) {
                rb_raise(rb_eFiddleDLError, "could not get handle file name: %s", dlerror());
            }
            return rb_str_new_cstr(filename);
        }
    #else
        (void)fiddle_handle;
        return Qnil;
    #endif
    }

Returns the file name of this handle.

sym(name)
Source

    static VALUE
    rb_fiddle_handle_sym(VALUE self, VALUE sym)
    {
        struct dl_handle *fiddle_handle;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
        if( ! fiddle_handle->open ){
            rb_raise(rb_eFiddleDLError, "closed handle");
        }

        return fiddle_handle_sym(fiddle_handle->ptr, sym);
    }

Get the address as an `Integer` for the function named `name`.

Also aliased as: [], []
sym_defined? (p1)
Source

    static VALUE
    rb_fiddle_handle_sym_defined(VALUE self, VALUE sym)
    {
        struct dl_handle *fiddle_handle;
        fiddle_void_func func;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
        if( ! fiddle_handle->open ){
            rb_raise(rb_eFiddleDLError, "closed handle");
        }

        func = fiddle_handle_find_func(fiddle_handle->ptr, sym);

        if( func ) {
            return PTR2NUM(func);
        }
        else {
            return Qnil;
        }
    }

to_i
Source

    static VALUE
    rb_fiddle_handle_to_i(VALUE self)
    {
        struct dl_handle *fiddle_handle;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
        return PTR2NUM(fiddle_handle->ptr);
    }

Returns the memory address for this handle.

to_ptr
Source

    static VALUE
    rb_fiddle_handle_to_ptr(VALUE self)
    {
        struct dl_handle *fiddle_handle;

        TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
        return rb_fiddle_ptr_new_wrap(fiddle_handle->ptr, 0, 0, self, 0);
    }

Returns the `Fiddle::Pointer` of this handle.