L'inverse de GetProcAddress

Version imprimable

Voir 40 message(s) de cette discussion en une page

26/06/2017, 10h34
tourlourou

Oui, il fonctionne comme ça ; mais mon objectif était d'inclure la déclaration des fonctions externes dans celle de la fonction proposée, pour ne pas avoir de déclaration en dehors de cette fonction, ce qui en faisait une proposition pratique pour la FAQ.

Je soupçonne sans avoir pu en trouver la preuve écrite qu'on n'a pas le droit de déclarer de fonctions externes statiques locales à une fonction.

Un palliatif serait de les déclarer et charger dynamiquement (à tester, peut-être, par curiosité), mais au prix d'un alourdissement du code, et surtout, d'un chargement/déchargement lors de chaque appel, qui n'a pas de sens.

salut

tu veut dire faire un truc de ce genre

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
 
unit MySym ;
 
interface
const
   SYMFLAG_FUNCTION = $00000800; // 2048
 
type
  TSYMBOL_INFO = record
    SizeOfStruct: DWORD; // 10 DWORD 5 uint64 256 AnsiChar => 336
    TypeIndex: DWORD;
    Reserved_1, Reserved_2: uint64;
    Index: DWORD;
    Size: DWORD;
    ModBase: int64;
    Flags: DWORD; // SYMFLAG_FUNCTION
    Value: Int64;
    Address: int64;
    Registre: DWORD;
    Scope: DWORD;
    Tag: DWORD;
    NameLen: DWORD;
    MaxNameLen: DWORD; //256
    Name: array[0..255] of Char;   // AnsiChar
  end;
 
var 
  SymHandleDLL: THandle; 
 
   function MySymInitialize(aHandle: HMODULE; aUserSearchPath: PChar;  aInvadeProcess: Boolean): Boolean;
   function MySymFromAddr(aHandle: HMODULE;  aAdress: int64;  aDisplacement: DWORD;  aSymbolInfo: Pointer): Boolean;
   function MySymCleanup( aHandle: HMODULE ) : Boolean;
 
implementation
 
   TSymInitialize = function(aHandle: HMODULE; aUserSearchPath: PChar;  aInvadeProcess: Boolean): Boolean;
   TSymFromAddr = function(aHandle: HMODULE;  aAdress: int64;  aDisplacement: DWORD;  aSymbolInfo: Pointer): Boolean;
   TSymCleanup  = function( aHandle: HMODULE ) : Boolean;
 
 
procedure ChargerDLL; 
begin 
  //Chargement de la DLL 
  SymHandleDLL := LoadLibrary(pAnsiChar('dbghelp.dll')); 
 
  //Si la DLL n'est pas chargée on ne continue pas 
  If SymHandleDLL = 0 then Exit; 
 
  //Récupération de l'adresse des fonctions nommée
  MYSymInitialize    := GetProcAddress(SymHandleDLL, pAnsiChar('SymInitialize')); 
  MYSymFromAddr  := GetProcAddress(SymHandleDLL, pAnsiChar('SymFromAddr'));
  MYSymCleanup    := GetProcAddress(SymHandleDLL, pAnsiChar('SymCleanup'));
  ...
end;
 //Appel de la fonction si on a bien récupéré son adresse 
 
 initialization 
   ChargerDLL;
 
 
 finalization 
    FreeLibrary(MyHandleDLL) ; 
end;

et ensuite l'utiliser comme une unité normale

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
 
uses MySym ;
var
  ProcessHandle: HMODULE;
  i, Deplacement: Cardinal;
  SymbolInfo: TSYMBOL_INFO;
 
begin
  Result := EmptyStr;
  ProcessHandle := GetCurrentProcess;
  // initialisation de la table des symboles
  if not MySymInitialize(ProcessHandle, nil, True) then Exit;
  // initialisation de la structure pour le retour des infos
  i := SizeOf(TSymbol_Info);
  ZeroMemory(@SymbolInfo, i);
  SymbolInfo.MaxNameLen := MaxSymbolNameLen;
  SymbolInfo.SizeOfStruct :=  i - Length(SymbolInfo.Name) * SizeOf(SymbolInfo.Name[0]);
  Deplacement := 0;
  // informations sur l'adresse demandée
  if MySymFromAddr(ProcessHandle, int64(aAddress), Deplacement, @SymbolInfo) then
  begin
    if (SymbolInfo.Flags or SYMFLAG_FUNCTION) = SYMFLAG_FUNCTION  // filtre les fonctions
    then Result := SymbolInfo.Name;
  end;
  // libération de la table des symboles
  MySymCleanup(ProcessHandle);
end;

Non ; voici ce qui ne compile pas chez moi, avec la mention "directive de compilation incorrecte : external" :

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
// retourne le nom d'une fonction d'une bibliothèque à partir de son adresse.
function GetDllFunctionNameFromAddress(aAddress: Pointer): String;
const
  SYMFLAG_FUNCTION = $00000800 or $00000200; // fonction ou export table
  DbgHelpDll = 'C:\windows\system32\dbghelp.dll';
  MaxSymbolNameLen = 256;
 
type
  TSYMBOL_INFO = record
    SizeOfStruct: Cardinal;
    TypeIndex: Cardinal;
    Reserved_1, Reserved_2: uint64;
    Index: Cardinal;
    Size: Cardinal;
    ModBase: uint64;
    Flags: Cardinal; // SYMFLAG_FUNCTION
    Value: uint64;
    Address: uint64;
    Registre: Cardinal;
    Scope: Cardinal;
    Tag: Cardinal;
    NameLen: Cardinal;
    MaxNameLen: Cardinal; // MaxSymbolNameLen (modifiable)
    Name: array[0..MaxSymbolNameLen-1] of Char; // pas à inclure dans TSYMBOL_INFO.SizeOfStruct
  end;
 
var
  ProcessHandle: HMODULE;
  i, Deplacement: Cardinal;
  SymbolInfo: TSYMBOL_INFO;
 
function SymInitialize(aHandle: HMODULE;
 aUserSearchPath: PChar;
 aInvadeProcess: Boolean): Boolean; stdcall; external DbgHelpDll
{$IFDEF UNICODE}
  name 'SymInitializeW'
{$ELSE}
  name 'SymInitialize'
{$ENDIF};
 
function SymFromAddr(aHandle: HMODULE;
 aAdress: uint64;
 var aDisplacement: Cardinal;
 aSymbolInfo: Pointer): Boolean; stdcall; external DbgHelpDll
{$IFDEF UNICODE}
  name 'SymFromAddrW'
{$ELSE}
  name 'SymFromAddr'
{$ENDIF};
 
function SymCleanup(aHandle: HMODULE): Boolean; stdcall; external DbgHelpDll;
 
begin
  Result := EmptyStr;
  ProcessHandle := GetCurrentProcess;
  // initialisation de la table des symboles
  if not SymInitialize(ProcessHandle, nil, True) then Exit;
  // initialisation de la structure pour le retour des infos
  i := SizeOf(TSymbol_Info);
  ZeroMemory(@SymbolInfo, i);
  SymbolInfo.MaxNameLen := MaxSymbolNameLen;
  SymbolInfo.SizeOfStruct :=  i - Length(SymbolInfo.Name) * SizeOf(SymbolInfo.Name[0]);
  Deplacement := 0;
  // informations sur l'adresse demandée
  if SymFromAddr(ProcessHandle, int64(aAddress), Deplacement, @SymbolInfo) then
  begin
    if (SymbolInfo.Flags or SYMFLAG_FUNCTION) = SYMFLAG_FUNCTION  // filtre les fonctions
    then Result := SymbolInfo.Name;
  end;
  // libération de la table des symboles
  SymCleanup(ProcessHandle);
end;

26/06/2017, 14h48
Cirec

ah oui ...
mais ça c'est pas possible ou tu charges les fonctions dynamiquement ou statiquement mais là tu essayes de mixer les deux du coup le compilateur ne comprend pas!

Cordialement,
@+

Voir 40 message(s) de cette discussion en une page