web-dev-qa-db-de.com

C++ Ausführen von CMD-Befehlen

Ich habe hier ein ernstes Problem. Ich muss eine CMD-Befehlszeile über C++ ausführen, ohne dass das Konsolenfenster angezeigt wird. Daher kann ich system(cmd) nicht verwenden, da das Fenster angezeigt wird.

Ich habe winExec(cmd, SW_HIDE) ausprobiert, aber das funktioniert auch nicht. CreateProcess ist eine andere, die ich ausprobiert habe. Dies ist jedoch für die Ausführung von Programmen oder Batchdateien.

Ich habe am Ende ShellExecute versucht:

ShellExecute( NULL, "open",
    "cmd.exe",
    "ipconfig > myfile.txt",
    "c:\projects\b",
    SW_SHOWNORMAL
);

Kann jemand mit dem obigen Code etwas falsch sehen? Ich habe SW_SHOWNORMAL verwendet, bis ich weiß, dass dies funktioniert.

Ich brauche dazu wirklich Hilfe. Nichts ist ans Licht gekommen und ich habe es schon eine ganze Weile versucht. Jeder Rat, den jemand geben könnte, wäre großartig :)

12
JP29

Das Umleiten der Ausgabe an Ihre eigene Pipe ist eine aufgeräumtere Lösung, da die Erstellung der Ausgabedatei vermieden wird. Dies funktioniert jedoch gut:

ShellExecute(0, "open", "cmd.exe", "/C ipconfig > out.txt", 0, SW_HIDE);

Sie sehen das Cmd-Fenster nicht und die Ausgabe wird wie erwartet umgeleitet.

Ihr Code schlägt wahrscheinlich fehl (abgesehen von der Sache /C), weil Sie den Pfad als "c:\projects\b" und nicht als "c:\\projects\\b" angeben.

8
arx

Sie sollten CreateProcess on cmd.exe mit dem Parameter /C verwenden, um den Befehl ipconfig zu tunneln. Das> funktioniert nicht per se in der Befehlszeile. Sie müssen das stdout programmgesteuert umleiten.

4
Felice Pollano

Hier ist meine Implementierung einer DosExec-Funktion, die es ermöglicht, jeden DOS-Befehl (unbeaufsichtigt) auszuführen und die erzeugte Ausgabe als Unicode-String abzurufen.

// Convert an OEM string (8-bit) to a UTF-16 string (16-bit) 
#define OEMtoUNICODE(str)   CHARtoWCHAR(str, CP_OEMCP)

/* Convert a single/multi-byte string to a UTF-16 string (16-bit).
 We take advantage of the MultiByteToWideChar function that allows to specify the charset of the input string.
*/
LPWSTR CHARtoWCHAR(LPSTR str, UINT codePage) {
    size_t len = strlen(str) + 1;
    int size_needed = MultiByteToWideChar(codePage, 0, str, len, NULL, 0);
    LPWSTR wstr = (LPWSTR) LocalAlloc(LPTR, sizeof(WCHAR) * size_needed);
    MultiByteToWideChar(codePage, 0, str, len, wstr, size_needed);
    return wstr;
}

/* Execute a DOS command.

 If the function succeeds, the return value is a non-NULL pointer to the output of the invoked command. 
 Command will produce a 8-bit characters stream using OEM code-page.

 As charset depends on OS config (ex: CP437 [OEM-US/latin-US], CP850 [OEM 850/latin-1]),
 before being returned, output is converted to a wide-char string with function OEMtoUNICODE.

 Resulting buffer is allocated with LocalAlloc.
 It is the caller's responsibility to free the memory used by the argument list when it is no longer needed. 
 To free the memory, use a single call to LocalFree function.
*/
LPWSTR DosExec(LPWSTR command){
    // Allocate 1Mo to store the output (final buffer will be sized to actual output)
    // If output exceeds that size, it will be truncated
    const SIZE_T RESULT_SIZE = sizeof(char)*1024*1024;
    char* output = (char*) LocalAlloc(LPTR, RESULT_SIZE);

    HANDLE readPipe, writePipe;
    SECURITY_ATTRIBUTES security;
    STARTUPINFOA        start;
    PROCESS_INFORMATION processInfo;

    security.nLength = sizeof(SECURITY_ATTRIBUTES);
    security.bInheritHandle = true;
    security.lpSecurityDescriptor = NULL;

    if ( CreatePipe(
                    &readPipe,  // address of variable for read handle
                    &writePipe, // address of variable for write handle
                    &security,  // pointer to security attributes
                    0           // number of bytes reserved for pipe
                    ) ){


        GetStartupInfoA(&start);
        start.hStdOutput  = writePipe;
        start.hStdError   = writePipe;
        start.hStdInput   = readPipe;
        start.dwFlags     = STARTF_USESTDHANDLES + STARTF_USESHOWWINDOW;
        start.wShowWindow = SW_HIDE;

// We have to start the DOS app the same way cmd.exe does (using the current Win32 ANSI code-page).
// So, we use the "ANSI" version of createProcess, to be able to pass a LPSTR (single/multi-byte character string) 
// instead of a LPWSTR (wide-character string) and we use the UNICODEtoANSI function to convert the given command 
        if (CreateProcessA(NULL,                    // pointer to name of executable module
                           UNICODEtoANSI(command),  // pointer to command line string
                           &security,               // pointer to process security attributes
                           &security,               // pointer to thread security attributes
                           TRUE,                    // handle inheritance flag
                           NORMAL_PRIORITY_CLASS,   // creation flags
                           NULL,                    // pointer to new environment block
                           NULL,                    // pointer to current directory name
                           &start,                  // pointer to STARTUPINFO
                           &processInfo             // pointer to PROCESS_INFORMATION
                         )){

            // wait for the child process to start
            for(UINT state = WAIT_TIMEOUT; state == WAIT_TIMEOUT; state = WaitForSingleObject(processInfo.hProcess, 100) );

            DWORD bytesRead = 0, count = 0;
            const int BUFF_SIZE = 1024;
            char* buffer = (char*) malloc(sizeof(char)*BUFF_SIZE+1);
            strcpy(output, "");
            do {                
                DWORD dwAvail = 0;
                if (!PeekNamedPipe(readPipe, NULL, 0, NULL, &dwAvail, NULL)) {
                    // error, the child process might have ended
                    break;
                }
                if (!dwAvail) {
                    // no data available in the pipe
                    break;
                }
                ReadFile(readPipe, buffer, BUFF_SIZE, &bytesRead, NULL);
                buffer[bytesRead] = '\0';
                if((count+bytesRead) > RESULT_SIZE) break;
                strcat(output, buffer);
                count += bytesRead;
            } while (bytesRead >= BUFF_SIZE);
            free(buffer);
        }

    }

    CloseHandle(processInfo.hThread);
    CloseHandle(processInfo.hProcess);
    CloseHandle(writePipe);
    CloseHandle(readPipe);

    // convert result buffer to a wide-character string
    LPWSTR result = OEMtoUNICODE(output);
    LocalFree(output);
    return result;
}
4

Ich habe ein ähnliches Programm [windows7 und 10] auf github getestet 

https://github.com/vlsireddy/remwin/tree/master/remwin

Dies ist ein Serverprogramm welches 

  1. überwacht die benannte Schnittstelle "Local Area Connection" in Windows auf den UDP-Port (5555) und empfängt das UDP-Paket. 
  2. empfangene udp-Paketinhalte werden auf cmd.exe ausgeführt [bitte nicht cmd.exe wird NICHT geschlossen, nachdem der Befehl ausgeführt wurde, und die Ausgabezeichenfolge [die Ausgabe des ausgeführten Befehls] wird über denselben UDP-Port an das Client-Programm zurückgegeben.
  3. Mit anderen Worten, der Befehl Wurde in udp package -> analysiertem udp package -> auf cmd.exe ausgeführt -> auf demselben Port an das Client-Programm zurückgesendete Ausgabe

Dies zeigt nicht "Konsolenfenster" Es ist nicht erforderlich, dass jemand den Befehl auf cmd.exe Manuell ausführt. Remwin.exe kann im Hintergrund ausgeführt werden und es ist ein Thin-Server-Programm

1
particlereddy

Um die Antwort von @ Cédric Françoys zu ergänzen, habe ich einige Dinge in seinem Code für einen Windows-Build korrigiert:

Fehlende Funktionsdefinition:

Fügen Sie die folgende Funktionsdefinition hinzu, um den Code zu kompilieren:

#define UNICODEtoANSI(str)   WCHARtoCHAR(str, CP_OEMCP)

LPSTR WCHARtoCHAR(LPWSTR wstr, UINT codePage) {
    int len = (int)wcslen(wstr) + 1;    
    int size_needed = WideCharToMultiByte(codePage, 0, wstr, len, NULL, 0, NULL, NULL);
    LPSTR str = (LPSTR)LocalAlloc(LPTR, sizeof(CHAR) * size_needed);
    WideCharToMultiByte(codePage, 0, wstr, len, str, size_needed, NULL, NULL);
    return str;
}

nsichere CRT-String-Funktionsaufrufe:

Ersetzen Sie strcpy und strcat durch die folgenden Aufrufe, um den Code zu kompilieren

strcpy_s(output, sizeof(output), "");

strcat_s(output, RESULT_SIZE, buffer);

Redundante Null-Terminierung entfernen:

In der do-while-Schleife entfernen:

buffer[bytesRead] = '\0';

da strcat_s kümmert sich darum.

0
kakyo