Class: Fiddle::Handle
- Defined in:
- ext/fiddle/handle.c,
ext/fiddle/handle.c
Overview
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
Constant Summary collapse
- 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.
predefined_fiddle_handle(RTLD_NEXT)
- DEFAULT =
A predefined pseudo-handle of RTLD_DEFAULT
Which will find the first occurrence of the desired symbol using the default library search order
predefined_fiddle_handle(RTLD_DEFAULT)
- RTLD_GLOBAL =
:Handle flag.
The symbols defined by this library will be made available for symbol resolution of subsequently loaded libraries.
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.)
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.
rtld Fiddle
Class Method Summary collapse
-
.[](sym) ⇒ Object
call-seq: sym(name).
-
.sym(sym) ⇒ Object
call-seq: sym(name).
- .sym_defined?(sym) ⇒ Boolean
Instance Method Summary collapse
-
#[](sym) ⇒ Object
call-seq: sym(name).
-
#close ⇒ Object
Close this handle.
-
#close_enabled? ⇒ Boolean
Returns
true
if dlclose() will be called when this handle is garbage collected. -
#disable_close ⇒ Object
Disable a call to dlclose() when this handle is garbage collected.
-
#enable_close ⇒ Object
Enable a call to dlclose() when this handle is garbage collected.
-
#file_name ⇒ Object
Returns the file name of this handle.
-
#new(library = nil, flags = Fiddle::RTLD_LAZY|Fiddle::RTLD_GLOBAL) ⇒ Object
constructor
Create a new handler that opens
library
withflags
. -
#sym(sym) ⇒ Object
call-seq: sym(name).
- #sym_defined?(sym) ⇒ Boolean
-
#to_i ⇒ Object
Returns the memory address for this handle.
-
#to_ptr ⇒ Object
Returns the Fiddle::Pointer of this handle.
Constructor Details
#new(library = nil, flags = Fiddle::RTLD_LAZY|Fiddle::RTLD_GLOBAL) ⇒ Object
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
.
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 |
# File 'ext/fiddle/handle.c', line 135
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
.[](sym) ⇒ Object
call-seq: sym(name)
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.
323 324 325 326 327 |
# File 'ext/fiddle/handle.c', line 323
static VALUE
rb_fiddle_handle_s_sym(VALUE self, VALUE sym)
{
return fiddle_handle_sym(RTLD_NEXT, sym);
}
|
.sym(sym) ⇒ Object
call-seq: sym(name)
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.
323 324 325 326 327 |
# File 'ext/fiddle/handle.c', line 323
static VALUE
rb_fiddle_handle_s_sym(VALUE self, VALUE sym)
{
return fiddle_handle_sym(RTLD_NEXT, sym);
}
|
.sym_defined?(sym) ⇒ Boolean
393 394 395 396 397 398 399 400 401 402 403 404 405 406 |
# File 'ext/fiddle/handle.c', line 393
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 Method Details
#[](sym) ⇒ Object
call-seq: sym(name)
Get the address as an Integer for the function named name
.
293 294 295 296 297 298 299 300 301 302 303 304 |
# File 'ext/fiddle/handle.c', line 293
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 ⇒ Object
Close this handle.
Calling close more than once will raise a Fiddle::DLError exception.
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 |
# File 'ext/fiddle/handle.c', line 69
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_enabled? ⇒ Boolean
Returns true
if dlclose() will be called when this handle is garbage collected.
See man(3) dlclose() for more info.
245 246 247 248 249 250 251 252 253 254 |
# File 'ext/fiddle/handle.c', line 245
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;
}
|
#disable_close ⇒ Object
Disable a call to dlclose() when this handle is garbage collected.
228 229 230 231 232 233 234 235 236 |
# File 'ext/fiddle/handle.c', line 228
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 ⇒ Object
Enable a call to dlclose() when this handle is garbage collected.
213 214 215 216 217 218 219 220 221 |
# File 'ext/fiddle/handle.c', line 213
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 ⇒ Object
Returns the file name of this handle.
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 |
# File 'ext/fiddle/handle.c', line 448
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
}
|
#sym(sym) ⇒ Object
call-seq: sym(name)
Get the address as an Integer for the function named name
.
293 294 295 296 297 298 299 300 301 302 303 304 |
# File 'ext/fiddle/handle.c', line 293
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);
}
|
#sym_defined?(sym) ⇒ Boolean
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 |
# File 'ext/fiddle/handle.c', line 408
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 ⇒ Object
Returns the memory address for this handle.
261 262 263 264 265 266 267 268 |
# File 'ext/fiddle/handle.c', line 261
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 ⇒ Object
Returns the Fiddle::Pointer of this handle.
275 276 277 278 279 280 281 282 |
# File 'ext/fiddle/handle.c', line 275
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);
}
|