Utilisation des FilesMapping sous C++ Builder

DjmSoftware

Ce tutoriel démontre l'utilisation des File Mapping avec un exemple d'application

Sources du Programme disponible ici. ♪

- Titre : Utilisation des FilesMapping sous C++ Builder

- Auteur : DjmSoftware

- Parution : 10 juillet 2003

- Mise à jour : 27 février 2013

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2013 DjmSoftware. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Définition

- II. Avantages

- II-A. API utilisées

- II-B. Programme d'exemple

- II-C. Limitation

- II-D. Cahier des Charges

- III. Définition du GUI

- III-A. définition de la forme principale

- III-B. ImageList

- III-C. ActionsList

- III-D. Menu Principal

- III-E. Tools Buttons

- IV. Classe TMMF

- IV-A. But de cette classe

- IV-B. Déclaration de la classe

- IV-C. Implémentation de la classe

- IV-D. Constructeur avec FileName

- IV-E. Destructeur

- IV-F. Méthode GetFile

- IV-G. Méthode GetMapping

- IV-H. Méthode GetPtrAdresse

- IV-I. Méthode Execute

- IV-J. Méthode GetSizeofFile

- IV-K. Explicatif

- IV-L. Description des méthodes

- IV-L-1. Le constructeur

- IV-L-2. le Destructeur

- IV-L-3. méthode GetFile()

- IV-L-4. méthode GetMapping

- IV-L-5. méthode GetPtrAdresse

- IV-L-6. méthode GetSizeofFile

- IV-L-7. méthode Execute

- V. Classe Tform

- V-A. Constructeur

- V-B. Méthode OpenFileExecute

- V-C. Méthode CloseApp

- V-D. Méthode ExecuteExecute

- V-E. Méthode CleanPtr

- V-F. Méthode CancelActionExecute

- V-G. Méthode FormDestroy

- V-H. Méthode ParseCmdLine

- VI. Installation dans C++ Builder

- VII. Utilisation dans C++ Builder

I - Définition

Files Mapping est une des plus puissantes fonctionnalités API Win32 permettant de partager dans la mémoire attribuée à chaque Processus (2 Gb) des zones de mémoires physiques ou de fichiers stockés sur disque.

Il est alors possible de travailler de manière avec le contenu d'un fichier ou contenu mémoire :

- les Fichiers sur disques peuvent être des tous de types même le système Page Files ;

- les Fichiers peuvent être chargés entièrement ou découpés en bloc ;

- la seule limitation est que l'on ne peut pas utiliser des fichiers se trouvant sur une autre Computer.

II - Avantages

Partage mémoire entre plusieurs Processus de manière à communiquer entre eux.

Accès très rapide aux fichiers sur le disque.

Mise a jour de DLL, etc.

II-A - API utilisées

1. CreateFile

2. CreateFileMapping

3. MapiewOfFile

4. MapViewOfFileEx

5. OpenMappedFile

6. UmpapViewOfFile

7. FlushViewOfFile

Explication des API

CreateFile : Permet de créer ou d'ouvrir les objets suivants :

1. files

2. pipes

3. mailslots

4. communications resources

5. disk devices (Windows NT only)

6. consoles

7. directories (open only)

CreateFileMapping : Crée un object de mémoire partagée Nommé ou anonyme

MapiewOfFile : Mappe dans la zone mémoire du process l'object précédemment obtenu par l'appel à Create FileMapping

MapViewOfFileEx : Identique à MapiewOfFile mais avec la possibilité supplémentaire d'indiquer ou l'object. FileMapping doit être placé dans la mémoire du process appelant

OpenFileMapping : Ouvre un object FileMapping

Cette fonction est généralement utilisée pour connaître le Handle d'un object FileMapping

UmpapViewOfFile : Retire de l'espace mémoire du process l'object FileMapping

FlushViewOfFile : Permet de remplir des fichiers Mappés sur disque avec la valeur 0 en précisant l'adresse de départ ainsi que le nombre d'éléments à supprimer

II-B - Programme d'exemple

Dans le but de démontrer une utilisation possible des Mapping Files, je vous propose une application

J'ai remarqué que depuis la version 3 du compilateur Borland C++ Builder la table d'exportation de l'exécutable généré est toujours emplie avec des symboles plus ou moins barbares du genre suivant :

- @@Testbitmap@Finalize

- @@Testbitmap@Initialize

- @Classes@TComponent@UpdateRegistry$qqr4boolx17System@AnsiStringxt2

- @Forms@TForm@$bctr$qqrp18Classes@TComponent

- @Forms@TForm@$bdtr$qqrv

ce qui ne donne pas une représentation très professionnelle de l'exécutable fourni. Les exécutables générés par Delphi ne souffrent pas de ce défaut.

L'application proposée à l'utilité de supprimer la table d'exportation des exécutables générés par C++ Builder.

II-C - Limitation

Ce programme est écrit en C++ à l'aide de C++ Builder 6.

Dans ce programme est utilisé certaines fonctionnalités VCL qui rendent la partie GUI non portable sur un autre compilateur, l'adaptation du code est par contre possible.

II-D - Cahier des Charges

- Établir un Tools avec un GUI.

- Permettre la possibilité d'installer et de désinstaller ce programme dans la Shell.

- Permettre le fonctionnement via une ligne de commande.

- Permettre la Commande Via la Shell (Touche droite de la souris sur un fichier Exe).

- Création d'une classe de travail pour les Files Mapping.

III - Définition du GUI

III-A - définition de la forme principale

Pour commencer, nous allons définir la forme Principale.

Déposer les Composants suivants sur une Form :

1 TAction List

ActionList1

1 TImageList

ImageList1

1 TMainMenu

MainMenu1

1 TOpenDialog

OpenDialog1

1 TTool Bar

Align = alTop

1 TPanel

Align = alClient

1 TStatusBar

""

Déposer les Composants sur le Panel

1 Tedit

Edit1

1 Tbutton

Button1

1 Tlabel

Label1

Cliquer avec la touche droite de la souris sur la tool Bar et créer quatre Boutons

TToolsButtons

ToolsButtons1

TToolsButtons

ToolsButtons2

TToolsButtons

ToolsButtons3

TToolsButtonsl

ToolsButtons4

III-B - ImageList

Nous allons créer Charger les Images dans le composant ImageList1

choisir cinq Images dans les fichiers communs de Borland

Image1

Open File

Image2

Execute

Image3

Cancel

Image4

Close

Image5

Help

III-C - ActionsList

Ouvrir le composant ActionList1

Nom

Caption

Image

OnExecute

OpenFile

Open

*

OpenFileExecute

Execute

Execute

*

ExecuteExecute

CancelAction

Cancel

*

CancelActionExecute

About

À propos de

*

AboutExecute

*= Index de l'image choisie

III-D - Menu Principal

Création d'un menu selon image suivante :

donner aux Items Actions les valeurs suivantes

Item

Action

Open

OpenFile

Execute

Execute

Close

CloseApp

À Propos de

About

III-E - Tools Buttons

Donner aux Actions de Buttons les Valeurs Suivantes

Item

Action

ToolButton1

OpenFile

ToolButton2

Execute

CancelAction

CancelAction

ToolButton6

CloseApp

Le design de l'application est maintenant terminé.

IV - Classe TMMF

Pour travailler en C++ avec les API WIN32 il est préférable de déclarer une nouvelle classe.

IV-A - But de cette classe

- Encapsuler les API relatives aux Files Mapping.

- Fournir via l'appel a une méthode public un pointeur sur une zone mappée.

- Dans le cas d'une erreur, fournir un message d'erreur win32.

IV-B - Déclaration de la classe

1. #ifndef MMFH

2. #define MMFH

3. #include <vcl.h>

4. //---------------------------------------------------------------------------

5. class TMMF {

7. private :

8. HANDLE FFileMap;

9. HANDLE FFileHandle;

10. void * FMappingPtr;

11. DWORD FFileSize;

12. DWORD FFileSizeHigh;

13. AnsiString FFileName;

14. AnsiString FErrorMsg;

15. void __fastcall GetFile();

16. void __fastcall GetMapping();

17. void __fastcall GetPtrAdresse();

18. void __fastcall GetSizeofFile();

20. protected :

22. public :

23. __fastcall TMMF();

24. __fastcall TMMF(AnsiString FileName);

25. __fastcall ~TMMF();

26. bool __fastcall Execute();

27. __property HANDLE FileHandle = { read = FFileHandle };

28. __property HANDLE MappingHandle = { read = FFileMap };

29. __property void * PtrMapping = { read = FMappingPtr };

30. __property AnsiString ErrorMessage = { read = FErrorMsg };

31. __property DWORD FileSize = { read = FFileSize };

34. } //---------------------------------------------------------------------------

définitions des champs

Champs

description

HANDLE FFileMap

Contient le Handle du fichier Ouvert

HANDLE FFileHandle

Contient le Nom du Fichier

void* FMappingPtr

Contient le pointeur sur la zone mappée

DWORD FFileSize

Contient la taille du fichier mappé

DWORD FFileSizeHigh

Contient la taille haute du fichier mappé

AnsiString FFileName

Contient le nom du fichier à mappé

AnsiString FErrorMsg

Contient le message d'erreur

définitions des méthodes

Méthode

partie

description

__fastcall TMMF()

public

Constructeur par défault

__fastcall TMMF(AnsiString FileName)

public

Constructeur avec nom du fichier

__fastcall ~TMMF();

public

destructeur

bool __fastcall Execute()

public

appel des différentes fonctions

void __fastcall GetFile()

private

initialise FfileHandle

void __fastcall GetPtrAdresse()

private

initialise FMappingPtr

void __fastcall GetSizeofFile()

private

initialise FfileSize et FfileSizeHigh

IV-C - Implémentation de la classe

Constructeur

1. #include "MMF.h"

2. //---------------------------------------------------------------------------

3. __fastcall TMMF::TMMF()

4. :FFileMap(NULL),

5. FFileHandle(NULL),

6. FMappingPtr(NULL),

7. FFileSize(0),

8. FFileSizeHigh(0),

9. FFileName(""),

10. FErrorMsg("")

12. {

14. }

IV-D - Constructeur avec FileName

1. //---------------------------------------------------------------------------

2. __fastcall TMMF::TMMF(AnsiString FileName)

3. :FFileMap(NULL),

4. FFileHandle(NULL),

5. FMappingPtr(NULL),

6. FFileSize(0),

7. FFileSizeHigh(0),

8. FFileName(""),

9. FErrorMsg("")

11. {

12. FFileName=FileName;

14. } //---------------------------------------------------------------------------

IV-E - Destructeur

1. __fastcall TMMF::~TMMF()

2. {

3. if (FMappingPtr)

4. {

5. UnmapViewOfFile(FMappingPtr);

6. FMappingPtr=NULL;

7. }

8. if (FFileMap)

9. {

10. CloseHandle(FFileMap);

11. FFileMap=NULL;

12. }

13. if (FFileHandle)

14. {

15. CloseHandle(FFileHandle);

16. FFileHandle=NULL;

17. }

19. } //---------------------------------------------------------------------------

IV-F - Méthode GetFile

1. void __fastcall TMMF::GetFile()

2. {

3. FFileHandle=CreateFile(FFileName.c_str(), // pointer to name of the file

5. GENERIC_READ|GENERIC_WRITE, // access (read-write) mode

6. FILE_SHARE_READ|FILE_SHARE_WRITE,// share mode

7. NULL, // pointer to security attributes

8. OPEN_EXISTING, // how to create

9. FILE_ATTRIBUTE_NORMAL, // file attributes

10. NULL); //TODO: Add your source code here

12. if (FFileHandle==NULL |(long )FFileHandle==-1)

13. RaiseLastOSError();

15. } //---------------------------------------------------------------------------

IV-G - Méthode GetMapping

1. void __fastcall TMMF::GetMapping()

2. {

3. FFileMap=CreateFileMapping(FFileHandle, // handle to file to map

5. NULL, // optional security attributes

6. PAGE_READWRITE, // protection for mapping object

7. 0, // high-order 32 bits of object size

8. 0, // low-order 32 bits of object size

9. NULL); //

11. if (!FFileMap)

12. RaiseLastOSError();

14. } //---------------------------------------------------------------------------

IV-H - Méthode GetPtrAdresse

1. void __fastcall TMMF::GetPtrAdresse()

2. {

3. FMappingPtr=MapViewOfFile(FFileMap,

5. FILE_MAP_ALL_ACCESS,

6. 0,

7. 0,

8. 0);

10. if (!FMappingPtr)

11. RaiseLastOSError();

13. }

IV-I - Méthode Execute

1. bool __fastcall TMMF::Execute()

2. {

3. try

4. {

5. GetFile();

6. GetMapping();

7. GetPtrAdresse();

8. }

9. catch (EOSError &E)

10. {

11. FErrorMsg=E.Message;

12. return false;

13. }

14. GetSizeofFile();

15. return true;

17. }

IV-J - Méthode GetSizeofFile

1. void __fastcall TMMF::GetSizeofFile()

2. {

3. FFileSize=GetFileSize(FFileHandle,&FFileSizeHigh);

4. }

IV-K - Explicatif

Généralement les APIwin32 retournent un code indiquant si l'opération désirée s'est terminée par un succès :

- une valeur de 0 ou true indique une opération terminée avec succès ;

- dans le cas contraire, un appel GetLastError() nous retourne le code d'erreur.

La VCL intègre une classe EOSError permettant de retourner dans la variable membre Message le code ainsi que le message d'erreur

Il suffit donc de tester la sortie de l'api et en cas d'insuccès de générer une exception De type EOSError par un appel à RaiseLastOSError()

La classe d'exception EOSError est intégrée dans C++ builder 6 dans les versions précédentes

On peut utiliser la classe d'exception EWin32Error et pour le déclenchement d'une exception de ce type l'appel à RaiseLastWin32Error()

IV-L - Description des méthodes

IV-L-1 - Le constructeur

1. __fastcall TMMF::TMMF(AnsiString FileName)

2. :FFileMap(NULL),

3. FFileHandle(NULL),

4. FMappingPtr(NULL),

5. FFileSize(0),

6. FFileSizeHigh(0),

7. FFileName(""),

8. FErrorMsg("")

10. {

11. FFileName=FileName;

13. } }

initialise les membres de la classe puis copie dans FFileName le paramètre du constructeur.

IV-L-2 - le Destructeur

1. __fastcall TMMF::~TMMF()

2. {

3. if (FMappingPtr)

4. {

5. UnmapViewOfFile(FMappingPtr);

6. FMappingPtr=NULL;

7. }

8. if (FFileMap)

9. {

10. CloseHandle(FFileMap);

11. FFileMap=NULL;

12. }

13. if (FFileHandle)

14. {

15. CloseHandle(FFileHandle);

16. FFileHandle=NULL;

17. }

19. } //---------------------------------------------------------------------------

teste l'état des différents pointeurs , libère la zone mappée ainsi que les handles de fichiers

IV-L-3 - méthode GetFile()

1. void __fastcall TMMF::GetFile()

2. {

3. FFileHandle=CreateFile(FFileName.c_str(), // pointer to name of the file

5. GENERIC_READ|GENERIC_WRITE, // access (read-write) mode

6. FILE_SHARE_READ|FILE_SHARE_WRITE,// share mode

7. NULL, // pointer to security attributes

8. OPEN_EXISTING, // how to create

9. FILE_ATTRIBUTE_NORMAL, // file attributes

10. NULL); //TODO: Add your source code here

12. if (FFileHandle==NULL |(long )FFileHandle==-1)

13. RaiseLastOSError();

15. } //---------------------------------------------------------------------------

cette méthode utilise l'API WIN32 CreateFile pour obtenir un Handle de fichier
le champ FFileHandle contient le Handle du fichier
si la valeur de retour est différente d'un Handle Valide, on génère une exception

IV-L-4 - méthode GetMapping

1. void __fastcall TMMF::GetMapping()

2. {

3. FFileMap=CreateFileMapping(FFileHandle, // handle to file to map

5. NULL, // optional security attributes

6. PAGE_READWRITE, // protection for mapping object

7. 0, // high-order 32 bits of object size

8. 0, // low-order 32 bits of object size

9. NULL); //

11. if (!FFileMap)

12. RaiseLastOSError();

14. } //---------------------------------------------------------------------------

cette méthode utilise l'API WIN32 CreateFileMapping pour créer une zone commune en mémoire et retourner dans le le champ FFileMap un Handle sur cette zone si la valeur de retour est NULL on génère une exception.

IV-L-5 - méthode GetPtrAdresse

1. void __fastcall TMMF::GetPtrAdresse()

2. {

3. FMappingPtr=MapViewOfFile(FFileMap,

5. FILE_MAP_ALL_ACCESS,

6. 0,

7. 0,

8. 0);

10. if (!FMappingPtr)

11. RaiseLastOSError();

13. }

cette méthode utilise l'API WIN32 MapViewofFile qui retourne dans FmappingPtr un pointeur sur la zone mappée en mémoire avec FFileMap en paramètre si la valeur de retour est NULL on génère une exception.

IV-L-6 - méthode GetSizeofFile

1. void __fastcall TMMF::GetSizeofFile()

2. {

3. FFileSize=GetFileSize(FFileHandle,&FFileSizeHigh);

4. }

cette méthode initialise les deux champs membres FFileSize et FFileSizeHigh avec la longueur du fichier obtenu par l'appel à GetFileSize.

IV-L-7 - méthode Execute

1. bool __fastcall TMMF::Execute()

2. {

3. try

4. {

5. GetFile();

6. GetMapping();

7. GetPtrAdresse();

8. }

9. catch (EOSError &E)

10. {

11. FErrorMsg=E.Message;

12. return false;

13. }

14. GetSizeofFile();

15. return true;

17. }

la méthode Execute est le cœur de cette classe , elle appelle successivement dans une partie protégée du programme (try catch) GetFile,GetMapping,GetPtrAdresse en cas d'erreur dans une de ces méthodes la variable FerrorMessage est initialisée avec le message d'erreur retournée par le système d'exploitation.

V - Classe Tform

Déclaration de la classe

1. //---------------------------------------------------------------------------

2. #ifndef mainH

3. #define mainH

4. //---------------------------------------------------------------------------

5. #include lt;Classes.hpp>

6. #include <Controls.hpp>

7. #include <StdCtrls.hpp>

8. #include <Forms.hpp>

9. #include <Dialogs.hpp>

10. #include <ActnList.hpp>

11. #include <ComCtrls.hpp>

12. #include <ExtCtrls.hpp>

13. #include <ImgList.hpp>

14. #include <Menus.hpp>

15. #include <ToolWin.hpp>

16. #define ExeKeyName "exefile\\shell"

17. #define CommandKeyName "ExportCleaner\\Command"

18. #define PrgKeyName "ExportCleaner"

19. #define Command "ExportCleaner.exe %1"

20. //---------------------------------------------------------------------------

21. class TForm1 : public TForm

22. {

23. __published: // Composants g&#195;&#169;r&#195;&#169;s par l'EDI

24. TPanel *Panel1;

25. TToolBar *ToolBar1;

26. TOpenDialog *OpenDialog1;

27. TMainMenu *MainMenu1;

28. TImageList *ImageList1;

29. TActionList *ActionList1;

30. TAction *OpenFile;

31. TAction *Execute;

32. TAction *CloseApp;

33. TEdit *Edit1;

34. TButton *Button1;

35. TLabel *Label1;

36. TMenuItem *Open1;

37. TMenuItem *Execute1;

38. TMenuItem *Open2;

39. TMenuItem *Close1;

40. TMenuItem *N3;

41. TAction *CancelAction;

42. TStatusBar *StatusBar1;

43. TToolButton *ToolButton1;

44. TToolButton *ToolButton2;

45. TToolButton *ToolButton5;

46. TToolButton *ToolButton6;

47. TMenuItem *Aide;

48. TAction *About;

49. TMenuItem *AProposde1;

50. void __fastcall OpenFileExecute(TObject *Sender);

51. void __fastcall CloseAppExecute(TObject *Sender);

52. void __fastcall ExecuteExecute(TObject *Sender);

53. void __fastcall CancelActionExecute(TObject *Sender);

54. void __fastcall FormDestroy(TObject *Sender);

55. void __fastcall AboutExecute(TObject *Sender);

56. private :

57. AnsiString FileName; // D&#195;&#169;clarations de l'utilisateur

58. void * DirectoryEntry;

59. void __fastcall CleanPtr();

60. void __fastcall ParseCmdLine();

61. public : // D&#195;&#169;clarations de l'utilisateur

62. __fastcall TForm1(TComponent* Owner);

64. } ;

65. //---------------------------------------------------------------------------

66. extern PACKAGE TForm1 *Form1;

67. //---------------------------------------------------------------------------

68. #endif

nous allons déclarer dans la partie private de la classe TForm1 les champs Suivants :

1. AnsiString FileName; // D&#195;&#169;clarations de l'utilisateur

2. void* DirectoryEntry;

les Méthodes suivantes :

1. void__fastcall CleanPtr();

2. void__fastcall ParseCmdLine();

description des champs :

- FileName est utilisé pour stocker le nom de l'exécutable à traiter ;

- DirectoryEntry est un pointeur sur la directoy entry de l'exécutable.

V-A - Constructeur

1. __fastcall TForm1::TForm1(TComponent* Owner)

2. : TForm(Owner)

4. {

5. pMap=NULL;

6. CleanPtr();

7. StatusBar1->SimpleText="Please Select exe File";

8. if (ParamCount()>=1)

10. ParseCmdLine(); // appel avec une ligne de commande

11. }

on appelle un méthode pour s'assurer que les pointeurs sont dans un état défini, et que les hanldes de fichiers sont tous libérés l'appel à la méthode ParseCmdLine permet de controler si une ligne de commande est présente.

V-B - Méthode OpenFileExecute

1. void __fastcall TForm1::OpenFileExecute(TObject *Sender)

2. {

3. if (OpenDialog1->Execute())

4. {

5. FileName=OpenDialog1->FileName;

6. Edit1->Text= FileName;

7. StatusBar1->SimpleText="Please Press Execute";

8. }

9. Execute->Enabled = (FileName!="");

10. }

cette méthode appelée depuis le menu ou un Tools Button affiche une DialogBox Standard qui permet la saisie de l'exécutable à traiter.

V-C - Méthode CloseApp

1. void __fastcall TForm1::CloseAppExecute(TObject *Sender)

2. {

3. Close();

4. }

Appelle la fermeture du programme.

V-D - Méthode ExecuteExecute

1. void __fastcall TForm1::ExecuteExecute(TObject *Sender)

2. {

3. ULONG DSize;

4. IMAGE_NT_HEADERS * myImage;

5. DWORD HeaderSum,CheckSum ;

6. TMMF * myMMF = new TMMF(FileName);

7. Execute->Enabled=false;

8. OpenFile->Enabled=false;

9. if (myMMF->Execute())

10. {

11. try

12. {

13. DirectoryEntry=ImageDirectoryEntryToData(myMMF->PtrMapping,

14. false,

15. IMAGE_DIRECTORY_ENTRY_EXPORT,

16. &DSize );

17. if (!DirectoryEntry)

18. RaiseLastOSError();

19. FlushViewOfFile(DirectoryEntry,DSize);

20. myImage= CheckSumMappedFile(myMMF->PtrMapping,

21. myMMF->FileSize,

22. &HeaderSum,

23. &CheckSum);

24. myImage->OptionalHeader.DataDirectory[0].VirtualAddress=0L;

25. myImage->OptionalHeader.DataDirectory[0].Size=0L;

26. }

27. catch (EOSError &E)

28. {

29. StatusBar1->SimpleText="Exe File Contains no Export Directories";

30. MessageDlg(StatusBar1->SimpleText,mtInformation,TMsgDlgButtons()<< mbOK, 0);

31. delete myMMF;

32. CleanPtr();

33. OpenFile->Enabled=true;

34. return ;

35. }

36. StatusBar1->SimpleText="Saved Successfuly ..." ;

37. MessageDlg(StatusBar1->SimpleText,mtInformation, TMsgDlgButtons()<< mbOK, 0);

38. }

39. else

40. {

41. MessageDlg(myMMF->ErrorMessage, mtError, TMsgDlgButtons() << mbOK, 0);

42. StatusBar1->SimpleText="Error occurs ....";

43. }

44. delete myMMF;

45. CleanPtr();

46. OpenFile->Enabled=true;

47. }

cette méthode est le cœur du programme

1. IMAGE_NT_HEADERS * myImage; DWORD HeaderSum,CheckSum ; ULONG DSize;

MyImage est un pointeur sur la structure IMAGE_NT_HEADERS qui contient la Strucuture du fichier dans le monde Windows PE32 HeaderSum,CheckSum,Dsize sont des variables de Travail

1. TMMF * myMMF = new TMMF(FileName); MyMMF contient une instance de la classe TMMF

L'appel à la méthode Execute va nous retourner un pointeur sur la zone mappée

Dans un bloc protégé on va tenter d'obtenir dans DirectoryEntry un pointeur sur la table d'exportation de l'exécutable par un appel a l'API WIN32 ImageDirectoryEntryToData. En cas de retour avec une valeur NULL une exception est déclenchée

Cette exception est interceptée dans le Bloc Catch qui affiche une boîte de dialogue Affiche un message dans la ligne de Status, détruit le myMMF,et sort de la méthode

si tout c'est bien passé. Il nous reste maintenant à supprimer cette table d'exportation à l'aide FlushViewOfFile(DirectoryEntry,DSize);

Nous devons maintenant ajuster l'entête PE de notre exécutable à une valeur correcte

1. myImage= CheckSumMappedFile(

3. pMap,

4. FielSize,

5. &HeaderSum,

6. &CheckSum);

7. myImage->OptionalHeader.DataDirectory[0].VirtualAddress=0L;

8. myImage->OptionalHeader.DataDirectory[0].Size=0L;

l'Api CheckSumMappedFile nous renvoie un pointeur sur IMAGE_NT_HEADERS, ainsi que la taille du Header et son check Summ on positionne à la taille à 0

1. myImage->OptionalHeader.DataDirectory[0].VirtualAddress=0L;

2. myImage->OptionalHeader.DataDirectory[0].Size=0L;

On affiche le résultat des opérations dans la StatusBar ,ainsi que dans une boite de dialogue , détruit le myMMF,et sort de la méthode

V-E - Méthode CleanPtr

1. void __fastcall TForm1::CleanPtr()

2. {

3. DirectoryEntry=NULL;

4. FileName=NULL;

5. Edit1->Text="";

6. }

la méthode CleanPtr réinitialise les variables,ainsi que le champ Edit1->Text

V-F - Méthode CancelActionExecute

1. void __fastcall TForm1::CancelActionExecute(TObject *Sender)

2. {

3. OpenFile->Enabled=true;

4. Execute->Enabled=false;

5. CleanPtr();

6. StatusBar1->SimpleText="Please Select exe File";

7. }

Cancel annule les ordres en cours , appelle cleanPtr, et remet le système dans son état de départ

V-G - Méthode FormDestroy

1. void __fastcall TForm1::FormDestroy(TObject *Sender)

2. {

3. CleanPtr();

4. }

Form Destroy Appelé par Close() libère la mémoire

V-H - Méthode ParseCmdLine

1. void __fastcall TForm1::ParseCmdLine() {

2. AnsiString Tmp;

3. int ParamNr=ParamCount();

4. if (ParamNr ==1) // Command Line Exists

5. {

6. AnsiString cmd=ParamStr(1).UpperCase();

7. if ((cmd =="/INSTALL") ||(cmd =="/UNINSTALL"))

8. {

9. TRegistry* mReg= new TRegistry();

10. try

11. {

12. mReg->RootKey=HKEY_CLASSES_ROOT;

13. mReg->OpenKey(ExeKeyName,false); // open Shell Key in registry

14. if (cmd =="/INSTALL")

15. }{

16. if (!mReg->KeyExists(PrgKeyName))

17. {

18. mReg->OpenKey(CommandKeyName,true); // Command Install

19. mReg->WriteString("",Command);

20. MessageDlg("Export Cleaner installed Succesfuly", mtInformation, TMsgDlgButtons() << mbOK, 0);

21. }

22. }

23. } if (cmd =="/UNINSTALL")

24. {

25. if (mReg->KeyExists(PrgKeyName))

26. mReg->DeleteKey(PrgKeyName); // delete Registry Key

27. MessageDlg("Export Cleaner desinstalled Succesfuly", mtInformation, TMsgDlgButtons() << mbOK, 0);

28. }

29. }

30. catch (...)

31. {

32. mReg->CloseKey();

33. }

34. delete mReg;

35. Application->Terminate(); // Exit Application

36. }

37. else

38. {

39. for (int i=0;i<ParamNr;i++)

40. {

41. Tmp+=ParamStr(i+1);

42. Tmp+=" ";

43. }

44. Tmp.Delete(Tmp.Length(),1); //delete Last Space

45. FileName=Tmp;

46. if ((!FileExists(Tmp)) &&(ExtractFileExt(Tmp)!=".exe")

47. ) MessageBox(Application->Handle,

48. "File Not Exist or Not a valid Exe File",

49. "Export Cleaner",

50. MB_OK|MB_ICONINFORMATION);

51. else ExecuteExecute(NULL); // Call suppress

52. Application->Terminate(); // Exit Application

53. }

54. }

55. }

cette méthode teste la présence d'une ligne de commande si la ligne de commande est égale à INSTALL le programme installe dans la registry un shell pour les fichiers de type exe ce qui permettra avec un clic bouton droit de la souris de lancer le programme exportCLeaner.exe

une boite de dialogue vous indique le résultat de l'opération

La ligne de commande avec une valeur égale à /UNINSTALL supprimera de la registry la shell pour les fichiers de type exe.

si une ligne de commande est présente et n'est pas égale aux commandes d'installation cela signifie que le paramètre est le nom du fichier exe à traiter on test s'il s'agit bien d'un fichier exécutable et si la réponse est positive on lance l'application.

VI - Installation dans C++ Builder

- Dans le menu Outils sélectionner Configurer les outils.

- Sélectionner ajouter.

- Dans le champ Titre insérer ExportCLeaner.

- Sélectionner le bouton Parcourir et sélectionner le fichier ExportCleaner.exe.

- Sélectionner le bouton Macro dans la listBox choisir $TDW.

- Sélectionner le bouton Insérer.

- Sélectionner le bouton OK.

ExportCleaner est désormais installé et apparait dans la liste d'outils.

VII - Utilisation dans C++ Builder

- Compiler un nouveau projet.

- Sélectionner dans le menu Outil l'item ExportCleaaner.

- À la fin de l'exécution du programme une boite de dialogue vous indique le résultat de l'opération.

Voir également mes autres articles :

- Utilisation des Files Mapping sous C++Builder C++ Builder

- La technique des PatchFiles C++ Builder

- Maîtrisez les files d'impression sous windows C++ Builder

- Travailler avec les Interfaces en C++Builder Partie 1 C++ Builder

- Composant de gestion des ports d'imprimantes C++ Builder

- Programme de Test Version ActiveX du composant TDLIoport Delphi

Sans oublier :

- la FAQ C++ Builder par Geronimo

- la FAQ C

- la FAQ C++