Comment une bibliothèque partagée (.so) peut-elle appeler une fonction implémentée dans son programme de chargement?

J'ai une bibliothèque partagée que j'mettre en œuvre et je veux le .afin d'appeler une fonction dans le programme principal de chargement de la bibliothèque.

Disons que j'ai principaux.c (exécutable) qui contient:

void inmain_function(void*);
dlopen("libmy.so");

Dans le mon.c (le code de la libmy.donc), je tiens à appeler inmain_function:

inmain_function(NULL);

Comment la bibliothèque partagée appel inmain_function indépendamment du fait inmain_function est défini dans le programme principal.

Note: je tiens à appeler un symbole dans la main.c de mon.c pas vice-versa, ce qui est l'usage commun.

source d'informationauteur 0x90

c gcc linux shared-libraries

Vous aurez besoin de faire un registre de la fonction dans votre .donc, pour que l'exécutable peut donner un pointeur de fonction de vos .donc pour l'utiliser plus tard.

Comme ceci:

void in_main_func () {
//this is the function that need to be called from a .so
}

void (*register_function)(void(*)());
void *handle = dlopen("libmylib.so");

register_function = dlsym(handle, "register_function");

register_function(in_main_func);

la register_function doit stocker le pointeur de fonction dans une variable dans le .alors, où l'autre fonction dans les .donc peut la trouver.

Votre mylib.c serait le besoin de ressembler à quelque chose comme ceci:

void (*callback)() = NULL;

void register_function( void (*in_main_func)())
{
    callback = in_main_func();
}

void function_needing_callback() 
{
     callback();
}

Vous avez deux options, à partir de laquelle vous pouvez choisir:

Option 1: exporter tous les symboles de votre exécutable.
C'est simple, lors de la construction de l'exécutable, ajouter un drapeau -Wl,--export-dynamic. Cela permettrait de faire toutes les fonctions disponibles à la bibliothèque des appels.

Option 2: créer un fichier d'export du fichier de symboles avec la liste des fonctions, et l'utilisation -Wl,--dynamic-list=exported.txt. Cela nécessite un peu d'entretien, mais plus précis.

À démontrer: simple exécutable et dynamiquement chargés de la bibliothèque.

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

void exported_callback() /*< Function we want to export */
{
    printf("Hello from callback!\n");
}

viud unexported_callback() /*< Function we don't want to export */
{
    printf("Hello from unexported callback!\n");
}

typedef void (*lib_func)();

int call_library()
{
   void     *handle  = NULL;
   lib_func  func    = NULL;
   handle = dlopen("./libprog.so", RTLD_NOW | RTLD_GLOBAL);
   if (handle == NULL)
   {
       fprintf(stderr, "Unable to open lib: %s\n", dlerror());
       return -1;
   }
   func = dlsym(handle, "library_function");

   if (func == NULL) {
       fprintf(stderr, "Unable to get symbol\n");
      return -1;
   }

   func();
   return 0;
}

int main(int argc, const char *argv[])
{
    printf("Hello from main!\n");
    call_library();
    return 0;
}

Code de bibliothèque (lib.c):

#include <stdio.h>
int exported_callback();

int library_function()
{
    printf("Hello from library!\n");
    exported_callback();
    /* unexported_callback(); */ /*< This one will not be exported in the second case */
    return 0;
}

Donc, en premier lieu la construction de la bibliothèque (cette étape n'est pas différent):

 gcc -shared -fPIC lib.c -o libprog.so

Maintenant construire un exécutable avec tous les symboles exportés:

 gcc -Wl,--export-dynamic main.c -o prog.exe -ldl

Exécuter l'exemple:

 $ ./prog.exe
 Hello from main!
 Hello from library!
 Hello from callback!

Symboles exportés:

 $ objdump -e prog.exe -T | grep callback
 00000000004009f4 g    DF .text  0000000000000015  Base        exported_callback
 0000000000400a09 g    DF .text  0000000000000015  Base        unexported_callback

Maintenant avec la liste exportée (exported.txt):

{
    extern "C"
    {
       exported_callback;
    };
};

Build & vérifiez les symboles visibles:

$ gcc -Wl,--dynamic-list=./exported.txt main.c -o prog.exe -ldl
$ objdump -e prog.exe -T | grep callback
0000000000400774 g    DF .text  0000000000000015  Base        exported_callback

4
1. Mettre votre principale prototype de la fonction dans un .h de fichier et de les inclure dans votre principal et dynamique de la bibliothèque de code.
2. Avec GCC, il suffit de compiler votre programme principal avec la -rdynamic drapeau.
3. Une fois chargé, votre bibliothèque sera en mesure d'appeler la fonction dans le programme principal.
Un peu plus loin l'explication est que, une fois compilé, votre bibliothèque dynamique aura un symbole non défini pour la fonction qui est dans le code principal. Sur votre application principale de charger la bibliothèque, le symbole sera résolu par le programme principal de la table des symboles. J'ai utilisé le schéma ci-dessus de nombreuses fois et il fonctionne comme un charme.
0

Le suivant peut être utilisé pour charger une bibliothèque dynamique dans votre code (dans le cas où quelqu'un est venu ici après avoir regardé comment le faire):
```
void* func_handle = dlopen ("my.so", RTLD_LAZY); /* open a handle to your library */

void (*ptr)() = dlsym (func_handle, "my_function"); /* get the address of the function you want to call */

ptr(); /* call it */

dlclose (func_handle); /* close the handle */
```
Ne pas oublier de mettre #include <dlfcn.h> et le lien avec l' –ldl option.

Vous pouvez également ajouter un peu de logique qui vérifie si NULL est retourné. Si c'est le cas, vous pouvez appeler dlerror et il devrait vous donner quelques messages significatifs en décrivant le problème.

D'autres affiches ont cependant fourni des réponses plus appropriées pour votre problème.

Vous devez vous connecter pour publier un commentaire.