c++windowswinapiterminal

I can't figure out how to pass a command to the windows terminal input control. C++


I am trying to write a program with which it will be possible to send a command highlighted in the browser to the terminal. I stumble on the fact that I can't figure out how to transfer any command to the terminal that my program opens. That's how I launch the terminal:

PROCESS_INFORMATION processInfo;
STARTUPINFO startupInfo = { sizeof(startupInfo) };
ZeroMemory(&startupInfo, sizeof(startupInfo));
startupInfo.cb = sizeof(startupInfo);

ZeroMemory(&processInfo, sizeof(processInfo));

char cmdPath[] = "C:\\Windows\\System32\\cmd.exe";
CreateProcess(cmdPath, nullptr, nullptr, nullptr, FALSE,
    CREATE_NEW_CONSOLE, nullptr, nullptr, &startupInfo, &processInfo);

Solution

  • RbMm's opinion is completely right. No matter supplying input to cmd or retrieve it's output. Pipe is an efficient method. Here is the sample:

    #include <stdio.h>
    #include <windows.h>    
    
    #define BUFFER_LENGTH 1024
    void handle_cleanup(STARTUPINFOW,  PROCESS_INFORMATION);
    DWORD WINAPI ReadPipe(LPVOID);
    
    HANDLE CMD_WRITE, PARENT_READ, CMD_READ, PARENT_WRITE;
    
    int CreateProcessCMD(void){
       DWORD ThreadID;
       DWORD bytes_written;
       HANDLE hProcessCMD;
       
       STARTUPINFOW PSTARTUPINFO;
       PROCESS_INFORMATION PPROCESSINFO;
       SECURITY_ATTRIBUTES SECURITYATTR;
    
       SECURITYATTR.nLength = sizeof(SECURITY_ATTRIBUTES);
       SECURITYATTR.bInheritHandle = TRUE;
       SECURITYATTR.lpSecurityDescriptor = NULL;
    
       if(!CreatePipe(&PARENT_READ,&CMD_WRITE, &SECURITYATTR,0)){
           printf("Could not create pipe");
           return EXIT_FAILURE;
       }
       printf("CreatePipe(PARENT_READ, CMD_WRITE) -  Success!\n");
       
       if(!CreatePipe(&CMD_READ,&PARENT_WRITE, &SECURITYATTR,0)){
          printf("Could not create pipe");
          return EXIT_FAILURE;
       }
       printf("CreatePipe(CMD_READ, PARENT_WRITE) - Success!\n");
    
       ZeroMemory(&PSTARTUPINFO, sizeof(STARTUPINFO));
       printf("ZeroMemory(&PSTARTUPINFO, sizeof(STARTUPINFO) -  Zeroing STARTUPINFO structure success!\n");
       
       PSTARTUPINFO.cb = sizeof(STARTUPINFO);
       PSTARTUPINFO.hStdOutput = CMD_WRITE;
       printf("CMD_WRITE ---> %x\n", CMD_WRITE);
       printf("STARTINFO.hStsOutput ---> %x\n", PSTARTUPINFO.hStdOutput);
       PSTARTUPINFO.hStdInput = CMD_READ;
       printf("CMD_READ ---> %x\n", CMD_READ);
       printf("STARTINFO.hStdsInput ---> %x\n", PSTARTUPINFO.hStdInput);
       PSTARTUPINFO.dwFlags |= STARTF_USESTDHANDLES;
       PSTARTUPINFO.dwFlags |= STARTF_USESHOWWINDOW;
       PSTARTUPINFO.wShowWindow = SW_SHOWNORMAL;
       BOOL success = CreateProcessW(L"C:\\Windows\\System32\\cmd.exe",
                          NULL,
                          NULL,
                          NULL,
                          TRUE,
                          NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE,
                          NULL,
                          NULL,
                          &PSTARTUPINFO,
                          &PPROCESSINFO);
       if(!success){
          printf("CreateProcessW() --> Could not create process!\n");
          printf("[-] Closing program");
          return EXIT_FAILURE;
       }
       
       printf("C:\\Windows\\System32\\cmd.exe started with PID ---> %i\n", PPROCESSINFO.dwProcessId);
    
       HANDLE hThread = CreateThread(NULL, 0, ReadPipe, NULL, 0, &ThreadID);
       if(hThread == NULL){
          printf("CreateThread() --> Failed, Returned %i\n", GetLastError());
          return EXIT_FAILURE;
       }
       printf("CreateThread() --> New thread created with TID --> %i\n", ThreadID);
       Sleep(2000);
          
       while(TRUE){   
          char cmd[256];
          printf("Prompt> ");
          gets(cmd);
          strcat_s(cmd, "\r\n");
          WriteFile(PARENT_WRITE, cmd, strlen(cmd), &bytes_written, NULL);
          printf("WriteFile() --> Wrote %i bytes\n", bytes_written);
       }
       
       hProcessCMD = PPROCESSINFO.hProcess;
       switch (WaitForSingleObject(hProcessCMD, INFINITE))
       {
       case WAIT_ABANDONED :
          printf("WaitForSingleObject(hProcess, Timeout) ---> Returned WAIT_ABANDONED\n");
          break;
       case WAIT_OBJECT_0:
          printf("WaitForSingleObject(hProcess, Timeout) ---> The state of the specified object is signaled (Process has terminated)\n");
          break;
       case WAIT_TIMEOUT:
          printf("WaitForSingleObject(hProcess, Timeout) ---> Returned WAIT_TIMEOUT\n");
          break;
       case WAIT_FAILED:
          printf("WaitForSingleObject(hProcess, Timeout) ---> Failed, Returned &i\n", GetLastError());
          break;
       default:
          break;
       }
       
    
       handle_cleanup(PSTARTUPINFO, PPROCESSINFO);
       return EXIT_SUCCESS;
    }
    
    int main(void){
    
       printf("Parent PID ------> %u\n", GetCurrentProcessId());
       if(CreateProcessCMD()){
          printf("CreateProcessCMD() - Function returned EXIT_FAILURE\n");
          return EXIT_FAILURE;
       }
       return EXIT_SUCCESS;
    }
    
    void handle_cleanup(STARTUPINFOW startupinfo,  PROCESS_INFORMATION  processinfo ){
        if(!CloseHandle(startupinfo.hStdInput)) printf("[-] Could not close stdin handle\n");
        if(!CloseHandle(startupinfo.hStdOutput)) printf("[-] Could not close stdout handle\n");
        if(!CloseHandle(startupinfo.hStdError)) printf("[-] Could not close stderr handle\n");
        if(!CloseHandle(processinfo.hProcess)) printf("[-] Could not close process handle\n");
        if(!CloseHandle(processinfo.hThread)) printf("[-] Could not close thread handle\n");
    }
    
    
    DWORD  WINAPI ReadPipe(LPVOID lpThreadParameter){
         char buffer[BUFFER_LENGTH];
         
         DWORD bytes_read_from_pipe;
         while(TRUE) {
            int ret = ReadFile(PARENT_READ, buffer, BUFFER_LENGTH, &bytes_read_from_pipe, NULL);
            printf("ReadFile() --> Read %i\n", bytes_read_from_pipe);
            if(bytes_read_from_pipe>0){
               printf("%s\n", buffer);
               ZeroMemory(buffer, BUFFER_LENGTH);
               bytes_read_from_pipe = 0;
               continue;
            }
            break;
       }
    }