开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbi_pipe.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：44k
源码类别：

生物技术

开发平台：

C/C++

ncbi_pipe.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbi_pipe.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 18:45:13  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.37
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbi_pipe.cpp,v 1000.4 2004/06/01 18:45:13 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Anton Lavrentiev, Mike DiCuccio, Vladimir Ivanov
  36.  *
  37.  *
  38.  */
  40. #include <ncbi_pch.hpp>
  41. #include <connect/ncbi_pipe.hpp>
  42. #include <corelib/ncbi_system.hpp>
  43. #include <memory>
  44. #include <stdio.h>
  46. #ifdef NCBI_OS_MSWIN
  47. #  include <windows.h>
  48. #elif defined NCBI_OS_UNIX
  49. #  include <unistd.h>
  50. #  include <errno.h>
  51. #  include <sys/time.h>
  52. #  include <sys/types.h>
  53. #  include <sys/wait.h>
  54. #  include <signal.h>
  55. #  include <fcntl.h>
  56. #  ifdef NCBI_COMPILER_MW_MSL
  57. #    include <ncbi_mslextras.h>
  58. #  endif
  59. #else
  60. #  error "Class CPipe is supported only on Windows and Unix"
  61. #endif
  64. BEGIN_NCBI_SCOPE
  67. // Sleep time for timeouts
  68. const unsigned int kSleepTime = 100;
  71. //////////////////////////////////////////////////////////////////////////////
  72. //
  73. // Auxiliary functions
  74. //
  76. #define IS_SET(flags, mask) (((flags) & (mask)) == (mask))
  79. static STimeout* s_SetTimeout(const STimeout* from, STimeout* to)
  80. {
  81.     if ( !from ) {
  82.         return const_cast<STimeout*>(kInfiniteTimeout);
  83.     }
  84.     to->sec  = from->usec / 1000000 + from->sec;
  85.     to->usec = from->usec % 1000000;
  86.     return to;
  87. }
  89. static string s_FormatErrorMessage(const string& where, const string& what)
  90. {
  91.     return "[CPipe::" + where + "]  " + what + ".";
  92. }
  95. //////////////////////////////////////////////////////////////////////////////
  96. //
  97. // Class CNamedPipeHandle handles forwarded requests from CPipe.
  98. // This class is reimplemented in a platform-specific fashion where needed.
  99. //
  101. #if defined(NCBI_OS_MSWIN)
  103. //////////////////////////////////////////////////////////////////////////////
  104. //
  105. // CPipeHandle -- MS Windows version
  106. //
  108. class CPipeHandle
  109. {
  110. public:
  111.     CPipeHandle();
  112.     ~CPipeHandle();
  113.     EIO_Status Open(const string& cmd, const vector<string>& args,
  114.                     CPipe::TCreateFlags create_flags);
  115.     EIO_Status Close(int* exitcode, const STimeout* timeout);
  116.     EIO_Status CloseHandle (CPipe::EChildIOHandle handle);
  117.     EIO_Status Read(void* buf, size_t count, size_t* n_read,
  118.                     const CPipe::EChildIOHandle from_handle,
  119.                     const STimeout* timeout);
  120.     EIO_Status Write(const void* buf, size_t count, size_t* written,
  121.                      const STimeout* timeout);
  122.     TProcessHandle GetProcessHandle(void) const { return m_ProcHandle; };
  124. private:
  125.     // Clear object state.
  126.     void x_Clear(void);
  127.     // Get child's I/O handle.
  128.     HANDLE x_GetHandle(CPipe::EChildIOHandle from_handle) const;
  129.     // Convert STimeout value to number of milliseconds.
  130.     long   x_TimeoutToMSec(const STimeout* timeout) const;
  131.     // Trigger blocking mode on specified I/O handle.
  132.     bool   x_SetNonBlockingMode(HANDLE fd, bool nonblock = true) const;
  134. private:
  135.     // I/O handles for child process.
  136.     HANDLE  m_ChildStdIn;
  137.     HANDLE  m_ChildStdOut;
  138.     HANDLE  m_ChildStdErr;
  140.     // Child process descriptor.
  141.     HANDLE  m_ProcHandle;
  142.     // Child process pid.
  143.     TPid    m_Pid;
  145.     // Pipe flags
  146.     CPipe::TCreateFlags m_Flags;
  147. };
  150. CPipeHandle::CPipeHandle()
  151.     : m_ProcHandle(INVALID_HANDLE_VALUE),
  152.       m_ChildStdIn(INVALID_HANDLE_VALUE),
  153.       m_ChildStdOut(INVALID_HANDLE_VALUE),
  154.       m_ChildStdErr(INVALID_HANDLE_VALUE),
  155.       m_Flags(0)
  156. {
  157.     return;
  158. }
  161. CPipeHandle::~CPipeHandle()
  162. {
  163.     static const STimeout kZeroTimeout = {0, 0};
  164.     Close(0, &kZeroTimeout);
  165.     x_Clear();
  166. }
  169. EIO_Status CPipeHandle::Open(const string&         cmd,
  170.                              const vector<string>& args,
  171.                              CPipe::TCreateFlags   create_flags)
  172. {
  173.     x_Clear();
  175.     bool need_restore_handles = false; 
  176.     m_Flags = create_flags;
  178.     HANDLE stdin_handle       = INVALID_HANDLE_VALUE;
  179.     HANDLE stdout_handle      = INVALID_HANDLE_VALUE;
  180.     HANDLE stderr_handle      = INVALID_HANDLE_VALUE;
  181.     HANDLE child_stdin_read   = INVALID_HANDLE_VALUE;
  182.     HANDLE child_stdin_write  = INVALID_HANDLE_VALUE;
  183.     HANDLE child_stdout_read  = INVALID_HANDLE_VALUE;
  184.     HANDLE child_stdout_write = INVALID_HANDLE_VALUE;
  185.     HANDLE child_stderr_read  = INVALID_HANDLE_VALUE;
  186.     HANDLE child_stderr_write = INVALID_HANDLE_VALUE;
  188.     try {
  189.         if (m_ProcHandle != INVALID_HANDLE_VALUE) {
  190.             throw string("Pipe is already open");
  191.         }
  193.         // Save current I/O handles
  194.         stdin_handle  = GetStdHandle(STD_INPUT_HANDLE);
  195.         stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
  196.         stderr_handle = GetStdHandle(STD_ERROR_HANDLE);
  197.         
  198.         // Flush std.output buffers before remap
  199.         FlushFileBuffers(stdout_handle);
  200.         FlushFileBuffers(stderr_handle);
  202.         // Set base security attributes
  203.         SECURITY_ATTRIBUTES attr;
  204.         attr.nLength = sizeof(attr);
  205.         attr.bInheritHandle = TRUE;
  206.         attr.lpSecurityDescriptor = NULL;
  208.         HANDLE current_process = GetCurrentProcess();
  209.         need_restore_handles = true; 
  211.         // Create pipe for child's stdin
  212.         assert(CPipe::fStdIn_Close);
  213.         if ( !IS_SET(create_flags, CPipe::fStdIn_Close) ) {
  214.             if ( !CreatePipe(&child_stdin_read,
  215.                              &child_stdin_write, &attr, 0) ) {
  216.                 throw string("CreatePipe() failed");
  217.             }
  218.             if ( !SetStdHandle(STD_INPUT_HANDLE, child_stdin_read) ) {
  219.                 throw string("Failed to remap stdin for child process");
  220.             }
  221.             // Duplicate the handle
  222.             if ( !DuplicateHandle(current_process, child_stdin_write,
  223.                                   current_process, &m_ChildStdIn,
  224.                                   0, FALSE, DUPLICATE_SAME_ACCESS) ) {
  225.                 throw string("DuplicateHandle() failed on "
  226.                              "child's stdin handle");
  227.             }
  228.             ::CloseHandle(child_stdin_write);
  229.             x_SetNonBlockingMode(m_ChildStdIn);
  230.         }
  232.         // Create pipe for child's stdout
  233.         assert(CPipe::fStdOut_Close);
  234.         if ( !IS_SET(create_flags, CPipe::fStdOut_Close) ) {
  235.             if ( !CreatePipe(&child_stdout_read,
  236.                              &child_stdout_write, &attr, 0)) {
  237.                 throw string("CreatePipe() failed");
  238.             }
  239.             if ( !SetStdHandle(STD_OUTPUT_HANDLE, child_stdout_write) ) {
  240.                 throw string("Failed to remap stdout for child process");
  241.             }
  242.             // Duplicate the handle
  243.             if ( !DuplicateHandle(current_process, child_stdout_read,
  244.                                   current_process, &m_ChildStdOut,
  245.                                   0, FALSE, DUPLICATE_SAME_ACCESS) ) {
  246.                 throw string("DuplicateHandle() failed on "
  247.                              "child's stdout handle");
  248.             }
  249.             ::CloseHandle(child_stdout_read);
  250.             x_SetNonBlockingMode(m_ChildStdOut);
  251.         }
  253.         // Create pipe for child's stderr
  254.         assert(CPipe::fStdErr_Open);
  255.         if ( IS_SET(create_flags, CPipe::fStdErr_Open) ) {
  256.             if ( !CreatePipe(&child_stderr_read,
  257.                              &child_stderr_write, &attr, 0)) {
  258.                 throw string("CreatePipe() failed");
  259.             }
  260.             if ( !SetStdHandle(STD_ERROR_HANDLE, child_stderr_write) ) {
  261.                 throw string("Failed to remap stderr for child process");
  262.             }
  263.             // Duplicate the handle
  264.             if ( !DuplicateHandle(current_process, child_stderr_read,
  265.                                   current_process, &m_ChildStdErr,
  266.                                   0, FALSE, DUPLICATE_SAME_ACCESS) ) {
  267.                 throw string("DuplicateHandle() failed on "
  268.                              "child's stderr handle");
  269.             }
  270.             ::CloseHandle(child_stderr_read);
  271.             x_SetNonBlockingMode(m_ChildStdErr);
  272.         }
  274.         // Prepare command line to run
  275.         string cmd_line(cmd);
  276.         ITERATE (vector<string>, iter, args) {
  277.             if ( !cmd_line.empty() ) {
  278.                 cmd_line += " ";
  279.             }
  280.             cmd_line += *iter;
  281.         }
  283.         // Create child process
  284.         PROCESS_INFORMATION pinfo;
  285.         STARTUPINFO sinfo;
  286.         ZeroMemory(&pinfo, sizeof(PROCESS_INFORMATION));
  287.         ZeroMemory(&sinfo, sizeof(STARTUPINFO));
  288.         sinfo.cb = sizeof(sinfo);
  290.         if ( !CreateProcess(NULL,
  291.                             const_cast<char*> (cmd_line.c_str()),
  292.                             NULL, NULL, TRUE, 0,
  293.                             NULL, NULL, &sinfo, &pinfo) ) {
  294.             throw "CreateProcess() for "" + cmd_line + "" failed";
  295.         }
  296.         ::CloseHandle(pinfo.hThread);
  297.         m_ProcHandle = pinfo.hProcess;
  298.         m_Pid        = pinfo.dwProcessId; 
  300.         assert(m_ProcHandle != INVALID_HANDLE_VALUE);
  302.         // Restore remapped handles back to their original states
  303.         if ( !SetStdHandle(STD_INPUT_HANDLE,  stdin_handle) ) {
  304.             throw string("Failed to remap stdin for parent process");
  305.         }
  306.         if ( !SetStdHandle(STD_OUTPUT_HANDLE, stdout_handle) ) {
  307.             throw string("Failed to remap stdout for parent process");
  308.         }
  309.         if ( !SetStdHandle(STD_ERROR_HANDLE,  stderr_handle) ) {
  310.             throw string("Failed to remap stderr for parent process");
  311.         }
  312.         // Close unused pipe handles
  313.         ::CloseHandle(child_stdin_read);
  314.         ::CloseHandle(child_stdout_write);
  315.         ::CloseHandle(child_stderr_write);
  317.         return eIO_Success;
  318.      }
  319.     catch (string& what) {
  320.         // Restore all standard handles on error
  321.         if ( need_restore_handles ) {
  322.             SetStdHandle(STD_INPUT_HANDLE,  stdin_handle);
  323.             SetStdHandle(STD_OUTPUT_HANDLE, stdout_handle);
  324.             SetStdHandle(STD_ERROR_HANDLE,  stderr_handle);
  326.             ::CloseHandle(child_stdin_read);
  327.             ::CloseHandle(child_stdin_write);
  328.             ::CloseHandle(child_stdout_read);
  329.             ::CloseHandle(child_stdout_write);
  330.             ::CloseHandle(child_stderr_read);
  331.             ::CloseHandle(child_stderr_write);
  332.         }
  333.         const STimeout kZeroZimeout = {0,0};
  334.         Close(0, &kZeroZimeout);
  335.         ERR_POST(s_FormatErrorMessage("Open", what));
  336.         return eIO_Unknown;
  337.     }
  338. }
  341. EIO_Status CPipeHandle::Close(int* exitcode, const STimeout* timeout)
  342. {
  343.     if (m_ProcHandle == INVALID_HANDLE_VALUE) {
  344.         return eIO_Closed;
  345.     }
  347.     DWORD      x_exitcode = -1;
  348.     EIO_Status status     = eIO_Unknown;
  350.     // Get exit code of child process
  351.     if ( GetExitCodeProcess(m_ProcHandle, &x_exitcode) ) {
  352.         if (x_exitcode == STILL_ACTIVE) {
  353.             // Wait for the child process to exit
  354.             DWORD ws = WaitForSingleObject(m_ProcHandle,
  355.                                            x_TimeoutToMSec(timeout));
  356.             if (ws == WAIT_OBJECT_0) {
  357.                 // Get exit code of child process over again
  358.                 if ( GetExitCodeProcess(m_ProcHandle, &x_exitcode) ) {
  359.                     status = (x_exitcode == STILL_ACTIVE) ? 
  360.                         eIO_Timeout : eIO_Success;
  361.                 }
  362.             } else if (ws == WAIT_TIMEOUT) {
  363.                 status = eIO_Timeout;
  364.             }
  365.         } else {
  366.             status = eIO_Success;
  367.         }
  368.     }
  370.     // Is the process running?
  371.     if (status == eIO_Timeout) {
  372.         x_exitcode = -1;
  373.         assert(CPipe::fKillOnClose);
  374.         if ( IS_SET(m_Flags, CPipe::fKillOnClose) ) {
  375.             status = CProcess(m_Pid, CProcess::ePid).Kill() ?
  376.                               eIO_Success : eIO_Unknown;
  377.         }
  378.         // Active by default.
  379.         assert(!CPipe::fCloseOnClose);
  380.         if ( !IS_SET(m_Flags, CPipe::fCloseOnClose) ) {
  381.             status = eIO_Success;
  382.         }
  383.         // fKeepOnClose -- nothing to do.
  384.         assert(CPipe::fKeepOnClose);
  385.     }
  387.     // Is the process still running? Nothing to do.
  388.     if (status != eIO_Timeout) {
  389.         x_Clear();
  390.     }
  391.     if ( exitcode ) {
  392.         *exitcode = (int) x_exitcode;
  393.     }
  394.     return status;
  395. }
  398. EIO_Status CPipeHandle::CloseHandle(CPipe::EChildIOHandle handle)
  399. {
  400.     switch (handle) {
  401.     case CPipe::eStdIn:
  402.         if (m_ChildStdIn == INVALID_HANDLE_VALUE) {
  403.             return eIO_Closed;
  404.         }
  405.         ::CloseHandle(m_ChildStdIn);
  406.         m_ChildStdIn = INVALID_HANDLE_VALUE;
  407.         break;
  408.     case CPipe::eStdOut:
  409.         if (m_ChildStdOut == INVALID_HANDLE_VALUE) {
  410.             return eIO_Closed;
  411.         }
  412.         ::CloseHandle(m_ChildStdOut);
  413.         m_ChildStdOut = INVALID_HANDLE_VALUE;
  414.         break;
  415.     case CPipe::eStdErr:
  416.         if (m_ChildStdErr == INVALID_HANDLE_VALUE) {
  417.             return eIO_Closed;
  418.         }
  419.         ::CloseHandle(m_ChildStdErr);
  420.         m_ChildStdErr = INVALID_HANDLE_VALUE;
  421.         break;
  422.     default:
  423.         return eIO_InvalidArg;
  424.     }
  425.     return eIO_Success;
  426. }
  429. EIO_Status CPipeHandle::Read(void* buf, size_t count, size_t* read, 
  430.                              const CPipe::EChildIOHandle from_handle,
  431.                              const STimeout* timeout)
  432. {
  433.     EIO_Status status = eIO_Unknown;
  435.     try {
  436.         if (m_ProcHandle == INVALID_HANDLE_VALUE) {
  437.             status = eIO_Closed;
  438.             throw string("Pipe is closed");
  439.         }
  440.         HANDLE fd = x_GetHandle(from_handle);
  441.         if (fd == INVALID_HANDLE_VALUE) {
  442.             throw string("Pipe I/O handle is closed");
  443.         }
  444.         if ( !count ) {
  445.             return eIO_Success;
  446.         }
  448.         DWORD x_timeout   = x_TimeoutToMSec(timeout);
  449.         DWORD bytes_avail = 0;
  450.         DWORD bytes_read  = 0;
  452.         // Wait for data from the pipe with timeout.
  453.         // NOTE:  The function WaitForSingleObject() does not work with pipes.
  454.         do {
  455.             if ( !PeekNamedPipe(fd, NULL, 0, NULL, &bytes_avail, NULL) ) {
  456.                 // Has peer closed the connection?
  457.                 if (GetLastError() == ERROR_BROKEN_PIPE) {
  458.                     return eIO_Closed;
  459.                 }
  460.                 throw string("PeekNamedPipe() failed");
  461.             }
  462.             if ( bytes_avail ) {
  463.                 break;
  464.             }
  465.             DWORD x_sleep = kSleepTime;
  466.             if (x_timeout != INFINITE) {
  467.                 if (x_timeout < kSleepTime) {
  468.                     x_sleep = x_timeout;
  469.                 }
  470.                 x_timeout -= x_sleep;
  471.             }
  472.             SleepMilliSec(x_sleep);
  473.         } while (x_timeout == INFINITE  ||  x_timeout);
  475.         // Data is available to read or read request has timed out
  476.         if ( !bytes_avail ) {
  477.             return eIO_Timeout;
  478.         }
  479.         // We must read only "count" bytes of data regardless of
  480.         // the amount available to read
  481.         if (bytes_avail > count) {
  482.             bytes_avail = count;
  483.         }
  484.         if ( !ReadFile(fd, buf, count, &bytes_avail, NULL) ) {
  485.             throw string("Failed to read data from pipe");
  486.         }
  487.         if ( read ) {
  488.             *read = bytes_avail;
  489.         }
  490.         status = eIO_Success;
  491.     }
  492.     catch (string& what) {
  493.         ERR_POST(s_FormatErrorMessage("Read", what));
  494.     }
  495.     return status;
  496. }
  499. EIO_Status CPipeHandle::Write(const void* buf, size_t count,
  500.                               size_t* n_written, const STimeout* timeout)
  502. {
  503.     EIO_Status status = eIO_Unknown;
  505.     try {
  506.         if (m_ProcHandle == INVALID_HANDLE_VALUE) {
  507.             status = eIO_Closed;
  508.             throw string("Pipe is closed");
  509.         }
  510.         if (m_ChildStdIn == INVALID_HANDLE_VALUE) {
  511.             throw string("Pipe I/O handle is closed");
  512.         }
  513.         if ( !count ) {
  514.             return eIO_Success;
  515.         }
  517.         DWORD x_timeout     = x_TimeoutToMSec(timeout);
  518.         DWORD bytes_written = 0;
  520.         // Wait for data from the pipe with timeout.
  521.         // NOTE:  The function WaitForSingleObject() does not work with pipes.
  522.         do {
  523.             if ( !WriteFile(m_ChildStdIn, (char*)buf, count,
  524.                            &bytes_written, NULL) ) {
  525.                 if ( n_written ) {
  526.                     *n_written = bytes_written;
  527.                 }
  528.                 throw string("Failed to write data into pipe");
  529.             }
  530.             if ( bytes_written ) {
  531.                 break;
  532.             }
  533.             DWORD x_sleep = kSleepTime;
  534.             if (x_timeout != INFINITE) {
  535.                 if (x_timeout < kSleepTime) {
  536.                     x_sleep = x_timeout;
  537.                 }
  538.                 x_timeout -= x_sleep;
  539.             }
  540.             SleepMilliSec(x_sleep);
  541.         } while (x_timeout == INFINITE  ||  x_timeout);
  543.         if ( !bytes_written ) {
  544.             return eIO_Timeout;
  545.         }
  546.         if ( n_written ) {
  547.             *n_written = bytes_written;
  548.         }
  549.         status = eIO_Success;
  550.     }
  551.     catch (string& what) {
  552.         ERR_POST(s_FormatErrorMessage("Write", what));
  553.     }
  554.     return status;
  555. }
  558. void CPipeHandle::x_Clear(void)
  559. {
  560.     if (m_ChildStdIn != INVALID_HANDLE_VALUE) {
  561.         ::CloseHandle(m_ChildStdIn);
  562.         m_ChildStdIn = INVALID_HANDLE_VALUE;
  563.     }
  564.     if (m_ChildStdOut != INVALID_HANDLE_VALUE) {
  565.         ::CloseHandle(m_ChildStdOut);
  566.         m_ChildStdOut = INVALID_HANDLE_VALUE;
  567.     }
  568.     if (m_ChildStdErr != INVALID_HANDLE_VALUE) {
  569.         ::CloseHandle(m_ChildStdErr);
  570.         m_ChildStdErr = INVALID_HANDLE_VALUE;
  571.     }
  572.     m_ProcHandle = INVALID_HANDLE_VALUE;
  573.     m_Pid = 0;
  574. }
  577. HANDLE CPipeHandle::x_GetHandle(CPipe::EChildIOHandle from_handle) const
  578. {
  579.     switch (from_handle) {
  580.     case CPipe::eStdIn:
  581.         return m_ChildStdIn;
  582.     case CPipe::eStdOut:
  583.         return m_ChildStdOut;
  584.     case CPipe::eStdErr:
  585.         return m_ChildStdErr;
  586.     }
  587.     return INVALID_HANDLE_VALUE;
  588. }
  591. long CPipeHandle::x_TimeoutToMSec(const STimeout* timeout) const
  592. {
  593.     return timeout ? (timeout->sec * 1000) + (timeout->usec / 1000) 
  594.         : INFINITE;
  595. }
  598. bool CPipeHandle::x_SetNonBlockingMode(HANDLE fd, bool nonblock) const
  599. {
  600.     // Pipe is in the byte-mode.
  601.     // NOTE: We cannot get a state of a pipe handle opened for writing.
  602.     //       We cannot set a state of a pipe handle opened for reading.
  603.     DWORD state = nonblock ? PIPE_READMODE_BYTE | PIPE_NOWAIT :
  604.         PIPE_READMODE_BYTE;
  605.     return SetNamedPipeHandleState(fd, &state, NULL, NULL) != 0; 
  606. }
  609. #elif defined(NCBI_OS_UNIX)
  613. //////////////////////////////////////////////////////////////////////////////
  614. //
  615. // CPipeHandle -- Unix version
  616. //
  618. class CPipeHandle
  619. {
  620. public:
  621.     CPipeHandle();
  622.     ~CPipeHandle();
  623.     EIO_Status Open(const string& cmd, const vector<string>& args,
  624.                     CPipe::TCreateFlags create_flags);
  625.     EIO_Status Close(int* exitcode, const STimeout* timeout);
  626.     EIO_Status CloseHandle (CPipe::EChildIOHandle handle);
  627.     EIO_Status Read(void* buf, size_t count, size_t* read,
  628.                     const CPipe::EChildIOHandle from_handle,
  629.                     const STimeout* timeout);
  630.     EIO_Status Write(const void* buf, size_t count, size_t* written,
  631.                      const STimeout* timeout);
  632.     TProcessHandle GetProcessHandle(void) const { return m_Pid; };
  634. private:
  635.     // Clear object state.
  636.     void x_Clear(void);
  637.     // Get child's I/O handle.
  638.     int  x_GetHandle(CPipe::EChildIOHandle from_handle) const;
  639.     // Trigger blocking mode on specified I/O handle.
  640.     bool x_SetNonBlockingMode(int fd, bool nonblock = true) const;
  641.     // Wait on the file descriptor I/O.
  642.     // Return eIO_Success when "fd" is found ready for the I/O.
  643.     // Return eIO_Timeout, if timeout expired before I/O became available.
  644.     // Throw an exception on error.
  645.     EIO_Status x_Wait(int fd, EIO_Event direction,
  646.                       const STimeout* timeout) const;
  648. private:
  649.     // I/O handles for child process.
  650.     int  m_ChildStdIn;
  651.     int  m_ChildStdOut;
  652.     int  m_ChildStdErr;
  654.     // Child process pid.
  655.     TPid m_Pid;
  657.     // Pipe flags
  658.     CPipe::TCreateFlags m_Flags;
  659. };
  662. CPipeHandle::CPipeHandle()
  663.     : m_ChildStdIn(-1), m_ChildStdOut(-1), m_ChildStdErr(-1),
  664.       m_Pid((pid_t)(-1)), m_Flags(0)
  665. {
  666.     return;
  667. }
  670. CPipeHandle::~CPipeHandle()
  671. {
  672.     static const STimeout kZeroTimeout = {0, 0};
  673.     Close(0, &kZeroTimeout);
  674.     x_Clear();
  675. }
  678. EIO_Status CPipeHandle::Open(const string&         cmd,
  679.                              const vector<string>& args,
  680.                              CPipe::TCreateFlags   create_flags)
  681. {
  682.     x_Clear();
  684.     bool need_delete_handles = false; 
  685.     int  fd_pipe_in[2], fd_pipe_out[2], fd_pipe_err[2];
  687.     m_Flags = create_flags;
  689.     // Child process I/O handles
  690.     fd_pipe_in[0]  = -1;
  691.     fd_pipe_out[1] = -1;
  692.     fd_pipe_err[1] = -1;
  694.     try {
  695.         if (m_Pid != (pid_t)(-1)) {
  696.             throw string("Pipe is already open");
  697.         }
  698.         need_delete_handles = true; 
  700.         // Create pipe for child's stdin
  701.         assert(CPipe::fStdIn_Close);
  702.         if ( !IS_SET(create_flags, CPipe::fStdIn_Close) ) {
  703.             if (pipe(fd_pipe_in) == -1) {
  704.                 throw string("Failed to create pipe for stdin");
  705.             }
  706.             m_ChildStdIn = fd_pipe_in[1];
  707.             x_SetNonBlockingMode(m_ChildStdIn);
  708.         }
  709.         // Create pipe for child's stdout
  710.         assert(CPipe::fStdOut_Close);
  711.         if ( !IS_SET(create_flags, CPipe::fStdOut_Close) ) {
  712.             if (pipe(fd_pipe_out) == -1) {
  713.                 throw string("Failed to create pipe for stdout");
  714.             }
  715.             fflush(stdout);
  716.             m_ChildStdOut = fd_pipe_out[0];
  717.             x_SetNonBlockingMode(m_ChildStdOut);
  718.         }
  719.         // Create pipe for child's stderr
  720.         assert(CPipe::fStdErr_Open);
  721.         if ( IS_SET(create_flags, CPipe::fStdErr_Open) ) {
  722.             if (pipe(fd_pipe_err) == -1) {
  723.                 throw string("Failed to create pipe for stderr");
  724.             }
  725.             fflush(stderr);
  726.             m_ChildStdErr = fd_pipe_err[0];
  727.             x_SetNonBlockingMode(m_ChildStdErr);
  728.         }
  730.         // Fork child process
  731.         switch (m_Pid = fork()) {
  732.         case (pid_t)(-1):
  733.             // Fork failed
  734.             throw string("Failed to fork process");
  735.         case 0:
  736.             // Now we are in the child process
  737.             int status = -1;
  739.             // Bind child's standard I/O file handles to pipe
  740.             assert(CPipe::fStdIn_Close);
  741.             if ( !IS_SET(create_flags, CPipe::fStdIn_Close) ) {
  742.                 if (dup2(fd_pipe_in[0], STDIN_FILENO) < 0) {
  743.                     _exit(status);
  744.                 }
  745.                 close(fd_pipe_in[0]);
  746.                 close(fd_pipe_in[1]);
  747.             } else {
  748.                 fclose(stdin);
  749.             }
  750.             assert(CPipe::fStdOut_Close);
  751.             if ( !IS_SET(create_flags, CPipe::fStdOut_Close) ) {
  752.                 if (dup2(fd_pipe_out[1], STDOUT_FILENO) < 0) {
  753.                     _exit(status);
  754.                 }
  755.                 close(fd_pipe_out[0]);
  756.                 close(fd_pipe_out[1]);
  757.             } else {
  758.                 fclose(stdout);
  759.             }
  760.             assert(!CPipe::fStdErr_Close);
  761.             if ( IS_SET(create_flags, CPipe::fStdErr_Open) ) {
  762.                 if (dup2(fd_pipe_err[1], STDERR_FILENO) < 0) {
  763.                     _exit(status);
  764.                 }
  765.                 close(fd_pipe_err[0]);
  766.                 close(fd_pipe_err[1]);
  767.             } else {
  768.                 fclose(stderr);
  769.             }
  771.             // Prepare program arguments
  772.             size_t cnt = args.size();
  773.             size_t i   = 0;
  774.             const char** x_args = new const char*[cnt + 2];
  775.             typedef ArrayDeleter<const char*> TArgsDeleter;
  776.             AutoPtr<const char*, TArgsDeleter> p_args = x_args;
  777.             ITERATE (vector<string>, arg, args) {
  778.                 x_args[++i] = arg->c_str();
  779.             }
  780.             x_args[0] = cmd.c_str();
  781.             x_args[cnt + 1] = 0;
  783.             // Execute the program
  784.             status = execvp(cmd.c_str(), const_cast<char**> (x_args));
  785.             _exit(status);
  786.         }
  788.         // Close unused pipe handles
  789.         assert(CPipe::fStdIn_Close);
  790.         if ( !IS_SET(create_flags, CPipe::fStdIn_Close) ) {
  791.             close(fd_pipe_in[0]);
  792.         }
  793.         assert(CPipe::fStdOut_Close);
  794.         if ( !IS_SET(create_flags, CPipe::fStdOut_Close) ) {
  795.             close(fd_pipe_out[1]);
  796.         }
  797.         assert(!CPipe::fStdErr_Close);
  798.         if ( IS_SET(create_flags, CPipe::fStdErr_Open) ) {
  799.             close(fd_pipe_err[1]);
  800.         }
  801.         return eIO_Success;
  802.     } 
  803.     catch (string& what) {
  804.         if ( need_delete_handles ) {
  805.             close(fd_pipe_in[0]);
  806.             close(fd_pipe_out[1]);
  807.             close(fd_pipe_err[1]);
  808.         }
  809.         // Close all opened file descriptors (close timeout doesn't apply here)
  810.         Close(0, 0);
  811.         ERR_POST(s_FormatErrorMessage("Open", what));
  812.         return eIO_Unknown;
  813.     }
  814. }
  817. EIO_Status CPipeHandle::Close(int* exitcode, const STimeout* timeout)
  818. {    
  819.     EIO_Status    status     = eIO_Unknown;
  820.     unsigned long x_timeout  = 1;
  821.     int           x_options  = 0;
  822.     int           x_exitcode = -1;
  824.     if (m_Pid == (pid_t)(-1)) {
  825.         status = eIO_Closed;
  826.     } else {
  827.         // If timeout is not infinite
  828.         if ( timeout ) {
  829.             x_timeout = (timeout->sec * 1000) + (timeout->usec / 1000);
  830.             x_options = WNOHANG;
  831.         }
  833.         // Retry if interrupted by signal
  834.         for (;;) {
  835.             pid_t ws = waitpid(m_Pid, &x_exitcode, x_options);
  836.             if (ws > 0) {
  837.                 // Process has terminated
  838.                 status = eIO_Success;
  839.                 break;
  840.             } else if (ws == 0) {
  841.                 // Process is still running
  842.                 assert(timeout);
  843.                 if ( !x_timeout ) {
  844.                     status = eIO_Timeout;
  845.                     break;
  846.                 }
  847.                 unsigned long x_sleep = kSleepTime;
  848.                 if (x_timeout < kSleepTime) {
  849.                     x_sleep = x_timeout;
  850.                 }
  851.                 x_timeout -= x_sleep;
  852.                 SleepMilliSec(x_sleep);
  853.             } else {
  854.                 // Some error
  855.                 if (errno != EINTR) {
  856.                     break;
  857.                 }
  858.             }
  859.         }
  860.     }
  862.     // Is the process running?
  863.     if (status == eIO_Timeout) {
  864.         x_exitcode = -1;
  865.         assert(CPipe::fKillOnClose);
  866.         if ( IS_SET(m_Flags, CPipe::fKillOnClose) ) {
  867.             status = CProcess(m_Pid, CProcess::ePid).Kill() ?
  868.                               eIO_Success : eIO_Unknown;
  869.         }
  870.         // Active by default.
  871.         assert(!CPipe::fCloseOnClose);
  872.         if ( !IS_SET(m_Flags, CPipe::fCloseOnClose) ) {
  873.             status = eIO_Success;
  874.         }
  875.         // fKeepOnClose -- nothing to do.
  876.         assert(CPipe::fKeepOnClose);
  877.     }
  879.     // Is the process still running? Nothing to do.
  880.     if (status != eIO_Timeout) {
  881.         x_Clear();
  882.     }
  883.     if ( exitcode ) {
  884.         // Get real exit code or -1 on error
  885.         *exitcode = (status == eIO_Success  &&  x_exitcode != -1) ?
  886.             WEXITSTATUS(x_exitcode) : -1;
  887.     }
  888.     return status;
  889. }
  892. EIO_Status CPipeHandle::CloseHandle(CPipe::EChildIOHandle handle)
  893. {
  894.     switch ( handle ) {
  895.     case CPipe::eStdIn:
  896.         if (m_ChildStdIn == -1) {
  897.             return eIO_Closed;
  898.         }
  899.         close(m_ChildStdIn);
  900.         m_ChildStdIn = -1;
  901.         break;
  902.     case CPipe::eStdOut:
  903.         if (m_ChildStdOut == -1) {
  904.             return eIO_Closed;
  905.         }
  906.         close(m_ChildStdOut);
  907.         m_ChildStdOut = -1;
  908.         break;
  909.     case CPipe::eStdErr:
  910.         if (m_ChildStdErr == -1) {
  911.             return eIO_Closed;
  912.         }
  913.         close(m_ChildStdErr);
  914.         m_ChildStdErr = -1;
  915.         break;
  916.     default:
  917.         return eIO_InvalidArg;
  918.     }
  919.     return eIO_Success;
  920. }
  923. EIO_Status CPipeHandle::Read(void* buf, size_t count, size_t* n_read, 
  924.                              const CPipe::EChildIOHandle from_handle,
  925.                              const STimeout* timeout)
  926. {
  927.     EIO_Status status = eIO_Unknown;
  929.     try {
  930.         if (m_Pid == (pid_t)(-1)) {
  931.             status = eIO_Closed;
  932.             throw string("Pipe is closed");
  933.         }
  934.         int fd = x_GetHandle(from_handle);
  935.         if (fd == -1) {
  936.             throw string("Pipe I/O handle is closed");
  937.         }
  938.         if ( !count ) {
  939.             return eIO_Success;
  940.         }
  942.         // Retry if either blocked or interrupted
  943.         for (;;) {
  944.             // Try to read
  945.             ssize_t bytes_read = read(fd, buf, count);
  946.             if (bytes_read >= 0) {
  947.                 if ( n_read ) {
  948.                     *n_read = (size_t)bytes_read;
  949.                 }
  950.                 status = bytes_read ? eIO_Success : eIO_Closed;
  951.                 break;
  952.             }
  954.             // Blocked -- wait for data to come;  exit if timeout/error
  955.             if (errno == EAGAIN  ||  errno == EWOULDBLOCK) {
  956.                 status = x_Wait(fd, eIO_Read, timeout);
  957.                 if (status != eIO_Success) {
  958.                     break;
  959.                 }
  960.                 continue;
  961.             }
  962.             // Interrupted read -- restart
  963.             if (errno != EINTR) {
  964.                 throw string("Failed to read data from pipe");
  965.             }
  966.         }
  967.     }
  968.     catch (string& what) {
  969.         ERR_POST(s_FormatErrorMessage("Read", what));
  970.     }
  971.     return status;
  972. }
  975. EIO_Status CPipeHandle::Write(const void* buf, size_t count,
  976.                               size_t* n_written, const STimeout* timeout)
  978. {
  979.     EIO_Status status = eIO_Unknown;
  981.     try {
  982.         if (m_Pid == (pid_t)(-1)) {
  983.             status = eIO_Closed;
  984.             throw string("Pipe is closed");
  985.         }
  986.         if (m_ChildStdIn == -1) {
  987.             throw string("Pipe I/O handle is closed");
  988.         }
  989.         if ( !count ) {
  990.             return eIO_Success;
  991.         }
  993.         // Retry if either blocked or interrupted
  994.         for (;;) {
  995.             // Try to write
  996.             ssize_t bytes_written = write(m_ChildStdIn, buf, count);
  997.             if (bytes_written >= 0) {
  998.                 if ( n_written ) {
  999.                     *n_written = (size_t) bytes_written;
  1000.                 }
  1001.                 status = eIO_Success;
  1002.                 break;
  1003.             }
  1005.             // Peer has closed its end
  1006.             if (errno == EPIPE) {
  1007.                 return eIO_Closed;
  1008.             }
  1009.             // Blocked -- wait for write readiness;  exit if timeout/error
  1010.             if (errno == EAGAIN  ||  errno == EWOULDBLOCK) {
  1011.                 status = x_Wait(m_ChildStdIn, eIO_Write, timeout);
  1012.                 if (status != eIO_Success) {
  1013.                     break;
  1014.                 }
  1015.                 continue;
  1016.             }
  1017.             // Interrupted write -- restart
  1018.             if (errno != EINTR) {
  1019.                 throw string("Failed to write data into pipe");
  1020.             }
  1021.         }
  1022.     }
  1023.     catch (string& what) {
  1024.         ERR_POST(s_FormatErrorMessage("Write", what));
  1025.     }
  1026.     return status;
  1027. }
  1030. void CPipeHandle::x_Clear(void)
  1031. {
  1032.     if (m_ChildStdIn  != -1) {
  1033.         close(m_ChildStdIn);
  1034.         m_ChildStdIn   = -1;
  1035.     }
  1036.     if (m_ChildStdOut != -1) {
  1037.         close(m_ChildStdOut);
  1038.         m_ChildStdOut  = -1;
  1039.     }
  1040.     if (m_ChildStdErr != -1) {
  1041.         close(m_ChildStdErr);
  1042.         m_ChildStdErr  = -1;
  1043.     }
  1044.     m_Pid = -1;
  1045. }
  1048. int CPipeHandle::x_GetHandle(CPipe::EChildIOHandle from_handle) const
  1049. {
  1050.     switch (from_handle) {
  1051.     case CPipe::eStdIn:
  1052.         return m_ChildStdIn;
  1053.     case CPipe::eStdOut:
  1054.         return m_ChildStdOut;
  1055.     case CPipe::eStdErr:
  1056.         return m_ChildStdErr;
  1057.     default:
  1058.         break;
  1059.     }
  1060.     return -1;
  1061. }
  1064. bool CPipeHandle::x_SetNonBlockingMode(int fd, bool nonblock) const
  1065. {
  1066.     return fcntl(fd, F_SETFL,
  1067.                  nonblock ?
  1068.                  fcntl(fd, F_GETFL, 0) | O_NONBLOCK :
  1069.                  fcntl(fd, F_GETFL, 0) & (int) ~O_NONBLOCK) != -1;
  1070. }
  1073. EIO_Status CPipeHandle::x_Wait(int fd, EIO_Event direction,
  1074.                                const STimeout* timeout) const
  1075. {
  1076.     // Wait for the file descriptor to become ready only
  1077.     // if timeout is set or infinite
  1078.     if (timeout  &&  !timeout->sec  &&  !timeout->usec) {
  1079.         return eIO_Timeout;
  1080.     }
  1081.     for (;;) { // Auto-resume if interrupted by a signal
  1082.         struct timeval* tmp;
  1083.         struct timeval  tm;
  1085.         if ( timeout ) {
  1086.             // NB: Timeout has been normalized already
  1087.             tm.tv_sec  = timeout->sec;
  1088.             tm.tv_usec = timeout->usec;
  1089.             tmp = &tm;
  1090.         } else
  1091.             tmp = 0;
  1092.         fd_set rfds;
  1093.         fd_set wfds;
  1094.         fd_set efds;
  1095.         switch (direction) {
  1096.         case eIO_Read:
  1097.             FD_ZERO(&rfds);
  1098.             FD_SET(fd, &rfds);
  1099.             break;
  1100.         case eIO_Write:
  1101.             FD_ZERO(&wfds);
  1102.             FD_SET(fd, &wfds);
  1103.             break;
  1104.         default:
  1105.             assert(0);
  1106.             return eIO_Unknown;
  1107.         }
  1108.         FD_ZERO(&efds);
  1109.         FD_SET(fd, &efds);
  1111.         int n = select(fd + 1,
  1112.                        direction == eIO_Read  ? &rfds : 0,
  1113.                        direction == eIO_Write ? &wfds : 0,
  1114.                        &efds, tmp);
  1115.         if (n == 0) {
  1116.             return eIO_Timeout;
  1117.         } else if (n > 0) {
  1118.             switch (direction) {
  1119.             case eIO_Read:
  1120.                 if ( !FD_ISSET(fd, &rfds) ) {
  1121.                     assert( FD_ISSET(fd, &efds) );
  1122.                     return eIO_Closed;
  1123.                 }
  1124.                 break;
  1125.             case eIO_Write:
  1126.                 if ( !FD_ISSET(fd, &wfds) ) {
  1127.                     assert( FD_ISSET(fd, &efds) );
  1128.                     return eIO_Closed;
  1129.                 }
  1130.                 break;
  1131.             default:
  1132.                 assert(0);
  1133.                 return eIO_Unknown;
  1134.             }
  1135.             break;
  1136.         } else if (errno != EINTR) {
  1137.             throw string("Failed select() on pipe");
  1138.         }
  1139.     }
  1140.     return eIO_Success;
  1141. }
  1144. #endif  /* NCBI_OS_UNIX | NCBI_OS_MSWIN */
  1148. //////////////////////////////////////////////////////////////////////////////
  1149. //
  1150. // CPipe
  1151. //
  1153. CPipe::CPipe(void)
  1154.     : m_PipeHandle(0), m_ReadHandle(eStdOut),
  1155.       m_ReadStatus(eIO_Closed), m_WriteStatus(eIO_Closed),
  1156.       m_ReadTimeout(0), m_WriteTimeout(0), m_CloseTimeout(0)
  1157.  
  1158. {
  1159.     // Create new OS-specific pipe handle
  1160.     m_PipeHandle = new CPipeHandle();
  1161.     if ( !m_PipeHandle ) {
  1162.         NCBI_THROW(CPipeException, eInit,
  1163.                    "Cannot create OS-specific pipe handle");
  1164.     }
  1165. }
  1168. CPipe::CPipe(const string& cmd, const vector<string>& args,
  1169.              TCreateFlags create_flags)
  1170.     : m_PipeHandle(0), m_ReadHandle(eStdOut),
  1171.       m_ReadStatus(eIO_Closed), m_WriteStatus(eIO_Closed),
  1172.       m_ReadTimeout(0), m_WriteTimeout(0), m_CloseTimeout(0)
  1173. {
  1174.     // Create new OS-specific pipe handle
  1175.     m_PipeHandle = new CPipeHandle();
  1176.     if ( !m_PipeHandle ) {
  1177.         NCBI_THROW(CPipeException, eInit,
  1178.                    "Cannot create OS-specific pipe handle");
  1179.     }
  1180.     EIO_Status status = Open(cmd, args, create_flags);
  1181.     if (status != eIO_Success) {
  1182.         NCBI_THROW(CPipeException, eOpen, "CPipe::Open() failed");
  1183.     }
  1184. }
  1187. CPipe::~CPipe(void)
  1188. {
  1189.     Close();
  1190.     if ( m_PipeHandle ) {
  1191.         delete m_PipeHandle;
  1192.     }
  1193. }
  1196. EIO_Status CPipe::Open(const string& cmd, const vector<string>& args,
  1197.                        TCreateFlags create_flags)
  1198. {
  1199.     if ( !m_PipeHandle ) {
  1200.         return eIO_Unknown;
  1201.     }
  1202.     assert(CPipe::fStdIn_Close);
  1205.     EIO_Status status = m_PipeHandle->Open(cmd, args, create_flags);
  1206.     if (status == eIO_Success) {
  1207.         m_ReadStatus  = eIO_Success;
  1208.         m_WriteStatus = eIO_Success;
  1209.     }
  1210.     return status;
  1211. }
  1214. EIO_Status CPipe::Close(int* exitcode)
  1215. {
  1216.     if ( !m_PipeHandle ) {
  1217.         return eIO_Unknown;
  1218.     }
  1219.     m_ReadStatus  = eIO_Closed;
  1220.     m_WriteStatus = eIO_Closed;
  1222.     return m_PipeHandle->Close(exitcode, m_CloseTimeout);
  1223. }
  1226. EIO_Status CPipe::CloseHandle(EChildIOHandle handle)
  1227. {
  1228.     if ( !m_PipeHandle ) {
  1229.         return eIO_Unknown;
  1230.     }
  1231.     return m_PipeHandle->CloseHandle(handle);
  1232. }
  1235. EIO_Status CPipe::Read(void* buf, size_t count, size_t* read,
  1236.                        EChildIOHandle from_handle)
  1237. {
  1238.     if ( read ) {
  1239.         *read = 0;
  1240.     }
  1241.     if (from_handle == eDefault)
  1242.         from_handle = m_ReadHandle;
  1243.     if (from_handle == eStdIn) {
  1244.         return eIO_InvalidArg;
  1245.     }
  1246.     if (count  &&  !buf) {
  1247.         return eIO_InvalidArg;
  1248.     }
  1249.     if ( !m_PipeHandle ) {
  1250.         return eIO_Unknown;
  1251.     }
  1252.     m_ReadStatus = m_PipeHandle->Read(buf, count, read, from_handle,
  1253.                                       m_ReadTimeout);
  1254.     return m_ReadStatus;
  1255. }
  1258. EIO_Status CPipe::SetReadHandle(EChildIOHandle from_handle)
  1259. {
  1260.     if (from_handle == eStdIn) {
  1261.         return eIO_Unknown;
  1262.     }
  1263.     if (from_handle != eDefault) {
  1264.         m_ReadHandle = from_handle;
  1265.     }
  1266.     return eIO_Success;
  1267. }
  1270. EIO_Status CPipe::Write(const void* buf, size_t count, size_t* written)
  1271. {
  1272.     if ( written ) {
  1273.         *written = 0;
  1274.     }
  1275.     if (count  &&  !buf) {
  1276.         return eIO_InvalidArg;
  1277.     }
  1278.     if ( !m_PipeHandle ) {
  1279.         return eIO_Unknown;
  1280.     }
  1281.     m_WriteStatus = m_PipeHandle->Write(buf, count, written,
  1282.                                         m_WriteTimeout);
  1283.     return m_WriteStatus;
  1284. }
  1287. EIO_Status CPipe::Status(EIO_Event direction) const
  1288. {
  1289.     switch ( direction ) {
  1290.     case eIO_Read:
  1291.         return m_ReadStatus;
  1292.     case eIO_Write:
  1293.         return m_WriteStatus;
  1294.     default:
  1295.         break;
  1296.     }
  1297.     return eIO_InvalidArg;
  1298. }
  1301. EIO_Status CPipe::SetTimeout(EIO_Event event, const STimeout* timeout)
  1302. {
  1303.     if (timeout == kDefaultTimeout) {
  1304.         return eIO_Success;
  1305.     }
  1306.     switch ( event ) {
  1307.     case eIO_Close:
  1308.         m_CloseTimeout = s_SetTimeout(timeout, &m_CloseTimeoutValue);
  1309.         break;
  1310.     case eIO_Read:
  1311.         m_ReadTimeout  = s_SetTimeout(timeout, &m_ReadTimeoutValue);
  1312.         break;
  1313.     case eIO_Write:
  1314.         m_WriteTimeout = s_SetTimeout(timeout, &m_WriteTimeoutValue);
  1315.         break;
  1316.     case eIO_ReadWrite:
  1317.         m_ReadTimeout  = s_SetTimeout(timeout, &m_ReadTimeoutValue);
  1318.         m_WriteTimeout = s_SetTimeout(timeout, &m_WriteTimeoutValue);
  1319.         break;
  1320.     default:
  1321.         return eIO_InvalidArg;
  1322.     }
  1323.     return eIO_Success;
  1324. }
  1327. const STimeout* CPipe::GetTimeout(EIO_Event event) const
  1328. {
  1329.     switch ( event ) {
  1330.     case eIO_Close:
  1331.         return m_CloseTimeout;
  1332.     case eIO_Read:
  1333.         return m_ReadTimeout;
  1334.     case eIO_Write:
  1335.         return m_WriteTimeout;
  1336.     default:
  1337.         ;
  1338.     }
  1339.     return kDefaultTimeout;
  1340. }
  1343. TProcessHandle CPipe::GetProcessHandle(void) const
  1344. {
  1345.     return m_PipeHandle ? m_PipeHandle->GetProcessHandle() : 0;
  1346. }
  1349. END_NCBI_SCOPE
  1352. /*
  1353.  * ===========================================================================
  1354.  * $Log: ncbi_pipe.cpp,v $
  1355.  * Revision 1000.4  2004/06/01 18:45:13  gouriano
  1356.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.37
  1357.  *
  1358.  * Revision 1.37  2004/05/17 20:58:13  gorelenk
  1359.  * Added include of PCH ncbi_pch.hpp
  1360.  *
  1361.  * Revision 1.36  2003/12/04 16:28:52  ivanov
  1362.  * CPipeHandle::Close(): added handling new create flags f*OnClose.
  1363.  * Added GetProcessHandle(). Throw/catch string exceptions instead char*.
  1364.  *
  1365.  * Revision 1.35  2003/11/14 13:06:01  ucko
  1366.  * +<stdio.h> (still needed by source...)
  1367.  *
  1368.  * Revision 1.34  2003/11/04 03:11:51  lavr
  1369.  * x_GetHandle(): default switch case added [for GCC2.95.2 to be happy]
  1370.  *
  1371.  * Revision 1.33  2003/10/24 16:52:38  lavr
  1372.  * Check RW bits before E bits in select()
  1373.  *
  1374.  * Revision 1.32  2003/09/25 04:40:42  lavr
  1375.  * Fixed uninitted member in ctor; few more minor changes
  1376.  *
  1377.  * Revision 1.31  2003/09/23 21:08:37  lavr
  1378.  * PipeStreambuf and special stream removed: now all in ncbi_conn_stream.cpp
  1379.  *
  1380.  * Revision 1.30  2003/09/16 13:42:36  ivanov
  1381.  * Added deleting OS-specific pipe handle in the destructor
  1382.  *
  1383.  * Revision 1.29  2003/09/09 19:30:33  ivanov
  1384.  * Fixed I/O timeout handling in the UNIX CPipeHandle. Cleanup code.
  1385.  * Comments and messages changes.
  1386.  *
  1387.  * Revision 1.28  2003/09/04 13:55:47  kans
  1388.  * added include sys/time.h to fix Mac compiler error
  1389.  *
  1390.  * Revision 1.27  2003/09/03 21:37:05  ivanov
  1391.  * Removed Linux ESPIPE workaround
  1392.  *
  1393.  * Revision 1.26  2003/09/03 20:53:02  ivanov
  1394.  * UNIX CPipeHandle::Read(): Added workaround for Linux -- read() returns
  1395.  * ESPIPE if a second pipe end is closed.
  1396.  * UNIX CPipeHandle::Close(): Implemented close timeout handling.
  1397.  *
  1398.  * Revision 1.25  2003/09/03 14:35:59  ivanov
  1399.  * Fixed previous accidentally commited log message
  1400.  *
  1401.  * Revision 1.24  2003/09/03 14:29:58  ivanov
  1402.  * Set r/w status to eIO_Success in the CPipe::Open()
  1403.  *
  1404.  * Revision 1.23  2003/09/02 20:32:34  ivanov
  1405.  * Moved ncbipipe to CONNECT library from CORELIB.
  1406.  * Rewritten CPipe class using I/O timeouts.
  1407.  *
  1408.  * Revision 1.22  2003/06/18 21:21:48  vakatov
  1409.  * Formal code formatting
  1410.  *
  1411.  * Revision 1.21  2003/06/18 18:59:33  rsmith
  1412.  * put in 0,1,2 for fileno(stdin/out/err) for library that does not have
  1413.  * fileno().
  1414.  *
  1415.  * Revision 1.20  2003/05/19 21:21:38  vakatov
  1416.  * Get rid of unnecessary unreached statement
  1417.  *
  1418.  * Revision 1.19  2003/05/08 20:13:35  ivanov
  1419.  * Cleanup #include <util/...>
  1420.  *
  1421.  * Revision 1.18  2003/04/23 20:49:21  ivanov
  1422.  * Entirely rewritten the Unix version of the CPipeHandle.
  1423.  * Added CPipe/CPipeHandle::CloseHandle().
  1424.  * Added flushing a standart output streams before it redirecting.
  1425.  *
  1426.  * Revision 1.17  2003/04/04 16:02:38  lavr
  1427.  * Lines wrapped at 79th column; some minor reformatting
  1428.  *
  1429.  * Revision 1.16  2003/04/03 14:15:48  rsmith
  1430.  * combine pp symbols NCBI_COMPILER_METROWERKS & _MSL_USING_MW_C_HEADERS
  1431.  * into NCBI_COMPILER_MW_MSL
  1432.  *
  1433.  * Revision 1.15  2003/04/02 16:22:34  rsmith
  1434.  * clean up metrowerks ifdefs.
  1435.  *
  1436.  * Revision 1.14  2003/04/02 13:29:53  rsmith
  1437.  * include ncbi_mslextras.h when compiling with MSL libs in Codewarrior.
  1438.  *
  1439.  * Revision 1.13  2003/03/10 18:57:08  kuznets
  1440.  * iterate->ITERATE
  1441.  *
  1442.  * Revision 1.12  2003/03/07 16:19:39  ivanov
  1443.  * MSWin CPipeHandle::Close() -- Handling GetExitCodeProcess() returns
  1444.  * value 259 (STILL_ACTIVE)
  1445.  *
  1446.  * Revision 1.11  2003/03/06 21:12:10  ivanov
  1447.  * Formal comments rearrangement
  1448.  *
  1449.  * Revision 1.10  2003/03/03 14:47:20  dicuccio
  1450.  * Remplemented CPipe using private platform specific classes.  Remplemented
  1451.  * Win32 pipes using CreatePipe() / CreateProcess() - enabled CPipe in windows
  1452.  * subsystem
  1453.  *
  1454.  * Revision 1.9  2002/09/05 18:38:07  vakatov
  1455.  * Formal code rearrangement to get rid of comp.warnings;  some nice-ification
  1456.  *
  1457.  * Revision 1.8  2002/07/15 18:17:24  gouriano
  1458.  * renamed CNcbiException and its descendents
  1459.  *
  1460.  * Revision 1.7  2002/07/11 14:18:27  gouriano
  1461.  * exceptions replaced by CNcbiException-type ones
  1462.  *
  1463.  * Revision 1.6  2002/07/02 16:22:25  ivanov
  1464.  * Added closing file descriptors of the local end of the pipe in Close()
  1465.  *
  1466.  * Revision 1.5  2002/06/12 14:20:44  ivanov
  1467.  * Fixed some bugs in CPipeStreambuf class.
  1468.  *
  1469.  * Revision 1.4  2002/06/12 13:48:56  ivanov
  1470.  * Fixed contradiction in types of constructor CPipeStreambuf and its
  1471.  * realization
  1472.  *
  1473.  * Revision 1.3  2002/06/11 19:25:35  ivanov
  1474.  * Added class CPipeIOStream, CPipeStreambuf
  1475.  *
  1476.  * Revision 1.2  2002/06/10 18:35:27  ivanov
  1477.  * Changed argument's type of a running child program from char*[]
  1478.  * to vector<string>
  1479.  *
  1480.  * Revision 1.1  2002/06/10 16:59:39  ivanov
  1481.  * Initial revision
  1482.  *
  1483.  * ===========================================================================
  1484.  */