Handle von Konsolen-App?

[charly52]

Hi all,

gibts ne Möglichkeit sowas wie

Delphi-Quellcode:

  hWindow := FindWindow('notepad', nil);
  SetForegroundWindow(hWindow);

auch für eine Konsolenanwendung zu machen?

Hat die überhaupt ein "Window" ?

Danke Charly

[himitsu]

Diese Anwendung selber hat natürlich kein Window-Handle.
Deine Anwendung läuft in einem ConsoleHost und an ihm kann ein Terminal hängen.

Wenn Sie aber in einer Console-/Terminal-Anwendung läuft angezeigt wird ... diese "Anwendung" hat natürlich ein Handle.

z.B.
cmd.exe > ConsoleWindowClass
Windows-Terminal > CASCADIA_HOSTING_WINDOW_CLASS / Windows.UI.Core.CoreWindow / Windows.UI.Composition.DesktopWindowContentBridge / ...


GetConsoleWindow

[Phoenix]

Guten Morgen Charly,

was möchtest Du denn machen?

Mit einer Konsolenanwendung kann man ja klassischerweise nur per stdin / stdout kommunizieren, also im Prinzip nach stdin Tasteneingaben hinschicken und die Ausgabe aus stdout (oder stderr) auslesen.

Wenn Du den Prozess selber steuerst / startest kannst Du Dich freilich an die streams dran hängen und beliebiges reinschreiben und auslesen.

Eine Konsolenanwendung muss aber nicht unbedingt ein Terminal haben. Sie kann z.B. als child-prozess eines anderen Programmes komplett unsichtbar laufen gelassen werden. Da wüsste ich aber ehrlich gesagt keinen Weg, wie man an stdout / stdin eines schon laufenden Prozesses käme.

[charly52]

ich habe folgenden Code in einer KonsolenApp

Delphi-Quellcode:

    selcmd:= 3;  
    repeat
      case selcmd of
        1 : tuewas; 
        2 : tue was anderes
        3 : .....
        else writeln('wrong command');
      end;

      writeln;
      writeln;
      writeln('Commands');
      writeln('0 : Quit the Kernel');
      writeln('1 : Reset ');
      writeln('2 : Calc');

      writeln('Enter command:');
      readln(selcmd);
    until (selcmd=0);

Und diese Kommandos "0,1,2,3,..." möchte ich von einem anderen Programm (einem Rest-Server) aus zur Konsolenanwendung schicken.
Die KonsolenApp läuft in einem "CMD-Fenster"??? z.B. nach einem Start mittels Konsolenanwendung.exe doppelklick
bis sie "0" bekommt.

Charly

[himitsu]

Die Löstung ist hier "notmalerweise" immer, dass man die Consolenanwendung startet und ihr ein anderes STDIN mitgibt, also einen Stream (Pipe), über Welchen man was dort rein gibt.
Und will man auf Ausgaben reagieren, dann auch noch STDOUT/STDERR auf eine Pipe umleiten, welche man dann ausliest.

Wie z.B. das | (Piepe) bzw. > und < in der CMD.

CreateProcess > STARTUPINFO.hStdInput




Klar, eventuell kann man auch das Fenster suchen und Tastendrücke simulieren, aber der Spaß beginnt schon damit, dass es viele Terminal-Programme gibt (nicht mehr nur die CMD.exe) und Jeder anders reagiert.
z.B. das neue Windows Terminal verarbeitet Tastatur/Maus über DirectX. (wenn ich mich nicht irre)
Aber sowas macht man nicht, da es zu unsicher ist.



Wenn beide Seiten von dir kommen, dann wäre es kein Problem einen anderen Weg zu gehen, also z.B. eine "globale" NamedPipe auf die dein zusätzlich Programm lauscht und an Welche das andere Programm etwas sendet.

Oder ein unsichtbares MessageOnly-Fenster generieren (so ähnlich wie das Application im Delphi), irgendwie dessen Handle rausgeben oder abrufen oder ihm einen bekannten Namen zu geben und dann via SendMessage etwas empfangen (WM_SETTEXT, WM_COPY oder sonstwas).

Oder ansonsten jegliche andere IPC-Lösung, inkl. DDE, ActiveX und Sonstwas.

[charly52]

Oh Je Oh Je

Zitat:

Zitat von himitsu (Beitrag 1511004)

Die Löstung ist hier "notmalerweise" immer, dass man die Consolenanwendung startet und ihr ein anderes STDIN mitgibt, also einen Stream (Pipe), über Welchen man was dort rein gibt.
Und will man auf Ausgaben reagieren, dann auch noch STDOUT/STDERR auf eine Pipe umleiten, welche man dann ausliest.

Wie z.B. das | (Piepe) bzw. > und < in der CMD.

CreateProcess > STARTUPINFO.hStdInput

Sorry, steh hier total auf dem Schlauch.
Ich kenne "prog1 | prog2" oder die Variante ne datei als Input "prog1 < file" oder so ähnlich auf der CMD Ebene.
Aber wie muss ich die Zeile verstehen. Ist das Code in meiner KonsolenApp??

Zitat:

Zitat von himitsu (Beitrag 1511004)

Wenn beide Seiten von dir kommen, dann wäre es kein Problem einen anderen Weg zu gehen, also z.B. eine "globale" NamedPipe auf die dein zusätzlich Programm lauscht und an Welche das andere Programm etwas sendet.

Das ist der Fall, gibts nen Link zu einem Beispiel für Dummies?
Wäre toll, da ich auch damit bisher nichts am Hut hatte

Danke Charly

[himitsu]

IPC
delphi IPC
delphi Inter-process communication

CreateProcess hStdInput
CreateProcess hStdOutput
Delphi CreateProcess hStdInput

Aus den ersten Suchergebnissen...
https://www.delphipraxis.net/189156-...owershell.html
https://www.delphipraxis.net/117567-...ung-nicht.html
Zeigt zumindestens schonmal ansatzweise, wie das aussieht
* Pipes erstellen
* * mindestens hStdInput, wo du deine Befehle rein schreiben kannst
* * und eventuell auch noch hStdOutput, wo die Antwort zurück kommt
* dann damit den Prozess starten
* auf dessen Ende warten
* und währenddessen die Ein-/Ausgaben behandeln, also in StdIn reinschreiben und aus StdOut lesen (ja, andersrum, da aus Sicht des gestarteten Programms)


Sonst hab ich jetzt nichts Fertiges anzubieten,
aber z.B. bezüglich ExecAndWait und Co., ala Programm starten und Ausgaben lesen, gibt es hier mehrere Beispiele.
https://www.delphipraxis.net/152426-...-umleiten.html
https://www.delphipraxis.net/164364-...-einlesen.html

https://getitnow.embarcadero.com/?q=...&categories=-1

[Delphi.Narium]

Was Du haben willst, ist ein klassisches CGI-Programm.

Mein olles Delphi7 bietet das unter

Datei
Neu
weitere
Web-Server-Anwendung

und dort dann CGI-Einzelanwendung

an.

Damit hast Du schonmal alles, was eine entsprechende Konsolenanwendung benötigt.

Die weitere Programmierung ist identisch mit der einer ISAPI.dll.

Und die war ja hier Daten lesen und schreiben aus einer ISAPI-Dll schonmal Thema. Damit sollte es für Dich da eine sehr geringe Lernkurve geben.

Bei Delphi 7 ist dashier ein Grundgerüst für ein CGI-Programm:

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

uses
  WebBroker,
  CGIApp,
  Unit1 in 'Unit1.pas' {WebModule1: TWebModule};

{$R *.res}

begin
  Application.Initialize;
  Application.CreateForm(TWebModule1, WebModule1);
  Application.Run;
end.

und dashier eine ISAPI.dll:

Delphi-Quellcode:

library Project2;

uses
  ActiveX,
  ComObj,
  WebBroker,
  ISAPIThreadPool,
  ISAPIApp,
  Unit1 in 'Unit1.pas' {WebModule1: TWebModule};

{$R *.res}

exports
  GetExtensionVersion,
  HttpExtensionProc,
  TerminateExtension;

begin
  CoInitFlags := COINIT_MULTITHREADED;
  Application.Initialize;
  Application.CreateForm(TWebModule1, WebModule1);
  Application.Run;
end.

Und wenn man das TWebModule1 in beides einbindet, kann man sehr einfach aus einem Webmodul sowohl eine ISAPI.dll als auch ein CGI-Programm machen und umgekehrt (derweil: Sie sind absolut kompatibel).

Achso: Man kann ein Konsolenprogramm auch per Pipe "bedienen", muss man bei CGI-Programmen aber nicht, das bekommt man hier geschenkt. (Zumindest war es bei Delphi 7 so, ob's aktuell auch noch so ist, müsstest Du mal überprüfen, kann mir aber nicht vorstellen, dass es hier jetzt auf einmal große Unterschiede geben könnte.)

[charly52]

Das ist ja ein ganzer Sack an Info.
Da muss ich mich jetzt erst mal reinfinden

Aber VIELEN Dank an alle

Charly

[charly52]

Zitat:

Zitat von himitsu (Beitrag 1511023)

Aus den ersten Suchergebnissen...
https://www.delphipraxis.net/117567-...ung-nicht.html
Zeigt zumindestens schonmal ansatzweise, wie das aussieht
* Pipes erstellen
* * mindestens hStdInput, wo du deine Befehle rein schreiben kannst
* * und eventuell auch noch hStdOutput, wo die Antwort zurück kommt
* dann damit den Prozess starten
* auf dessen Ende warten
* und währenddessen die Ein-/Ausgaben behandeln, also in StdIn reinschreiben und aus StdOut lesen (ja, andersrum, da aus Sicht des gestarteten Programms)

hi himitsu,

danke, das hat schon richtig geholfen.
Kann jetzt meine KonsolenApp starten.
Habe dann im Code von little_budda an der Stelle

//jetzt mit ReadFile/WriteFile kommunizieren

folgendes eingeführt:

Delphi-Quellcode:

  
var
    chBuf   : Array[1..2] of Char;
    written : longWord;

begin 
  .........
//jetzt mit ReadFile/WriteFile kommunizieren
    while true do
      begin
        chbuf[1]:= '3';
        chbuf[2]:= #13;

        bSuccess:= WriteFile(WriteInput{g_hChildStd_IN_Wr}, chBuf, 2{dwRead}, Written{&dwWritten}, nil);

        if (NOT bSuccess) then
        begin
          err:= GetLastError;
          break;
        end;
      end;

Und jetzt was zum Verständnis.
Wenn ich in der STARTUPINFO Struktur einen "Input-Handle" für die KonsolenApp erzeuge

Delphi-Quellcode:

  CreatePipe(StartStruct.hStdInput, WriteInput, @SecAttr, 0); //die Handles erzeugen

sollte ich mit WriteFile doch direkt da reinschreiben könen? Oder nicht?

Oder muss ich in der KonsolenApp auch noch explizit aus dem neuen Handle lesen?
Ich dachte eigentlich, das beim Starten der KonsolenApp deren StdInput schon umgebogen wird?????

Ihr seht, mir fehlt da ganz Grundsätzliches

Danke für weitere Hilfe


Charly

[himitsu]

Das STARTUPINFO gibt der Anwendung ein optionales Handle. (ist das leer, dann werden die Standrad-Handles des Systems verwendet)

Du schreibst in

Delphi-Quellcode:

WriteFile(PipeWrite, ...

und in der anderen Anwendung kommt es dann bei GetStdHandle(STD_INPUT_HANDLE) an, bzw. bei den Delphi-APIs, welche das nutzen, wie z.B. ReadLn (ohne den File-Parameter).

Andersum genauso, wenn die andere Anwendung auf STD_OUTPUT_HANDLE schreibt, bzw. mit WriteLn,
dann kommt es bei dir im PipeRead (STARTUPINFO.hStdOutput)

[charly52]

Das heist also, daß ich in meiner Konsolenapp _nichts_ tun muß?
Das readln liest ja bereits aus StandardIn.

Bei mir kommt in der KonsolenApp nämlich nichts an wenn ich z.B 2 Chars ('3' und #13) schicke.
ABer in der Variablen "written" steht ne 2 und bSucess ist auch True.
Und eigentlich sollte doch dann meine App die '3' mit nem CR dahinter genau wie ein Kommando wie von der Tastatur
hier ne 3 und Enter behandeln?
Das tut sie nicht!!!!

Charly

[himitsu]

Wie schickst du diese Chars?

das Encoding ist schon wichtig.

[Delphi.Narium]

ReadLn ließt bis zum nächsten Zeilenumbruch und der ist unter Windows #13#10. Es gibt dazu auch die Konstante sLineBreak, mit der ist man dann plattformunabhängig, da sie automatisch den für die Zielplattform richtigen Wert enthält.

[himitsu]

ReadLn ist es egal, es kommt allen Kombinationen zurecht, also CR, CR+LF oder LF (so wie die TStringList)

[charly52]

Hallo himitsu, Delphi.Narium

erstmal VIELEN Dank für eure Hilfe, ich habe da wirklich nur im Nebel gestochert.
Jetzt gehts. Aber ihr habt beide nur teilweise recht.
Meine Konsole/werauch ímmer kann wohl nur AnsiChar

und somit sende ich:

Delphi-Quellcode:

//  chBuf   : Array[1..3] of AnsiChar = ('3',#13,#10);   //geht
//  chBuf   : Array[1..3] of AnsiChar = ('3',#10);       //geht
    chBuf   : Array[1..2] of byte = (51,10);             //geht

begin

    bSuccess:= WriteFile(WriteInput{g_hChildStd_IN_Wr}, chBuf, 2 | 3 (je nach definition oben), Written, nil);

Zitat:

Zitat von himitsu (Beitrag 1511211)

ReadLn ist es egal, es kommt allen Kombinationen zurecht, also CR, CR+LF oder LF (so wie die TStringList)

Nur CR geht NICHT

Zitat:

Zitat von Delphi.Narium (Beitrag 1511208)

ReadLn ließt bis zum nächsten Zeilenumbruch und der ist unter Windows #13#10. Es gibt dazu auch die Konstante sLineBreak, mit der ist man dann plattformunabhängig, da sie automatisch den für die Zielplattform richtigen Wert enthält.

Es geht auch NUR #10
Aber sLineBreak geht wiederum nicht, da es WideString ist.


Danke Charly

[himitsu]

Ja, Delphi-Consolen können nur ANSI, bzw. OEM. (was sich jeweils umschalten ließe)
Aber wenn man nicht die uralten Delphi-Funktionen verwendet, dann wäre auch alles Andere Möglich.

Delphi-Quellcode:

function _WriteWString(var t: TTextRec; const s: WideString; width: Longint): Pointer;
var
  i: Integer;
begin
  i := Length(s);
  _WriteSpaces(t, width - i);
  Result := _WriteLString(t, AnsiString(s), 0);
end;

procedure _ReadUString(var t: TTextRec; var s: UnicodeString);
var
  Temp: AnsiString;
begin
  // !!! FIXME
  _ReadLString(t, Temp, DefaultSystemCodePage);
  s := UnicodeString(Temp);
end;

Das sLineBreak hat per se in seiner Deklaration keinen Typen.
Es müsste sich demnach jeweils an den Zieltyp anpassen (der Compiler dürfte es bereits gecastet übergeben). Und selbst wenn nicht, dann würde es bei Verwendung einfach implizit gecastet.

Zitat:

Nur CR geht NICHT

Laut Code sollte es aber gehn. :stupid:

Delphi-Quellcode:

procedure _ReadLn(var t: TTextRec);
{$IF not defined(CPU386)}
var
  c: Word;
begin
  while True do
  begin
    c := _ReadCharEx(t);
    if (c and $00ff) = cLF then break; // accept LF as end of line
    if (c and $ff00) shr 8 = cEOF then break;
>>> if (c and $00ff) = cCR then
    begin
      c := _ReadCharEx(t);
>>>>> if (c and $00ff) = cLF then break; // accept CR+LF as end of line
      if (c and $ff00) shr 8 = cEOF then break; // accept CR+EOF as end of line
      Dec(t.BufPos);
      // else CR+ anything else is not a line break.
    end;
  end;
end;

[charly52]

ok, da ist ja wieder viel Stoff zu verdauen.

Möchte aber vorher ein weiteres evtl. neues? Problem zur Diskusion stellen.

Ich habe ja eine Version, die meine ConsolenApp creiert und was hin schickt.
Jetzt ist aber der Effekt so, daß wenn ich mein CreateProcess() in einem Formular habe, dann müssen die Parameter alle Wide-String-Variante sein, sonst mault der Compiler.

Wenn ich das ganze Create/WriteFile in eine Unit auslagere, dann muss es Ansi-String sein.

Ich habe die Projekte "CreateProcess" und "WebKernel" in eine Gruppe CreateProcessGroup gepackt und alles zusammengezipt.

Ich häng dieses zip mit an.

Vieleicht kann mir das ja jemand erklären. Danke

Charly

[charly52]

Zitat:

Zitat von himitsu (Beitrag 1511241)

Ja, Delphi-Consolen können nur ANSI, bzw. OEM. (was sich jeweils umschalten ließe)
Aber wenn man nicht die uralten Delphi-Funktionen verwendet, dann wäre auch alles Andere Möglich.

Delphi-Quellcode:

function _WriteWString(var t: TTextRec; const s: WideString; width: Longint): Pointer;

procedure _ReadUString(var t: TTextRec; var s: UnicodeString);

Hi himitsu, auch auf die Gefahr das ich als begriffstutzig gelte,

was mach ich mit _ReadUString?
Wie kann ich das in meiner Konsole nutzen?

Vieleicht kannst du ja mal mein Projekt anschauen. :-)

Sorry für die viele Fragerei und Danke

Charly

[charly52]

Hi

Zitat:

Zitat von himitsu (Beitrag 1511241)

Ja, Delphi-Consolen können nur ANSI, bzw. OEM. (was sich jeweils umschalten ließe)
Aber wenn man nicht die uralten Delphi-Funktionen verwendet, dann wäre auch alles Andere Möglich.
[/DELPHI]

Wie bzw. wo kann man das umschalten? In meinem Programm

oder in den Eigenschaften der Konsole/CMD oder wer auch immer mit meiner KonsolenApp hochkommt?

Charly :-(

[himitsu]

Die "alten" Pascal-Funktionen für den Dateizugriff sind Compiler-Magic.

Du machst damit nichts.

z.B. ein

Delphi-Quellcode:

WriteLn('abc', 123, 0.75, True);

macht der Compiler intern zu einer Reihe von _WriteLString('abc'), _Write0Long('123), _Write0Ext(0.75), _Write0Bool(True) und _WriteLn()

Zitat:

umschalten

In diesem Fall in der Console
CHCP

bzw. SetConsoleCP und SetConsoleOutputCP

Und wenn man im Programm selber ANSI-File-APIs benutzt, wie z.B. CreateFileA,
dann SetFileApisToOEM, SetFileApisToANSI und AreFileApisANSI

[charly52]

hi himitsu

gehört hier nicht hin, aber ich kann dir keine private Nachricht schicken.

Zitat:

Der Posteingang von himitsu ist voll. himitsu kann keine weiteren Privaten Nachrichten empfangen, solange ältere Private Nachrichten nicht gelöscht worden sind.

Gruß Charly

[charly52]

Hi

hier http://www.felix-colibri.com/papers/...in_stdout.html
habe ich ne ganz tolle Beschreibung der Zusammenhänge gefunden.


Charly