ShellExecute liefert ERROR_ACCESS_DENIED

[Amateurprofi]

Mit den unten stehenden Prozeduren will ich einen Beitrag aus Wikipedia anzeigen bzw. in GoogleMaps eine bestimmte Position.
Das funktioniert nur dann problemlos, wenn der Internet Explorer geöffnet ist.
Ist der IE nicht geöffnet gibt ShellExecute als Returncode 5 (ERROR_ACCESS_DENIED) zurück.
Weiß jemand was der Grund für dieses Verhalten, und ob und wie man das beheben kann.

Delphi-Quellcode:

type
   TGeoPos=packed Record
      Latitude:Extended;
      Longitude:Extended;
   end;

PROCEDURE ShowGoogleMaps(GP:TGeoPos);
var S,S1,S2:String;
begin
   S1:=Trim(FloatToStrF(GP.Latitude,ffFixed,6,6));
   S2:=Trim(FloatToStrF(-GP.Longitude,ffFixed,6,6));
   S:='http://maps.google.de/maps?q='+S1+','+S2+'&z=12';
   ShellExecute(0,'open',PWideChar(S),nil,nil,SW_SHOWNORMAL);
end;

PROCEDURE ShowWikipedia(const Term:String);
var S:String;
begin
   S:='https://de.wikipedia.org/wiki/'+Term;
   ShellExecute(0,'open',PWideChar(S),nil,nil,SW_SHOWNORMAL);
end;

[Delphi.Narium]

Schau mal bitte hier: https://www.codeproject.com/Question...efault-browser

Das hieße: Statt SW_SHOWNORMAL bitte SW_SHOWDEFAULT nehmen.

Literatur dazu: https://msdn.microsoft.com/de-de/lib...(v=vs.85).aspx

[himitsu]

Zitat:

Ist der IE nicht geöffnet gibt ShellExecute als Returncode 5 (ERROR_ACCESS_DENIED) zurück.

Ich hoffe das hier ist nur ein Beispielcode und im Programm ist am Ende doch eine Fehlerbehandlung verbaut.


Extended: Diesen Typen sollte man besser nicht verwenden und ihn nur für interne Berechnungen benutzen.
Und ich glaub kaum, dass die Position auf der Erde im Mikrometerbereich wirklich notwendig ist. :roll:
Double (12 Nachkommastellen) oder gar Single (5 Nachkommastellen)

Aber das Wichtigste: Immer RICHTIGE Typen verwenden? :!:

String > PChar > ShellExecute
ODER
WideString/UnicodeString > PWideChar > ShellExecuteW

Gut, ist kein wirklicher Fehler, aber wozu ist Trim da?
Da gibt es doch keine Ausführungszeichen.
Und statt der 3 Variablen und 3 Codezeilen hätte ich eher ein Format verwendet. :angle:

[Amateurprofi]

Zitat:

Zitat von Delphi.Narium (Beitrag 1389532)

Schau mal bitte hier: https://www.codeproject.com/Question...efault-browser

Das hieße: Statt SW_SHOWNORMAL bitte SW_SHOWDEFAULT nehmen.

Literatur dazu: https://msdn.microsoft.com/de-de/lib...(v=vs.85).aspx

Vielen Dank!
Problem gelöst.

[Amateurprofi]

Zitat:

Zitat von himitsu (Beitrag 1389533)

Ich hoffe das hier ist nur ein Beispielcode und im Programm ist am Ende doch eine Fehlerbehandlung verbaut.

Da trügt deine Hoffnung. Ich merke in diesen Fällen auch ohne Fehlermeldung, wenn da etwas nicht funktioniert.

Zitat:

Zitat von himitsu (Beitrag 1389533)

Extended: Diesen Typen sollte man besser nicht verwenden und ihn nur für interne Berechnungen benutzen.

Das mag sein dass "man" diesen Typ nicht benutzen sollte - aber ICH benutze ihn bevorzugt.

Zitat:

Zitat von himitsu (Beitrag 1389533)

Und ich glaub kaum, dass die Position auf der Erde im Mikrometerbereich wirklich notwendig ist. :roll:
Double (12 Nachkommastellen) oder gar Single (5 Nachkommastellen)

Das ganze ist Bestandteil eines Programms das sich mit astronomischen Daten befasst und alle Daten als Extended führt, u.a. auch Koordinaten.

Zitat:

Zitat von himitsu (Beitrag 1389533)

Aber das Wichtigste: Immer RICHTIGE Typen verwenden? :!:
String > PChar > ShellExecute
ODER
WideString/UnicodeString > PWideChar > ShellExecuteW

Wenn ich bei ShellExecute(... den Cursor hinter die ( stelle und Ctrl-Space drücke, wird in der Parameterliste "Filename : PWideChar" gezeigt. Hat ja auch funktioniert. Habs aber jetzt mit PChar versucht - geht auch.

Zitat:

Zitat von himitsu (Beitrag 1389533)

Gut, ist kein wirklicher Fehler, aber wozu ist Trim da?
Da gibt es doch keine Ausführungszeichen.

Das Trim soll führende Blanks entfernen. Ich vermute, dass ich früher die Floats mit einer Funktion in Strings gewandelt habe, die u.U. führende Blanks lieferte - kann ich heute nicht mehr nachvollziehen.

Zitat:

Zitat von himitsu (Beitrag 1389533)

Und statt der 3 Variablen und 3 Codezeilen hätte ich eher ein Format verwendet. :angle:

Format ist mir zu kompliziert zu unübersichtlich zu ach alles mögliche. Hab ich nie benutzt und werde ich nie benutzen.

So, ich glaube ich bin auf alles eingegangen.
Nun erzähl mir mal, was das mit dem in #1 geschilderten Problem zu tun hatte?

[himitsu]

Ja, bei dir ist "aktuell" PChar ein Alias für PWideChar und leider zeigt das CodeInsight den internen Typen an. (beim Compilieren wurde der Alias ersetzt)
Wenn du dir die Deklaration von ShellExecute ansiehst, siehst du den richtigen Typen.

In Bezug auf die WinAPI ist das Muster aber meistens recht leicht zu merken.
String > PChar > ShellExecute
AnsiString > PAnsiChar > ShellExecuteA
WideString/UnicodeString > PWideChar > ShellExecuteW

PS: Solches "Hat ja auch funktioniert" führte bei der Umstellung von ANSI zu Unicode zu problemen, da es danach plötzlich nicht mehr funktionierte. Das Selbe betrifft auch 32 und 64 Bit.
Hätte aber oft funktioniert, wenn die Typen wirklich gepasst hätten. :zwinker:

Vorallem Komplikationen beim Upgrade und für die Wiederverwendbarkeit der Codes, ist es immer Ratsam auf die Typen zu achten.
Meistens nimmt man den Typen der Eingangsparameter und wählt darauf die Casts und Funktionen,
oder ausgehend von der Funktion wird der Typ des Eingangsparameters ausgewählt.

[EdAdvokat]

Hallo Klaus (Amateurprofi), wie ruft Du ShowGoogleMaps auf? Ich wollte das Ganze mal ausprobieren mit einem Button und einem edit-Feld auf einer Form.
Die Geoposition wollte ich in das edit-Feld eintragen (welches Format haben diese?) und dann wollte ich per Button diese Pos. in GoogleMaps suchen lassen.
Irgendwie scheitere ich bei der Übergabe von (GP:TGeopos). Ich selle mich wohl zu blöd dazu an.

[Zacherl]

Zitat:

Zitat von Amateurprofi (Beitrag 1389535)

Zitat:

Zitat von himitsu (Beitrag 1389533)

Extended: Diesen Typen sollte man besser nicht verwenden und ihn nur für interne Berechnungen benutzen.

Das mag sein dass "man" diesen Typ nicht benutzen sollte - aber ICH benutze ihn bevorzugt.

Achtung. Die X86-64 FPU hat keine Unterstützung mehr für 80-Bit Floats (Extended). Entweder wird unter 64-Bit also emuliert, was fürchterlich langsam sein wird, oder deine Werte werden einfach truncated.

[himitsu]

Die Such-Syntax lautet
https://www.google.de/maps?q=suchbegriff&z=15

Er missbraucht das, da man auch nach Koordinaten suchen kann, anstatt sie anzugeben (zu beachten sind die Dezimaltrennzeichen in englischem Format)
http://maps.google.de/maps?q=51.0535283,13.7238866&z=15

Die korrekten URLs lauten z.B. wie folgt (mit @ wird die Angabe für Position und Zoom definiert)
https://www.google.de/maps/@51.0535283,13.7238866,15z
https://www.google.de/maps/search/suchbegriff/@51.0535283,13.7238866,15z
https://www.google.de/maps/place/Zwinger/@51.0535283,13.7238866,15z

[Delphi.Narium]

Eine Google-Maps-Urls sieht so aus:

Code:

https://www.google.de/maps/@53.5437308,9.9867191,15z

Allgemein:

Code:

http://maps.google.com/maps/@<lat>,<long>,<zoomfaktor>z

Delphi-Quellcode:

   sUrl := Format('https://www.google.de/maps/@%s,%s,%sz', [editLatitude.Text, editLongitude.Text, editZoomfaktor.Text]); 
   ShellExecute(0,'open',PWideChar(sUrl),nil,nil,SW_SHOWDEFAULT);

Hierbei gilt: Der Dezimalseparator in den Editfeldern ist der Punkt.

Zuerst aus den Zeichenfolgen der Editfelder Extended zu machen, um die dann in ShowGoogleMaps wieder in Zeichenfolgen zu verwandeln, halte ich für übertrieben.

[EdAdvokat]

Danke Delphin.Arium, so funktioniert es nun nur so als Test für mich:

Delphi-Quellcode:

 Pos1:=(edt1.text);
    Pos2:=(edt2.text);
    Pos3:=(edt3.text);

    sUrl := Format('https://www.google.de/maps/@%s,%s,%sz', [Pos1, Pos2, Pos3]);
   ShellExecute(0,'open',PChar(sUrl),nil,nil,SW_SHOWDEFAULT);

nochmals Danke

[Amateurprofi]

Zitat:

Zitat von EdAdvokat (Beitrag 1389553)

Hallo Klaus (Amateurprofi), wie ruft Du ShowGoogleMaps auf? Ich wollte das Ganze mal ausprobieren mit einem Button und einem edit-Feld auf einer Form.
Die Geoposition wollte ich in das edit-Feld eintragen (welches Format haben diese?) und dann wollte ich per Button diese Pos. in GoogleMaps suchen lassen.
Irgendwie scheitere ich bei der Übergabe von (GP:TGeopos). Ich selle mich wohl zu blöd dazu an.

Wie in #1 gezeigt ist TGeoPos ein Record der die Felder Latitude und Longitude hat und diesen Record übergebe ich an ShowGoogleMaps.

Zum Beispiel:

var GP:TGeoPos;
begin
GP.Latituder:=50;
GP.Longitude:=10;
ShowGoogleMaps(GP);
end;

Das mache ich aber nur so, weil die Koordinaten ohnehin in dieser Form in meinem Programm vorliegen.
aber es spricht auch nichts dagegen die Prozedur z.B. so zu definieren
Procedure ShowGoogleMaps(GP:String);
und GP direkt aus deinem Edit zu übernehmen.
Dann sollte das Edit z.B. "53.567000,10.033000" enthalten, also Breitengrad und Längengrad durch ein Komma getrennt.
Im ShellExcute übergebe ich dann als Filename z.B. "http://maps.google.de/maps?q=53.567000,10.033000&z=12"

[Amateurprofi]

Zitat:

Zitat von Zacherl (Beitrag 1389554)

Achtung. Die X86-64 FPU hat keine Unterstützung mehr für 80-Bit Floats (Extended). Entweder wird unter 64-Bit also emuliert, was fürchterlich langsam sein wird, oder deine Werte werden einfach truncated.

Meine 64Bit CPU beinhaltet eine FPU, die 80-Bit Floats verarbeitet.
Da wird nichts emuliert oder fürchterlich langsam oder einfach truncated.
Aber: Delphi, im 64Bit Modus, unterstützt die FPU nicht mehr.

[Bernhard Geyer]

Zitat:

Zitat von Amateurprofi (Beitrag 1389564)

Zitat:

Zitat von Zacherl (Beitrag 1389554)

Achtung. Die X86-64 FPU hat keine Unterstützung mehr für 80-Bit Floats (Extended). Entweder wird unter 64-Bit also emuliert, was fürchterlich langsam sein wird, oder deine Werte werden einfach truncated.

Meine 64Bit CPU beinhaltet eine FPU, die 80-Bit Floats verarbeitet.
Da wird nichts emuliert oder fürchterlich langsam oder einfach truncated.
Aber: Delphi, im 64Bit Modus, unterstützt die FPU nicht mehr.

Gibt es irgendwelche Systeme die 80-Bit im 64-Modus unterstützen?

Die Kommentare im Lazarus-Forums sind hier ganz gut (http://forum.lazarus.freepascal.org/...?topic=29678.0)

Zitat:

The logic behind it is that the previous 80bit float is supported on the 32bit intel instruction set, but NOT on the 64bit AMD/Intel instruction set, so you would have to revert to soft float anyway. Technically one could use the FPU87 instruction set but it will conflict with the more modern fp units in that they use the same register space, i.e. you can use 1 and loose the benefits of the other.

[Amateurprofi]

Zitat:

Zitat von Bernhard Geyer (Beitrag 1389566)

Zitat:

Zitat von Amateurprofi (Beitrag 1389564)

Zitat:

Zitat von Zacherl (Beitrag 1389554)

Achtung. Die X86-64 FPU hat keine Unterstützung mehr für 80-Bit Floats (Extended). Entweder wird unter 64-Bit also emuliert, was fürchterlich langsam sein wird, oder deine Werte werden einfach truncated.

Meine 64Bit CPU beinhaltet eine FPU, die 80-Bit Floats verarbeitet.
Da wird nichts emuliert oder fürchterlich langsam oder einfach truncated.
Aber: Delphi, im 64Bit Modus, unterstützt die FPU nicht mehr.

Gibt es irgendwelche Systeme die 80-Bit im 64-Modus unterstützen?

Die Kommentare im Lazarus-Forums sind hier ganz gut (http://forum.lazarus.freepascal.org/...?topic=29678.0)

Zitat:

The logic behind it is that the previous 80bit float is supported on the 32bit intel instruction set, but NOT on the 64bit AMD/Intel instruction set, so you would have to revert to soft float anyway. Technically one could use the FPU87 instruction set but it will conflict with the more modern fp units in that they use the same register space, i.e. you can use 1 and loose the benefits of the other.

Weiß nicht, on irgendwelche Systeme die 80-Bit im 64-Modus unterstützen.
Das ist in diesem Zusammenhang auch irrelevant, denn es ging nicht um die Frage ob irgendwelche Systeme die im 64 Bit Mode unterstützen, sondern darum ob eine X86-64 FPU sie unterstützt.
Und meine tut das! Wie das bei den neuesten CPUs ist weiß ich nicht.
Auch der obige Kommentar aus dem Lazarus Forum scheint mir fehlerhaft zu sein.
Im "Intel® 64 and IA-32 Architectures Software Developer’s Manual Volume 2A: Instruction Set Reference, A-M" steht z.B. für die FPU-Instruction FCOS (Cosinus berechnen):

Opcode = D9 FF
Instruction = FCOS
64-Bit Mode = Valid
Compat/Leg Mode = Valid
Description = Replace ST(0) with its cosine.

Also auch im 64 Bit Mode gültig, und das gilt für alle FPU-Befehle.
Die Aussage "Technically one could use the FPU87 instruction set but it will conflict with the more modern fp units in that they use the same register space" ist nur bedingt richtig.
Richtig ist, dass die FPU-Register und die 64 Bit MMX-Register den gleichen Adressraum belegen.
Richtig ist aber auch dass das bei den 128Bit XMM-Registern NICHT der Fall ist, d.h. FPU- und SSE-Register sind voneinander getrennt.

[Fukiszo]

falls das weiterhelfen kann, hier meine funktionen um etwas zu laden/starten:
sorry, ich habs nur in englisch kommentiert.

viel spass damit.

Delphi-Quellcode:

// this is my oldschool Execution function from MS-DOS now "Windownized" ;-)
// Similar as if you would execute anything on Command-Line
// Result will be greater than 31 on success
// if result is 4294967295/$FFFFFFFF than its a general error
// Example: if ExecuteCommandLine('C;\WINDOWS\TEMP\FILENAME.EXE', False) > 31 then Success := True else Success := False;
Function ExecuteCommandLine(const cmdLine: string; const ShowConsole: Boolean): Cardinal;
const
  flags: array [Boolean] of Integer = (SW_HIDE, SW_SHOWNORMAL);
var
  cmdbuffer: array [0..MAX_PATH] of Char;
begin
 Result := Cardinal($FFFFFFFF);
 GetEnvironmentVariable('COMSPEC', cmdBUffer, SizeOf(cmdBuffer));
 StrCat(cmdbuffer, ' /C ');
 StrPCopy(StrEnd(cmdbuffer), cmdLine);
 Result := WinExec(cmdbuffer, flags[ShowConsole]);
end;

// this is my "ShellExecuteEx" implementation
// Example:
//  to run something type
//  ExecuteShell('C;\Windows\Temp\FileName.exe','Parameters',False,False);
//  to run something type and wait that it finish type
//  ExecuteShell('C;\Windows\Temp\FileName.exe','-Parameters',False,True);
// ShowConsole should only be activated for Console Programs
// Returned Value is either ErrorCode from ShellExecuteEx or Init/Exit Code from "Executable"
// if result is 4294967295/$FFFFFFFF than its a general error
function ExecuteShell(const Executable, Commands: String; const ShowConsole, DoWait: Boolean): Cardinal;
 var
  ProcessInfo: TShellExecuteInfo;
 begin
  Result := Cardinal($FFFFFFFF);
  FillChar(ProcessInfo, SizeOf(TShellExecuteInfo), #0);
  with ProcessInfo do
  begin
   cbSize:= SizeOf( TShellExecuteInfo );
   fMask := SEE_MASK_NOCLOSEPROCESS or SEE_MASK_FLAG_DDEWAIT;
   Wnd := GetActiveWindow();
   lpVerb := 'open';
(* lpVerb can be one of this:
    'edit'  Launches an editor and opens the document for editing.
    'explore' Explores the folder specified by lpFile.
    'find' Initiates a search starting from the specified directory.
    'open' Opens the file, folder specified by the lpFile parameter.
    'print' Prints the document file specified by lpFile.
    'properties' Displays the file or folder's properties.*)
   lpFile:= PChar(Executable);
   lpParameters := PChar(Commands);
   lpDirectory := PChar(ExtractFilePath(Executable));
   if ShowConsole then nShow := SW_SHOWNORMAL else nShow := SW_HIDE;
  end;
  if ShellExecuteEx(@ProcessInfo) then
  begin
//   if DoWait then WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
   if DoWait then while WaitForSingleObject(ProcessInfo.hProcess, 500) <> WAIT_OBJECT_0 do ProcessMessages;
   if not GetExitCodeProcess(ProcessInfo.hProcess, Result) then Result := Cardinal($FFFFFFFF);
//   GetExitCodeProcess(ProcessInfo.hProcess, Result);
   CloseHandle(ProcessInfo.hProcess);
  end
  else
  begin
   Result := GetLastError;
   exit;
  end;
 end;

// this function execute any Associated Program with "Executable" as Input-Filename optional wait that it finish
// give back as Result the Init/Exit Code of Associated Program or Error Code from FindExecutable
// Example: ExecuteAssociated('ReadMe.txt', False, True);
//           that would open "ReadMe.txt" in Editor and wait that Editor terminate
//          ExecuteAssociated('ReadMe.html', False, False);
//           that would open your Internet Browser with "ReadMe.html" and not wait
// ShowConsole should only be activated for Console Programs
// if result is 4294967295/$FFFFFFFF than its a general error
function ExecuteAssociated(const Executable: String; const ShowConsole, DoWait: Boolean): Cardinal;
var
  Prg: string;
  Security   : TSecurityAttributes;
  ProcessInfo: TProcessInformation;
  StartupInfo: TStartupInfo;
 begin
  Result := Cardinal($FFFFFFFF);
  SetLength(Prg, MAX_PATH);
  Result := FindExecutable(PChar(Executable), nil, PChar(Prg));
  if Result > 32 then
  begin
   with Security do begin
    nLength              := SizeOf(TSecurityAttributes);
    lpSecurityDescriptor := nil;
    bInheritHandle       := False;
   end;
   SetLength(Prg, StrLen(PChar(Prg)));
   FillChar(StartupInfo, SizeOf(TStartupInfo), #0);
   with StartupInfo do
   begin
    cb := SizeOf(TStartupInfo);
    dwFlags := STARTF_USESHOWWINDOW or STARTF_FORCEONFEEDBACK;
    if ShowConsole then wShowWindow := SW_SHOWNORMAL else wShowWindow := SW_HIDE;
   end;
   if CreateProcess(PChar(Prg), PChar(Format('%s %s', [Prg, Executable])), @Security, @Security, False, CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, PChar(ExtractFilePath(Executable)), StartupInfo, ProcessInfo) then
   begin
    if DoWait then while WaitForSingleObject(ProcessInfo.hProcess, 500) <> WAIT_OBJECT_0 do ProcessMessages;
//    if DoWait then WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
    if not GetExitCodeProcess(ProcessInfo.hProcess, Result) then Result := Cardinal($FFFFFFFF);
//    GetExitCodeProcess(ProcessInfo.hProcess, Result);
    CloseHandle(ProcessInfo.hProcess);
    CloseHandle(ProcessInfo.hThread);
   end
   else
    Result := GetLastError;
  end;
 end;

// this function execute any Executable with Commands optional wait that it finish
// give back as Result the Init/Exit Code of Executable or Error Code from CreateProcess
// example:
//  to execute a executable type
//   ExecuteExe('C:\WINDOWS\TEMP\FILENAME.EXE','Parameters',False,False);
//  to execute a executable and wait type
//   ExecuteExe('C:\WINDOWS\TEMP\FILENAME.EXE','Parameters',False,True);
// ShowConsole should only be activated for Console Programs
// DoWait will AntiFreeze and Lock your visible GUI
//        this way you could still Update Display in your Application (like a text scroller, or any graphic etc)
//        SideEffect: All commands that you click/do/set while in DoWait mode,
//                    will be executed at once when DoWait is finished.
// if result is 4294967295/$FFFFFFFF than its a general error
// Result can be Init/Exit Code of Executable
function ExecuteExe(const Executable: String; Commands: String; const ShowConsole, DoWait: Boolean): Cardinal;
  procedure WaitFor(processHandle: THandle);
  var
    Msg: TMsg;
    ret: DWORD;
  begin
    repeat
      ret := MsgWaitForMultipleObjects(1, { 1 handle to wait on }
              processHandle, { the handle }
              False, { wake on any event }
              INFINITE, { wait without timeout }
              QS_PAINT or { wake on paint messages }
              QS_SENDMESSAGE { or messages from other threads }
             );
      if ret = WAIT_FAILED then Exit; { can do little here }
      if ret = (WAIT_OBJECT_0 + 1) then
      begin
//      if Msg.Message = WM_COMMAND then begin Msg.Message := WM_NULL end else
      while PeekMessage(Msg, 0, WM_PAINT, WM_PAINT, PM_REMOVE) do
//        while PeekMessage(Msg, 0, WM_NULL, WM_USER, PM_REMOVE) do (* this would total un-freeze = DoWait would not lock GUI *)
          DispatchMessage(Msg);
      end;
    until ret = WAIT_OBJECT_0;
  end; { Waitfor }
var
  Security   : TSecurityAttributes;
  StartupInfo: TStartupInfo;
  ProcessInfo: TProcessInformation;
begin
 Result := Cardinal($FFFFFFFF);
 if ((Length(Commands) > 1)and(Commands[1]<>' ')) then Commands := ' ' + Commands;
 with Security do begin
   nLength              := SizeOf(TSecurityAttributes);
   lpSecurityDescriptor := nil;
   bInheritHandle       := False;
 end;
  FillChar(StartupInfo, SizeOf(StartupInfo), #0);
  StartupInfo.cb          := SizeOf(StartupInfo);
  StartupInfo.dwFlags     := STARTF_USESHOWWINDOW or STARTF_FORCEONFEEDBACK;
  if ShowConsole then StartupInfo.wShowWindow := SW_SHOWNORMAL else StartupInfo.wShowWindow := SW_HIDE;
  if CreateProcess(PChar(Executable), PChar(Commands), @Security, @Security, False, CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, PChar(ExtractFilePath(Executable)), StartupInfo, ProcessInfo) then
  begin
   if DoWait then WaitFor(ProcessInfo.hProcess);
   if not GetExitCodeProcess(ProcessInfo.hProcess, Result) then Result := Cardinal($FFFFFFFF);
//    GetExitCodeProcess(ProcessInfo.hProcess, Result);
//    if Result = 0 then Result := STATUS_PENDING;
    CloseHandle(ProcessInfo.hThread);
    CloseHandle(ProcessInfo.hProcess);
  end
  else
    Result := GetLastError;
end;

// this function will execute a console application
// give all console output back to "Output:PChar" parameter
// give back as Result the ExitCode of "Executable"
// ShowConsole should only be activated if you want to see a blank Console Window aslong Process is running
// WARNING: DO NOT EXECUTE CONSOLE APPLICATIONS THAT NEED KEYBOARD/MOUSE INPUT!!!
// if result is 4294967295/$FFFFFFFF than its a general error
Function ExecuteConsole(const Executable: String; Commands: String; const ShowConsole: Boolean; var Output: PChar): Cardinal;
const
 ReadBuffer = 4000;
var
  Security            : TSecurityAttributes;
  ReadPipe,WritePipe  : THandle;
  StartupInfo         : TStartUpInfo;
  ProcessInfo         : TProcessInformation;
  Buffer              : Pchar;
  BytesRead           : DWord;
  AppRunning          : DWord;
begin
 Result := Cardinal($FFFFFFFF);
 if ((Length(Commands) > 1)and(Commands[1]<>' ')) then Commands := ' ' + Commands;
 with Security do begin
  nLength              := SizeOf(TSecurityAttributes);
  lpSecurityDescriptor := nil;
  bInheritHandle       := True;
 end;
 if CreatePipe (ReadPipe, WritePipe, @Security, 0) then
 begin
  Buffer := AllocMem(ReadBuffer + 1);
  FillChar(StartupInfo,SizeOf(StartupInfo), #0);
  StartupInfo.cb          := SizeOf(StartupInfo);
  StartupInfo.hStdOutput  := WritePipe;
  StartupInfo.hStdInput   := ReadPipe;
  StartupInfo.dwFlags     := STARTF_USESTDHANDLES or STARTF_USESHOWWINDOW;
  if ShowConsole then StartupInfo.wShowWindow := SW_SHOWNORMAL else StartupInfo.wShowWindow := SW_HIDE;
  if CreateProcess(PChar(Executable), PChar(Commands), @Security, @Security, True, CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, PChar(ExtractFilePath(Executable)), StartupInfo, ProcessInfo) then
  begin
   repeat
    ProcessMessages;
    Apprunning := WaitForSingleObject(ProcessInfo.hProcess,100);
   until (Apprunning <> WAIT_TIMEOUT);
//    if DoWait then while WaitForSingleObject(ProcessInfo.hProcess, 500) <> WAIT_OBJECT_0 do ProcessMessages;
   repeat
    BytesRead := 0;
    ReadFile(ReadPipe,Buffer[0], ReadBuffer, BytesRead,nil);
    Buffer[BytesRead]:= #0;
   OemToChar(Buffer, Output);
   until (BytesRead < ReadBuffer);
   end;
  FreeMem(Buffer);
  if not GetExitCodeProcess(ProcessInfo.hProcess, Result) then Result := Cardinal($FFFFFFFF);
//  GetExitCodeProcess(ProcessInfo.hProcess, Cardinal(Result));
  CloseHandle(ReadPipe);
  CloseHandle(WritePipe);
  CloseHandle(ProcessInfo.hThread);
  CloseHandle(ProcessInfo.hProcess);
 end;
end;

[himitsu]

Zitat:

Zitat von MSDN - WinExec

Note This function is provided only for compatibility with 16-bit Windows. Applications should use the CreateProcess function.

Und ich könnte wetten, dass der Compiler hier ein paar Meldungen anzeigt, die jemand vergessen hat zu beheben.
> mindesten "Auf 'ExecuteCommandLine' zugewiesener Wert wird niemals benutzt"
> und seit Delphi 2009 wird es in ExecuteConsole bestimmt Meldungen bezüglich Unicode geben

[Fukiszo]

Falls etwas mit meinem code nicht stimmen sollte, ich bin offen für Kritik ;-)
Ich nutz leider keine IDE um mir solche Meldungen anzuschauen,
ich programmier meist mit Notepad++, reicht aus für meine kleinen belange hehe
Ich hab den source mit/für Delphi 7 erschaffen, wie andere Delphi varianten reagieren weiss ich nicht und kann ich auch nicht testen, tut mir leid.
Für delphi 7 taugt der code, hat mich noch nie im stich gelassen.
WinExec ist rückwärtskompatibel, ja. Ich verstehe das zitat nicht.
Es sind ja mehrere varianten vorhanden, man kann entscheiden wie was ausgeführt wird.
Falls ich ein totes überbleibsel aus test zeiten vergessen hab zu löschen, verzeih #zwei

[himitsu]

Bis auf das Unicodeproblem, was aber zufällig keinen Bufferoverflow erzeugt, sondern eher einen Bufferunderflow, sah ich eine direkten "schwerwiegenden" Fehler.
OK, abgesehn von einer Funktion (WinExex), welche seit 23 Jahren als "nicht verwenden, nur für Abwärtskompatibilität von uraltem Code" gekennzeichnet ist.

In ExecuteConsole wird ab D2009 halt ANSI in einem Unicode-CharArray gespeichert wird, was so kaum stört, aber OemToChar wird meckern, vonwegen potentiellem Datenverlust, weil es ja einen PAnsiChar haben will, aber einen PChar/PWideChar bekommt. (der Compiler weiß nunmal nicht, dass dort wirklich nur ANSI drin ist, durch den vorherigen Fehler beim Befüllen).

Zitat:

Für delphi 7 taugt der code, hat mich noch nie im stich gelassen.

Problem ist halt, dass schon seit 9 Jahren Delphi standardmäßig mit Unicode arbeitet, was in der EDV gefühlt einem halben Jahrhundert entspricht.
Vorallem Codes, welche Andere verwenden sollen, wären gut beraten, wenn sie mit halbwegs aktuellen Delphiversionen zusammen arbeiten.
Tipp zum Testen: https://www.embarcadero.com/de/products/delphi/starter


PS: Wäre vor Jahrzehnten schon AnsiChar statt Char dort verwendet worden, wo explizit ANSI genutzt wird, dann hätte es dieses Problem nicht gegeben.
Sowas war eines der größten Gründe, welche bei Einführung von Delphi 2009 in vielen AltCodes zu Problemen führte.
> immer die "richtigen" Typen verwenden und schon minimieren sich die potentiellen Fehlerstellen.

[Fukiszo]

UniCode, guter Rat kommt schnell, vielen Dank, das lässt sich ja problemlos justieren/nachrüsten,
zum beispiel mit einer "if compiler version >= XYZ" then pAnsiChar anstelle pChar direktive.

Danke für den Link, auf arbeit kann ich mit RADStudio XE 10.2 compilieren, ich sollt mal meine privaten codes damit checken,
danke nochmals für den Hinweis.

Für meine privaten Zwecke erstellt mir Delphi ab Version über 7 viel zu grosse Dateien (dateigröße),
deshalb bleib ich privat bei 7 und programmiere privat auch nur damit.

WinExec:
Nur weil was nicht benutzt werden sollte, sollte doch zumindest die möglichkeit gezeigt werden das solch eine funktion existiert
bzw. wie man diese veraltete funktion in der jetzt-zeit dennoch erfolgreich einsetzen könnte, oder etwa nicht?
Delphi 7 hat halt die definition in der Windows.pas datei, ich zeig wie man sie einsetzten könnte.

Danke für deine draufsicht ob fehler existieren!!!

[HolgerX]

Hmm..

Da bei Delphi 7 PChar = PAnsiChar ist, kannst Du auch eigendlich konsequent immer PAnsiChar verwenden.
Jedoch dann am Besten auch ShellExecuteA und die Strings sollte dann fix AnsiString sein.

Alternativ konsequent PWideChar in Verbindung mit ShellExecuteW und WideString.

Dann ist es Type-Konform, egal welche Delphi Version.

[himitsu]

Eine nutzbare Funktion mit abgelaufenem Code neu zu verbreiten ist nicht wirklich ideal.
Am Ende kommt noch wer auf die Idee und baut es in ein neues Programm ein. :zwinker:


Wie gesagt, an der Stelle ist garkein IFDEF nötig.

ReadFile liefert OEM, also ANSI,
OemToChar will ANSI rein bekommen,
also braucht der Buffer immer nur ANSI zu sein und wird somit auch explizit als ANSI deklariert. (AnsiChar/PAnsiChar/AnsiString)



Da gibt es bei deinem Trainer schlimmere Problemstellen, wenn man mit Unicode kompilieren würde (ab Delphi 2009)
und Einiges (FixStr) ist in jeder Delphiversion potentiell gefährlich.

Hier

Delphi-Quellcode:

Function StatusText ( StatusID : myStatusIDs ) : pChar; stdcall;

klappt das mit dem Result, da es auf Konstanten zeigt, die bestehen bleiben.

Bei

Delphi-Quellcode:

Function FixStr ( Input : PChar ) : PChar; stdcall;

zeigt Result auf eine temporäre Variable, die beim Verlassen der Funktion freigegeben wird.
Wird der Speicher zwischenzeitlich mit irgendwas überschrieben, dann knallt es womöglich.
War die Variable der letzte genutzte Teil des Speicherblocks, dann wird der freigegeben und es knallt.
Mit etwas Glück passiert nichts und es wird anschließend auf den noch nicht freigegebenen/überschriebenen Speicherbereich zugegriffen.

Delphi-Quellcode:

MessageBox(Handle, PAnsiChar(...

: Wie schon gesagt, muß alles zusammenpassen.
String > PChar > MessageBox
AnsiString > PAnsiChar > MessageBoxA
WideString/UnicodeString > PWideChar > MessageBoxW

Mein Tipp wäre hier einfach immer nur mit String/AnsiString/WideString/... zu arbeiten, vorallem bezütlich String-Verarbeitung und Speichermanagement (speichern und weitergeben der Strings)
und nur bei übergabe an die WinAPI nach PChar zu casten.

[Fukiszo]

beim debuggen der shellexecute funktion ist mir folgendes aufgefallen,
wenn die datei die man mit shellexecute ausführen will,
die aber "locked" ist, wie zum beispiel "PageFile.sys"
dann gibt es leider auch den ERROR_ACCESS_DENIED.

[Luckie]

Das ist doch in Ordnung. Warum leider?

[Fukiszo]

mit leider mein ich die plumpe rückmeldung "Zugriff verweigert."
wenn du zum beispiel eine datei ausführen willst,
die physikalisch zwar vorhanden, im explorer auch angezeigt wird,
aber eine execution unmöglich ist mit obriger rückmeldung,
weisst du ja eigentlich immernoch nicht wieso weshalb warum.
stünde da ein ERROR_FILE_LOCKED zur verfügung,
hät man das schneller unter kontrolle.
ich hab zwar eine "IsFileInUse" funktion,
die fängt aber leider nicht solche locked files ab.
die sagt logischerweise, klar, file is in use, weil's ja locked ist und irgendein process XYZ der die datei offen hat.
ich such mal im DP ob es eine möglichkeit gibt den status zu prüfen (locked/unlocked)...