C++ Wykonywanie poleceń CMD

Question

Mam tutaj poważny problem. Muszę wykonać wiersz polecenia CMD przez C++ bez wyświetlania okna konsoli. Dlatego nie mogę użyć system(cmd), ponieważ wyświetli się okno.

Próbowałem winExec(cmd, SW_HIDE), ale to też nie działa. CreateProcess to kolejny, którego próbowałem. Dotyczy to jednak uruchamiania programów lub plików wsadowych.

I skończyło się starają ShellExecute:

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

Czy ktoś widział niczego złego w powyższym kodzie? Użyłem SW_SHOWNORMAL, dopóki nie wiem, że to działa.

Naprawdę potrzebuję pomocy w tym zakresie. Nic nie wyszło na jaw, a ja próbowałem przez jakiś czas. Każda rada, którą ktokolwiek mógłby dać, byłaby świetna :)

Answer 1

Przekierowanie wyjścia do własnego rury jest porządniej rozwiązaniem, ponieważ pozwala uniknąć tworzenia pliku wyjściowego, ale to działa prawidłowo:

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

Nie widzisz cmd okno i wyjście jest przekierowywane zgodnie z oczekiwaniami .

Kod jest prawdopodobnie braku (oprócz /C rzeczy), ponieważ można określić ścieżkę "c:\projects\b" zamiast "c:\\projects\\b".

Answer 2

Powinieneś użyć CreateProcess na cmd.exe z parametrem /C do tunelowania polecenia ipconfig. Opcja> nie działa jako taka w linii poleceń. Musisz redirect programmatically the stdout.

Answer 3

Oto moja implementacja funkcji DosExec, która pozwala (cicho) wykonać dowolne polecenie DOS i pobrać wygenerowane dane wyjściowe jako ciąg znaków Unicode.

// 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; 
} 

Answer 4

mam podobny program [Windows7 i 10 przetestowany] na github

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

Jest to program serwera, który

1. Słuchacze na "Local Area Connection" o nazwie interfejsu w Windows dla portu UDP (5555) i odbiera pakiet udp.
2. odebrana zawartość pakietu udp jest wykonywana na cmd.exe [proszę nie cmd.exe NIE jest zamykane po uruchomieniu polecenia, a ciąg wyjściowy [wynik wykonanego polecenia] jest przekazywany do programu klienckiego przez ten sam port udp].
3. Innymi słowy, komenda otrzymała w pakiecie UDP -> analizowany pakiet UDP -> wykonywany na cmd.exe -> wyjście odesłane na samego portu do programu klienckiego

nie pokazać „okno konsoli” Nie ma potrzeby, aby ktoś wykonywał ręcznie polecenie na cmd.exe. Remwin.exe może działać w tle, a jego cienki program serwera: