Programmation d'applications modulaires

En préambule, j'aimerais vous dire quelque chose à propos de trois fonctions que nous allons utiliser dans notre application. Elles sont appelées : dlopen, dlsym et dlclose. Elles viennent toutes du fichier d'en-tête dlfcn.h et sont implémentées dans les bibliothèques du système Linux. La première d'entre elles est utilisée pour charger une bibliothèque partagée. Elle nécessite deux arguments : le nom du fichier de la bibliothèque partagée (const char*) et un drapeau (int). Il existe plusieurs drapeaux que nous pouvons utiliser, mais le plus commun est RTLD_LAZY. Il provoque le chargement des symboles lorsque ceux-ci sont utilisés pour la première fois. Nous allons utiliser ce drapeau dans nos premiers exemples. Vous pouvez en apprendre davantage sur les drapeaux dans les pages de man Linux ; (man dlopen). dlopen renvoie un pointeur void (void*) appelé gestionnaire.

La seconde (dlsym) est utilisée pour obtenir l'adresse de la fonction dont le symbole a été chargé et passé au gestionnaire par la fonction dlopen. dlsym retourne un pointeur (void*) sur la fonction trouvée dans la ressource partagée passée comme premier argument (gestionnaire reçu de dlopen). Le nom de la fonction à trouver est passé en second argument (char*). Si le système n'arrive pas à trouver cette fonction, il retourne un pointeur NULL (adresse zéro). En C++, nous pouvons transtyper le pointeur reçu vers le type de pointeur réel de la fonction.

La dernière fonction, dlclose, sera utilisée pour fermer la bibliothèque partagée ouverte par dlopen .

La connaissance de ces fonctions nous permet d'écrire notre première application modulaire.

I-C-1-a. Exemple de base▲

#include <dlfcn.h>
#include <iostream>
int main(int argc, char ** argv)
{
  if (argc == 1)
  {
    std::cerr << "Usage: " << argv[0] << " modules...\n";
    return 1;
  }
  for (int i = 1; i < argc; ++i)
  {
    void* shared_library = dlopen(argv[i], RTLD_LAZY);
    void (*module)() = reinterpret_cast<void (*)()>(dlsym(shared_library, "module"));
    if (module)
    {
      module();
      dlclose(shared_library);
    } else
    {
      std::cerr << "Error while loading: " << argv[i] << "\n";
    }
  }
  return 0;
}

I-C-1-b. Explication du code▲

I-C-1-c. Compilation▲

Il est temps, maintenant, d'écrire un ou deux modules simples. Chaque module sera dans son propre fichier *.cpp. Un tel fichier doit comporter la définition d'au moins une fonction. Le nom de cette fonction doit être module. Comme je le disais avant, cette fonction doit être écrite avec la syntaxe C. Cela signifie que nous devons ajouter extern "C" avant sa déclaration.

Je vais créer deux modules qui vont écrire une ligne de texte sur la sortie standard. Voici le code du premier (module_start.cpp) :

#include <iostream>
extern "C" void module()
{
  std::cout << "Start module function!\n";
}

et celui du deuxième (module_other.cpp) :

#include <iostream>
extern "C" void module()
{
  std::cout << "Other module function!\n";
}

Maintenant, nous pouvons compiler ces deux modules en utilisant ces commandes :

g++ -fPIC -shared module_start.cpp -o module_start.so
g++ -fPIC -shared module_other.cpp -o module_other.so

Vous devez vous rappeler des options -shared et -fPIC. Le premier ne fait qu'indiquer que le code est celui d'une bibliothèque partagée. Le second est une abréviation pour code à position indépendante, qui signifie que les positions dans le code assembleur seront relatives au lieu d'être absolues. Grâce à cela, le code sera capable d'être chargé dynamiquement n'importe où dans la mémoire de l'application.

Si la compilation n'échoue pas, nous pouvons lancer l'application avec un ou les deux modules :

./app ./module_start.so
./app ./module_other.so
./app ./module_start.so ./module_other.so

Comme vous pouvez le voir, nous passons à l'application les chemins relatifs des bibliothèques partagées. Si le chemin n'est ni un chemin parent ni un chemin absolu, dlopen cherchera l'objet partagé dans ces localisations :

1. Les chemins de LD_LIBRARY_PATH ;
2. Dans la liste placée dans /etc/ld.so.cache ;
3. /lib ;
4. /usr/lib.

Sinon, dlopen utilisera le chemin relatif ou absolu fourni.

Le prochain exemple d'application modulaire sera très similaire, mais maintenant chaque module sera une classe qui dérive de la classe de base des modules. Ils auront également une fonction appelée chargeur qui allouera de la mémoire pour l'objet module de classe et le construira. Elle renverra un pointeur vers la mémoire allouée.

Afin de ne pas réécrire tout depuis le début, nous allons :

1. Écrire la classe de base pour les modules ;
2. Changer un peu le code de l'application ;
3. Écrire de nouveaux modules avec chargeurs.

I-C-3-a. Classe de base des modules▲

class SomeClass
{
    virtual void myFunction() = 0; // ceci est une fonction virtuelle pure
};

#ifndef MODULE_BASE_HPP
#define MODULE_BASE_HPP
class ModuleBase
{
  public:
    virtual void run() = 0;
};
#endif

I-C-3-b. Charger des modules▲

#include <dlfcn.h>
#include <iostream>
 
#include "ModuleBase.hpp"
int main(int argc, char ** argv)
{
  if (argc == 1)
  {
    std::cerr << "Usage: " << argv[0] << " modules...\n";
    return 1;
  }
  for (int i = 1; i < argc; ++i)
  {
    void* shared_library = dlopen(argv[i], RTLD_LAZY);
    ModuleBase* (*loader)() = reinterpret_cast<ModuleBase* (*)()>(dlsym(shared_library, "loader"));
    ModuleBase* module;
    if (loader)
    {
      module = loader();
      module->run();
    } else
    {
      std::cerr << "Erreur de chargement: " << argv[i] << "\n";
    }
  }
  return 0;
}

I-C-3-c. Écrire un module▲

#include "ModuleBase.hpp"
#include <iostream>
class ModuleStart :
  public ModuleBase
{
  public:
    void run()
    {
      std::cout << "Le module de démarrage tourne!\n";
    }
};
extern "C" ModuleBase* loader()
{
  ModuleBase* m = new ModuleStart;
  return m;
}

#include "ModuleBase.hpp"
#include <iostream>
class ModuleSoph :
  public ModuleBase
{
  public:
    void run()
    {
      std::cout << "Le module sophistiqué tourne!\n";
    }
};
extern "C" ModuleBase* loader()
{
  ModuleBase* m = new ModuleSoph;
  return m;
}

Les exemples que je vous ai indiqués ne sont ni très utiles ni flexibles. Ils montrent seulement l'aspect technique de l'écriture d'applications modulaires en C++. Pour écrire une bonne solution modulaire, vous devez la concevoir précisément. Dans la partie suivante de l'article, je vous présenterai des exemples plus complexes d'applications modulaires.