{-# LANGUAGE EmptyDataDecls, ForeignFunctionInterface #-}

{- |
Module      : System.Posix.Redirect
Copyright   : Galois, Inc. 2010
Maintainer  : ezyang@galois.com
Stability   : experimental
Portability : non-portable (POSIX, GHC)

Misbehaved third-party libraries (usually not written in Haskell)
may print error messages directly to stdout or stderr when we would
actually like to capture them and propagate them as a normal exception.
In such cases, it would be useful to temporarily override those file
descriptors to point to a pipe that we control.

This module is not portable and not thread safe.  However, it can
safely manage arbitrarily large amounts of data, as it spins off another
thread to read from the pipe created; therefore, you must use -threaded
to compile a program with this.  If you are making a foreign call,
you must ensure that the foreign call is marked safe or there is a
possibility of deadlock.

While this module is an interesting novelty, it is the module author's
opinion that it is not a sustainable method for making C libraries
behave properly, primarily due to its unportability (this trick does not
appear to be possible on Windows).  Use at your own risk.
-}

module System.Posix.Redirect
    ( redirectStdout
    , redirectStderr
    -- * Low-level operations
    , redirectWriteHandle
    , unsafeRedirectWriteFd
    ) where

import System.Posix.Types
import System.Posix.IO
import System.IO

import Foreign
import Foreign.C.Types

import Data.ByteString as BS

import Control.Concurrent
import Control.Exception

dupTo_ :: Fd -> Fd -> IO ()
dupTo_ a b = dupTo a b >>= \_ -> return ()

-- | @'unsafeRedirectFd' fd f@ executes the computation @f@, passing as
-- an argument a handle which is the read end of a pipe that
-- @fd@ now points to.  When the computation is done, the original file
-- descriptor is restored.  Use with care: if there are any file
-- handles with this descriptor that have unflushed buffers, they will
-- not flush to the old file descriptor, but the new file descriptor.
unsafeRedirectWriteFd :: Fd -> IO a -> IO (ByteString, a)
unsafeRedirectWriteFd fd f = do
    -- setup
    (rfd, wfd) <- createPipe
    old <- dup fd
    dupTo_ wfd fd
    -- fork a thread to consume output
    outMVar <- newEmptyMVar
    outHandle <- fdToHandle rfd
    _ <- forkIO (BS.hGetContents outHandle >>= putMVar outMVar)
    -- run the code
    r <- f
    -- cleanup
    dupTo_ old fd
    closeFd wfd
    -- wait for output
    out <- takeMVar outMVar
    hClose outHandle
    return (out, r)

-- | @'redirectWriteHandle' oldFd oldHandle oldCHandle f@ executes the
-- computation @f@, passing as an argument a handle which is the read
-- end of a pipe that @fd@ now points to.  This function appropriately
-- flushes the Haskell @oldHandle@ and the C @oldCHandle@ before
-- and after @f@'s execution.
redirectWriteHandle :: Fd -> Handle -> Ptr FILE -> IO a -> IO (ByteString, a)
redirectWriteHandle oldFd oldHandle cOldHandle f = do
    hFlush oldHandle
    hFlush stdout
    _ <- c_fflush cOldHandle
    unsafeRedirectWriteFd oldFd $ do
        r <- f
        hFlush oldHandle
        _ <- c_fflush cOldHandle
        return r

-- | @'redirectStdout' f@ redirects standard output during the execution
-- of @f@ into a pipe passed as the first argument to @f@.
redirectStdout :: IO a -> IO (ByteString, a)
redirectStdout f = do
    c_stdout <- cio_stdout
    redirectWriteHandle stdOutput stdout c_stdout f

-- | @'redirectStderr' f@ redirects standard error during the execution
-- of @f@ into a pipe passed as the first argument to @f@.
redirectStderr :: IO a -> IO (ByteString, a)
redirectStderr f = do
    c_stderr <- cio_stderr
    redirectWriteHandle stdError stderr c_stderr f

---------------------------------------------------
-- FFI imports, since we need to flush the C buffer

data FILE

foreign import ccall safe "stdio.h fflush"
    c_fflush :: Ptr FILE -> IO CInt

foreign import ccall unsafe "hsredirect.h PosixRedirect_stdout"
    cio_stdout :: IO (Ptr FILE)
foreign import ccall unsafe "hsredirect.h PosixRedirect_stderr"
    cio_stderr :: IO (Ptr FILE)