"Crossprocess Subclassing" Warum funzt das nicht?

[Metal_Snake2]

Ich möchte gerne die "Toolbar32" komponente der Windows Taskbar des Explorers Subclassen.

Klar ist das ich in den Explorer Adressraum rein muß.

Das mache ich über einer Dll und einem Thread- Lokalen Windows Hook über SetWindowsHookEx.

Der Hook wird auch erfolgreich gesetzt und die DLL ist auch in dem Explorer drinnen jedoch kann ich
mit meiner Hook Prozedure überhaupt keine Fensternachrichten abfangen.

Ich möchte die Spezielle nachricht "WM_NOTIFY" der Toolbar32 abfangen. Hierzu Subclasse ich die Fensterprozedure
der Toolbar. In der WM_NOTIFY Nachricht ist auch die Toolbar button ID enthalten was mein Ziel ist auszulesen.

Über IPC (SendMessage) sende ich die Information der TB Button ID an den Clienten. IPC scheint soweit zu funktionieren,
jedoch funzt das Subclassing und das Fensternachrichten abfangen nicht ganz.

Ich verwende momentan einen "WH_CALLWNDPROC" und weis garnicht ob es geeignet dafür ist mit einem "WH_CBT" Hook hatte ich weniger
erfolg.


Hier ist mein Code aus der DLL unit:

Delphi-Quellcode:

unit uDllWindowsHook;

interface

uses
  Windows, Messages, SysUtils, Dialogs;

const
  IPCExitMSG = 'Exit';

function Start(Host, TB, Client: HWND): Boolean; stdcall;
function GetTBHandle: HWND;
function GetClientWnd: HWND;
procedure Stop; stdcall;
procedure UnSubClassTBWndProc(hWnd: HWND);
procedure IPCSendMessage(Client: HWND; Msg: PChar);

implementation



//Globale Var
var
  HookingFlag : Boolean = false; //Ist True fall der Hook erfolgreich ausgeführt wurde
  TBSubclassed: Boolean = false;
  HookHandle  : HHOOK = 0; //Handle zur Hook hProcedure welche die Messages verarbeitet
  HostWnd     : HWND = 0;  //Fenster Handle vom Module(DLL
  OldTBWndProc: Pointer = nil; //Adresse der Orginalen Toolbar32 Fensterprozedure der Taskbar des Explorers
  Tb32hWnd    : HWND = 0; //Handle der Toolbar32 der Taskbar
  ClientWnd   : HWND = 0; //Fensterhandle des Clients



procedure IPCSendMessage(Client: HWND; Msg: PChar);
var
  aCopyData: TCopyDataStruct;
begin
  with aCopyData do begin
    dwData := 0;
    cbData := StrLen(Msg) + 1;
    lpData := Msg;
  end;

  SendMessage(Client, WM_COPYDATA, Longint(HostWnd), Longint(@aCopyData));
  Msg := '';
end;


function GetTBHandle: HWND;
begin
  Result := Tb32hWnd;
end;


function GetClientWnd: HWND;
begin
  Result := ClientWnd;
end;

function NewTBWndProc(hWnd: HWND; Msg: WORD; wParam: WORD; lParam: LONGINT):LONGINT;
type
   PNMHDR = ^NMHDR; //FIXME: Ich hoffe die def. ist in ordnung
var
   MessageProcessed: Boolean;
   buff : array[0..512] of Char;
   myNMHDR : PNMHDR; //NMHDR ist die datenstruktur welche aus der WM_NOTIFY Nachricht die gewünschten Informationen enthält
begin
   MessageProcessed := False;

   IPCSendMessage(ClientWnd, 'Eine Nachricht angekommen');

   case Msg of
      WM_NOTIFY : begin
                    myNMHDR := PNMHDR(lParam); //FIXME: Hoffe der Typcast ist in ordnung

                    wsprintf(buff, PChar(myNMHDR.idFrom)); //pNMHDR.idFrom beinhaltet nun die ID des Toolbar32 buttons der Taskbar des Explorers

                    //Nun client den Client die TB Button ID via IPC(SendMessage) senden
                    IPCSendMessage(ClientWnd, buff);

                    ShowMessage('INDEX: ' + buff);
                    
                    MessageProcessed := true;
                  end;
   end;

   if not MessageProcessed then
     Result := CallWindowProc(Pointer(OldTBWndProc), hWnd, Msg, wParam, lParam)
   else
     Result := 0;
end;


procedure SubClassTBWndProc(hWnd: HWND);
begin
   OldTBWndProc := Pointer(GetWindowLong(hWnd, GWL_WNDPROC));
   SetWindowLong(hWnd, GWL_WNDPROC, Integer(@NewTBWndProc));

   TBSubclassed := True;

   IPCSendMessage(ClientWnd, 'DLL: erfoglreich gesubclassed');
   ShowMessage('DLL: erfoglreich gesubclassed!!!!!!!');
end;


procedure UnSubClassTBWndProc(hWnd: HWND);
begin
  SetWindowLong(hWnd, GWL_WNDPROC, Integer(@OldTBWndProc));
end;


function HookProc(nCode:integer;wParam:Integer;lParam:Integer):Integer; stdcall;
var
  cwps: TCWPStruct;
begin
  if (nCode = HC_ACTION) then
    begin
      CopyMemory(@cwps, Pointer(lParam), SizeOf(CWPSTRUCT));
      if (cwps.hwnd = Tb32hWnd) then //Ist es unser Toolbar32 Fenster
        begin
          if (TBSubclassed = false) then
            begin
              SubClassTBWndProc(Tb32hWnd);
              ShowMessage('Dll: Erfolgreich injeziert und Hook erfolgreich gestartet und gesubclassed');
              IPCSendMessage(ClientWnd, 'Aktiviert');
          end;
      end;
  end;

  Result:= CallNextHookEx(HookHandle, nCode, wParam, lParam)
end;


function Start(Host, TB, Client: HWND): Boolean; stdcall;
var
  TID : DWord;
begin
  Result :=False;

  HostWnd := Host; //Fenster handle des Modules

  Tb32hWnd := TB;

  ClientWnd := Client;

  TID := GetWindowThreadProcessId(Tb32hWnd, nil);


  if (TID = 0) then
    begin
      ShowMessage('Error TID ist null');
      Stop;
      FreeLibrary(hinstance);
    end
  else
    begin
      HookHandle := SetWindowsHookEx(WH_CALLWNDPROC,
                                 @HookProc,
                                 hInstance,
                                 TID);

  end;

  if (HookHandle > 0) then
    begin
       HookingFlag:=True;
       Result:=True;
       ShowMessage('HOOK INSTALLIERT!');
       IPCSendMessage(ClientWnd, 'GEstartet');
  end;
end;


procedure Stop; stdcall;
begin
  if HookingFlag then
    UnhookWindowsHookEx(HookHandle);

  HookHandle := 0;
  HostWnd := 0;
  Tb32hWnd := 0;
  ClientWnd := 0;
  HookingFlag := false;
  OldTBWndProc := nil;
  TBSubclassed := false;

  ShowMessage('DLL: Erfolgreich Hook gestoppt'); 
end;


initialization
begin
  HookingFlag:=False;
end;



end.

Ich rufe die Start methode im Clienten folgendermasen auf:

Delphi-Quellcode:

  if (hHookLib = 0) then
    hHookLib := LoadLibrary('pHookDll.DLL');

  if (hHookLib <> 0) then
    Start(TaskmanWindow ,FindWindowEx(TaskmanWindow, 0, 'ToolbarWindow32', nil), Handle);

Was mache ich falsch warum will das einfach nicht funktionieren?

Bitte hilf mir einer ich verzweifel hier gerad.

[Dezipaitor]

muss die WindowProc NewTBWndProc nicht stdcall sein!?

[sirius]

Ich verstehe nicht genau, wie du vorgehst.
Und du lädst die DLL in einem eigenen Thread. Jeder Thread hat eine eigene Nachrichtenschleife (wenn überhaupt eine vorhanden ist).

[Metal_Snake2]

@Dezipaitor: Ich hab die Fensterprocedure nun als StdCall def. noch es bringt leider nichts.
@sirius: Es ist eigentlich ein simpeles prinziep: DLL wird benötigt um in den Adr. Raum vom Explorer zu gelangen und das Subclassing um die WM_NOTIFY Nachricht der Toolbar32 abzufangen.


Hmm irgendwie komme ich nicht wieter, kann es villeicht daran liegen das die ganzen globalen var. in der DLL also:

Delphi-Quellcode:

//Globale Var
var
  HookingFlag : Boolean = false; //Ist True fall der Hook erfolgreich ausgeführt wurde
  TBSubclassed: Boolean = false;
  HookHandle  : HHOOK = 0; //Handle zur Hook hProcedure welche die Messages verarbeitet
  HostWnd     : HWND = 0;  //Fenster Handle vom Module(DLL
  OldTBWndProc: Pointer = nil; //Adresse der Orginalen Toolbar32 Fensterprozedure der Taskbar des Explorers
  Tb32hWnd    : HWND = 0; //Handle der Toolbar32 der Taskbar
  ClientWnd   : HWND = 0; //Fensterhandle des Clients

Lieber in einem Record mit einem Pointer gepackt werden sollten villeicht?

Hoffe mir kann jemand weiterhelfen.

[sirius]

Ich weiß wie man eine DLL in einen fremden Process lädt.
Aber wo rufst du Loadlibrary auf? In deinem Process?

[Metal_Snake2]

Ich habe jetz eine konkrete fragt:

Ich bin jetzt im adressraum des anderen Prozesses via Windows Hook, aber warum funktioniert nun das subclassing nicht?

Delphi-Quellcode:

var
  OldWndProc  : Integer;

function HeaderProc(wnd: HWND; Msg: Cardinal; wParam: wParam; lParam: lParam): Longint; stdcall;
var
   MessageProcessed: Boolean;
begin
   MessageProcessed := False;
   IPCSendMessage(pHookRec1.ClientWnd, 'Leave');
   case Msg of
    WM_NOTIFY: MessageProcessed := true;
    WM_MOUSELEAVE: begin
                     IPCSendMessage(pHookRec1.ClientWnd, 'Leave');
                   end;
   end;

   if not MessageProcessed then
      Result := CallWindowProc(Pointer(GetWindowLong(wnd, GWL_USERDATA)),wnd,Msg,wParam,lParam)
   else
      Result := 0;
end;



procedure Subclass(wnd: HWND);
begin
  OldWndProc:= GetWIndowLong(wnd, GWL_WNDPROC);
  SetWindowLong(wnd, GWL_USERDATA, OldWndProc);
  SetWindowLong(wnd, GWL_WNDPROC, Integer(@HeaderProc));
end;

procedure Unsubclass(wnd: HWND);
begin
  if (OldWndProc <> 0) then
     SetWindowLong(wnd,GWL_WNDPROC, GetWindowLong(wnd, GWL_USERDATA));
end;

Ich mein das Fensterhandle der zu welches ich subclassen will ist in ordnung jedoch liefert mir
jedesmal der aufruf "GetWIndowLong(wnd, GWL_WNDPROC)" gleich 0, warum bekomme ich einfach micht den handle zu Fensterprozedure.

Das müßte doch eigentlich jetzt funzen da ich ja in dem richtigen Adressraum bin.