DLL HOOK EN RESSOURCE BINAIRE DU PROG (WIN32)

Commentaire de JCDjcd le 16/08/2004 20:19:23

Je ne comprend pas l'utilisation d'un DLL, pour recupere CTRL+SHIT+F11/12 je peux simplement faire un HHOOK sur le clavier non ?

Commentaire de JCDjcd le 17/08/2004 00:08:43

Si je n'es plus le focus, mon hook ne marche plus ?

Commentaire de JCDjcd le 17/08/2004 00:22:14

donc si on a un nouveau programme est au premier plan, alors on recharge encore la fonction du hook sur clavier ?

Commentaire de JCDjcd le 17/08/2004 09:00:01

BOOL WINAPI DllMain(HINSTANCE hDll, DWORD dwReason, LPVOID Reserved)
{
  if(dwReason == DLL_PROCESS_ATTACH) thismod = hDll;
  return 1;
}


***************
si dwReason ne vaut pas , alors thismode vaut NULL, donc pour le reste du programme c'est pas embetant ? et comment on sait ce que faut dwReason ?

Commentaire de JCDjcd le 17/08/2004 11:49:04

mais le systems apelle DllMain pou chaque cas, i.e. une fois pour ATTACH et une autre pour DETACH ?

Commentaire de BruNews le 17/08/2004 12:06:45 administrateur CS

Regarde Richter chapitre 20, il fait une analyse complete de tout cela.

Commentaire de BruNews le 17/08/2004 16:07:49 administrateur CS

Windows est un multitache preemptif ou donc user a toujours priorite. Le systeme va placer les entrees clavier dans la pile d'appels du process de 1er plan.
Si tu masques ta fenetre, il y en aura bien une autre en 1er plan a sa place, ok ? alors tu ne reçois plus les touches, voila pourquoi hook clavier GLOBAL OBLIGATOIRE et par force en dll.

Commentaire de BruNews le 17/08/2004 17:48:03 administrateur CS

Analyse le deroulement et tu verras.

Commentaire de BruNews le 28/10/2005 22:15:09 administrateur CS

Rien à voir avec le fait que soit linké ou chargé en dynamique, DllMain sera appelé dans tous les cas.

Commentaire de BruNews le 28/10/2005 22:34:06 administrateur CS

etat_hook est inutile, hHook à zéro fera idem pour test.
Toute procédure de hook doit être le plus rapide possible sinon le système passera son chemin pour ne pas se mettre en péril. Il ne faut donc absolument pas mettre de fonction bloquante comme MessageBox.

Commentaire de BruNews le 28/10/2005 22:39:26 administrateur CS

Faut mettre un retour sur DemarrerHook() ainsi tu sauras si hook lancé.
Regarde dans mes exemples:
int __stdcall DemarrerHook()
{
  ....
  return (int) hook;
}

Commentaire de BruNews le 28/10/2005 23:03:19 administrateur CS

ben tu vois que y a pas besoin de MessageBox, y a plus qu'à chercher l'erreur.
Le mieux tu mets un de mes exemples à coté de ton code et tu regardes ce qui diffère:
HOOK SYSTEM SUR WM_MOUSEWHEEL (WIN32)
http://www.cppfrance.com/code.aspx?ID=25998
DLL HOOK EN RESSOURCE BINAIRE DU PROG (WIN32)
http://www.cppfrance.com/code.aspx?id=25450
HOOK F11 SUR IE (WIN32)
http://www.cppfrance.com/code.aspx?id=18202
HOOK CLAVIER
http://www.cppfrance.com/code.aspx?id=17818
LIMITE LE NBR DE FENETRES IE V2 (WIN32)
http://www.cppfrance.com/code.aspx?id=17387
etc, etc...

Commentaire de BruNews le 28/10/2005 23:12:47 administrateur CS

Une idée comme je ne connais pas ton compilo:
HHOOK hHook = 0;
Faut toujours garantir le zéro sinon test ultérieur pas certain.

Commentaire de victorcoasne le 28/10/2005 23:27:56

HHOOK hHook = 0;    // Handle du hook global
HINSTANCE hExe; // Handle de notre dll

BOOL WINAPI DllMain(HINSTANCE hDll, DWORD dwReason, LPVOID Reserved)
{
  if(dwReason == DLL_PROCESS_ATTACH) hExe = hDll;
  return 1;
}
LRESULT CALLBACK kbdProc(int nCode, WPARAM wParam, LPARAM lParam) {
  // VK_F11 = 0x7A, VK_CONTROL = 0x11 , VK_SHIFT = 0x10
  if(nCode < 0)
  return CallNextHookEx(hHook, nCode, wParam, lParam);
  if(wParam != VK_F11)
  return CallNextHookEx(hHook, nCode, wParam, lParam);
  if(!(lParam & 0x80000000))
  return CallNextHookEx(hHook, nCode, wParam, lParam); // UP pour certitude 1 SEULE FOIS
  if(!(GetKeyState(VK_CONTROL) & 0x80000000))
  return CallNextHookEx(hHook, nCode, wParam, lParam);
  
  return CallNextHookEx(hHook, nCode, wParam, lParam);
}

int __declspec(dllexport) DemarrerHook()
{
    if (hHook==0)
    {
         hHook  = SetWindowsHookEx(WH_KEYBOARD, kbdProc, hExe, 0);
        //hHook = SetWindowsHookEx( WH_KEYBOARD_LL, (HOOKPROC) HookProc, hExe, 0);
        //etat_hook=1;//Mettre le flag d'etat à 1 (actif)
    }  
    return (int) hHook;
}

Voilà le prog me retourne toujours 0 !

Commentaire de victorcoasne le 29/10/2005 11:17:50

ok je suis sous dev mais les différences sont pas énormes si pas de MFC alors voilà la dll (les fonctions qui sont importés sont dans le programme au cas ou le hook marche) :
#include <windows.h>


typedef bool (__stdcall* lpMyCallBack) (LPSTR szMsg);
typedef bool (__stdcall* lpMyCallBack_int) (int szMsg);
typedef bool (__stdcall* lpMyCallBack_char) (char szMsg);
typedef bool (__stdcall* lpMyCallBack_bool) (bool szMsg);

lpMyCallBack envoiedonnee_char;
lpMyCallBack_int envoiedonnee_int,envoiedonneeconvert_int;
lpMyCallBack_char envoiedonneeconvert_char;
lpMyCallBack_bool envoiedonnee_bool,envoiedonneeconvert_bool;
void __declspec(dllexport) initdll(
lpMyCallBack dw_envoiedonnee_char,lpMyCallBack_int dw_envoiedonnee_int,
lpMyCallBack_bool dw_envoiedonnee_bool,lpMyCallBack_int dw_envoiedonneeconvert_int,
lpMyCallBack_char dw_envoiedonneeconvert_char,lpMyCallBack_bool dw_envoiedonneeconvert_bool)
{
    envoiedonnee_char=(lpMyCallBack)dw_envoiedonnee_char;
    envoiedonnee_int=(lpMyCallBack_int)dw_envoiedonnee_int;
    envoiedonnee_bool=(lpMyCallBack_bool)dw_envoiedonnee_bool;
    envoiedonneeconvert_int=(lpMyCallBack_int)dw_envoiedonneeconvert_int;
    envoiedonneeconvert_char=(lpMyCallBack_char)dw_envoiedonneeconvert_char;
    envoiedonneeconvert_bool=(lpMyCallBack_bool)dw_envoiedonneeconvert_bool;
}


HHOOK hHook = 0;    // Handle du hook global
HINSTANCE hExe; // Handle de notre dll

BOOL APIENTRY DllMain(HINSTANCE hDll, DWORD dwReason, LPVOID Reserved)
{
  if(dwReason == DLL_PROCESS_ATTACH) hExe = hDll;
  return 1;
}

// Fonction de gestion du hook
LRESULT CALLBACK kbdProc(int nCode, WPARAM wParam, LPARAM lParam) {
  // VK_F11 = 0x7A, VK_CONTROL = 0x11 , VK_SHIFT = 0x10
  if(nCode < 0)
  return CallNextHookEx(hHook, nCode, wParam, lParam);
  if(wParam != VK_F11)
  return CallNextHookEx(hHook, nCode, wParam, lParam);
  if(!(lParam & 0x80000000))
  return CallNextHookEx(hHook, nCode, wParam, lParam); // UP pour certitude 1 SEULE FOIS
  if(!(GetKeyState(VK_CONTROL) & 0x80000000))
  return CallNextHookEx(hHook, nCode, wParam, lParam);
  
  return CallNextHookEx(hHook, nCode, wParam, lParam);
}

int __declspec(dllexport) DemarrerHook()
{
    if (hHook==0)
    {
         hHook  = SetWindowsHookEx(WH_KEYBOARD, kbdProc, hExe, 0);
        //hHook = SetWindowsHookEx( WH_KEYBOARD_LL, (HOOKPROC) HookProc, hExe, 0);
        //etat_hook=1;//Mettre le flag d'etat à 1 (actif)
    }  
    return (int) hHook;
}

int __declspec(dllexport) StopperHook()
{
    if (hHook!=0)
    {
        UnhookWindowsHookEx(hHook);
        //etat_hook=0;// Mettre le flag d'état à 0 (inactif)
    }
    return (int) hHook;
}

/******** In exe **********/
    typedef void (__stdcall* lpMyCallBack_void) ();
    typedef int (__stdcall* lpMyCallBack_intr) ();
typedef bool (__stdcall* lpMyCallBack) (LPSTR szMsg);
typedef bool (__stdcall* lpMyCallBack_int) (int szMsg);
typedef bool (__stdcall* lpMyCallBack_char) (char szMsg);
typedef bool (__stdcall* lpMyCallBack_bool) (bool szMsg);

typedef void (__stdcall* lpDemandeCallBack_param) (
lpMyCallBack dw_envoiedonnee_char,lpMyCallBack_int dw_envoiedonnee_int,
lpMyCallBack_bool dw_envoiedonnee_bool,lpMyCallBack_int dw_envoiedonneeconvert_int,
lpMyCallBack_char dw_envoiedonneeconvert_char,lpMyCallBack_bool dw_envoiedonneeconvert_bool);
lpMyCallBack_intr DemarrerHook;
lpMyCallBack_intr StopperHook;
lpDemandeCallBack_param initdll;
lpMyCallBack_void test;

bool __stdcall CALLBACK envoiedonnee(char* donnees);
bool __stdcall CALLBACK envoiedonnee(int donnees);
bool __stdcall CALLBACK envoiedonnee(bool donnees);
bool __stdcall CALLBACK envoiedonneeconvert(int donnees);
bool __stdcall CALLBACK envoiedonneeconvert(char donnees);
bool __stdcall CALLBACK envoiedonneeconvert(bool donnees);
HANDLE hDLL = LoadLibrary("VNC.dll");
    if (hDLL==NULL)
    {
    MessageBox(NULL,"VNC.dll est introuvable !",0,16);
    return -1;
    }
    
    DemarrerHook = (lpMyCallBack_intr)
    GetProcAddress((HINSTANCE)hDLL, "_Z12DemarrerHookv");
    if (DemarrerHook == NULL)
    {
    MessageBox(NULL,"DemarrerHook est introuvable dans la DLL VNC.dll",0,16);
    return -1;
    }
    StopperHook = (lpMyCallBack_intr)
    GetProcAddress((HINSTANCE)hDLL, "_Z11StopperHookv");
    if (StopperHook == NULL)
    {
    MessageBox(NULL,"StopperHook est introuvable dans la DLL VNC.dll",0,16);
    return -1;
    }
    
    initdll = (lpDemandeCallBack_param)
    GetProcAddress((HINSTANCE)hDLL, "_Z7initdllPFbPcEPFbiEPFbbES3_PFbcES5_");
    if (initdll == NULL)
    {
    MessageBox(NULL,"initdll est introuvable dans la DLL VNC.dll",0,16);
    return -1;
    }
    
    initdll(&envoiedonnee,&envoiedonnee,&envoiedonnee,    &envoiedonneeconvert,&envoiedonneeconvert,&envoiedonneeconvert);

              if (DemarrerHook()!=0)
              printf("\n\nHook\tOK");
              else
              printf("\n\nHook\tERREUR");

Commentaire de BruNews le 29/10/2005 19:34:58 administrateur CS

Dans la source la dll est chargée dynamiquement et DllMain est bien appelée sinon hook ne fonctionnerait pas à cause du hdll qui vaudrait 0.

Commentaire de BruNews le 29/10/2005 19:44:25 administrateur CS

Mais l'appel de DllMain n'est pas 'dynamique' ou non, c'est le chargeur du système qui l'appelle, on n'a donc pas à s'en occuper si la dll est construite correctement.

Commentaire de BruNews le 29/10/2005 21:24:19 administrateur CS

C'est le retour de LoadLibrary() qui te le donne, le même que le system enverra à DllMain s'il trouve ce point d'entrée dans la dll. Suffit donc d'exporter une fonction du genre SetHandle(HINSTANCE hDll) et tu envoies ce que t'aura donné LoadLibrary.
Tout ceci ne sera que du bricolage, tu ferais mieux de voir comment on fait une dll correcte avec devcpp sinon tourne toi vers VC.

Commentaire de BruNews le 29/10/2005 23:49:54 administrateur CS

Vire cette histoire de classe au complet, il n'y a que le DllMain d'intéressant là dedans. Remets normalement tes fonctions à exporter.
Je bosse avec VC, je ne connais donc pas les subtilités de devcpp. Essaie de voir s'il accepte un fichier def pour l'export des fonctions.

Commentaire de BruNews le 30/10/2005 14:17:09 administrateur CS

Je laisse le reste des comments, si d'autres ont le même genre de problème on peut espérer que ça leur servira.