Class: Fiddle::Handle

Relationships & Source Files
Inherits:	Object
Defined in:	ext/fiddle/handle.c

Overview

The 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

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

Constant Summary

DEFAULT =

A predefined pseudo-handle of RTLD_DEFAULT

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

# File 'ext/fiddle/handle.c', line 539
```
predefined_fiddle_handle(RTLD_DEFAULT)
```
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.

# File 'ext/fiddle/handle.c', line 530
```
predefined_fiddle_handle(RTLD_NEXT)
```
RTLD_GLOBAL =

:Handle flag.

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

# File 'ext/fiddle/handle.c', line 548
```
rtld Fiddle
```
RTLD_LAZY =

: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.)

# File 'ext/fiddle/handle.c', line 560
```
rtld Fiddle
```
RTLD_NOW =

: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.

# File 'ext/fiddle/handle.c', line 571
```
rtld Fiddle
```

Class Method Summary

.[](name) (also: .sym)

Get the address as an Integer for the function named name.
.new(library = nil, flags = Fiddle::RTLD_LAZY | Fiddle::RTLD_GLOBAL) constructor

Create a new handler that opens library with flags.
.sym(name)

Alias for .[].
.sym_defined?(sym) ⇒ Boolean

Instance Attribute Summary

#close_enabled? ⇒ Boolean readonly

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

Instance Method Summary

#[](name) (also: #sym)

Get the address as an Integer for the function named name.
#close
#disable_close

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

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

Returns the file name of this handle.
#sym(name)

Alias for #[].
#sym_defined?(sym) ⇒ Boolean
#to_i ⇒ Integer

Returns the memory address for this handle.
#to_ptr ⇒ ?

Returns the Pointer of this handle.

Constructor Details

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

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.

[ GitHub ]

# File 'ext/fiddle/handle.c', line 130


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;
}

Class Method Details

.[](name) Also known as: .sym

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

[ GitHub ]

# File 'ext/fiddle/handle.c', line 318


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

.[](name) .sym(name)

Alias for .[].

.sym_defined?(sym) ⇒ `Boolean`

[ GitHub ]

# File 'ext/fiddle/handle.c', line 388


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;
    }
}

Instance Attribute Details

#close_enabled? ⇒ `Boolean` (readonly)

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

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

[ GitHub ]

# File 'ext/fiddle/handle.c', line 240


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;
}

Instance Method Details

#[](name) Also known as: #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.

[ GitHub ]

# File 'ext/fiddle/handle.c', line 288


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);
}

#close

[ GitHub ]

# File 'ext/fiddle/handle.c', line 64


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;
}

#disable_close

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

[ GitHub ]

# File 'ext/fiddle/handle.c', line 223


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;
}

#enable_close

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

[ GitHub ]

# File 'ext/fiddle/handle.c', line 208


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;
}

#file_name

Returns the file name of this handle.

[ GitHub ]

# File 'ext/fiddle/handle.c', line 443


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
}

#[](name) #sym(name)

Alias for #[].

#sym_defined?(sym) ⇒ `Boolean`

[ GitHub ]

# File 'ext/fiddle/handle.c', line 403


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 ⇒ `Integer`

Returns the memory address for this handle.

[ GitHub ]

# File 'ext/fiddle/handle.c', line 256


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);
}

#to_ptr ⇒ ?

Returns the Pointer of this handle.

[ GitHub ]

# File 'ext/fiddle/handle.c', line 270


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);
}

Class: Fiddle::Handle

Overview

Example

Setup

Setup, with flags

Addresses to symbols

Constant Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

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

Class Method Details

.[](name) Also known as: .sym

.[](name) .sym(name)

.sym_defined?(sym) ⇒ Boolean

Instance Attribute Details

#close_enabled? ⇒ Boolean (readonly)

Instance Method Details

#[](name) Also known as: #sym

#close

#disable_close

#enable_close

#file_name

#[](name) #sym(name)

#sym_defined?(sym) ⇒ Boolean

#to_i ⇒ Integer

#to_ptr ⇒ ?

.sym_defined?(sym) ⇒ `Boolean`

#close_enabled? ⇒ `Boolean` (readonly)

#sym_defined?(sym) ⇒ `Boolean`

#to_i ⇒ `Integer`