Teď jste offline a čekáte, až se znova připojí internet.

Jak spustit procesů konzoly s úchyty pro přesměrované standardní

Důležité: Tento článek byl přeložen pomocí software společnosti Microsoft na strojový překlad, ne profesionálním překladatelem. Společnost Microsoft nabízí jak články přeložené překladatelem, tak články přeložené pomocí software na strojový překlad, takže všechny články ve Znalostní databázi (Knowledge Base) jsou dostupné v češtině. Překlad pomocí software na strojový překlad ale není bohužel vždy dokonalý. Obsahuje chyby ve skloňování slov, skladbě vět, nebo gramatice, podobně jako když cizinci dělají chyby při mluvení v češtině. Společnost Microsoft není právně zodpovědná za nepřesnosti, chyby nebo škody vzniklé chybami v překladu, nebo při použití nepřesně přeložených instrukcí v článku zákazníkem. Společnost Microsoft aktualizuje software na strojový překlad, aby byl počet chyb omezen na minimum.

Projděte si také anglickou verzi článku:190351
Souhrn
Tento článek popisuje, jak přesměrovat vstup a výstup podřízený proces, který přijme vstup ze standardní vstupní popisovač nebo odešle výstup do standardního výstupu popisovač. Rozhraní Win32 API umožňuje aplikacím spustit proces konzoly dítěte s úchyty pro přesměrované standardní. Tato funkce umožňuje nadřazeného procesu odesílat a přijímat vstup a výstup podřízeného procesu.

Poznámka: Některé aplikace konzoly založené nepoužívejte standardní úchyty pro jejich vstupní a výstupní operace (IO). Rozhraní API systému Win32 nepodporuje přesměrování těchto procesů.
Další informace
Rozhraní API CreateProcess() strukturou OBVYKLE umožňujepřesměrování standardní táhla podřízený proces konzoly, které jsou založeny. Pokud člen dwFlags nastavena na STARTF_USESTDHANDLES, zadejte následující členy OBVYKLE standardní táhla podřízený proces konzoly, které jsou založeny:
   HANDLE hStdInput - Standard input handle of the child process.   HANDLE hStdOutput - Standard output handle of the child process.   HANDLE hStdError - Standard error handle of the child process.				
Tyto úchyty lze nastavit buď popisovač kanálu, popisovač souboru nebo libovolnýPopisovač lze provést synchronní čte a zapisuje až ReadFile() aWriteFile() rozhraní API. Úchyty musí být dědičná a CreateProcess()Rozhraní API, musíte určit, že dědičné úchyty se převezmou podřízenézpracovat zadáním hodnoty TRUE v parametru bInheritHandles. Pokud nadřazenýproces přeje pouze jednu nebo dvě standardní táhla, určení přesměrováníGetStdHandle() pro specifické popisovače způsobí vytvoření podřízenéStandardní popisovač jako obvykle bez přesměrování. Například pokudnadřazený proces potřebuje pouze přesměrování standardního výstupu a chybupodřízený proces, pak člen hStdInput struktury OBVYKLE vyplněno takto:
   hStdInput = GetStdHandle(STD_INPUT_HANDLE);				
Poznámka: Podřízené procesy, které používají takové c spuštění funkce jako printf() a fprintf() lze chovat špatně při přesměrování. C Runtime funkcízachovat samostatnou vstupně-výstupní vyrovnávací paměti. Při přesměrování, nemusí být vyrovnávací pamětivyprázdnění bezprostředně po každé volání IO. V důsledku výstup dopotrubí pro přesměrování volání printf() nebo vstup z volání getch() nenívyprázdněny okamžitě a dochází k prodlevám, někdy nepřetržitě zpoždění. K tomuto problému se lze vyhnout, pokud podřízený proces vyprázdnění vyrovnávacích pamětí IO po každé volání funkce IO C Runtime. Podřízený proces lze vyprázdnění vyrovnávacích IO C Runtime. Proces lze vyprázdnění vyrovnávacích IO C Runtime voláním funkce fflush().

Poznámka: Windows 95 a Windows 98 vyžaduje o další krok při přesměrování standardní táhla některé podřízené procesy.

Následující ukázka přesměruje standardní vstup, výstup a chybuzadané ve volání CreateProcess podřízeného procesu. Přesměruje tento vzorekproces poskytnutého konzoly (Child.c).

Ukázkový kód

   /*++      Copyright (c) 1998  Microsoft Corporation      Module Name:         Redirect.c      Description:          This sample illustrates how to spawn a child console based          application with redirected standard handles.          The following import libraries are required:          user32.lib      Dave McPherson (davemm)   11-March-98   --*/    #include<windows.h>   #pragma comment(lib, "User32.lib")   void DisplayError(char *pszAPI);   void ReadAndHandleOutput(HANDLE hPipeRead);   void PrepAndLaunchRedirectedChild(HANDLE hChildStdOut,                                     HANDLE hChildStdIn,                                     HANDLE hChildStdErr);   DWORD WINAPI GetAndSendInputThread(LPVOID lpvThreadParam);   HANDLE hChildProcess = NULL;   HANDLE hStdIn = NULL; // Handle to parents std input.   BOOL bRunThread = TRUE;   void main ()   {      HANDLE hOutputReadTmp,hOutputRead,hOutputWrite;      HANDLE hInputWriteTmp,hInputRead,hInputWrite;      HANDLE hErrorWrite;      HANDLE hThread;      DWORD ThreadId;      SECURITY_ATTRIBUTES sa;      // Set up the security attributes struct.      sa.nLength= sizeof(SECURITY_ATTRIBUTES);      sa.lpSecurityDescriptor = NULL;      sa.bInheritHandle = TRUE;      // Create the child output pipe.      if (!CreatePipe(&hOutputReadTmp,&hOutputWrite,&sa,0))         DisplayError("CreatePipe");      // Create a duplicate of the output write handle for the std error      // write handle. This is necessary in case the child application      // closes one of its std output handles.      if (!DuplicateHandle(GetCurrentProcess(),hOutputWrite,                           GetCurrentProcess(),&hErrorWrite,0,                           TRUE,DUPLICATE_SAME_ACCESS))         DisplayError("DuplicateHandle");      // Create the child input pipe.      if (!CreatePipe(&hInputRead,&hInputWriteTmp,&sa,0))         DisplayError("CreatePipe");      // Create new output read handle and the input write handles. Set      // the Properties to FALSE. Otherwise, the child inherits the      // properties and, as a result, non-closeable handles to the pipes      // are created.      if (!DuplicateHandle(GetCurrentProcess(),hOutputReadTmp,                           GetCurrentProcess(),                           &hOutputRead, // Address of new handle.                           0,FALSE, // Make it uninheritable.                           DUPLICATE_SAME_ACCESS))         DisplayError("DupliateHandle");      if (!DuplicateHandle(GetCurrentProcess(),hInputWriteTmp,                           GetCurrentProcess(),                           &hInputWrite, // Address of new handle.                           0,FALSE, // Make it uninheritable.                           DUPLICATE_SAME_ACCESS))      DisplayError("DupliateHandle");      // Close inheritable copies of the handles you do not want to be      // inherited.      if (!CloseHandle(hOutputReadTmp)) DisplayError("CloseHandle");      if (!CloseHandle(hInputWriteTmp)) DisplayError("CloseHandle");      // Get std input handle so you can close it and force the ReadFile to      // fail when you want the input thread to exit.      if ( (hStdIn = GetStdHandle(STD_INPUT_HANDLE)) ==                                                INVALID_HANDLE_VALUE )         DisplayError("GetStdHandle");      PrepAndLaunchRedirectedChild(hOutputWrite,hInputRead,hErrorWrite);      // Close pipe handles (do not continue to modify the parent).      // You need to make sure that no handles to the write end of the      // output pipe are maintained in this process or else the pipe will      // not close when the child process exits and the ReadFile will hang.      if (!CloseHandle(hOutputWrite)) DisplayError("CloseHandle");      if (!CloseHandle(hInputRead )) DisplayError("CloseHandle");      if (!CloseHandle(hErrorWrite)) DisplayError("CloseHandle");      // Launch the thread that gets the input and sends it to the child.      hThread = CreateThread(NULL,0,GetAndSendInputThread,                              (LPVOID)hInputWrite,0,&ThreadId);      if (hThread == NULL) DisplayError("CreateThread");      // Read the child's output.      ReadAndHandleOutput(hOutputRead);      // Redirection is complete      // Force the read on the input to return by closing the stdin handle.      if (!CloseHandle(hStdIn)) DisplayError("CloseHandle");      // Tell the thread to exit and wait for thread to die.      bRunThread = FALSE;      if (WaitForSingleObject(hThread,INFINITE) == WAIT_FAILED)         DisplayError("WaitForSingleObject");      if (!CloseHandle(hOutputRead)) DisplayError("CloseHandle");      if (!CloseHandle(hInputWrite)) DisplayError("CloseHandle");   }   ///////////////////////////////////////////////////////////////////////    // PrepAndLaunchRedirectedChild   // Sets up STARTUPINFO structure, and launches redirected child.   ///////////////////////////////////////////////////////////////////////    void PrepAndLaunchRedirectedChild(HANDLE hChildStdOut,                                     HANDLE hChildStdIn,                                     HANDLE hChildStdErr)   {      PROCESS_INFORMATION pi;      STARTUPINFO si;      // Set up the start up info struct.      ZeroMemory(&si,sizeof(STARTUPINFO));      si.cb = sizeof(STARTUPINFO);      si.dwFlags = STARTF_USESTDHANDLES;      si.hStdOutput = hChildStdOut;      si.hStdInput  = hChildStdIn;      si.hStdError  = hChildStdErr;      // Use this if you want to hide the child:      //     si.wShowWindow = SW_HIDE;      // Note that dwFlags must include STARTF_USESHOWWINDOW if you want to      // use the wShowWindow flags.      // Launch the process that you want to redirect (in this case,      // Child.exe). Make sure Child.exe is in the same directory as      // redirect.c launch redirect from a command line to prevent location      // confusion.      if (!CreateProcess(NULL,"Child.EXE",NULL,NULL,TRUE,                         CREATE_NEW_CONSOLE,NULL,NULL,&si,&pi))         DisplayError("CreateProcess");      // Set global child process handle to cause threads to exit.      hChildProcess = pi.hProcess;      // Close any unnecessary handles.      if (!CloseHandle(pi.hThread)) DisplayError("CloseHandle");   }   ///////////////////////////////////////////////////////////////////////    // ReadAndHandleOutput   // Monitors handle for input. Exits when child exits or pipe breaks.   ///////////////////////////////////////////////////////////////////////    void ReadAndHandleOutput(HANDLE hPipeRead)   {      CHAR lpBuffer[256];      DWORD nBytesRead;      DWORD nCharsWritten;      while(TRUE)      {         if (!ReadFile(hPipeRead,lpBuffer,sizeof(lpBuffer),                                          &nBytesRead,NULL) || !nBytesRead)         {            if (GetLastError() == ERROR_BROKEN_PIPE)               break; // pipe done - normal exit path.            else               DisplayError("ReadFile"); // Something bad happened.         }         // Display the character read on the screen.         if (!WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),lpBuffer,                           nBytesRead,&nCharsWritten,NULL))            DisplayError("WriteConsole");      }   }   ///////////////////////////////////////////////////////////////////////    // GetAndSendInputThread   // Thread procedure that monitors the console for input and sends input   // to the child process through the input pipe.   // This thread ends when the child application exits.   ///////////////////////////////////////////////////////////////////////    DWORD WINAPI GetAndSendInputThread(LPVOID lpvThreadParam)   {      CHAR read_buff[256];      DWORD nBytesRead,nBytesWrote;      HANDLE hPipeWrite = (HANDLE)lpvThreadParam;      // Get input from our console and send it to child through the pipe.      while (bRunThread)      {         if(!ReadConsole(hStdIn,read_buff,1,&nBytesRead,NULL))            DisplayError("ReadConsole");         read_buff[nBytesRead] = '\0'; // Follow input with a NULL.         if (!WriteFile(hPipeWrite,read_buff,nBytesRead,&nBytesWrote,NULL))         {            if (GetLastError() == ERROR_NO_DATA)               break; // Pipe was closed (normal exit path).            else            DisplayError("WriteFile");         }      }      return 1;   }   ///////////////////////////////////////////////////////////////////////    // DisplayError   // Displays the error number and corresponding message.   ///////////////////////////////////////////////////////////////////////    void DisplayError(char *pszAPI)   {       LPVOID lpvMessageBuffer;       CHAR szPrintBuffer[512];       DWORD nCharsWritten;       FormatMessage(                FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,                NULL, GetLastError(),                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),                (LPTSTR)&lpvMessageBuffer, 0, NULL);       wsprintf(szPrintBuffer,         "ERROR: API    = %s.\n   error code = %d.\n   message    = %s.\n",                pszAPI, GetLastError(), (char *)lpvMessageBuffer);       WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),szPrintBuffer,                     lstrlen(szPrintBuffer),&nCharsWritten,NULL);       LocalFree(lpvMessageBuffer);       ExitProcess(GetLastError());   }   //////////////////////////////////////////////////////////////////////    // child.c   // Echoes all input to stdout. This will be redirected by the redirect   // sample. Compile and build child.c as a Win32 Console application and   // put it in the same directory as the redirect sample.   //    #include<windows.h>   #include<stdio.h>   #include<string.h>   void main ()   {      FILE*    fp;      CHAR     szInput[1024];      // Open the console. By doing this, you can send output directly to      // the console that will not be redirected.      fp = fopen("CON", "w");      if (!fp) {         printf("Error opening child console - perhaps there is none.\n");         fflush(NULL);      }      else      {      // Write a message direct to the console (will not be redirected).         fprintf(fp,"This data is being printed directly to the\n");         fprintf(fp,"console and will not be redirected.\n\n");         fprintf(fp,"Since the standard input and output have been\n");         fprintf(fp,"redirected data sent to and from those handles\n");         fprintf(fp,"will be redirected.\n\n");         fprintf(fp,"To send data to the std input of this process.\n");         fprintf(fp,"Click on the console window of the parent process\n");         fprintf(fp,"(redirect), and enter data from it's console\n\n");         fprintf(fp,"To exit this process send the string 'exit' to\n");         fprintf(fp,"it's standard input\n");         fflush(fp);      }      ZeroMemory(szInput,1024);      while (TRUE)      {         gets(szInput);         printf("Child echoing [%s]\n",szInput);         fflush(NULL);  // Must flush output buffers or else redirection                        // will be problematic.         if (!_stricmp(szInput,"Exit") )            break;         ZeroMemory(szInput,strlen(szInput) );      }   }
Odkazy
Dokumentaci SDK knihovny MSDN: CreateProcess(); OBVYKLE struktury

Dědí vzorek v sadě Platform SDK pod Win32:
   \MSSDK\samples\winbase\ipc\inherit				
Dědičnost přesměrování přesměrovat stdhandles

Upozornění: Tento článek je přeložený automaticky

Vlastnosti

ID článku: 190351 - Poslední kontrola: 04/23/2011 10:33:00 - Revize: 9.0

Microsoft Win32 Application Programming Interface

  • kbapi kbconsole kbFAQ kbhowto kbipc kbkernbase kbmt KB190351 KbMtcs
Váš názor
ePV = 1; var varClickTracking = 1; var varCustomerTracking = 1; var Route = "76500"; var Ctrl = ""; document.write(" tml>dy> track by $index" class="col-sm-6 col-xs-24 ng-scope"> Venezuela - Español
1.microsoft.com/c.gif?DI=4050&did=1&t="> did=1&t=">>ml> "//c.microsoft.com/ms.js'><\/script>"); &t=">>