Datei ausführen unter Windows 64-Bit

[Rakshasa]

Hallo Leute,

unter Windows64 ist der FileSystemRedirector aktiv, der Anfragen von 32-Bit Programmen umleitet, bsp. "sieht" eine 32-Bit-Anwendung nur den Inhalt des Ordners "Windows\SysWow64\..." während 64-Bit-Anwendungen den Ordner "Windows\System32" sehen.
Nachlesen Problematisch wird dies, wenn eine 32-Bit-Anwendung eine 64-Bit-Anwendung ausführen will.

Mein Programm soll unter Win64 die Datei "regedit.exe" ausführen. Von dieser Datei existieren 2 Varianten: Eine C:\Windows\regedit.exe und eine C:\windows\syswow64\regedit.exe. Wenn mein (32-Bit) Programm nun ShellExecute ausführt, wird immer nur die 32-Bit Variante ausgeführt. Ich will aber die 64-Bit-Variante ausführen... Ist halt schlecht, da z.B. 32-Bit-RegEdit keine 64-Bit-Schlüssel sehen kann.

Umgehen kann man das nach MS durch bestimmte Flags, etwa "Wow64DisableWow64FsRedirection" oder "Wow64EnableWow64FsRedirection", welche wohl vor API calls gesetzt werden müssen.

MS hat hier was dazu geschrieben, leider schaffe ich es nicht mal annähern, den Code in Delphi umzusetzen ... hat da jemand eine Idee??

[TonyR]

Code:

#define _WIN32_WINNT 0x0501
#include <windows.h>

    PVOID OldValue;
    HANDLE hFile;

    BOOL bRet = Wow64DisableWow64FsRedirection (&OldValue);

    if (bRet == TRUE) 
    {
        // Open a file
        
        hFile = CreateFile(TEXT("c:\\windows\\system32\\notepad.exe"),  
            GENERIC_READ,
            FILE_SHARE_READ,
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            NULL);

        // Restore the previous WOW64 file system redirection value.
 
        Wow64RevertWow64FsRedirection (OldValue);
    }
    
    if( INVALID_HANDLE_VALUE != hFile )  
    {
        // Use the file handle
    }

Also wenn ich das richtig verstehe, dann wird hier (ich weis nicht was PVOID für ein Daten-Typ sein soll) in "OldValue" mithilfe von der Funktion "Wow64DisableWow64FsRedirection" der Ursprungszustand gespeichert, wenn das geglückt ist, dann wird die Datei einfach nur aufgerufen (sozusagen dem shellexecute entsprechend, bloß eben mit dem Umweg erst ein Handle der Datei zu bekommen und danach erst die Datei zu öffnen) und danach wird das mit dem Umleiten wieder auf den Ursprungswert zurückgesetzt!
Das erscheint mir eigentlich ganz einleuchtend...
Aber wie man diese Redirection-Funktion in Delphi verwendet (bzw. weis ich gar nicht ob es die da gibt) hab ich keine Ahnung. Weil mir C++ hab ich mich noch nie beschäftigt, aber es gibt hier im Forum glaub ich ein paar die das mal "übersetzen" könnten... :wink:

[Rakshasa]

Ja, vielleicht ist hier ja ein "C-ler", der eine kurze Übersetzung des Codes probieren könnte ... :-)

[himitsu]

zwar kein alter C-ler, aber dennoch ein grober Versuch?

mit Hilfe von:
Wow64DisableWow64FsRedirection
Wow64RevertWow64FsRedirection

Delphi-Quellcode:

Function Wow64DisableWow64FsRedirection(Var Wow64FsEnableRedirection: LongBool): LongBool; StdCall;
  External 'Kernel32.dll' Name 'Wow64DisableWow64FsRedirection';
Function Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection: LongBool): LongBool; StdCall;
  External 'Kernel32.dll' Name 'Wow64EnableWow64FsRedirection';

Var Wow64FsEnableRedirection: LongBool;

Begin
  If Wow64DisableWow64FsRedirection(Wow64FsEnableRedirection) Then Begin
    If ShellExecute(0, nil, PChar('c:\windows\system32\notepad.exe'), nil, nil, 0) = 0 Then
      Error...
    Wow64RevertWow64FsRedirection(Wow64FsEnableRedirection);
  End Else Error...
End;

Die (aufgehobene) Umleitung sollte doch wohl auch auf ShellExecute eine Auswirkung haben.

[add] ungetestet!

[Rakshasa]

Zitat:

Zitat von himitsu

zwar kein alter C-ler, aber dennoch ein grober Versuch?
........
Die (aufgehobene) Umleitung sollte doch wohl auch auf ShellExecute eine Auswirkung haben.
[add] ungetestet!

Hallo,

besten Dank Himitsu, es hat super geklappt!!!
(Bis auf eine kleine Änderung: Du hast

Delphi-Quellcode:

Wow64RevertWow64FsRedirection(Wow64FsEnableRedirection);

geschrieben; ich hab das zu einem

Delphi-Quellcode:

Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection);

geändert)
Ich habe das Ganze in eine kleine Function gepackt, diese überprüft mittels IsWin64, ob ein 64-Bit-Windows vorliegt oder nicht und führt das dementsprechend dann aus. Habe leider keine Möglichkeit, das auf Win32 zu testen; vielleicht kann das ja mal jemand machen und hier ein kleines Feedback posten?! :)
Wenn jemand was Schöneres für isWin64() hat, möge er es ebenfalls posten...

Delphi-Quellcode:

uses ShellApi, Registry, Windows;

Function Wow64DisableWow64FsRedirection(Var Wow64FsEnableRedirection: LongBool): LongBool; StdCall;
 External 'Kernel32.dll' Name 'Wow64DisableWow64FsRedirection';
Function Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection: LongBool): LongBool; StdCall;
 External 'Kernel32.dll' Name 'Wow64EnableWow64FsRedirection';
Var Wow64FsEnableRedirection: LongBool;

....

Function FileExec(const sDatei: String): Integer;
 Function IsWin64: Boolean;
 begin
  With TRegistry.Create do begin
   RootKey := HKEY_LOCAL_MACHINE;
   Result := KeyExists('\SOFTWARE\Wow6432Node');
   Free;
  end;
 end;
begin

if isWin64 then begin

 If Wow64DisableWow64FsRedirection(Wow64FsEnableRedirection) Then Begin
  Result := ShellExecute(0, nil, PChar(sDatei), nil, nil, 0);
  Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection);
 End else
 Result := ShellExecute(0, nil, PChar(sdatei), nil, nil, 0);

end else
 Result := ShellExecute(0, nil, PChar(sdatei), nil, nil, 0);

end;

[Matze]

Hallo,

das klappt bei mir irgendwie nicht. Kompilieren kann ich das unter Win32 problemlos, doch beim Ausführen springt der Debugger zum "begin" in der Project.dpr. Spaßeshalber wollte ich dann mit F8 schauen, ob's irgendwie weitergeht, doch dann kommt:

Code:

---------------------------
Benachrichtigung über Debugger-Problem
---------------------------
In Projekt D:\Eigene Dateien\Borland Studio-Projekte\Project1.exe trat ein Problem mit folgender Meldung auf: 'access violation at 0x7c947a50: write of address 0x00030d24'. Prozess angehalten. Mit Einzelne Anweisung oder Start fortsetzen.
---------------------------
OK   
---------------------------

Anschließend öffnet sich das CPU-Fenster und markiert ist diese Zeile:

Code:

7C947A50 56               push esi

OS: Win XP Pro SP2,32 Bit
Benutzerrechte: Sowohl eingeschränkt, als auch Admin. Beides mal der gleiche Fehler.

[Rakshasa]

Zitat:

Zitat von Matze

Hallo,

das klappt bei mir irgendwie nicht. Kompilieren kann ich das unter Win32 problemlos, doch beim Ausführen springt der Debugger zum "begin" in der Project.dpr. Spaßeshalber wollte ich dann mit F8 schauen, ob's irgendwie weitergeht, doch dann kommt:

Hö?! Das ist aber ziemlich seltsam, da durch den Code

Code:

 if isWin64 then begin

eigentlich nur der normale ShellExecute() Teil unter Win32 ausgeführt werden sollte ... vielleicht stimmt ja mit ShellExecute was nicht? Oder meint ihr, der Fehler wird durch die Aufrufe

Code:

Function Wow64DisableWow64FsRedirection(Var Wow64FsEnableRedirection: LongBool): LongBool; StdCall; 
External 'Kernel32.dll' Name 'Wow64DisableWow64FsRedirection'; 
Function Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection: LongBool): LongBool; StdCall; 
External 'Kernel32.dll' Name 'Wow64EnableWow64FsRedirection'; 
Var Wow64FsEnableRedirection: LongBool;

verursacht? Jetzt bin ich etwas verwirrt ... :-)

[Rakshasa]

So, jetzt bin ich weniger verwirrt. Habe meine VMWare zum Laufen bekommen und konnte das Ganze auf Win32 (XP, SP2) testen. Dabei trat bei mir der Fehler auf, dass schon die Functionen der kernel32.dll einen Fehler beim Starten des Programms verursacht haben, da diese bei WIn32 fehlen. Auch hat die "0" bei ShellExecute (letzt Parameter) dazu geführt, das RegEdit unsichtbar startet - dies war bei Win64 (Vista) komischerweise nicht der Fall, anscheinend dürften hier Applikatione nicht mehr unsichtbar sein oder so.

Fazit: Habe das Ganze also dynamisch eingebunden und dabei ist folgende Function() herausgekommen; bei mir funktionierte alles unter Win XP32 und Vista 64-Bit tadellos.

Delphi-Quellcode:

uses ShellApi, Windows, Registry;

....

Function FileExec(const sDatei, sParam: String; iShowCmd: Integer = sw_Shownormal): Integer;
type
  TWow64DisableWow64FsRedirection = function(Var Wow64FsEnableRedirection: LongBool): LongBool; StdCall;
  TWow64EnableWow64FsRedirection = function(Wow64FsEnableRedirection: LongBool): LongBool; StdCall;
var
  Wow64FsEnableRedirection: LongBool;

Function IsWin64: Boolean;
begin
  With TRegistry.Create do begin
   RootKey := HKEY_LOCAL_MACHINE;
   Result := KeyExists('\SOFTWARE\Wow6432Node');
   Free;
  end;
end;

var
  hHandle: THandle; // Handle zur DLL
  Wow64DisableWow64FsRedirection: TWow64DisableWow64FsRedirection;
  Wow64EnableWow64FsRedirection: TWow64EnableWow64FsRedirection;
begin

if isWin64 then begin // Win64

 hHandle := LoadLibrary(PChar('kernel32.dll'));
  if hHandle <> 0 then begin
    @Wow64EnableWow64FsRedirection := GetProcAddress(hHandle, 'Wow64EnableWow64FsRedirection');
    @Wow64DisableWow64FsRedirection := GetProcAddress(hHandle, 'Wow64DisableWow64FsRedirection');

    if (@Wow64EnableWow64FsRedirection <> nil) AND (@Wow64DisableWow64FsRedirection <> nil) then begin // Alles OK? Dann Datei ausführen!
      Wow64DisableWow64FsRedirection(Wow64FsEnableRedirection);
      Result := ShellExecute(0, nil, PChar(sdatei), Pchar(sParam), nil, iShowCmd);
      Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection);
    end;

    FreeLibrary(hHandle);
  end;

end else begin // Normales Win32
 Result := ShellExecute(0, nil, PChar(sdatei), Pchar(sParam), nil, iShowCmd);
end;


end;

Der Aufruf erfolgt dann über:

Delphi-Quellcode:

 Fileexec('C:\Windows\regedit.exe', '');

Vielleicht kann's ja jemand anders nochmals testen und ggf. Optimierungsmöglichkeiten posten.

[himitsu]

Da kernel32.dll in deinen Anwendungen eh immer bereits geladen sein wird, brauchst du ssie nicht nochmals zu laden/freizugeben ^^

FreeLibrary(hHandle); entfällt und hHandle := LoadLibrary('kernel32.dll'); wird durch hHandle := GetModuleHandle('kernel32.dll'); ersetzt.

Dein IsWin64 kannst du eigentlich auch weglassen, denn du fühst die Anwendung ja so oder so aus, selbst wenn Wow64DisableWow64FsRedirection nicht funkioniert.
Außerdem wird Wow64DisableWow64FsRedirection eh nur unter Win64 laufen. ;)
Also kann man auch durch Aufrufen 'ner Win64-Funktion gleich mit auf Win64 testen. :angel:

Hier mal eine Kurzfassung deines Codes, wobei hier bei einem fehlgeschalgenem Aufruf mit Wow64FsRedirection nochmal es nochmals ohne versucht wird.

Delphi-Quellcode:

Function FileExec(Const sDatei, sParam: String; iShowCmd: Integer = sw_ShowNormal): Integer;
  Type TWow64DisableWow64FsRedirection = Function(Var Wow64FsEnableRedirection: LongBool): LongBool; StdCall;
    TWow64EnableWow64FsRedirection     = Function(Wow64FsEnableRedirection: LongBool): LongBool; StdCall;

  Var hHandle: THandle;
    Wow64DisableWow64FsRedirection: TWow64DisableWow64FsRedirection;
    Wow64EnableWow64FsRedirection:  TWow64EnableWow64FsRedirection;
    Wow64FsEnableRedirection:       LongBool;

  Begin
    hHandle := GetModuleHandle('kernel32.dll');
    @Wow64EnableWow64FsRedirection  := GetProcAddress(hHandle, 'Wow64EnableWow64FsRedirection');
    @Wow64DisableWow64FsRedirection := GetProcAddress(hHandle, 'Wow64DisableWow64FsRedirection');
    If (hHandle <> 0) and (@Wow64EnableWow64FsRedirection <> nil)
      and (@Wow64DisableWow64FsRedirection <> nil) Then
      Wow64DisableWow64FsRedirection(Wow64FsEnableRedirection);
      Result := ShellExecute(0, nil, PChar(sDatei), PChar(sParam), nil, iShowCmd);
      Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection);
    End Else Result := 0;
    Result := Result or ShellExecute(0, nil, PChar(sDatei), PChar(sParam), nil, iShowCmd);
  End;

[Rakshasa]

Zitat:

Zitat von himitsu

Da kernel32.dll in deinen Anwendungen eh immer bereits geladen sein wird, brauchst du ssie nicht nochmals zu laden/freizugeben ^^
FreeLibrary(hHandle); entfällt und hHandle := LoadLibrary('kernel32.dll'); wird durch hHandle := GetModuleHandle('kernel32.dll'); ersetzt.

Dein IsWin64 kannst du eigentlich auch weglassen, denn du fühst die Anwendung ja so oder so aus, selbst wenn Wow64DisableWow64FsRedirection nicht funkioniert.
Außerdem wird Wow64DisableWow64FsRedirection eh nur unter Win64 laufen. ;)
Also kann man auch durch Aufrufen 'ner Win64-Funktion gleich mit auf Win64 testen. :angel:

Hallo himitsu,

danke mal wieder für Deine Optimierung des Codes. Funktioniert jetzt unter Win64 (Vista) und Win32 (XP, SP2) fast ohne Probleme oder Fehler.
Einziges Problem habe ich mit der TTaskDialog Komponente von TMS. Sobald eine Datei über FileExec() aufgerufen wurde, kann der Dialog nicht mehr angezeigt werden (keine Fehlermeldungen o.ä.).
ShowMessage(), MessageDlg() funktionieren normal ...
Dieser Fehler taucht übrigens nicht auf, wenn ich die Datei direkt über Shellexecute() (also ohne Wow64DisableWow64FsRedirection) ausführe.