DLL et include

Version imprimable

26/06/2008, 11h12
Jérôme5

DLL et include

Bonjour,

Petite question à propos des DLLs...

J'ai écrit une DLL avec comme include windows.h et stdafx.h

Si j'utilise cette DLL sur un autre ordinateur, par exemple en l'appelant sous LabVIEW, dois je m'assurer, pour que la DLL fonctionne correctement, que cet ordinateur possède bien ces deux bibliothèques, ? Ou celle ci est elle suffisante à elle même ?

Merci de votre aide !!
Jérôme.
26/06/2008, 11h26
Fab62_

Sans être certain à 100%, je crois qu'elle se suffira à elle-même vu que le code sera compilé avec ces librairies.

Néanmoins, j'ai développé une appli utilisant la bibliothèque de classes MFC de manière dynamique, et donc, lorsque ma DLL est utilisée ailleurs, je dois avoir les DLL MFC sur le poste pour que ca marche.

A voir avec les grands manitous du Forum qui ont plus d'expérience :P

Citation:

Envoyé par Fab62_

Sans être certain à 100%, je crois qu'elle se suffira à elle-même vu que le code sera compilé avec ces librairies.

Néanmoins, j'ai développé une appli utilisant la bibliothèque de classes MFC de manière dynamique, et donc, lorsque ma DLL est utilisée ailleurs, je dois avoir les DLL MFC sur le poste pour que ca marche.

A voir avec les grands manitous du Forum qui ont plus d'expérience :P

Merci de votre réponse rapide !

J'en appelle aux grands manitous alors !!!!! :hola:

En fait lorsque j'appelle cette DLL sous labview j'ai un message d'erreur pas trop compréhensible, du coup je cherche toutes les causes possibles de bug !

le message est le suivant : "Erreur lors du chargement de "D:\DLL_WRITE.dll". Cette application n'a pas pu démarrer car la configuration de l'application est incorrecte. Réinstaller l'application pourrait résoudre le probleme"

et le code de la DLL est le suivant :
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 /Includes #include "stdafx.h" #include <Windows.h> //fonction principale de la DLL BOOL APIENTRY DLLMain (HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { return TRUE; } extern "C" __declspec(dllexport) void __cdecl Write(HANDLE *WriteH, int *Output); void __cdecl Write (HANDLE *WriteH, int *Output) { DWORD BytesWritten = 0; DWORD BytesRead = 0; unsigned char OutputPacketBuffer[65]; OutputPacketBuffer[0] = 0; OutputPacketBuffer[1] = 0x80; OutputPacketBuffer[2] = *Output; WriteFile(*WriteH, &OutputPacketBuffer, 65, &BytesWritten, 0); } // end of Write
Merci de votre aide !!

26/06/2008, 20h31
Médinoc

Windows.h et stdafx.h ne sont pas des bibliothèques. Ce sont des fichiers d'en-tête pour les bibliothèques livrées en standard avec Windows.
(sauf stdafx.h : On peut mettre n'importe quoi dedans).
27/06/2008, 11h20
nicroman
"windows.h" c'est les librairies windows (Windows SDK). Que d'ailleurs on doit écrire:
Code:

1 2 #include <windows.h>
par opposition avec:
Code:

1 2 #include "stdafx.h"
Qui n'existe pas dans les "librairies", et est un fichier de ton projet.

Il se trouve que Visual, par défaut, utilise ce fichier pour les headers précompilés (mais tu pourrais utiliser "tartempion.h" ca serait pareil).
Tu dois d'ailleurs avoir un "stadfx.cpp" (qui ne fait que #include "stadfx.h") qui est utilisé pour compiler ces headers justement.

Sachant que "windows.h" n'utilise que des librairies 'systeme', il faut vérifier pour quelle version de Windows ta librairie a été compilée.
Pour le reste, il faudrait regarder le "stadfx.h" justement, et vérifier qu'il n'inclut pas de <stdio.h> ou de <iostream>

Bonjour,

tout d'abord merci des nombreuses réponses !!
J'ai réussi a resoudre ce probleme pour deux de mes trois DLLs.

Pour la 3eme DLL j'ai le même type de probleme dont voici le code (le code a été réalisé a partir des sources d'un fabricant de microcontroleur, je n'ai fait que l'adapter pour pouvoir en faire une DLL) :

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
//Includes
#include "stdafx.h"    
#include <Windows.h>   
#include <setupapi.h>   
 
 
#include <malloc.h>
 
 
 
#define MY_DEVICE_ID  "Vid_04d8&Pid_0040"    
 
 
 
using namespace System;
 
 
//fonction principale de la DLL
BOOL APIENTRY DLLMain (HANDLE hModule,
                           DWORD ul_reason_for_call,
                           LPVOID lpReserved
                           )
{
    return TRUE;
}
 
 
 
 
// déclaration de la fonction connect
 
extern "C" __declspec(dllexport) void __cdecl connect(HANDLE *WriteH, HANDLE *ReadH, int *conok);
 
 
 
 
// fonction récupération des handles du périphérique
 
void __cdecl connect(HANDLE *WriteH, HANDLE *ReadH, int *conok)
{
 
 
 
        GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, 0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30};
 
        HDEVINFO DeviceInfoTable = INVALID_HANDLE_VALUE;
        PSP_DEVICE_INTERFACE_DATA InterfaceDataStructure = new SP_DEVICE_INTERFACE_DATA;
        PSP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure = new SP_DEVICE_INTERFACE_DETAIL_DATA;
        SP_DEVINFO_DATA DevInfoData;
 
        DWORD InterfaceIndex = 0;
        DWORD StatusLastError = 0;
        DWORD dwRegType;
        DWORD dwRegSize;
        DWORD StructureSize = 0;
        PBYTE PropertyValueBuffer;
        bool MatchFound = false;
        DWORD ErrorStatus;
 
 
        HANDLE WriteHandle = INVALID_HANDLE_VALUE;    //Need to get a write "handle" to our device before we can write to it.
        HANDLE ReadHandle = INVALID_HANDLE_VALUE;    //Need to get a read "handle" to our device before we can read from it.
 
 
 
 
 
String^ DeviceIDToFind = MY_DEVICE_ID;  // MY_DEVICE_ID  "Vid_04d8&Pid_003F"
 
 
DeviceInfoTable = SetupDiGetClassDevs(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
 
 
    while(true)
        {
            InterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
            SetupDiEnumDeviceInterfaces(DeviceInfoTable, NULL, &InterfaceClassGuid, InterfaceIndex, InterfaceDataStructure);
            ErrorStatus = GetLastError();
            if(ERROR_NO_MORE_ITEMS == GetLastError())   
            {   
                SetupDiDestroyDeviceInfoList(DeviceInfoTable);
                return;       
            }
 
 
 
            DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
            SetupDiEnumDeviceInfo(DeviceInfoTable, InterfaceIndex, &DevInfoData);
 
 
            SetupDiGetDeviceRegistryProperty(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID, &dwRegType, NULL, 0, &dwRegSize);
 
 
            PropertyValueBuffer = (BYTE *) malloc (dwRegSize);
            if(PropertyValueBuffer == NULL)   
            {   
                SetupDiDestroyDeviceInfoList(DeviceInfoTable);   
                return;       
            }
 
 
            SetupDiGetDeviceRegistryProperty(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID, &dwRegType, PropertyValueBuffer, dwRegSize, NULL);
 
 
            #ifdef UNICODE
            String^ DeviceIDFromRegistry = gcnew String((wchar_t *)PropertyValueBuffer);
            #else
            String^ DeviceIDFromRegistry = gcnew String((char *)PropertyValueBuffer);
            #endif
 
            DeviceIDFromRegistry = DeviceIDFromRegistry->ToLowerInvariant();   
            DeviceIDToFind = DeviceIDToFind->ToLowerInvariant();               
 
            MatchFound = DeviceIDFromRegistry->Contains(DeviceIDToFind);       
            if(MatchFound == true)
            {
 
                DetailedInterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
 
                SetupDiGetDeviceInterfaceDetail(DeviceInfoTable, InterfaceDataStructure, NULL, NULL, &StructureSize, NULL);   
                DetailedInterfaceDataStructure = (PSP_DEVICE_INTERFACE_DETAIL_DATA)(malloc(StructureSize));       
                if(DetailedInterfaceDataStructure == NULL)   
                {   
                    SetupDiDestroyDeviceInfoList(DeviceInfoTable);   
                    return;       
                }
                DetailedInterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
 
                SetupDiGetDeviceInterfaceDetail(DeviceInfoTable, InterfaceDataStructure, DetailedInterfaceDataStructure, StructureSize, NULL, NULL);
 
 
 
                WriteHandle = CreateFile((DetailedInterfaceDataStructure->DevicePath), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
                ReadHandle = CreateFile((DetailedInterfaceDataStructure->DevicePath), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
                ErrorStatus = GetLastError();
                if(ErrorStatus == ERROR_SUCCESS)
                {
                        *WriteH = WriteHandle;
                        *ReadH = ReadHandle;           
                        *conok = 1;
                }
                else
                {
                *WriteH = INVALID_HANDLE_VALUE;
                *ReadH = INVALID_HANDLE_VALUE;           
                *conok = 0;
                }
 
                SetupDiDestroyDeviceInfoList(DeviceInfoTable);   
                return;
            }//fin du if (matchfound == true)
 
            InterfaceIndex++;   
 
        }//end of while(true)   
    return;
}// end connect

J'ai un peu (un tout petit peu !!) isolé le problème. J'ai tout d'abord désactivé la génération du manifest. La compilation passe.

Et lorsque je change d'ordi (sous XP) pour essayer ma DLL sous Labview, j'ai l'erreur suivante : "Cette application n'a pas pu démarrer car MSVCR90.dll est introuvable. La réinstallation de cette application peut corriger ce problème"

une petite recherche sur msdn me dit que cette DLL vient de l'option "option du projet => C/C++=> generation de code => bibliothèque runtime : DLL multithread"

Alors je me suis dit que j'allais changer cette option en Multithread tout court, mais la compilation me dit que c'est pas compatible avec l'utilisation du Common Language Runtime.
Common Language Runtime nécessaire pour l'utilisation de #using namespace System.

Comme vous pouvez vous en doutez, je ne maitrise pas du tout Visual C++ :oops:

J'ai donc besoin d'un peu d'aide pour faire marcher cette DLL sur l'autre ordinateur ...

ca ferait faire un bond à mon projet !!:mouarf:

Cordialement,
Jérôme.

01/07/2008, 10h38
nicroman

Ha ben voui... si tu utilises les <stdio.h> ou les types std:: il te faut une librairie additionelle appelée "runtime" (et peu comme .Net quoi !).
La librairie (DLL) runtime de MicroSoft Visual C++ s'appelle:
MSVCR... 90 étant la version du compilo (98?).

Il faut donc:
- Ou bien fournir la DLL avec ton executable (a coté du fichier .exe) [attention, je suis pas sur que ce sois légal... mais pour tester...]
- Ou bien installer le "Redistributable Runtime" qui vient avec Visual (il faut donc passer par un installeur).

Il est par contre illégal de "fournir" la version 'debug' de ces librairies.... Donc soit bien sur de compiler en release avant de distribuer ton appli.
01/07/2008, 12h29
Lucien63

Citation:

"windows.h" c'est les librairies windows (Windows SDK).

N'importe quoi !

Les lib windows elle ce nomme user32.dll , kernel32.dll, gdi32.dll .........
Bien sur il y a les librairies d'importations corespondant à ces dll qui sont fournit avec le compilateur et qui peuvent avoir des noms qui differes selon les compilateur
01/07/2008, 14h03
Jérôme5

Citation:

Envoyé par nicroman

Il faut donc:
- Ou bien fournir la DLL avec ton executable (a coté du fichier .exe) [attention, je suis pas sur que ce sois légal... mais pour tester...]
- Ou bien installer le "Redistributable Runtime" qui vient avec Visual (il faut donc passer par un installeur).

Merci pour ta réponse nicroman !

Effectivement, d'apres les recherches que j'ai pu faire (et l'aide que j'ai eu sur le forum de msdn) il semblerait que je sois obligé d'installer le Visual Redistributable sur le PC cible.

Mais bon ca, vu que j'utilise Labview, je sens gros comme une maison que ca risque de m'enquiquiner !

Une autre piste à laquelle j'ai pensé, serait de réecrire le code de 3e DLL (voir post précédent) sans utiliser ni le Common Language Runtime, ni le .NET.

Je pense que ca doit être possible, vu que le code fait principalement appelle à des fonctions de setupapi.dll (je rappelle que j'ai récupéré la majeure partie du code sur un exemple fourni par la fabricant de microcontroleur !)

Le gros problème vient des instructions comme celles-ci :

Code:

String^ DeviceIDFromRegistry = gcnew String((wchar_t *)PropertyValueBuffer);

car je ne sais pas du tout comment les changer en instructions plus "classiques" (je me débrouille un petit peu en C mais alors le C++ depuis trois semaines, ca me donne la migraine !!:mouarf: )

Est il possible de les "transformer" aisément en instruction plus classiques ?
Ou encore pensez vous qu'il serait plus "facile" de retaper les instructions en C ?

Cordialement,
Jérôme.