Chinaunix首页 | 论坛 | 博客

爱飞的鱼henry.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

leibniz_zsu

  • 博客访问： 1695789
  • 博文数量： 584
  • 博客积分： 13857
  • 博客等级： 上将
  • 技术积分： 11883
  • 用 户 组： 普通用户
  • 注册时间： 2009-12-16 09:34
文章分类

全部博文（584）

推荐博文
相关博文
与CreateProcess()交互执行

分类： WINDOWS

2011-04-19 14:36:06

CreatePipe创建的是匿名管道，匿名管道数据只能单向流动，所以如果要能对子进程输入数据也能读出执行结果，就是创建两个匿名管道了，一个用来输 入数据到子进程，一个用来从子进程中读出数据。CreatePipe分别有两个HANDLE的读写句柄，把这两个管道的读写句柄分别用在 CreateProcess()的STARTINFO的参数上，然后创建进程就可以了。


  1. HANDLE hSTDINWrite,hSTDINRead,hSTDINWriteup; //用于重定向子进程输入的句柄
  2. HANDLE hSTDOUTWrite,hSTDOUTRead, hSTDOUTReadup; //用于重定向子进程输出的句柄
  3. SECURITY_ATTRIBUTES sa;

  5. sa.bInheritHandle = true;
  6. sa.lpSecurityDescriptor = NULL;
  7. sa.nLength = sizeof(sa);
  8. //创建子进程输出匿名管道
  9. if( !CreatePipe(&hSTDOUTRead, &hSTDOUTWrite, &sa,0) )
  10. {
  11. AfxMessageBox( "Create STDOUT pipe failed ");
  12. return 0;
  13. }

  15. if( !DuplicateHandle( ::GetCurrentProcess(), hSTDOUTRead, ::GetCurrentProcess(), &hSTDOUTReadup, 0, false,DUPLICATE_SAME_ACCESS) )
  16. {
  17. AfxMessageBox( "DuplicateHandle failed ");
  18. return 0;
  19. }
  20. ::CloseHandle( hSTDOUTRead );

  22. //创建子进程输入匿名管道
  23. if( !CreatePipe(&hSTDINRead, &hSTDINWrite, &sa,0) )
  24. {
  25. AfxMessageBox( "Create STDIN pipe failed ");
  26. return 0;
  27. }
  28. if( !DuplicateHandle( ::GetCurrentProcess(), hSTDINWrite, ::GetCurrentProcess(), &hSTDINWriteup, 0, false,DUPLICATE_SAME_ACCESS) )
  29. {
  30. AfxMessageBox( "DuplicateHandle failed ");
  31. return 0;
  32. }
  33. ::CloseHandle( hSTDINWrite );


  36. CTestpipeDlg *pDlg = (CTestpipeDlg *)lpData;
  37. PROCESS_INFORMATION pi;
  38. STARTUPINFO si;
  39. ZeroMemory( &si, sizeof(si));


  42. si.cb = sizeof(STARTUPINFO);
  43. si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
  44. si.wShowWindow = SW_HIDE;
  45. si.hStdInput = hSTDINRead; //重定向子进程输入
  46. si.hStdOutput = hSTDOUTWrite; //重定向子进程输入
  47. si.hStdError = GetStdHandle( STD_ERROR_HANDLE );
  48. if( !::CreateProcess(NULL, (char *)(LPCSTR)pDlg-> m_strCmd, NULL, NULL, true, 0,NULL,NULL,&si,&pi) )
  49. {
  50. AfxMessageBox( "create process failed ");
  51. return 0;
  52. }

  54. char strData[1024];
  55. const char *strIn = "2 3\n2 4\n4 67\n0 0\n ";
  56. pDlg-> m_strOut = " ";
  57. ::SendMessage(pDlg-> m_hWnd, WM_UPDATE_MYDATA,0,0);
  58. DWORD dwBytes = 0;

  60. ::CloseHandle( hSTDINRead );
  61.                   //将数据写入子进程，我在子进程中进行的是对strIn的每两个数进行相加操作
  62. ::WriteFile( hSTDINWriteup, strIn, strlen(strIn), &dwBytes, NULL);

  64. //在调用ReadFile前必须关闭该句柄，否则由于父进程的管道写入端有未关闭的Write句柄，ReadFile最后无法返回0
  65. ::CloseHandle( hSTDOUTWrite );

  67. //从子进程中读出执行结果
  68. while( ::ReadFile( hSTDOUTReadup, strData, sizeof(strData), &dwBytes, NULL) )
  69. {
  70. strData[dwBytes] = '\0 ';
  71. pDlg-> m_strOut += strData;
  72. ::SendMessage(pDlg-> m_hWnd, WM_UPDATE_MYDATA,0,0);
  73. }


  76. ::WaitForSingleObject( pi.hProcess, INFINITE);
  77. ::CloseHandle( hSTDOUTReadup );
  78. ::CloseHandle( hSTDINWriteup );
  79. ::CloseHandle(pi.hProcess);
  80. ::CloseHandle(pi.hThread);


  1. //网上抄来的,供参考
  2. /*++

  4.             Copyright (c) 1998 Microsoft Corporation

  6.             Module Name:

  8.                   Redirect.c

  10.             Description:
  11.                     This sample illustrates how to spawn a child console based
  12.                     application with redirected standard handles.

  14.                     The following import libraries are required:
  15.                     user32.lib

  17.             Dave McPherson (davemm) 11-March-98

  19.       --*/

  21.       #include <windows.h>

  23.       void DisplayError(char *pszAPI);
  24.       void ReadAndHandleOutput(HANDLE hPipeRead);
  25.       void PrepAndLaunchRedirectedChild(HANDLE hChildStdOut,
  26.                                                                           HANDLE hChildStdIn,
  27.                                                                           HANDLE hChildStdErr);
  28.       DWORD WINAPI GetAndSendInputThread(LPVOID lpvThreadParam);

  30.       HANDLE hChildProcess = NULL;
  31.       HANDLE hStdIn = NULL; // Handle to parents std input.
  32.       BOOL bRunThread = TRUE;


  35.       void main ()
  36.       {
  37.             HANDLE hOutputReadTmp,hOutputRead,hOutputWrite;
  38.             HANDLE hInputWriteTmp,hInputRead,hInputWrite;
  39.             HANDLE hErrorWrite;
  40.             HANDLE hThread;
  41.             DWORD ThreadId;
  42.             SECURITY_ATTRIBUTES sa;


  45.             // Set up the security attributes struct.
  46.             sa.nLength= sizeof(SECURITY_ATTRIBUTES);
  47.             sa.lpSecurityDescriptor = NULL;
  48.             sa.bInheritHandle = TRUE;


  51.             // Create the child output pipe.
  52.             if (!CreatePipe(&hOutputReadTmp,&hOutputWrite,&sa,0))
  53.                   DisplayError( "CreatePipe ");


  56.             // Create a duplicate of the output write handle for the std error
  57.             // write handle. This is necessary in case the child application
  58.             // closes one of its std output handles.
  59.             if (!DuplicateHandle(GetCurrentProcess(),hOutputWrite,
  60.                                                       GetCurrentProcess(),&hErrorWrite,0,
  61.                                                       TRUE,DUPLICATE_SAME_ACCESS))
  62.                   DisplayError( "DuplicateHandle ");


  65.             // Create the child input pipe.
  66.             if (!CreatePipe(&hInputRead,&hInputWriteTmp,&sa,0))
  67.                   DisplayError( "CreatePipe ");


  70.             // Create new output read handle and the input write handles. Set
  71.             // the Properties to FALSE. Otherwise, the child inherits the
  72.             // properties and, as a result, non-closeable handles to the pipes
  73.             // are created.
  74.             if (!DuplicateHandle(GetCurrentProcess(),hOutputReadTmp,
  75.                                                       GetCurrentProcess(),
  76.                                                       &hOutputRead, // Address of new handle.
  77.                                                       0,FALSE, // Make it uninheritable.
  78.                                                       DUPLICATE_SAME_ACCESS))
  79.                   DisplayError( "DupliateHandle ");

  81.             if (!DuplicateHandle(GetCurrentProcess(),hInputWriteTmp,
  82.                                                       GetCurrentProcess(),
  83.                                                       &hInputWrite, // Address of new handle.
  84.                                                       0,FALSE, // Make it uninheritable.
  85.                                                       DUPLICATE_SAME_ACCESS))
  86.             DisplayError( "DupliateHandle ");


  89.             // Close inheritable copies of the handles you do not want to be
  90.             // inherited.
  91.             if (!CloseHandle(hOutputReadTmp)) DisplayError( "CloseHandle ");
  92.             if (!CloseHandle(hInputWriteTmp)) DisplayError( "CloseHandle ");


  95.             // Get std input handle so you can close it and force the ReadFile to
  96.             // fail when you want the input thread to exit.
  97.             if ( (hStdIn = GetStdHandle(STD_INPUT_HANDLE)) ==
  98.                                                                                                 INVALID_HANDLE_VALUE )
  99.                   DisplayError( "GetStdHandle ");

  101.             PrepAndLaunchRedirectedChild(hOutputWrite,hInputRead,hErrorWrite);


  104.             // Close pipe handles (do not continue to modify the parent).
  105.             // You need to make sure that no handles to the write end of the
  106.             // output pipe are maintained in this process or else the pipe will
  107.             // not close when the child process exits and the ReadFile will hang.
  108.             if (!CloseHandle(hOutputWrite)) DisplayError( "CloseHandle ");
  109.             if (!CloseHandle(hInputRead )) DisplayError( "CloseHandle ");
  110.             if (!CloseHandle(hErrorWrite)) DisplayError( "CloseHandle ");


  113.             // Launch the thread that gets the input and sends it to the child.
  114.             hThread = CreateThread(NULL,0,GetAndSendInputThread,
  115.                                                             (LPVOID)hInputWrite,0,&ThreadId);
  116.             if (hThread == NULL) DisplayError( "CreateThread ");


  119.             // Read the child 's output.
  120.             ReadAndHandleOutput(hOutputRead);
  121.             // Redirection is complete


  124.             // Force the read on the input to return by closing the stdin handle.
  125.             if (!CloseHandle(hStdIn)) DisplayError( "CloseHandle ");


  128.             // Tell the thread to exit and wait for thread to die.
  129.             bRunThread = FALSE;

  131.             if (WaitForSingleObject(hThread,INFINITE) == WAIT_FAILED)
  132.                   DisplayError( "WaitForSingleObject ");

  134.             if (!CloseHandle(hOutputRead)) DisplayError( "CloseHandle ");
  135.             if (!CloseHandle(hInputWrite)) DisplayError( "CloseHandle ");
  136.       }


  139.       ///////////////////////////////////////////////////////////////////////
  140.       // PrepAndLaunchRedirectedChild
  141.       // Sets up STARTUPINFO structure, and launches redirected child.
  142.       ///////////////////////////////////////////////////////////////////////
  143.       void PrepAndLaunchRedirectedChild(HANDLE hChildStdOut,
  144.                                                                           HANDLE hChildStdIn,
  145.                                                                           HANDLE hChildStdErr)
  146.       {
  147.             PROCESS_INFORMATION pi;
  148.             STARTUPINFO si;

  150.             // Set up the start up info struct.
  151.             ZeroMemory(&si,sizeof(STARTUPINFO));
  152.             si.cb = sizeof(STARTUPINFO);
  153.             si.dwFlags = STARTF_USESTDHANDLES;
  154.             si.hStdOutput = hChildStdOut;
  155.             si.hStdInput = hChildStdIn;
  156.             si.hStdError = hChildStdErr;
  157.             // Use this if you want to hide the child:
  158.             // si.wShowWindow = SW_HIDE;
  159.             // Note that dwFlags must include STARTF_USESHOWWINDOW if you want to
  160.             // use the wShowWindow flags.


  163.             // Launch the process that you want to redirect (in this case,
  164.             // Child.exe). Make sure Child.exe is in the same directory as
  165.             // redirect.c launch redirect from a command line to prevent location
  166.             // confusion.
  167.             if (!CreateProcess(NULL, "d:\\winnt\\system32\\cmd.exe ",NULL,NULL,TRUE,
  168.                                                   CREATE_NEW_CONSOLE,NULL,NULL,&si,&pi))
  169.                   DisplayError( "CreateProcess ");


  172.             // Set global child process handle to cause threads to exit.
  173.             hChildProcess = pi.hProcess;


  176.             // Close any unnecessary handles.
  177.             if (!CloseHandle(pi.hThread)) DisplayError( "CloseHandle ");
  178.       }


  181.       ///////////////////////////////////////////////////////////////////////
  182.       // ReadAndHandleOutput
  183.       // Monitors handle for input. Exits when child exits or pipe breaks.
  184.       ///////////////////////////////////////////////////////////////////////
  185.       void ReadAndHandleOutput(HANDLE hPipeRead)
  186.       {
  187.             CHAR lpBuffer[256];
  188.             DWORD nBytesRead;
  189.             DWORD nCharsWritten;

  191.             while(TRUE)
  192.             {
  193.                   if (!ReadFile(hPipeRead,lpBuffer,sizeof(lpBuffer),
  194.                                                                                     &nBytesRead,NULL) || !nBytesRead)
  195.                   {
  196.                         if (GetLastError() == ERROR_BROKEN_PIPE)
  197.                               break; // pipe done - normal exit path.
  198.                         else
  199.                               DisplayError( "ReadFile "); // Something bad happened.
  200.                   }

  202.                   // Display the character read on the screen.
  203.                   if (!WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),lpBuffer,
  204.                                                       nBytesRead,&nCharsWritten,NULL))
  205.                         DisplayError( "WriteConsole ");
  206.             }
  207.       }



  1. ///////////////////////////////////////////////////////////////////////
  2.       // GetAndSendInputThread
  3.       // Thread procedure that monitors the console for input and sends input
  4.       // to the child process through the input pipe.
  5.       // This thread ends when the child application exits.
  6.       ///////////////////////////////////////////////////////////////////////
  7.       DWORD WINAPI GetAndSendInputThread(LPVOID lpvThreadParam)
  8.       {
  9.             CHAR read_buff[256];
  10.             DWORD nBytesRead,nBytesWrote;
  11.             HANDLE hPipeWrite = (HANDLE)lpvThreadParam;

  13.             // Get input from our console and send it to child through the pipe.
  14.             while (bRunThread)
  15.             {
  16.                   if(!ReadConsole(hStdIn,read_buff,1,&nBytesRead,NULL))
  17.                         DisplayError( "ReadConsole ");

  19.                   read_buff[nBytesRead] = '\0 '; // Follow input with a NULL.

  21.                   if (!WriteFile(hPipeWrite,read_buff,nBytesRead,&nBytesWrote,NULL))
  22.                   {
  23.                         if (GetLastError() == ERROR_NO_DATA)
  24.                               break; // Pipe was closed (normal exit path).
  25.                         else
  26.                         DisplayError( "WriteFile ");
  27.                   }
  28.             }

  30.             return 1;
  31.       }


  34.       ///////////////////////////////////////////////////////////////////////
  35.       // DisplayError
  36.       // Displays the error number and corresponding message.
  37.       ///////////////////////////////////////////////////////////////////////
  38.       void DisplayError(char *pszAPI)
  39.       {
  40.               LPVOID lpvMessageBuffer;
  41.               CHAR szPrintBuffer[512];
  42.               DWORD nCharsWritten;

  44.               FormatMessage(
  45.                                 FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
  46.                                 NULL, GetLastError(),
  47.                                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  48.                                 (LPTSTR)&lpvMessageBuffer, 0, NULL);

  50.               wsprintf(szPrintBuffer,
  51.                   "ERROR: API = %s.\n error code = %d.\n message = %s.\n ",
  52.                                 pszAPI, GetLastError(), (char *)lpvMessageBuffer);

  54.               WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),szPrintBuffer,
  55.                                           lstrlen(szPrintBuffer),&nCharsWritten,NULL);

  57.               LocalFree(lpvMessageBuffer);
  58.               ExitProcess(GetLastError());
  59.       }

  1. http://www.codeguru.com/Cpp/W-D/console/redirection/article.php/c541/

  3. 这个是可以输入的（我没有用过输入部分）

  5. 对于 DOS 程序的输出，我认为这个程序是我见过的最好的了，希望对你有用 :)

  7. 文件只需要
  8.         Redirect.cpp
  9.         Redirect.h
  10. 可以派生，用着很好用。








阅读(2632) | 评论(0) | 转发(1) |
0

上一篇：关于ShellExecute的使用

下一篇：Creating Process with Redirected Input and Output

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6