Création d'un module de système (chargement dynamique) dans C

dlopen est le chemin à parcourir. Voici quelques exemples:

Chargement d'un plugin avec dlopen:

#include <dlfcn.h>
...
int
main (const int argc, const char *argv[])
{

  char *plugin_name;
  char file_name[80];
  void *plugin;
  ...
  plugin = dlopen(file_name, RTLD_NOW);
  if (!plugin)
  {
     fatal("Cannot load %s: %s", plugin_name, dlerror ());
  }

La compilation ci-dessus:

% cc  -ldl -o program program.o 

Ensuite, en supposant que cette API pour les plugins:

/* The functions we will find in the plugin */
typedef void (*init_f) ();
init_f init;
typedef int (*query_f) ();
query_f query;

Trouver l'adresse de la fonction init() dans le plugin:

init = dlsym(plugin, "init");
result = dlerror();
if (result)
{
   fatal("Cannot find init in %s: %s", plugin_name, result);
}
init();

Avec l'autre fonction query(), qui retourne une valeur:

query = dlsym (plugin, "query");
result = dlerror();
if (result)
{
    fatal("Cannot find query in %s: %s", plugin_name, result);
}
printf("Result of plugin %s is %d\n", plugin_name, query ());

Vous pouvez récupérer l'exemple complet sur la ligne.

pour les utilisateurs de GNU/Linux

dynamique de chargement de la bibliothèque est un mécanisme qui, avec l'aide de cela, nous pouvons lancer notre programme, et au moment de l'exécution, décider quelle fonction, nous voulons utiliser. Je pense que dans certains cas static variable est également possible.

D'abord commencer par voir man 3 dlopen ou consultez-le en ligne

Le fichier d'en-tête qui est nécessaire est: dlfcn et depuis cela ne fait pas partie de la norme que vous devrait comme à votre fichier objet avec cette bibliothèque: libdl.(so/a) et, par conséquent, vous avez besoin de quelque chose comme:

gcc yours.c -ldl

alors vous avez un nom de fichier a.out et vous pouvez l'exécuter MAIS il ne fonctionne pas correctement et je vais vous expliquer pourquoi.

---

Un exemple complet:

première caisse 2 fichiers func1.c et func2.c respectivement. Nous voulons appeler ces fonctions au moment de l'exécution.

la touche func.c

int func1(){
    return 1;
}

func2.c

const char* func2(){
    return "upgrading to version 2";
}

Maintenant, nous avons 2 fonctions, nous allons faire nos modules:

ALP ❱ gcc -c -fPIC func1.c
ALP ❱ gcc -c -fPIC func2.c
ALP ❱ gcc -o libfunc.so -shared -fPIC func1.o func2.o 

pour l'esprit curieux à propos de -fPIC => PIC

Maintenant, vous avez un dynamic library noms: libfunc.so

Nous allons créer le programme principal (= temp.c) qui souhaite utiliser ces fonctions.

fichiers d'en-tête

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h> 

et le programme principal

int main()
{
    //pointer function to func1 and func2
    int         ( *f1ptr )();
    const char* ( *f2ptr )();

    //for pointing to the library
    void* handle = NULL;

    //for saving the error messages
    const char* error_message = NULL;

    //on error dlopen returns NULL
    handle = dlopen( "libfunc.so", RTLD_LAZY );

    //check for error, if it is NULL
    if( !handle )
    {
        fprintf( stderr, "dlopen() %s\n", dlerror() );
        exit( 1 );
    }

    /*
        according to the header file:

        When any of the above functions fails, call this function
        to return a string describing the error.  Each call resets
        the error string so that a following call returns null.

        extern char *dlerror (void) __THROW;
    */

    //So, reset the error string, of course we no need to do it just for sure
    dlerror();

    //point to func1
    f1ptr = (int (*)()) dlsym( handle, "func1" );

    //store the error message to error_message
    //because it is reseted if we use it directly
    error_message = dlerror();
    if( error_message ) //  it means if it is not null
    {
        fprintf( stderr, "dlsym() for func1 %s\n", error_message );
        dlclose( handle );
        exit( 1 );
    }

    //point the func2
    f2ptr = (const char* (*)()) dlsym( handle, "func2" );

    //store the error message to error_message
    //because it is reseted if we use it directly
    error_message = dlerror();
    if( error_message ) //  it means if it is not null
    {
        fprintf( stderr, "dlsym() for func2 %s\n", error_message );
        dlclose( handle );
        exit( 1 );
    }

    printf( "func1: %d\n", ( *f1ptr )() );
    printf( "func2: %s\n", ( *f2ptr )() );

    //unload the library
    dlclose( handle );

    //the main return value
    return 0;
}

Maintenant nous avons juste besoin de compiler ce code (= temp.c), donc essayer:

ALP ❱ gcc temp.c -ldl
ALP ❱ ./a.out
libfunc.so: cannot open shared object file: No such file or directory

Il ne fonctionne pas! POURQUOI facile; parce que notre a.out programme ne sais pas où trouver la bibliothèque connexe: libfunc.so et, par conséquent, il nous dit cannot not open ...

comment dire le programme (= a.out) pour trouver sa bibliothèque?

1. à l'aide de ld de l'éditeur de liens
2. à l'aide de la variable d'environnement LD_LIBRARY_PATH
3. en utilisant le chemin d'accès standard

première manière, avec l'aide de ld

utilisation -Wl,-rpath, et pwd et mettre le chemin comme un argument

ALP ❱ gcc temp.c -ldl
ALP ❱ ./a.out
libfunc.so: cannot open shared object file: No such file or directory
ALP ❱ pwd
/home/shu/codeblock/ALP
ALP ❱ gcc temp.c -ldl -Wl,-rpath,/home/shu/codeblock/ALP
ALP ❱ ./a.out
func1: 1
func2: upgrading to version 2

deuxième façon

ALP ❱ gcc temp.c -ldl
ALP ❱ ./a.out
libfunc.so: cannot open shared object file: No such file or direc
ALP ❱ export LD_LIBRARY_PATH=$PWD
ALP ❱ echo $LD_LIBRARY_PATH
/home/shu/codeblock/ALP
ALP ❱ ./a.out
func1: 1
func2: upgrading to version 2
ALP ❱ export LD_LIBRARY_PATH=
ALP ❱ ./a.out
libfunc.so: cannot open shared object file: No such file or 

et troisième voie

vous avez libfunc.so en vous chemin d'accès actuel, donc vous pouvez le copier dans un chemin d'accès standard pour les bibliothèques.

ALP $ sudo cp libfunc.so /usr/lib
ALP ❱ gcc temp.c -ldl
ALP ❱ ./a.out
func1: 1
func2: upgrading to version 2

vous pouvez le supprimer de /usr/lib et de l'utiliser. C'est à vous.

NOTE

comment savoir que notre a.out connaît son chemin?

facile:

ALP ❱ gcc temp.c -ldl -Wl,-rpath,/home/shu/codeblock/ALP
ALP ❱ strings a.out  | grep \/
/lib/ld-linux.so.2
/home/shu/codeblock/ALP

comment nous pouvons l'utiliser dans c++?

Aussi longtemps que je sais que vous ne pouvez pas parce que g++ mangles les noms de fonction alors que gcc n'est pas ainsi que vous devez utiliser: extern "C" int func1(); par exemple.

Pour plus de détails, voir les pages de manuel Linux et la programmation de livres.

Si vous êtes prêt à envisager le cadre, Qt fournit QPluginLoader: Qt 5 docs (ou pour les vieux Qt 4.8 docs voir ici)

Si vous avez besoin de plus de précision, de contrôle, Qt fournit également un moyen de charger des bibliothèques à la volée avec QLibrary: Qt 5 docs (ou pour les vieux Qt 4.8 docs voir ici)

Encore mieux, ce sont portable sur l'ensemble des plates-formes.

Il y a une approche de DIY. Bien que la méthode (et la possibilité) de le faire varie d'un système à l'autre, l'idée générale est d'ouvrir un fichier, lire le contenu du fichier dans la mémoire, faire dit mémoire exécutable, l'initialisation d'un pointeur de fonction à une position valide au sein de ce mémoire, et vous y êtes.

Bien sûr, c'est en supposant que c'est juste le code de l'exécutable - très peu probable. Le code exige probablement les données à charger dans la RAM aussi, et peut exiger de l'espace mondial/variables statiques. Vous pouvez charger tout cela vous-même, mais vous auriez besoin d'aller dans le code exécutable et de régler toutes les références de mémoire en elle.

La plupart des systèmes d'exploitation permettent la liaison dynamique, qui fait tout pour vous.