Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » Daten an Stdin eines DOS- Programmes senden

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
19.07.2005, 08:27 Uhr
ziba



Hallo,
ich habe ein altes DOS- Programm, das unter WinXP in der Konsole (cmd) läuft. Jetzt möchte ich dieses Programm von meinem VC++ Programm aus starten und das DOS- Programm bedienen, also Texte schreiben oder F- Tasten simulieren.

Ich lege eine Pipe an (CreatePipe), starte den Prozess mit CreateProcess und schreibe mit WriteFile in die Pipe.

Was muss ich tun, damit das DOS- Programm, das nichts von der Pipe weiss, diese Eingaben auch annimmt/ anzeigt?

Mit dem folgenden Programm kann ich den Prozess starten und in die Pipe schreiben, allerdings kommt nichts an.



C++:
void CShellViewDlg::OnCreate()
{
    
    SECURITY_ATTRIBUTES sa;
    ZeroMemory(&sa,sizeof(SECURITY_ATTRIBUTES));
    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
    sa.bInheritHandle = TRUE;
    sa.lpSecurityDescriptor = NULL;  //TODO

    //sichern des Handles
    hSaveStdin = GetStdHandle(STD_INPUT_HANDLE);
    
    HANDLE hSaveStdin = GetStdHandle(STD_INPUT_HANDLE);
    //Pipe anlegen
    if(!CreatePipe(&hChildStdinRd, &hChildStdinWr, &sa,0)){
        MessageBox("Fehler beim Pipe- Erzeugen");
    }

    if(!SetStdHandle(STD_INPUT_HANDLE, hChildStdinRd)){
        MessageBox("Fehler bei Verbindung zu Stdin");
    }

    //Duplizieren des Schreib Handels, damit es nicht vererbt wird
    if(!DuplicateHandle(GetCurrentProcess(), hChildStdinWr, GetCurrentProcess(), &hChildStdinWrDup, 0,FALSE, DUPLICATE_SAME_ACCESS)){
        MessageBox("Fehler beim Duplizieren");
    }
    CloseHandle(hChildStdinWr);

/********************************************************************
**********  Prozess starten  **********************************
********************************************************************/

    STARTUPINFO    si;
    ZeroMemory(&si,sizeof(STARTUPINFO));

     // stdin, stdout und stderr des Kindes in STARTUPINFO eintragen
    si.cb         = sizeof(STARTUPINFO);
    si.dwFlags    = STARTF_USESTDHANDLES;
    si.hStdInput  = hChildStdinRd;
    si.hStdOutput = hChildStdoutWr;
    si.hStdError  = hChildStdoutWr;

    PROCESS_INFORMATION  pi;
    ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
    
    GetStartupInfo(&si);

    BOOL ret = CreateProcess(NULL,"C:\\WINNT\\System32\\cmd.exe",// Name der Appl
      &sa,      // Default process security attributes
      NULL,      // Default thread security attributes
      TRUE,      // inherit handles from the parent
      0,      // Normal priority
      NULL,      // Use the same environment as the parent
      NULL,      // Launch in the current directory
      &si,      // Startup Information
      &pi);      // Process information stored upon return
    
    if(ret){
        int dwProcessId = pi.dwProcessId;
        char final_string[200];
        sprintf(final_string, "ProzessId: %i", dwProcessId);
        MessageBox(final_string);
        //Beendet den Prozess
//        HANDLE hProcess = OpenProcess (PROCESS_ALL_ACCESS, FALSE,dwProcessId );
//        TerminateProcess (hProcess,0);
//        CloseHandle(hProcess);
    }
    else
    {
        MessageBox("Fehler beim Erzeugen des Prozesses");
    }
    
}

//in die Pipe schreiben
void CShellViewDlg::Write(HANDLE childStdinWrDup)
{
    LPCTSTR line = "Test von Stdin";
    DWORD dwWritten;
    if(!WriteFile(childStdinWrDup, line, _tcslen(line)*sizeof(TCHAR),&dwWritten,NULL)){
        MessageBox("Fehler beim Schreiben");
    }
    else{
        char final_string[200];
        sprintf(final_string, "Länge des geschriebenen Textes: %i", dwWritten);
        MessageBox(final_string);
    }
}

//
void CShellViewDlg::OnWrite()
{
    Write(hChildStdinWrDup);
}


gruss
ziba

Dieser Post wurde am 19.07.2005 um 09:09 Uhr von ziba editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
19.07.2005, 09:01 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


du musst in childStdinRd schreiben, das ist der Input vom Child, das andere ist der Output
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
19.07.2005, 11:37 Uhr
ziba



Wenn ich das ändere, bekomme ich beim Schreiben nur eine Fehlermeldung. (geht dann also gar nicht mehr)

Welches Handle muss eigentlich welchem zugeordnet werden?
Ich dachte, ich muss den Output meines Windowsprogrammes (Vaterprozess) dem Input des Kindes zuordnen. Und der Input sollte ja eigentlich die Schnittstelle sein, die auch bei einer Tastatureingabe genutzt wird. Oder versteh ich da was falsch?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
21.07.2005, 08:32 Uhr
ziba



Habs inzwischen hinbekommen ein Konsolenprogrammm so aus meinem Windowsprogramm heraus zu starten, dass ich Stdin und Stdout des Kindprozesses schreiben/ lesen kann. Das Konsolenprogramm ist aber in diesem Fall ein eigenes 32Bit- Testprogramm. Wenn ich mein Programm aber mit dem 16Bit- DOS- Programm teste, kann ich grad noch den Kindprozess starten und dann ist die Verbindung zwischen Kind-& Vaterprozess abgebrochen.
Wo kann da der Unterschied liegen?
Bekommen DOS- Programme ihren Input nicht über Stdin?

gruss
ziba
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
21.07.2005, 08:50 Uhr
Tommix



Hallo,

Zitat von ziba:
Bekommen DOS- Programme ihren Input nicht über Stdin?

Kommt drauf an. Viele DOS-Compiler verwendeten eher direkte Hardwarezugriffe für IO-Operationen. Das läßt sich aber leicht rausfinden:

Code:
echo xyz | prog.exe
bzw.
prog.exe < input.txt


Gruß, Tommix

Dieser Post wurde am 21.07.2005 um 08:51 Uhr von Tommix editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
21.07.2005, 14:11 Uhr
ziba



Danke erstmal für die Antwort.

Sowohl "echo xyz | prog.exe", als auch die Steuerung über eine Binärdatei funktionieren mit dem DOS- Programm. Also sollte da doch kein Unterschied zu Windowsprogrammen sein.

Das Programmgerüst, mit dem ich arbeite entspricht im Großen und Ganzen dem Beispiel von MSDN
http://support.microsoft.com/default.aspx?scid=kb;en-us;190351

Bis zu der Threaderzeugung, die in Stdin schreibt, gehts auch mit dem DOS- Programm. Das Schreiben selbst funktioniert den nicht mehr. Das Programm scheint das Handle für Stdin nicht zu bekommen, wenn das DOS- Programm gesteuert werden soll.

gruss
ziba

Dieser Post wurde am 21.07.2005 um 14:12 Uhr von ziba editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: