warum HookHandle global machen?

[originalhanno]

Hallo zusammen,
ich habe eine Frage die wie folgt aussieht:
Warum muss ich den Handle auf einen globalen Hook auch global machen?
Hört sich vielleicht doof an.... aber
Es wird ja nun von meiner DLL in jeden Prozess ( und auch THREAD ???) eine Kopie geladen.
Wieso kann dann nicht auch jeder Prozess seinen eigenen Handle auf seine eigene Kopie haben?



Bin für Antwortn sehr dankbar

[originalhanno]

Um die Sache noch interessanter zu machen, habe ich in Visual Studio einen Maus-Hook geschrieben.
Funktioniert gut, sogar mit einem Hook-Handle, das nicht durch shared-segments global gemacht wurde.


Wenn sich jemand erbarmen würde, und mir die Lösung des Rätsels verraten, würde ich glatt mich zu einer Spende von ein oder zwei
bereit erklären.



LG

[negaH]

Zitat:

Wieso kann dann nicht auch jeder Prozess seinen eigenen Handle auf seine eigene Kopie haben?

Du siehst einen Widerspruch wo keiner ist. Jeder Prozess hat sein eigenes Datensegment und eine globale Variable in diesem Prozess wäre eine "eigene Kopie für jeden Prozess". Eine DLL die in mehreren Prozessen geladen wurde und in der DLL selber eine globale Variable ablegt, hat defakto für jeden Prozess in dem sie geladen wurde ein eigenes Datensegment und ergo eine eigene Kopie pro Prozess von diesem Datensegment und ergo auch Prozessbezogene Kopien dieser globalen Variablen.

Die Benuztung von globalen Variablen ist also in diesem Zusammenhang nichts widersprüchliches sondern nur konsequent.

Wenn also ein Prozess eine DLL lädt dann wird zwar der Code dieser DLL in den meisten Fällen gemeinsam durch alle Prozesse die die gleiche DLL geladen haben, auch gemeinsam benutzt. Die Datensegment dieser DLL werden aber quasi als "Kopien" für jeden Prozess indiviuell "dupliziert".

Es entsteht also nicht das Problem eine globale Variable einer DLL für jeden Prozess separat zu halten, sondern umgekehrt "wie kann eine solche DLL, Prozess-übergreifend, bzw. Prozess-unabhängig eine globale Variable" implementieren. Das wird meistens durch Sharded Segemente in den DLLs erledigt. Geht aber eben nur in einer Programmiersprache die erstens eine solche Möglichkeit bieten und zweitens auch einen Linker enthält der sowas unterstützt. Beides ist in Delphi nicht der Fall. Also muß man den "umständlichen" Weg gehen und über MMFs, Semaphore, Events, Threads und gloable Mutex gehen.

Gruß Hagen

[originalhanno]

Hi,
sorry, ich Esel hab netürlich vergessen Den COde zu posten. Hier ist er:

Code:

#define MAKE_DLL

// INCLUDES //////////////////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>
#include <fstream>
#include <String.h>
#include "Hook.h"
using namespace std;
#pragma data_seg ("shared")

//iNumInstances = 0;
//HHOOK hMouseHook =0;
#pragma data_seg ()
#pragma comment(linker,"/SECTION:shared,RWS")

// PROTOTYPES ////////////////////////////////////////////////////////////

LRESULT CALLBACK MouseHookProc(int, WPARAM, LPARAM);

// VARIABLES /////////////////////////////////////////////////////////////

HINSTANCE   hDllInstance;
HHOOK hMouseHook =0;
int x, y=0;
char message[10];

// METHODS ///////////////////////////////////////////////////////////////

// FUNCTIONS /////////////////////////////////////////////////////////////

int APIENTRY DllMain(HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved)
{
   hDllInstance = hInstance;
   return TRUE;
}

BOOL CALLBACK InstallHooks(void)
{
   if (hMouseHook  ==0)
   {
      hMouseHook = SetWindowsHookEx(WH_MOUSE, MouseHookProc, hDllInstance, NULL);
      if(hMouseHook!=NULL)//succesfully installed
      {
         OutputDebugString("Install");
         return TRUE;
      }else
      {
         OutputDebugString("Fehler bei Install");// not installed
         return FALSE;
      }
   }
   return FALSE;
}

BOOL CALLBACK UnInstallHooks(void)
{
    if (UnhookWindowsHookEx(hMouseHook))//succesfully deinstalled
   {
      hMouseHook=NULL;
      OutputDebugString("De_Install");
      return TRUE;
   }else
   {
      OutputDebugString("Fehler bei De_Install");// not deinstalled
      return FALSE;
   }
}

LRESULT CALLBACK MouseHookProc(int nCode, WPARAM wParam,LPARAM lParam)
{
   if(nCode < 0) return CallNextHookEx(hMouseHook, nCode, wParam, lParam); //if not allowed to work ->CallNextHook

   //else:start filtering...

   if (wParam==WM_RBUTTONDOWN)
   {   
      //MOUSEHOOKSTRUCT* pMouseStruct = (MOUSEHOOKSTRUCT*)lParam;
      //if (pMouseStructex);
      //x=pMouseStruct->pt.x;
      //x=GET_X_LPARAM(lParam);
      //mouse_event(MOUSEEVENTF_MOVE,50,50,0,0);
      sprintf(message,"%d",x);   //convert integer to string
      OutputDebugString("JAU");
   }
   return CallNextHookEx(hMouseHook, nCode, wParam, lParam);
}

Ich habe mir erlaubt, C++ COde zu posten, ich hoffe das ich dafür nicht gesteinigt werde.
Vielleicht kann man mein Problem nun besser verstehen...
Ich habe nämlich genau das NICHT !!! gemacht, was Du gerade erklärt hast.
Nämlich den Hook-Handle global machen (z.B. hier mit shared segments), sondern habe ihn lokal gehalten, so dass er ja nun
nur dem lokalen Daten-Teil der DLL existieren sollte. Damit ist er unsichtbar für die anderen Prozesse.
WIESO geht das ganze dann aber trotzdem????

Danke fürs nachdenken....

[edit=sakura] [delphi]->[c] Tags := Mfg, sakura[/edit]

[negaH]

Wie kommst du darauf das es lokal ist ?

Mit #pragma data_seg ("shared") hats du gesagt das für alle nachfolgenden und global deklarierten Variablen ein shared Datensegement angelegt wird.

Danach deklarierst du

HINSTANCE hDllInstance;
HHOOK hMouseHook =0;
int x, y=0;
char message[10];

und das sind alles globale Variablen in deiner DLL. Durch das vorherige #Pragma sind es sogar globale Variablen Prozess übergreifend.

Gruß Hagen

[originalhanno]

Ich habe die Variablen aber ausserhalb von

Code:

#pragma data_seg ("shared")


#pragma data_seg ()

deklariert.
Um das noch mal zu prüfeb, habe ich folgendes Beispiel:

Code:

#define MAKE_DLL

// INCLUDES //////////////////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>
#include <fstream>
#include <String.h>
#include "Hook.h"
using namespace std;
#pragma data_seg ("shared")

//iNumInstances = 0;
//HHOOK hMouseHook =0;
#pragma data_seg ()
#pragma comment(linker,"/SECTION:shared,RWS")

// PROTOTYPES ////////////////////////////////////////////////////////////

LRESULT CALLBACK MouseHookProc(int, WPARAM, LPARAM);

// VARIABLES /////////////////////////////////////////////////////////////
HINSTANCE   hDllInstance;
HHOOK hMouseHook =0;
int x, y=0;
char message[10];

// METHODS ///////////////////////////////////////////////////////////////

// FUNCTIONS /////////////////////////////////////////////////////////////

int APIENTRY DllMain(HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved)
{
   hDllInstance = hInstance;
   return TRUE;
}

BOOL CALLBACK InstallHooks(void)
{
   if (hMouseHook  ==0)
   {
      hMouseHook = SetWindowsHookEx(WH_MOUSE, MouseHookProc, hDllInstance, NULL);
      if(hMouseHook!=NULL)//succesfully installed
      {
         OutputDebugString("Install");
         return TRUE;
      }else
      {
         OutputDebugString("Fehler bei Install");// not installed
         return FALSE;
      }
   }
   return FALSE;
}
//WINVER
BOOL CALLBACK UnInstallHooks(void)
{
    if (UnhookWindowsHookEx(hMouseHook))//succesfully deinstalled
   {
      hMouseHook=NULL;
      OutputDebugString("De_Install");
      return TRUE;
   }else
   {
      OutputDebugString("Fehler bei De_Install");// not deinstalled
      return FALSE;
   }
}

LRESULT CALLBACK MouseHookProc(int nCode, WPARAM wParam,LPARAM lParam)
{
   if(nCode < 0) return CallNextHookEx(hMouseHook, nCode, wParam, lParam); //if not allowed to work ->CallNextHook

   //else:start filtering...

   if (wParam==WM_RBUTTONDOWN)
   {   
      
      //MOUSEHOOKSTRUCT* pMouseStruct = (MOUSEHOOKSTRUCT*)lParam;
      //if (pMouseStructex);
      //x=pMouseStruct->pt.x;
      //x=GET_X_LPARAM(lParam);
      //mouse_event(MOUSEEVENTF_MOVE,50,50,0,0);
      x++;
      sprintf(message,"%d",x);   //convert integer to string
      OutputDebugString(message);
   }
   return CallNextHookEx(hMouseHook, nCode, wParam, lParam);
}

Hier wird x nicht in einem shared segment gehalten, sondern lokal.
Dadurch kannst Du auch beim testen sehen, das beim klicken auf Programm A von 0 bis 5 gezählt wird ( wenn man 5 mal klickt).
Klickt man nun auf Programm B wird wieder von 0 gezählt ( z.B. von 0 bis 3)
Klick auf Programm A -> 6
Klick auf Programm A ->7
Klick auf Programm B ->4
Klick auf Programm A ->8

usw.
Dadurch habe ich gedacht (und denke es auch immer noch), das hier die Daten in einem lokalen Bereich gehalten werden.

Währe für eine Belehrung überaus dankbar....

[edit=sakura] [delphi]->[c] Tags Mfg, sakura[/edit]

[negaH]

Gut, das abschließende #pragma habe ich übersehen.

Denoch die Frage was verstehst du unter global und lokal ?

Deine Variablen sind global zur DLL, und damit quasi global für den Prozess die diese DLL lädt. Sie sind aber lokal zu jedem Prozess gesehen, werden also nicht zwischen den verschiedenen Prozessen gemeinsam benutzt. Eben weil für eine DLL es X unterschiedliche Datensegmente gibt, nämlich exakt für X Prozesse in die diese DLL geladen wurde.

Gruß Hagen

[originalhanno]

Gut. Soweit ist alles klar.
Jetzt aber:
- Es gibt die DLL einmal, kopiert wird nur der Datenteil, d.h. jeder Prozess besitzt einen Datenteil.
Alle Prozesse greifen aber auf die gleiche DLL zurück, wenn es um den Code an sich geht, also nicht Daten.
Nun greift Prozess A auf die DLL zu und kopiert sich den Datenteil. Damit hat es einen Handler auf die HookProc.
Jetzt greift auch Prozess B auf die DLL zu und kopiert sich den Datenteil. Damit hat auch er einen Handler auf die HookProc.

Jetzt kommt die global oder lokal Frage auf:
Sind die beiden Handler lokal, also im Datenteil des jeweiligen Prozesse, sind sie unterschiedlich.
Gibt es einen globalen Handler, muss dieser in einem shared segment liegen, da beide Prozesse darauf zugreifen müssen.
Ich habe gedacht, es funktioniert nur mit EINEM GLOBALEN HANDLER.
Anscheinend tuts dass aber auch mit zwei lokalen Handlern, die nichts voneinander wissen (siehe Beispiel oben).

That's what I don't understand.

Danke für Deine Hilfe, ich hoffe wir können das noch lösen....

[thkerkmann]

Hi,

meiner Meinung nach müssen die Handles sogar lokal sein. Sie gehören dem Prozess, der den Hook (in der dll) installiert, damit er sich daraus wieder verabschieden kann. Global muss also nicht das Handle sein, sondern die HookProcedure muss global zur Verfügung gestellt werden - und das geht eben über die dll.

Die dll wird bei systemweiten Hooks nämlich nicht mit der Beendigung deines Programmes entladen, sondern erst, wenn keine Ereignisse mehr über sie laufen, d.h. ALLE Prozesse, die in die Hook-Kette eingeklinkt sind, beendet wurden. Im spätesten Fall erst beim Windows beenden.

Hoffe das hilft dir weiter.

Gruss

Thomas.

[originalhanno]

Hallo,
das hilft bedingt weiter.
Zwar ist das eine klare Aussage, allerdings passt die nicht zu:


http://www.delphipraxis.net/internal...ct.php?t=80321

und:

http://www.joachimrohde.com/cms/xoop...icle.php?id=82

und ein paar anderen Tutorials.
Allerdings würde ich Dir auch eher glauben, da mein Programm ja eigentlich schon die Antwort gibt.
Irgendwie aber komisch, ich halte es für fragwürdig, ob sich alle Artikel dazu irren???

Nun denn, vielleicht weiss ja jemand anderes die Antwort, ich brauch sie nämlih unbedingt...
Ich werde das Programm das dabei rauskommt auf einer Messe vorstellen, da währe ews mir lieb, wenn ich wüsste was ich da programmiert habe...