Copyright	(c) The University of Glasgow 2004
License	BSD-style (see the file libraries/base/LICENSE)
Maintainer	[email protected]
Stability	experimental
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

data ProcessHandle Source

A handle to a process, which can be used to wait for termination of the process using waitForProcess.

None of the process-creation functions in this library wait for termination: they all return a ProcessHandle which may be used to wait for the process later.

On Windows a second wait method can be used to block for event completion. This requires two handles. A process job handle and a events handle to monitor.

data ProcessHandle__ Source

type PHANDLE = CPid Source

closePHANDLE :: PHANDLE -> IO () Source

mkProcessHandle :: PHANDLE -> Bool -> IO ProcessHandle Source

data CGid

type GroupID = CGid

type UserID = CUid

modifyProcessHandle :: ProcessHandle -> (ProcessHandle__ -> IO (ProcessHandle__, a)) -> IO a Source

withProcessHandle :: ProcessHandle -> (ProcessHandle__ -> IO a) -> IO a Source

data CreateProcess Source

data CmdSpec Source

data StdStream Source

data ProcRetHandles Source

contains the handles returned by a call to createProcess_Internal

createProcess_ Source

This function is almost identical to createProcess. The only differences are:

• Handles provided via UseHandle are not closed automatically.
• This function takes an extra String argument to be used in creating error messages.

This function has been available from the System.Process.Internals module for some time, and is part of the System.Process module since version 1.2.1.0.

Since: process-1.2.1.0

runGenProcess_ Source

fdToHandle :: FD -> IO Handle

startDelegateControlC :: IO () Source

endDelegateControlC :: ExitCode -> IO () Source

stopDelegateControlC :: IO () Source

unwrapHandles :: ProcRetHandles -> (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) Source

pPrPr_disableITimers :: IO () Source

c_execvpe :: CString -> Ptr CString -> Ptr CString -> IO CInt Source

runInteractiveProcess_lock :: MVar () Source

runInteractiveProcess blocks signals around the fork(). Since blocking/unblocking of signals is a global state operation, we need to ensure mutual exclusion of calls to runInteractiveProcess. This lock is exported so that other libraries which also need to fork() (and also need to make the same global state changes) can protect their changes with the same lock. See https://github.com/haskell/process/pull/154.

Since: process-1.6.6.0

ignoreSignal :: CLong Source

defaultSignal :: CLong Source

withFilePathException :: FilePath -> IO a -> IO a Source

withCEnvironment :: [(String, String)] -> (Ptr CString -> IO a) -> IO a Source

translate :: String -> String Source

createPipe :: IO (Handle, Handle) Source

Create a pipe for interprocess communication and return a (readEnd, writeEnd) Handle pair.

• WinIO Support

When this function is used with WinIO enabled it's the caller's responsibility to register the handles with the I/O manager. If this is not done the operation will deadlock. Association can be done as follows:

    #if defined(IO_MANAGER_WINIO)
    import GHC.IO.SubSystem ((!))
    import GHC.IO.Handle.Windows (handleToHANDLE)
    import GHC.Event.Windows (associateHandle')
    #endif

    ...

    #if defined (IO_MANAGER_WINIO)
    return () ! (do
      associateHandle' =handleToHANDLE <handle)
    #endif

Only associate handles that you are in charge of read/writing to. Do not associate handles passed to another process. It's the process's reponsibility to register the handle if it supports async access.

Since: process-1.2.1.0

createPipeFd :: IO (FD, FD) Source

Create a pipe for interprocess communication and return a (readEnd, writeEnd) FD pair.

Since: process-1.4.2.0

interruptProcessGroupOf Source

Sends an interrupt signal to the process group of the given process.

On Unix systems, it sends the group the SIGINT signal.

On Windows systems, it generates a CTRL_BREAK_EVENT and will only work for processes created using createProcess and setting the create_group flag

withForkWait :: IO () -> (IO () -> IO a) -> IO a Source

Fork a thread while doing something else, but kill it if there's an exception.

This is important in the cases above because we want to kill the thread that is holding the Handle lock, because when we clean up the process we try to close that handle, which could otherwise deadlock.

Since: process-1.6.20.0

ignoreSigPipe :: IO () -> IO () Source

Handle any SIGPIPE errors in the given computation.

Since: process-1.6.20.0