Output von NetCat (nc.exe) auslesen

[Aljoscha]

Hi.
Ich benutze die unten genannte, sehr bekannte Funktion um die Ausgabe eines Programms abzufangen.
Das klappt auch immer alles wunderbar, aber das Problem ist:
Nur wenn das Programm "fertig ist", das heißt der Befehl ausgeführt wurde wird die Ausgabe in einem Stück gesendet.
Viele von euch kennen sicher das Programm NetCat.
Man kann damit z.B. auf eingehende Verbindungen warten.
Das ganze sieht aber so aus, dass das Programm so zu sagen nie den Befehl fertig ausführt, weil es endlos auf neue Eingänge wartet.
Das heißt in meinem programm kommt nie eine Ausgabe an.
Wenn ich aber NetCat beende, wird die bis dahin im Fenster stehende Ausgabe in mein Programm übernommen, da der Befehl ja abgebrochen wurde, aber ansonsten nie.

Meine Frage also:
Wie könnte ich den Code so ändern, das die Ausgabe sofort gesendet wird und nicht erst zusammen in einem rutsch am Ende?

Ich hoffe man versteht was ich damit sagen will
Ich habe schon alles mögliche probiert, aber nach allen modifikationen kam endweder gar nichts an, oder eben wieder nur nac hdem abbruch des Programms.

thx 4 help

Und hier noch der Code

Delphi-Quellcode:

function GetConsoleOutput(const Command: String; var Output, Errors: TStringList): Boolean; 
var 
  StartupInfo: TStartupInfo; 
  ProcessInfo: TProcessInformation; 
  SecurityAttr: TSecurityAttributes; 
  PipeOutputRead: THandle; 
  PipeOutputWrite: THandle; 
  PipeErrorsRead: THandle; 
  PipeErrorsWrite: THandle; 
  Succeed: Boolean; 
  Buffer: array [0..255] of Char; 
  NumberOfBytesRead: DWORD; 
  Stream: TMemoryStream; 
begin 
  //Initialisierung ProcessInfo 
  FillChar(ProcessInfo, SizeOf(TProcessInformation), 0); 

  //Initialisierung SecurityAttr 
  FillChar(SecurityAttr, SizeOf(TSecurityAttributes), 0); 
  SecurityAttr.nLength := SizeOf(SecurityAttr); 
  SecurityAttr.bInheritHandle := true; 
  SecurityAttr.lpSecurityDescriptor := nil; 

  //Pipes erzeugen 
  CreatePipe(PipeOutputRead, PipeOutputWrite, @SecurityAttr, 0); 
  CreatePipe(PipeErrorsRead, PipeErrorsWrite, @SecurityAttr, 0); 

  //Initialisierung StartupInfo 
  FillChar(StartupInfo, SizeOf(TStartupInfo), 0); 
  StartupInfo.cb:=SizeOf(StartupInfo); 
  StartupInfo.hStdInput := 0; 
  StartupInfo.hStdOutput := PipeOutputWrite; 
  StartupInfo.hStdError := PipeErrorsWrite; 
  StartupInfo.wShowWindow := sw_Hide; 
  StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES; 

  if  CreateProcess(nil, PChar(command), nil, nil, true, 
  CREATE_DEFAULT_ERROR_MODE or CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, nil, 
  StartupInfo, ProcessInfo) then begin 
    result:=true; 
    //Write-Pipes schließen 
    CloseHandle(PipeOutputWrite); 
    CloseHandle(PipeErrorsWrite); 

    //Ausgabe Read-Pipe auslesen 
    Stream := TMemoryStream.Create; 
    try 
      while true do begin 
        succeed := ReadFile(PipeOutputRead, Buffer, 255, NumberOfBytesRead, nil); 
        if not succeed then break; 
        Stream.Write(Buffer, NumberOfBytesRead); 
      end; 
      Stream.Position := 0; 
      Output.LoadFromStream(Stream); 
    finally 
      Stream.Free; 
    end; 
    CloseHandle(PipeOutputRead); 

    //Fehler Read-Pipe auslesen 
    Stream := TMemoryStream.Create; 
    try 
      while true do begin 
        succeed := ReadFile(PipeErrorsRead, Buffer, 255, NumberOfBytesRead, nil); 
        if not succeed then break; 
        Stream.Write(Buffer, NumberOfBytesRead); 
      end; 
      Stream.Position := 0; 
      Errors.LoadFromStream(Stream); 
    finally 
      Stream.Free; 
    end; 
    CloseHandle(PipeErrorsRead); 

    WaitForSingleObject(ProcessInfo.hProcess, INFINITE); 
    CloseHandle(ProcessInfo.hProcess); 
  end 
  else begin 
    result:=false; 
    CloseHandle(PipeOutputRead); 
    CloseHandle(PipeOutputWrite); 
    CloseHandle(PipeErrorsRead); 
    CloseHandle(PipeErrorsWrite); 
  end; 
end;