Capturar la salida de un comando dos.

[Flecha]

Hola a todos.

Estoy también en busca de algo que me ayude a capturar la salida para mostrarla en TMemo. Ese enlace que puso ElKurgan ya está obsoleto. El link correcto es este: http://www.trucomania.org/trucomania/truco.cgi?320&esp

No obstante, lo he probado y no vale ese truco porque en ocasiones no logra capturar la respuesta.

¿Alguien conoce otro método que sea más eficaz?

Muchas gracias.

[[kurono]]

este te permite ejecutar comando de Ms-dos y ver sus resultados quisas seas lo que busca

Código Delphi [-]
function IsWinNT: boolean;
var
  OSV: OSVERSIONINFO;
begin
  OSV.dwOSVersionInfoSize := sizeof(osv);
  GetVersionEx(OSV);
  result := OSV.dwPlatformId = VER_PLATFORM_WIN32_NT;
end;

function CmdExec(Cmd: string): string;
var
  Buffer: array[0..4096] of Char;
  si: STARTUPINFO;
  sa: SECURITY_ATTRIBUTES;
  sd: SECURITY_DESCRIPTOR;
  pi: PROCESS_INFORMATION;
  newstdin, newstdout, read_stdout, write_stdin: THandle;
  exitcod, bread, avail: Cardinal;
begin
  Result:= '';
  if IsWinNT then
  begin
    InitializeSecurityDescriptor(@sd, SECURITY_DESCRIPTOR_REVISION);
    SetSecurityDescriptorDacl(@sd, true, nil, false);
    sa.lpSecurityDescriptor := @sd;
  end
  else sa.lpSecurityDescriptor := nil;
  sa.nLength := sizeof(SECURITY_ATTRIBUTES);
  sa.bInheritHandle := TRUE;
  if CreatePipe(newstdin, write_stdin, @sa, 0) then
  begin
    if CreatePipe(read_stdout, newstdout, @sa, 0) then
    begin
      GetStartupInfo(si);
      with si do
      begin
        dwFlags := STARTF_USESTDHANDLES or STARTF_USESHOWWINDOW;
        wShowWindow := SW_HIDE;
        hStdOutput := newstdout;
        hStdError := newstdout;
        hStdInput := newstdin;
      end;
      Fillchar(Buffer, SizeOf(Buffer), 0);
      GetEnvironmentVariable('COMSPEC', @Buffer, SizeOf(Buffer) - 1);
      StrCat(@Buffer,PChar(' /c ' + Cmd));
      if CreateProcess(nil, @Buffer, nil, nil, TRUE, CREATE_NEW_CONSOLE, nil, nil, si, pi) then
      begin
        repeat
          PeekNamedPipe(read_stdout, @Buffer, SizeOf(Buffer) - 1, @bread, @avail, nil);
          if bread > 0 then
          begin
            Fillchar(Buffer, SizeOf(Buffer), 0);
            ReadFile(read_stdout, Buffer, bread, bread, nil);
            Result:= Result + String(PChar(@Buffer));
          end;
          Application.ProcessMessages;
          GetExitCodeProcess(pi.hProcess, exitcod);
        until (exitcod <> STILL_ACTIVE) and (bread = 0);
      end;
      CloseHandle(read_stdout);
      CloseHandle(newstdout);
    end;
    CloseHandle(newstdin);
    CloseHandle(write_stdin);
  end;
end;

ejemplo de uso

begin

ShowMessage(CmdExec('dir c:\'));
ShowMessage(CmdExec('netstat -a -n'));

end;
end.

[Flecha]

Muchas gracias por responder, kurono. Pero por desgracia no me vale.

También he provado ese código que me ofreces. Pero no deja de ser una variante del truco de Trucomanía. Hay órdenes cuya respuesta no es capaz de capturar.

¿Alguien conoce otra alternativa?

Muchas Gracias.

[[newtron]]

Hola.

Igual digo una tontería pero los comandos de msdos si los acabas con el signo > seguido de un nombre crea un archivo con la salida del comando. Unicamente tendrías que ejecutar el comando msdos con el signo y el nombre del fichero y después leer el fichero que es un fichero de txt normal.

Saludos

[Casimiro Notevi]

Empezado por newtron

Hola.

Igual digo una tontería pero los comandos de msdos si los acabas con el signo > seguido de un nombre crea un archivo con la salida del comando. Unicamente tendrías que ejecutar el comando msdos con el signo y el nombre del fichero y después leer el fichero que es un fichero de txt normal.

Saludos

Exacto, y si en lugar de '>' pones '>>' lo que hace es añadirlo al final del fichero indicado.

[mcs]

Empezado por Casimiro Notevi

Exacto, y si en lugar de '>' pones '>>' lo que hace es añadirlo al final del fichero indicado.

siempre y cuando usen las funciones del DOS para escribir en pantalla, cosa que pocas aplicaciones hacían debido a que era muy lento... (lo fácil y rápido era escribir directamente a la memoria de la VGA... dirección $B8000000, si no recuerdo mal! )

[[newtron]]

Empezado por mcs

siempre y cuando usen las funciones del DOS para escribir en pantalla, cosa que pocas aplicaciones hacían debido a que era muy lento... (lo fácil y rápido era escribir directamente a la memoria de la VGA... dirección $B8000000, si no recuerdo mal! )

....juer... 10 años programando en msdos y otros 10 en guindoun y ahora me entero de eso de escribir en la memoria de la vga.... dirección qué dices? jajajajajaja

[Flecha]

Espero no tener que vigilar las escrituras directas en VGA, porque para lo que necesito capturar la salida..., sería un auténtico engorro tener que andarme con esas cosas...


Ya sabía lo del > y el >> . Es lo más básico de lo más mínima programación elemental . Pero preferiría no tener que recurrir a ese truco.


De todos modos, muchas gracias a todos.
La captura de la salida a MS-DOS que necesito hacer, es sólo una pequeña parte de un problema mayor que debo resolver. Si consigo perfeccionar el resto de los puntos de mi problema, quizá no necesite ser "tan exigente" con la captura. Y en este caso, la solución presente en TrucoManía, y la presentada por kurono, cualquiera de las dos podría valerme.


No obstante. Debo reseñar una cosa al respecto de sendas soluciones. Ambas tienen un bucle, dentro del cual se va capturando la salida a MS-DOS mientras que el proceso sigue activo...
En ocasiones, dependiendo de qué se quiera ejecutar, nunca se detecta el fin de la actividad del proceso. En esos casos el bucle se convierte en infinito.
Por lo tanto, aconsejo a quien vaya a utilizar esos trucos, que incorpore en dicho bucle un Time-Out, el que cada cual estime más oportuno...

Por ejemplo..., éste es el bucle al que hago referencia en la solución aportada por kurono:

Código Delphi [-]
[...]
begin
[...]
        repeat
          PeekNamedPipe(read_stdout, @Buffer, SizeOf(Buffer) - 1, @bread, @avail, nil);
          if bread > 0 then
          begin
            Fillchar(Buffer, SizeOf(Buffer), 0);
            ReadFile(read_stdout, Buffer, bread, bread, nil);
            Result:= Result + String(PChar(@Buffer));
          end;
          Application.ProcessMessages;
          GetExitCodeProcess(pi.hProcess, exitcod);
        until (exitcod <> STILL_ACTIVE) and (bread = 0);
[...]
end;

Conviene declarar una variable TDateTime para controlar el tiempo transcurrido. Primero la inicializamos reflejando en ella el TimeOut a respetar, y luego añadimos el control del TimeOut dentro de la condición de salida del bucle.

Código Delphi [-]
var
  TimeOut : TDateTime;  // esta variable servirá para controlar el TimeOut
[...]
begin
[...]
        TimeOut := Now + EncodeTime(0,0,30,0);   // esto es un TimeOut de 30 segundos

        repeat
          PeekNamedPipe(read_stdout, @Buffer, SizeOf(Buffer) - 1, @bread, @avail, nil);
          if bread > 0 then
          begin
            Fillchar(Buffer, SizeOf(Buffer), 0);
            ReadFile(read_stdout, Buffer, bread, bread, nil);
            Result:= Result + String(PChar(@Buffer));
          end;
          Application.ProcessMessages;
          GetExitCodeProcess(pi.hProcess, exitcod);

        until ((exitcod <> STILL_ACTIVE) and (bread = 0))
           or (timeout < now);  // añadir esta condición para controlar el TimeOut
[...]
end;