比较懒，而且时间也不早了，就贴上英文，以后有机会在翻译吧。

DLOPEN(3)     Linux Programmer's Manual  DLOPEN(3)

NAME

dladdr, dlclose, dlerror, dlopen, dlsym, dlvsym - program-

ming interface to dynamic linking loader

SYNOPSIS

#include

void *dlopen(const char *filename, int flag);

char *dlerror(void);

void *dlsym(void *handle, const char *symbol);

int dlclose(void *handle);

DESCRIPTION

The four functions dlopen(), dlsym(), dlclose(), dlerror()

implement the interface to the dynamic linking loader.

dlerror

The  function  dlerror()  returns  a human readable string

describing the most recent error that occurred from any of

the  dl routines (dlopen, dlsym or dlclose) since the last

call to dlerror().  It returns  NULL  if  no  errors  have

occurred since initialization or since it was last called.

dlopen

The function dlopen() loads the dynamic library file named

by  the null-terminated  string  filename  and returns an

opaque "handle" for the dynamic library.  If  filename  is

NULL,  then  the  returned handle is for the main program.

If filename contains a slash ("/"), then it is interpreted

as  a  (relative  or  absolute) pathname.  Otherwise, the

dynamic linker searches for the library as  follows  (see

ld.so(8) for further details):

o      (ELF  only)  If the executable file for the calling

program contains a DT_RPATH tag, and does not  con-

tain  a DT_RUNPATH tag, then the directories listed

in the DT_RPATH tag are searched.

o      If  the  environment  variable  LD_LIBRARY_PATH  is

defined to contain a colon-separated list of direc-

tories, then these are searched.  (As  a  security

measure  this  variable  is ignored for set-UID and

set-GID programs.)

o      (ELF only) If the executable file for  the  calling

program  contains a DT_RUNPATH tag, then the direc-

tories listed in that tag are searched.

o      The  cache  file /etc/ld.so.cache  (maintained  by

ldconfig(8))  is checked to see whether it contains

an entry for filename.

o      The directories /lib and /usr/lib are searched  (in

that order).

If the library has dependencies on other shared libraries,

then these are also automatically loaded  by  the  dynamic

linker  using  the  same  rules.   (This process may occur

recursively, if those libraries in turn have dependencies,

and so on.)

The  value  of  flag  can be either RTLD_LAZY or RTLD_NOW.

When RTLD_NOW is specified, or  the  environment  variable

LD_BIND_NOW  is set  to a non-empty string, all undefined

symbols in  the  library  are  resolved  before  dlopen()

returns.  If  this  cannot  be done, an error is returned.

Otherwise  binding  is  lazy:  symbol  values  are   first

resolved when needed.

Optionally,  RTLD_GLOBAL  may be or'ed into flag, in which

case the external symbols defined in the library  will  be

made  available for  symbol  resolution  of  subsequently

loaded  libraries.   (The  converse  of  RTLD_GLOBAL   is

RTLD_LOCAL.  This is the default.)

If filename is a NULL pointer, then the returned handle is

for the main program.  When given to dlsym(), this  handle

causes a search for a symbol in the main program, followed

by all shared libraries loaded  at  program  startup,  and

then all shared libraries loaded by dlopen() with the flag

RTLD_GLOBAL.

External references in the library are resolved using  the

libraries  in that library's dependency list and any other

libraries previously opened with the RTLD_GLOBAL flag.  If

the  executable was linked with the flag "-rdynamic" (or,

synonymously, "--export-dynamic"), then the global symbols

in  the executable will also be used to resolve references

in a dynamically loaded library.

If the same library is loaded  again  with  dlopen(),  the

same  file  handle  is  returned. The dl library maintains

reference counts for library handles, so a dynamic library

is  not deallocated until dlclose() has been called on it

as many times as dlopen() has succeeded on it.  The  _init

routine, if present, is only called once. But a subsequent

call with RTLD_NOW  may force  symbol  resolution  for a

library earlier loaded with RTLD_LAZY.

If dlopen() fails for any reason, it returns NULL.

dlsym

The function dlsym() takes a "handle" of a dynamic library

returned by dlopen and  the  NUL-terminated  symbol  name,

returning  the  address where  that symbol is loaded into

memory. If the symbol is  not  found,  in  the specified

library or  any  of the libraries that were automatically

loaded by dlopen() when that library was  loaded,  dlsym()

returns NULL.  (The search performed by dlsym() is breadth

first through the dependency  tree  of  these  libraries.)

Since  the  value of the symbol could actually be NULL (so

that a NULL return  from  dlsym()  need not  indicate  an

error), the  correct  way to test for an error is to call

dlerror() to clear any old  error  conditions,  then  call

dlsym(),  and then call dlerror() again, saving its return

value into a variable, and check whether this saved  value

is not NULL.

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.

dlclose

The  function  dlclose() decrements the reference count on

the dynamic library handle handle.  If the reference count

drops to zero and no other loaded libraries use symbols in

it, then the dynamic library is unloaded.

The function dlclose() returns 0 on success, and  non-zero

on error.

The obsolete symbols _init and _fini

The linker recognizes special symbols _init and _fini.  If

a dynamic library exports a routine named _init, then that

code  is  executed  after  the  loading,  before  dlopen()

returns. If the dynamic library exports a  routine  named

_fini, then that routine is called just before the library

is unloaded.  In case you  need to  avoid  linking against

the  system  startup files, this can be done by giving gcc

the "-nostartfiles" parameter on the command line.

Using these routines, or the gcc -nostartupfiles or -nost-

dlib  options, is not recommended. Their use may result in

undesired behavior, since the constructor/destructor  rou-

tines  will  not  be executed (unless special measures are

taken).

Instead,  libraries  should  export  routines  using   the

__attribute__((constructor))  and  __attribute__((destruc-

tor)) function attributes.  See the  gcc  info  pages  for

information  on these. Constructor routines are executed

before dlopen returns, and destructor  routines are  exe-

cuted before dlclose returns.

GNU EXTENSIONS

Glibc adds two functions not described by POSIX, with pro-

totypes

#define GNU_SOURCE

#include

int dladdr(void *addr, Dl_info *info);

void *dlvsym(void *handle, char *symbol, char *version);

The function dladdr() takes a function pointer  and  tries

to  resolve name and file where it is located. Information

is stored in the Dl_info structure:

typedef struct {

const char *dli_fname;/* File name of defining object */

void *dli_fbase;      /* Load address of that object */

const char *dli_sname;/* Name of nearest lower symbol */

void *dli_saddr;      /* Exact value of nearest symbol */

} Dl_info;

dladdr() returns 0 on error, and non-zero on success.

The function dlvsym() does the same as dlsym() but takes a

version string as additional argument.

EXAMPLE

Load the math library, and print the cosine of 2.0:

#include

#include

int main(int argc, char **argv) {

void *handle;

double (*cosine)(double);

char *error;

handle = dlopen ("libm.so", RTLD_LAZY);

if (!handle) {

fprintf (stderr, "%s\n", dlerror());

exit(1);

}

dlerror(); /* Clear any existing error */

*(void **) (&cosine) = dlsym(handle, "cos");

if ((error = dlerror()) != NULL)  {

fprintf (stderr, "%s\n", error);

exit(1);

}

printf ("%f\n", (*cosine)(2.0));

dlclose(handle);

return 0;

}

If  this  program  were in a file named "foo.c", you would

build the program with the following command:

gcc -rdynamic -o foo foo.c -ldl

Libraries exporting _init() and _fini() will  want  to  be

compiled as follows, using bar.c as the example name:

gcc -shared -nostartfiles -o bar bar.c

NOTES

The  symbols  RTLD_DEFAULT  and RTLD_NEXT  are defined by

only when _GNU_SOURCE was defined before includ-

ing it.

HISTORY

The  dlopen interface standard comes from SunOS. That sys-

tem also has dladdr, but not dlvsym.

CONFORMING TO

POSIX  1003.1-2003  describes  dlclose, dlerror,  dlopen,

dlsym.

SEE ALSO

ld(1),  ldd(1), ld.so(8),  ldconfig(8), ld.so info pages,

gcc info pages, ld info pages

Linux       2003-11-17   DLOPEN(3)