DLL en gcc sous Linux

Version imprimable

24/06/2011, 15h36
devroot

DLL en gcc sous Linux

Bonjour,

Je travaille avec Netbeans gcc et j'essaie d'écrire une dll.
J'ai réussi- je crois - à créer le fichier *.so mais je ne trouve pas
comment l'appeler depuis un autre programme.

Je ne trouve que des exemples pour des dll windows avec des include "windows.h"
que mon compilateur ne reconnaît pas.

Est-ce quelqu'un a un exemple à me fournir ?

Merci !
24/06/2011, 15h54
TheGzD

Une DLL est une bibliothèque applicatif fonctionnant sous Windows ...
24/06/2011, 16h01
devroot

Oui, d'accord, j'ai bien compris que sous Linux
on avait affaire à des fichiers .so que j'ai réussi à créer.

Mon souci est comment on appelle ce fichier .so depuis un autre programme,
lui aussi programmé en gcc sous Netbeans-Linux?

A long terme je cherche à écrire un programme avec ses DLLs sous Netbeans
pour ensuite les compiler sur une machine Ubuntu, une autre Windows, une autre MAC.

L'idée étant de ré-utiliser le même source.
24/06/2011, 16h22
dragonjoker59

Euh, si tu compiles bien une librairie dynamique (Dll sous windows, shared library sous Linux), tu n'as strictement rien à faire de plus que sous Windows, il faut que ton fichier .so soit dans le même répertoire que ton binary, ou dans le répertoire /bin ou /lib de ta distrib linux.

Attends, je soupçonne quand même que l'appel à la librairie est diffèrente.
En effet, les lignes suivantes fonctionnaent sous Windows mais pas sous Linux:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 /* get handle to dll */
   HINSTANCE hGetProcIDDLL = LoadLibrary("C:\\MyDLL.dll");
 
   /* get pointer to the function in the dll*/
   FARPROC lpfnGetProcessID = GetProcAddress(HMODULE (hGetProcIDDLL),"MyFunction");
 
   /*
      Define the Function in the DLL for reuse. This is just prototyping the dll's function.
      A mock of it. Use "stdcall" for maximum compatibility.
   */
   typedef int (__stdcall * pICFUNC)(char *, int);
 
   pICFUNC MyFunction;
   MyFunction = pICFUNC(lpfnGetProcessID);
 
   /* The actual call to the function contained in the dll */
   int intMyReturnVal = MyFunction("hello", 5);
 
   /* Release the Dll */
   FreeLibrary(hGetProcIDDLL);
 
   /* The return val from the dll */
    returnintMyReturnVal;

24/06/2011, 16h49
fregolo52

Ah les joies du code multi-plateformes !!!

En effet, si le code est générique et que tu utilises un framework multi plateformes (Qt, wxWidgets, boost ....) le code est unique, seuls les makefiles seront custom pour l'OS.

Bon tu réponds pendant que j'écris :aie:
LoadLibrary vs dlopen
GetProcAddress vs dlsym
....

avec du code comme ça, tu vas avoir de joli #ifdef WIN32
24/06/2011, 17h03
devroot

Ah, ça m'intéresse !

J'utilise déjà QT dans mon appli principale.

Tu es en train de me dire que si dans Netbeans je crée un "QT dynamic library", les choses
seront plus simples pour maintenir le code d'une plateforme à l'autre ?

Si, oui, je suis preneur.
24/06/2011, 17h12
fregolo52

Je laisse les spécialistes répondre.
Perso j'ai fait une appli réseau en mode console, donc pas trop de contraintes multi plateforme (à part pthread).

Moi j'ai ça comme code, qui fonctionne sous Linux et Windows (pas de Mac pour tester)
.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//! Platform independant dynamic library
/*!
Loads a dynamic library and gives access to it's functions in a platform independant way
\author Sylvain DOREMUS
\version 0.6.1.0
\date 03/01/2011
*/
class DynamicLibrary
{
private:
	void * m_library;
	std::string m_pathLibrary;
 
public:
	DynamicLibrary()throw()
		:	m_library (NULL)
	{
	}
	~DynamicLibrary()throw()
	{
		_close();
	}
 
public:
	/**
         * Opens a library from a path
         */
	bool Open( const char * p_name)throw();
	bool Open( const std::string & p_name)throw();
 
	/**@name Accessors */
	//@{
	void * GetFunction( const char * p_name)throw();
	void * GetFunction( const std::string & p_name)throw();
	inline bool			IsOpen	()const { return m_library != NULL; }
	inline const std::string & GetPath	()const { return m_pathLibrary; }
	//@}
 
private:
	void _close()throw();
};

.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include "DynamicLibrary.hpp"
 
#ifdef _WIN32
#	include <windows.h>
#else
#	include <dlfcn.h>
#endif
 
void DynamicLibrary :: _close()throw()
{
	if (m_library)
	{
#ifdef _WIN32
		UINT l_uiOldMode = SetErrorMode( SEM_FAILCRITICALERRORS);
#endif
 
		try
		{
#ifdef _WIN32
			FreeLibrary( static_cast <HMODULE> ( m_library));
#else
			dlclose( m_library);
#endif
		}
		catch ( ... )
		{
		}
 
#ifdef _WIN32
		SetErrorMode( l_uiOldMode);
#endif
 
		m_library = NULL;
	}
}
 
bool DynamicLibrary :: Open( const char * p_name)throw()
{
	_close();
 
#ifdef _WIN32
	UINT l_uiOldMode = SetErrorMode( SEM_FAILCRITICALERRORS);
#endif
 
	try
	{
#ifdef _WIN32
		m_library = LoadLibrary( p_name);
#else
		m_library = dlopen( p_name, RTLD_LAZY);
#endif
		m_pathLibrary = p_name;
	}
	catch ( ... )
	{
		m_library = NULL;
	}
 
#ifdef _WIN32
	SetErrorMode( l_uiOldMode);
#endif
 
	return m_library != NULL;
}
 
bool DynamicLibrary :: Open( const std::string & p_name)throw()
{
	return Open( p_name.c_str());
}
 
void * DynamicLibrary :: GetFunction( const char * p_name)throw()
{
	void * l_pReturn = NULL;
 
	if (m_library)
	{
#ifdef _WIN32
		UINT l_uiOldMode = SetErrorMode( SEM_FAILCRITICALERRORS);
#endif
 
		try
		{
#ifdef _WIN32
			l_pReturn = (void *)( GetProcAddress( static_cast<HMODULE>( m_library), p_name));
#else
			l_pReturn = dlsym( m_library, p_name);
#endif
		}
		catch ( ... )
		{
			l_pReturn = NULL;
		}
 
#ifdef _WIN32
		SetErrorMode( l_uiOldMode);
#endif
	}
 
	return l_pReturn;
}
 
void * DynamicLibrary :: GetFunction( const std::string & p_name)throw()
{
	return GetFunction( p_name.c_str());
}

24/06/2011, 18h05
devroot

Bon, j'essaie de reprendre ton code dans mon programme mais je butte sur :

MemoryTraced<DynamicLibrary>
et
shared_ptr<DynamicLibrary>

que mon système ne reconnaît pas du tout...

Et tu compiles tout ça comme une DLL sous Windows puis comme .SO sous Linux ?
24/06/2011, 18h48
dragonjoker59

Ah attends je modifie mon bout de code, mais il suffit que tu enlèves le typedef utilisant shared_ptr, ainsi que l'héritage de MemoryTraced.
Il sert à charger une DLL, pas à en créer une, soit dit en passant.
24/06/2011, 20h51
Matthieu Brucher

Pourquoi charger la bibliothèque à la volée ? Pourquoi ne pas lier statiquement cette bibliothèque dynamique ? Vu tes questions, je pense que :
- tu ne connais pas l'édition des liens statiques et tu n'as pas besoin de charger dynamiquement cette bibliothèque dynamique
- tu as besoin de ce chargement, mais ton niveau en C++ n'est pas suffisant pour comprendre ce que tu fais, et dans ce cas, je te propose de prendre un crash course en C++ avant de t'attaquer à ces chargements dynamiques !
24/06/2011, 23h26
devroot

Merci Matthieu Brucher pour tes encouragements !

1) les librairies dynamiques - suivant le peu que je sais - sont chargées durant le runtime
et déchargées sur commande. Du moins c'est comme ça que ça fonctionne sur les 10-15
applications avec DLL dynamiques que j'ai réussi à écrire. C'est cette dynamique que je souhaite recréer sous environnement Linux.

2) les librairies statiques - suivant le peu que je sais - sont incluses dans l'exe
au moment de la compilation produisant de ce fait un exe un peu plus lourd à chaque
fois que je lui ajoute une librarie. Or, ça ne m'intéresse pas d'avoir un exe qui fait 2 mégas
(là encore j'ai déjà réussi à en écrire des comme ça et ça me convient pas).

3) au delà de mon petit problème personnel à moi, je crois comprendre que les sujets/questions/réponses/parcours dans ce forum doivent servir au fil du temps à d'autres personnes qui tomberaient sur le même type de problème. Donc, avant de poster j'ai regardé sur ce site et d'autres si quelqu'un avait déjà rencontré ce type de problème. Je n'ai pas trouvé un cas semblable au mien, du coup j'ai présenté mon problème à la communauté. Si je me trompe sur l'inexistence d'une page exposant un
problème semblable alors mea culpa, qu'on m'envoie vers la page en question.
Mais un "crash course" en C++ ? Je ne suis pas sûr que les dlls pour Linux+Windows y figure.

Bonsoir !
25/06/2011, 08h06
Matthieu Brucher

1) non, ça, ce sont des bibliothèques dynamiques chargées dynamiquement. Pour toi, tu devrais charger statiquement des bibliothèques dynamiques. Tu fais une édition des liens dans ce cas avec cette bibliothèque. Tu trouveras des exemples dans les cours.

Par exemple la page des cours sur les bibliothèques (http://cpp.developpez.com/cours/?page=bibliotheques) ne présente pas la partie chargement dynamique. Pourquoi ? Parce que c'est inutile dans 99.9% des cas !
25/06/2011, 12h20
dragonjoker59

Citation:

Pourquoi ? Parce que c'est inutile dans 99.9% des cas !

+1

Je ne m'en sers que lors de chargement de plugins.
25/06/2011, 19h06
devroot

Merci pour vos interventions...

Pour les lecteurs "de la postérité" j'ai trouvé une explication claire et du code source ici :
http://www.yolinux.com/TUTORIALS/Lib...ndDynamic.html

Salut !