{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE InterruptibleFFI #-}
{-# LANGUAGE CPP, NoImplicitPrelude, CApiFFI #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE MagicHash #-}
{-# OPTIONS_HADDOCK not-home #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  System.Posix.Internals
-- Copyright   :  (c) The University of Glasgow, 1992-2002
-- License     :  see libraries/base/LICENSE
--
-- Maintainer  :  cvs-ghc@haskell.org
-- Stability   :  internal
-- Portability :  non-portable (requires POSIX)
--
-- POSIX support layer for the standard libraries.
-- This library is built on *every* platform, including Win32.
--
-- Non-posix compliant in order to support the following features:
--      * S_ISSOCK (no sockets in POSIX)
--
-----------------------------------------------------------------------------

module System.Posix.Internals where

#include "HsBaseConfig.h"

import System.Posix.Types

import Foreign
import Foreign.C

-- import Data.Bits
import Data.Maybe

#if !defined(HTYPE_TCFLAG_T)
import System.IO.Error
#endif

import GHC.Base
import GHC.Num
import GHC.Real
import GHC.IO
import GHC.IO.IOMode
import GHC.IO.Exception
import GHC.IO.Device
#if !defined(mingw32_HOST_OS)
import {-# SOURCE #-} GHC.IO.Encoding (getFileSystemEncoding)
import qualified GHC.Foreign as GHC
#endif

-- ---------------------------------------------------------------------------
-- Debugging the base package

puts :: String -> IO ()
puts :: String -> IO ()
puts String
s = forall a. String -> (CStringLen -> IO a) -> IO a
withCAStringLen (String
s forall a. [a] -> [a] -> [a]
++ String
"\n") forall a b. (a -> b) -> a -> b
$ \(Ptr CChar
p, Int
len) -> do
            -- In reality should be withCString, but assume ASCII to avoid loop
            -- if this is called by GHC.Foreign
           CSsize
_ <- CInt -> Ptr Word8 -> CSize -> IO CSsize
c_write CInt
1 (forall a b. Ptr a -> Ptr b
castPtr Ptr CChar
p) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len)
           forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- ---------------------------------------------------------------------------
-- Types

data {-# CTYPE "struct flock" #-} CFLock
data {-# CTYPE "struct group" #-} CGroup
data {-# CTYPE "struct lconv" #-} CLconv
data {-# CTYPE "struct passwd" #-} CPasswd
data {-# CTYPE "struct sigaction" #-} CSigaction
data {-# CTYPE "sigset_t" #-} CSigset
data {-# CTYPE "struct stat" #-}  CStat
data {-# CTYPE "struct termios" #-} CTermios
data {-# CTYPE "struct tm" #-} CTm
data {-# CTYPE "struct tms" #-} CTms
data {-# CTYPE "struct utimbuf" #-} CUtimbuf
data {-# CTYPE "struct utsname" #-} CUtsname

type FD = CInt

-- ---------------------------------------------------------------------------
-- stat()-related stuff

fdFileSize :: FD -> IO Integer
fdFileSize :: CInt -> IO Integer
fdFileSize CInt
fd =
  forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
sizeof_stat forall a b. (a -> b) -> a -> b
$ \ Ptr CStat
p_stat -> do
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1Retry_ String
"fileSize" forall a b. (a -> b) -> a -> b
$
        CInt -> Ptr CStat -> IO CInt
c_fstat CInt
fd Ptr CStat
p_stat
    CMode
c_mode <- Ptr CStat -> IO CMode
st_mode Ptr CStat
p_stat :: IO CMode
    if Bool -> Bool
not (CMode -> Bool
s_isreg CMode
c_mode)
        then forall (m :: * -> *) a. Monad m => a -> m a
return (-Integer
1)
        else do
      COff
c_size <- Ptr CStat -> IO COff
st_size Ptr CStat
p_stat
      forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (Integral a, Num b) => a -> b
fromIntegral COff
c_size)

fileType :: FilePath -> IO IODeviceType
fileType :: String -> IO IODeviceType
fileType String
file =
  forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
sizeof_stat forall a b. (a -> b) -> a -> b
$ \ Ptr CStat
p_stat ->
  forall a. String -> (Ptr CChar -> IO a) -> IO a
withFilePath String
file forall a b. (a -> b) -> a -> b
$ \Ptr CChar
p_file -> do
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1Retry_ String
"fileType" forall a b. (a -> b) -> a -> b
$
      Ptr CChar -> Ptr CStat -> IO CInt
c_stat Ptr CChar
p_file Ptr CStat
p_stat
    Ptr CStat -> IO IODeviceType
statGetType Ptr CStat
p_stat

-- NOTE: On Win32 platforms, this will only work with file descriptors
-- referring to file handles. i.e., it'll fail for socket FDs.
fdStat :: FD -> IO (IODeviceType, CDev, CIno)
fdStat :: CInt -> IO (IODeviceType, CDev, CIno)
fdStat CInt
fd =
  forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
sizeof_stat forall a b. (a -> b) -> a -> b
$ \ Ptr CStat
p_stat -> do
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1Retry_ String
"fdType" forall a b. (a -> b) -> a -> b
$
        CInt -> Ptr CStat -> IO CInt
c_fstat CInt
fd Ptr CStat
p_stat
    IODeviceType
ty <- Ptr CStat -> IO IODeviceType
statGetType Ptr CStat
p_stat
    CDev
dev <- Ptr CStat -> IO CDev
st_dev Ptr CStat
p_stat
    CIno
ino <- Ptr CStat -> IO CIno
st_ino Ptr CStat
p_stat
    forall (m :: * -> *) a. Monad m => a -> m a
return (IODeviceType
ty,CDev
dev,CIno
ino)

fdType :: FD -> IO IODeviceType
fdType :: CInt -> IO IODeviceType
fdType CInt
fd = do (IODeviceType
ty,CDev
_,CIno
_) <- CInt -> IO (IODeviceType, CDev, CIno)
fdStat CInt
fd; forall (m :: * -> *) a. Monad m => a -> m a
return IODeviceType
ty

statGetType :: Ptr CStat -> IO IODeviceType
statGetType :: Ptr CStat -> IO IODeviceType
statGetType Ptr CStat
p_stat = do
  CMode
c_mode <- Ptr CStat -> IO CMode
st_mode Ptr CStat
p_stat :: IO CMode
  case () of
      ()
_ | CMode -> Bool
s_isdir CMode
c_mode        -> forall (m :: * -> *) a. Monad m => a -> m a
return IODeviceType
Directory
        | CMode -> Bool
s_isfifo CMode
c_mode Bool -> Bool -> Bool
|| CMode -> Bool
s_issock CMode
c_mode Bool -> Bool -> Bool
|| CMode -> Bool
s_ischr  CMode
c_mode
                                -> forall (m :: * -> *) a. Monad m => a -> m a
return IODeviceType
Stream
        | CMode -> Bool
s_isreg CMode
c_mode        -> forall (m :: * -> *) a. Monad m => a -> m a
return IODeviceType
RegularFile
         -- Q: map char devices to RawDevice too?
        | CMode -> Bool
s_isblk CMode
c_mode        -> forall (m :: * -> *) a. Monad m => a -> m a
return IODeviceType
RawDevice
        | Bool
otherwise             -> forall a. IOError -> IO a
ioError IOError
ioe_unknownfiletype

ioe_unknownfiletype :: IOException
ioe_unknownfiletype :: IOError
ioe_unknownfiletype = Maybe Handle
-> IOErrorType
-> String
-> String
-> Maybe CInt
-> Maybe String
-> IOError
IOError forall a. Maybe a
Nothing IOErrorType
UnsupportedOperation String
"fdType"
                        String
"unknown file type"
                        forall a. Maybe a
Nothing
                        forall a. Maybe a
Nothing

fdGetMode :: FD -> IO IOMode
#if defined(mingw32_HOST_OS)
fdGetMode _ = do
    -- We don't have a way of finding out which flags are set on FDs
    -- on Windows, so make a handle that thinks that anything goes.
    let flags = o_RDWR
#else
fdGetMode :: CInt -> IO IOMode
fdGetMode CInt
fd = do
    CInt
flags <- forall a. (Eq a, Num a) => String -> IO a -> IO a
throwErrnoIfMinus1Retry String
"fdGetMode"
                (CInt -> CInt -> IO CInt
c_fcntl_read CInt
fd CInt
const_f_getfl)
#endif
    let
       wH :: Bool
wH  = (CInt
flags forall a. Bits a => a -> a -> a
.&. CInt
o_WRONLY) forall a. Eq a => a -> a -> Bool
/= CInt
0
       aH :: Bool
aH  = (CInt
flags forall a. Bits a => a -> a -> a
.&. CInt
o_APPEND) forall a. Eq a => a -> a -> Bool
/= CInt
0
       rwH :: Bool
rwH = (CInt
flags forall a. Bits a => a -> a -> a
.&. CInt
o_RDWR) forall a. Eq a => a -> a -> Bool
/= CInt
0

       mode :: IOMode
mode
         | Bool
wH Bool -> Bool -> Bool
&& Bool
aH  = IOMode
AppendMode
         | Bool
wH        = IOMode
WriteMode
         | Bool
rwH       = IOMode
ReadWriteMode
         | Bool
otherwise = IOMode
ReadMode

    forall (m :: * -> *) a. Monad m => a -> m a
return IOMode
mode

#if defined(mingw32_HOST_OS)
withFilePath :: FilePath -> (CWString -> IO a) -> IO a
withFilePath = withCWString

newFilePath :: FilePath -> IO CWString
newFilePath = newCWString

peekFilePath :: CWString -> IO FilePath
peekFilePath = peekCWString
#else

withFilePath :: FilePath -> (CString -> IO a) -> IO a
newFilePath :: FilePath -> IO CString
peekFilePath :: CString -> IO FilePath
peekFilePathLen :: CStringLen -> IO FilePath

withFilePath :: forall a. String -> (Ptr CChar -> IO a) -> IO a
withFilePath String
fp Ptr CChar -> IO a
f = IO TextEncoding
getFileSystemEncoding forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \TextEncoding
enc -> forall a. TextEncoding -> String -> (Ptr CChar -> IO a) -> IO a
GHC.withCString TextEncoding
enc String
fp Ptr CChar -> IO a
f
newFilePath :: String -> IO (Ptr CChar)
newFilePath String
fp = IO TextEncoding
getFileSystemEncoding forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \TextEncoding
enc -> TextEncoding -> String -> IO (Ptr CChar)
GHC.newCString TextEncoding
enc String
fp
peekFilePath :: Ptr CChar -> IO String
peekFilePath Ptr CChar
fp = IO TextEncoding
getFileSystemEncoding forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \TextEncoding
enc -> TextEncoding -> Ptr CChar -> IO String
GHC.peekCString TextEncoding
enc Ptr CChar
fp
peekFilePathLen :: CStringLen -> IO String
peekFilePathLen CStringLen
fp = IO TextEncoding
getFileSystemEncoding forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \TextEncoding
enc -> TextEncoding -> CStringLen -> IO String
GHC.peekCStringLen TextEncoding
enc CStringLen
fp

#endif

-- ---------------------------------------------------------------------------
-- Terminal-related stuff

#if defined(HTYPE_TCFLAG_T)

setEcho :: FD -> Bool -> IO ()
setEcho :: CInt -> Bool -> IO ()
setEcho CInt
fd Bool
on =
  forall a. CInt -> (Ptr CTermios -> IO a) -> IO a
tcSetAttr CInt
fd forall a b. (a -> b) -> a -> b
$ \ Ptr CTermios
p_tios -> do
    CTcflag
lflag <- Ptr CTermios -> IO CTcflag
c_lflag Ptr CTermios
p_tios :: IO CTcflag
    let new_lflag :: CTcflag
new_lflag
         | Bool
on        = CTcflag
lflag forall a. Bits a => a -> a -> a
.|. forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
const_echo
         | Bool
otherwise = CTcflag
lflag forall a. Bits a => a -> a -> a
.&. forall a. Bits a => a -> a
complement (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
const_echo)
    Ptr CTermios -> CTcflag -> IO ()
poke_c_lflag Ptr CTermios
p_tios (CTcflag
new_lflag :: CTcflag)

getEcho :: FD -> IO Bool
getEcho :: CInt -> IO Bool
getEcho CInt
fd =
  forall a. CInt -> (Ptr CTermios -> IO a) -> IO a
tcSetAttr CInt
fd forall a b. (a -> b) -> a -> b
$ \ Ptr CTermios
p_tios -> do
    CTcflag
lflag <- Ptr CTermios -> IO CTcflag
c_lflag Ptr CTermios
p_tios :: IO CTcflag
    forall (m :: * -> *) a. Monad m => a -> m a
return ((CTcflag
lflag forall a. Bits a => a -> a -> a
.&. forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
const_echo) forall a. Eq a => a -> a -> Bool
/= CTcflag
0)

setCooked :: FD -> Bool -> IO ()
setCooked :: CInt -> Bool -> IO ()
setCooked CInt
fd Bool
cooked =
  forall a. CInt -> (Ptr CTermios -> IO a) -> IO a
tcSetAttr CInt
fd forall a b. (a -> b) -> a -> b
$ \ Ptr CTermios
p_tios -> do

    -- turn on/off ICANON
    CTcflag
lflag <- Ptr CTermios -> IO CTcflag
c_lflag Ptr CTermios
p_tios :: IO CTcflag
    let new_lflag :: CTcflag
new_lflag | Bool
cooked    = CTcflag
lflag forall a. Bits a => a -> a -> a
.|. (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
const_icanon)
                  | Bool
otherwise = CTcflag
lflag forall a. Bits a => a -> a -> a
.&. forall a. Bits a => a -> a
complement (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
const_icanon)
    Ptr CTermios -> CTcflag -> IO ()
poke_c_lflag Ptr CTermios
p_tios (CTcflag
new_lflag :: CTcflag)

    -- set VMIN & VTIME to 1/0 respectively
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not Bool
cooked) forall a b. (a -> b) -> a -> b
$ do
            Ptr Word8
c_cc <- Ptr CTermios -> IO (Ptr Word8)
ptr_c_cc Ptr CTermios
p_tios
            let vmin :: Ptr Word8
vmin  = (Ptr Word8
c_cc forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
const_vmin))  :: Ptr Word8
                vtime :: Ptr Word8
vtime = (Ptr Word8
c_cc forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
const_vtime)) :: Ptr Word8
            forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr Word8
vmin  Word8
1
            forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr Word8
vtime Word8
0

tcSetAttr :: FD -> (Ptr CTermios -> IO a) -> IO a
tcSetAttr :: forall a. CInt -> (Ptr CTermios -> IO a) -> IO a
tcSetAttr CInt
fd Ptr CTermios -> IO a
fun =
     forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
sizeof_termios  forall a b. (a -> b) -> a -> b
$ \Ptr CTermios
p_tios -> do
        forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1Retry_ String
"tcSetAttr"
           (CInt -> Ptr CTermios -> IO CInt
c_tcgetattr CInt
fd Ptr CTermios
p_tios)

        -- Save a copy of termios, if this is a standard file descriptor.
        -- These terminal settings are restored in hs_exit().
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CInt
fd forall a. Ord a => a -> a -> Bool
<= CInt
2) forall a b. (a -> b) -> a -> b
$ do
          Ptr CTermios
p <- CInt -> IO (Ptr CTermios)
get_saved_termios CInt
fd
          forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Ptr CTermios
p forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) forall a b. (a -> b) -> a -> b
$ do
             Ptr CTermios
saved_tios <- forall a. Int -> IO (Ptr a)
mallocBytes Int
sizeof_termios
             forall a. Ptr a -> Ptr a -> Int -> IO ()
copyBytes Ptr CTermios
saved_tios Ptr CTermios
p_tios Int
sizeof_termios
             CInt -> Ptr CTermios -> IO ()
set_saved_termios CInt
fd Ptr CTermios
saved_tios

        -- tcsetattr() when invoked by a background process causes the process
        -- to be sent SIGTTOU regardless of whether the process has TOSTOP set
        -- in its terminal flags (try it...).  This function provides a
        -- wrapper which temporarily blocks SIGTTOU around the call, making it
        -- transparent.
        forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
sizeof_sigset_t forall a b. (a -> b) -> a -> b
$ \ Ptr CSigset
p_sigset ->
          forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
sizeof_sigset_t forall a b. (a -> b) -> a -> b
$ \ Ptr CSigset
p_old_sigset -> do
             forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"sigemptyset" forall a b. (a -> b) -> a -> b
$
                 Ptr CSigset -> IO CInt
c_sigemptyset Ptr CSigset
p_sigset
             forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"sigaddset" forall a b. (a -> b) -> a -> b
$
                 Ptr CSigset -> CInt -> IO CInt
c_sigaddset   Ptr CSigset
p_sigset CInt
const_sigttou
             forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"sigprocmask" forall a b. (a -> b) -> a -> b
$
                 CInt -> Ptr CSigset -> Ptr CSigset -> IO CInt
c_sigprocmask CInt
const_sig_block Ptr CSigset
p_sigset Ptr CSigset
p_old_sigset
             a
r <- Ptr CTermios -> IO a
fun Ptr CTermios
p_tios  -- do the business
             forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1Retry_ String
"tcSetAttr" forall a b. (a -> b) -> a -> b
$
                 CInt -> CInt -> Ptr CTermios -> IO CInt
c_tcsetattr CInt
fd CInt
const_tcsanow Ptr CTermios
p_tios
             forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"sigprocmask" forall a b. (a -> b) -> a -> b
$
                 CInt -> Ptr CSigset -> Ptr CSigset -> IO CInt
c_sigprocmask CInt
const_sig_setmask Ptr CSigset
p_old_sigset forall a. Ptr a
nullPtr
             forall (m :: * -> *) a. Monad m => a -> m a
return a
r

foreign import ccall unsafe "HsBase.h __hscore_get_saved_termios"
   get_saved_termios :: CInt -> IO (Ptr CTermios)

foreign import ccall unsafe "HsBase.h __hscore_set_saved_termios"
   set_saved_termios :: CInt -> (Ptr CTermios) -> IO ()

#else

-- 'raw' mode for Win32 means turn off 'line input' (=> buffering and
-- character translation for the console.) The Win32 API for doing
-- this is GetConsoleMode(), which also requires echoing to be disabled
-- when turning off 'line input' processing. Notice that turning off
-- 'line input' implies enter/return is reported as '\r' (and it won't
-- report that character until another character is input..odd.) This
-- latter feature doesn't sit too well with IO actions like IO.hGetLine..
-- consider yourself warned.
setCooked :: FD -> Bool -> IO ()
setCooked fd cooked = do
  x <- set_console_buffering fd (if cooked then 1 else 0)
  if (x /= 0)
   then ioError (ioe_unk_error "setCooked" "failed to set buffering")
   else return ()

ioe_unk_error :: String -> String -> IOException
ioe_unk_error loc msg
 = ioeSetErrorString (mkIOError OtherError loc Nothing Nothing) msg

-- Note: echoing goes hand in hand with enabling 'line input' / raw-ness
-- for Win32 consoles, hence setEcho ends up being the inverse of setCooked.
setEcho :: FD -> Bool -> IO ()
setEcho fd on = do
  x <- set_console_echo fd (if on then 1 else 0)
  if (x /= 0)
   then ioError (ioe_unk_error "setEcho" "failed to set echoing")
   else return ()

getEcho :: FD -> IO Bool
getEcho fd = do
  r <- get_console_echo fd
  if (r == (-1))
   then ioError (ioe_unk_error "getEcho" "failed to get echoing")
   else return (r == 1)

foreign import ccall unsafe "consUtils.h set_console_buffering__"
   set_console_buffering :: CInt -> CInt -> IO CInt

foreign import ccall unsafe "consUtils.h set_console_echo__"
   set_console_echo :: CInt -> CInt -> IO CInt

foreign import ccall unsafe "consUtils.h get_console_echo__"
   get_console_echo :: CInt -> IO CInt

foreign import ccall unsafe "consUtils.h is_console__"
   is_console :: CInt -> IO CInt

#endif

-- ---------------------------------------------------------------------------
-- Turning on non-blocking for a file descriptor

setNonBlockingFD :: FD -> Bool -> IO ()
#if !defined(mingw32_HOST_OS)
setNonBlockingFD :: CInt -> Bool -> IO ()
setNonBlockingFD CInt
fd Bool
set = do
  CInt
flags <- forall a. (Eq a, Num a) => String -> IO a -> IO a
throwErrnoIfMinus1Retry String
"setNonBlockingFD"
                 (CInt -> CInt -> IO CInt
c_fcntl_read CInt
fd CInt
const_f_getfl)
  let flags' :: CInt
flags' | Bool
set       = CInt
flags forall a. Bits a => a -> a -> a
.|. CInt
o_NONBLOCK
             | Bool
otherwise = CInt
flags forall a. Bits a => a -> a -> a
.&. forall a. Bits a => a -> a
complement CInt
o_NONBLOCK
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CInt
flags forall a. Eq a => a -> a -> Bool
/= CInt
flags') forall a b. (a -> b) -> a -> b
$ do
    -- An error when setting O_NONBLOCK isn't fatal: on some systems
    -- there are certain file handles on which this will fail (eg. /dev/null
    -- on FreeBSD) so we throw away the return code from fcntl_write.
    CInt
_ <- CInt -> CInt -> CLong -> IO CInt
c_fcntl_write CInt
fd CInt
const_f_setfl (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
flags')
    forall (m :: * -> *) a. Monad m => a -> m a
return ()
#else

-- bogus defns for win32
setNonBlockingFD _ _ = return ()

#endif

-- -----------------------------------------------------------------------------
-- Set close-on-exec for a file descriptor

#if !defined(mingw32_HOST_OS)
setCloseOnExec :: FD -> IO ()
setCloseOnExec :: CInt -> IO ()
setCloseOnExec CInt
fd =
  forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"setCloseOnExec" forall a b. (a -> b) -> a -> b
$
    CInt -> CInt -> CLong -> IO CInt
c_fcntl_write CInt
fd CInt
const_f_setfd CLong
const_fd_cloexec
#endif

-- -----------------------------------------------------------------------------
-- foreign imports

#if !defined(mingw32_HOST_OS)
type CFilePath = CString
#else
type CFilePath = CWString
#endif

foreign import ccall unsafe "HsBase.h __hscore_open"
   c_open :: CFilePath -> CInt -> CMode -> IO CInt

-- | The same as 'c_safe_open', but an /interruptible operation/
-- as described in "Control.Exception"—it respects `uninterruptibleMask`
-- but not `mask`.
--
-- We want to be able to interrupt an openFile call if
-- it's expensive (NFS, FUSE, etc.), and we especially
-- need to be able to interrupt a blocking open call.
-- See #17912.
c_interruptible_open :: CFilePath -> CInt -> CMode -> IO CInt
c_interruptible_open :: Ptr CChar -> CInt -> CMode -> IO CInt
c_interruptible_open Ptr CChar
filepath CInt
oflags CMode
mode =
  IO MaskingState
getMaskingState forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    -- If we're in an uninterruptible mask, there's basically
    -- no point in using an interruptible FFI call. The open system call
    -- will be interrupted, but the exception won't be delivered
    -- unless the caller manually futzes with the masking state. So
    -- then the caller (assuming they're following the usual conventions)
    -- will retry the call (in response to EINTR), and we've just
    -- wasted everyone's time.
    MaskingState
MaskedUninterruptible -> Ptr CChar -> CInt -> CMode -> IO CInt
c_safe_open_ Ptr CChar
filepath CInt
oflags CMode
mode
    MaskingState
_ -> do
      CInt
open_res <- Ptr CChar -> CInt -> CMode -> IO CInt
c_interruptible_open_ Ptr CChar
filepath CInt
oflags CMode
mode
      -- c_interruptible_open_ is an interruptible foreign call.
      -- If the call is interrupted by an exception handler
      -- before the system call has returned (so the file is
      -- not yet open), we want to deliver the exception.
      -- In point of fact, we deliver any pending exception
      -- here regardless of the *reason* the system call
      -- fails.
      forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CInt
open_res forall a. Eq a => a -> a -> Bool
== -CInt
1) forall a b. (a -> b) -> a -> b
$
        if Bool
hostIsThreaded
          then
            -- Control.Exception.allowInterrupt, inlined to avoid
            -- messing with any Haddock links.
            forall a. IO a -> IO a
interruptible (forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
          else
            -- Try to make this work somewhat better on the non-threaded
            -- RTS. See #8684. This inlines the definition of `yield`; module
            -- dependencies look pretty hairy here and I don't want to make
            -- things worse for one little wrapper.
            forall a. IO a -> IO a
interruptible (forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> (# State# RealWorld -> State# RealWorld
yield# State# RealWorld
s, () #))
      forall (f :: * -> *) a. Applicative f => a -> f a
pure CInt
open_res

foreign import ccall interruptible "HsBase.h __hscore_open"
   c_interruptible_open_ :: CFilePath -> CInt -> CMode -> IO CInt

-- | Consult the RTS to find whether it is threaded.
hostIsThreaded :: Bool
hostIsThreaded :: Bool
hostIsThreaded = Int
rtsIsThreaded_ forall a. Eq a => a -> a -> Bool
/= Int
0

foreign import ccall unsafe "rts_isThreaded" rtsIsThreaded_ :: Int

c_safe_open :: CFilePath -> CInt -> CMode -> IO CInt
c_safe_open :: Ptr CChar -> CInt -> CMode -> IO CInt
c_safe_open Ptr CChar
filepath CInt
oflags CMode
mode =
  IO MaskingState
getMaskingState forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    -- When exceptions are unmasked, we use an interruptible
    -- open call. If the system call is successfully
    -- interrupted, the situation will be the same as if
    -- the exception had arrived before this function was
    -- called.
    MaskingState
Unmasked -> Ptr CChar -> CInt -> CMode -> IO CInt
c_interruptible_open_ Ptr CChar
filepath CInt
oflags CMode
mode
    MaskingState
_ -> Ptr CChar -> CInt -> CMode -> IO CInt
c_safe_open_ Ptr CChar
filepath CInt
oflags CMode
mode

foreign import ccall safe "HsBase.h __hscore_open"
   c_safe_open_ :: CFilePath -> CInt -> CMode -> IO CInt

foreign import ccall unsafe "HsBase.h __hscore_fstat"
   c_fstat :: CInt -> Ptr CStat -> IO CInt

foreign import ccall unsafe "HsBase.h __hscore_lstat"
   lstat :: CFilePath -> Ptr CStat -> IO CInt

{- Note: Win32 POSIX functions
Functions that are not part of the POSIX standards were
at some point deprecated by Microsoft. This deprecation
was performed by renaming the functions according to the
C++ ABI Section 17.6.4.3.2b. This was done to free up the
namespace of normal Windows programs since Windows isn't
POSIX compliant anyway.

These were working before since the RTS was re-exporting
these symbols under the undeprecated names. This is no longer
being done. See #11223

See https://msdn.microsoft.com/en-us/library/ms235384.aspx
for more.

However since we can't hope to get people to support Windows
packages we should support the deprecated names. See #12497
-}
foreign import capi unsafe "unistd.h lseek"
   c_lseek :: CInt -> COff -> CInt -> IO COff

foreign import ccall unsafe "HsBase.h access"
   c_access :: CString -> CInt -> IO CInt

foreign import ccall unsafe "HsBase.h chmod"
   c_chmod :: CString -> CMode -> IO CInt

foreign import ccall unsafe "HsBase.h close"
   c_close :: CInt -> IO CInt

foreign import ccall unsafe "HsBase.h creat"
   c_creat :: CString -> CMode -> IO CInt

foreign import ccall unsafe "HsBase.h dup"
   c_dup :: CInt -> IO CInt

foreign import ccall unsafe "HsBase.h dup2"
   c_dup2 :: CInt -> CInt -> IO CInt

foreign import ccall unsafe "HsBase.h isatty"
   c_isatty :: CInt -> IO CInt

#if defined(mingw32_HOST_OS)
-- See Note: Windows types
foreign import capi unsafe "HsBase.h _read"
   c_read :: CInt -> Ptr Word8 -> CUInt -> IO CInt

-- See Note: Windows types
foreign import capi safe "HsBase.h _read"
   c_safe_read :: CInt -> Ptr Word8 -> CUInt -> IO CInt

foreign import ccall unsafe "HsBase.h _umask"
   c_umask :: CMode -> IO CMode

-- See Note: Windows types
foreign import capi unsafe "HsBase.h _write"
   c_write :: CInt -> Ptr Word8 -> CUInt -> IO CInt

-- See Note: Windows types
foreign import capi safe "HsBase.h _write"
   c_safe_write :: CInt -> Ptr Word8 -> CUInt -> IO CInt

foreign import ccall unsafe "HsBase.h _pipe"
   c_pipe :: Ptr CInt -> IO CInt
#else
-- We use CAPI as on some OSs (eg. Linux) this is wrapped by a macro
-- which redirects to the 64-bit-off_t versions when large file
-- support is enabled.

-- See Note: Windows types
foreign import capi unsafe "HsBase.h read"
   c_read :: CInt -> Ptr Word8 -> CSize -> IO CSsize

-- See Note: Windows types
foreign import capi safe "HsBase.h read"
   c_safe_read :: CInt -> Ptr Word8 -> CSize -> IO CSsize

foreign import ccall unsafe "HsBase.h umask"
   c_umask :: CMode -> IO CMode

-- See Note: Windows types
foreign import capi unsafe "HsBase.h write"
   c_write :: CInt -> Ptr Word8 -> CSize -> IO CSsize

-- See Note: Windows types
foreign import capi safe "HsBase.h write"
   c_safe_write :: CInt -> Ptr Word8 -> CSize -> IO CSsize

foreign import ccall unsafe "HsBase.h pipe"
   c_pipe :: Ptr CInt -> IO CInt
#endif

foreign import ccall unsafe "HsBase.h unlink"
   c_unlink :: CString -> IO CInt

foreign import capi unsafe "HsBase.h utime"
   c_utime :: CString -> Ptr CUtimbuf -> IO CInt

foreign import ccall unsafe "HsBase.h getpid"
   c_getpid :: IO CPid

foreign import ccall unsafe "HsBase.h __hscore_stat"
   c_stat :: CFilePath -> Ptr CStat -> IO CInt

foreign import ccall unsafe "HsBase.h __hscore_ftruncate"
   c_ftruncate :: CInt -> COff -> IO CInt

#if !defined(mingw32_HOST_OS)
foreign import capi unsafe "HsBase.h fcntl"
   c_fcntl_read  :: CInt -> CInt -> IO CInt

foreign import capi unsafe "HsBase.h fcntl"
   c_fcntl_write :: CInt -> CInt -> CLong -> IO CInt

foreign import capi unsafe "HsBase.h fcntl"
   c_fcntl_lock  :: CInt -> CInt -> Ptr CFLock -> IO CInt

foreign import ccall unsafe "HsBase.h fork"
   c_fork :: IO CPid

foreign import ccall unsafe "HsBase.h link"
   c_link :: CString -> CString -> IO CInt

-- capi is required at least on Android
foreign import capi unsafe "HsBase.h mkfifo"
   c_mkfifo :: CString -> CMode -> IO CInt

foreign import capi unsafe "signal.h sigemptyset"
   c_sigemptyset :: Ptr CSigset -> IO CInt

foreign import capi unsafe "signal.h sigaddset"
   c_sigaddset :: Ptr CSigset -> CInt -> IO CInt

foreign import capi unsafe "signal.h sigprocmask"
   c_sigprocmask :: CInt -> Ptr CSigset -> Ptr CSigset -> IO CInt

-- capi is required at least on Android
foreign import capi unsafe "HsBase.h tcgetattr"
   c_tcgetattr :: CInt -> Ptr CTermios -> IO CInt

-- capi is required at least on Android
foreign import capi unsafe "HsBase.h tcsetattr"
   c_tcsetattr :: CInt -> CInt -> Ptr CTermios -> IO CInt

foreign import ccall unsafe "HsBase.h waitpid"
   c_waitpid :: CPid -> Ptr CInt -> CInt -> IO CPid
#endif

-- POSIX flags only:
foreign import ccall unsafe "HsBase.h __hscore_o_rdonly" o_RDONLY :: CInt
foreign import ccall unsafe "HsBase.h __hscore_o_wronly" o_WRONLY :: CInt
foreign import ccall unsafe "HsBase.h __hscore_o_rdwr"   o_RDWR   :: CInt
foreign import ccall unsafe "HsBase.h __hscore_o_append" o_APPEND :: CInt
foreign import ccall unsafe "HsBase.h __hscore_o_creat"  o_CREAT  :: CInt
foreign import ccall unsafe "HsBase.h __hscore_o_excl"   o_EXCL   :: CInt
foreign import ccall unsafe "HsBase.h __hscore_o_trunc"  o_TRUNC  :: CInt

-- non-POSIX flags.
foreign import ccall unsafe "HsBase.h __hscore_o_noctty"   o_NOCTTY   :: CInt
foreign import ccall unsafe "HsBase.h __hscore_o_nonblock" o_NONBLOCK :: CInt
foreign import ccall unsafe "HsBase.h __hscore_o_binary"   o_BINARY   :: CInt

foreign import capi unsafe "sys/stat.h S_ISREG"  c_s_isreg  :: CMode -> CInt
foreign import capi unsafe "sys/stat.h S_ISCHR"  c_s_ischr  :: CMode -> CInt
foreign import capi unsafe "sys/stat.h S_ISBLK"  c_s_isblk  :: CMode -> CInt
foreign import capi unsafe "sys/stat.h S_ISDIR"  c_s_isdir  :: CMode -> CInt
foreign import capi unsafe "sys/stat.h S_ISFIFO" c_s_isfifo :: CMode -> CInt

s_isreg  :: CMode -> Bool
s_isreg :: CMode -> Bool
s_isreg CMode
cm = CMode -> CInt
c_s_isreg CMode
cm forall a. Eq a => a -> a -> Bool
/= CInt
0
s_ischr  :: CMode -> Bool
s_ischr :: CMode -> Bool
s_ischr CMode
cm = CMode -> CInt
c_s_ischr CMode
cm forall a. Eq a => a -> a -> Bool
/= CInt
0
s_isblk  :: CMode -> Bool
s_isblk :: CMode -> Bool
s_isblk CMode
cm = CMode -> CInt
c_s_isblk CMode
cm forall a. Eq a => a -> a -> Bool
/= CInt
0
s_isdir  :: CMode -> Bool
s_isdir :: CMode -> Bool
s_isdir CMode
cm = CMode -> CInt
c_s_isdir CMode
cm forall a. Eq a => a -> a -> Bool
/= CInt
0
s_isfifo :: CMode -> Bool
s_isfifo :: CMode -> Bool
s_isfifo CMode
cm = CMode -> CInt
c_s_isfifo CMode
cm forall a. Eq a => a -> a -> Bool
/= CInt
0

foreign import ccall unsafe "HsBase.h __hscore_sizeof_stat" sizeof_stat :: Int
foreign import ccall unsafe "HsBase.h __hscore_st_mtime" st_mtime :: Ptr CStat -> IO CTime
#if defined(mingw32_HOST_OS)
foreign import ccall unsafe "HsBase.h __hscore_st_size" st_size :: Ptr CStat -> IO Int64
#else
foreign import ccall unsafe "HsBase.h __hscore_st_size" st_size :: Ptr CStat -> IO COff
#endif
foreign import ccall unsafe "HsBase.h __hscore_st_mode" st_mode :: Ptr CStat -> IO CMode
foreign import ccall unsafe "HsBase.h __hscore_st_dev" st_dev :: Ptr CStat -> IO CDev
foreign import ccall unsafe "HsBase.h __hscore_st_ino" st_ino :: Ptr CStat -> IO CIno

foreign import ccall unsafe "HsBase.h __hscore_echo"         const_echo :: CInt
foreign import ccall unsafe "HsBase.h __hscore_tcsanow"      const_tcsanow :: CInt
foreign import ccall unsafe "HsBase.h __hscore_icanon"       const_icanon :: CInt
foreign import ccall unsafe "HsBase.h __hscore_vmin"         const_vmin   :: CInt
foreign import ccall unsafe "HsBase.h __hscore_vtime"        const_vtime  :: CInt
foreign import ccall unsafe "HsBase.h __hscore_sigttou"      const_sigttou :: CInt
foreign import ccall unsafe "HsBase.h __hscore_sig_block"    const_sig_block :: CInt
foreign import ccall unsafe "HsBase.h __hscore_sig_setmask"  const_sig_setmask :: CInt
foreign import ccall unsafe "HsBase.h __hscore_f_getfl"      const_f_getfl :: CInt
foreign import ccall unsafe "HsBase.h __hscore_f_setfl"      const_f_setfl :: CInt
foreign import ccall unsafe "HsBase.h __hscore_f_setfd"      const_f_setfd :: CInt
foreign import ccall unsafe "HsBase.h __hscore_fd_cloexec"   const_fd_cloexec :: CLong

#if defined(HTYPE_TCFLAG_T)
foreign import ccall unsafe "HsBase.h __hscore_sizeof_termios"  sizeof_termios :: Int
foreign import ccall unsafe "HsBase.h __hscore_sizeof_sigset_t" sizeof_sigset_t :: Int

foreign import ccall unsafe "HsBase.h __hscore_lflag" c_lflag :: Ptr CTermios -> IO CTcflag
foreign import ccall unsafe "HsBase.h __hscore_poke_lflag" poke_c_lflag :: Ptr CTermios -> CTcflag -> IO ()
foreign import ccall unsafe "HsBase.h __hscore_ptr_c_cc" ptr_c_cc  :: Ptr CTermios -> IO (Ptr Word8)
#endif

s_issock :: CMode -> Bool
#if !defined(mingw32_HOST_OS)
s_issock :: CMode -> Bool
s_issock CMode
cmode = CMode -> CInt
c_s_issock CMode
cmode forall a. Eq a => a -> a -> Bool
/= CInt
0
foreign import capi unsafe "sys/stat.h S_ISSOCK" c_s_issock :: CMode -> CInt
#else
s_issock _ = False
#endif

foreign import ccall unsafe "__hscore_bufsiz"  dEFAULT_BUFFER_SIZE :: Int
foreign import capi  unsafe "stdio.h value SEEK_CUR" sEEK_CUR :: CInt
foreign import capi  unsafe "stdio.h value SEEK_SET" sEEK_SET :: CInt
foreign import capi  unsafe "stdio.h value SEEK_END" sEEK_END :: CInt

{-
Note: Windows types

Windows' _read and _write have types that differ from POSIX. They take an
unsigned int for length and return a signed int where POSIX uses size_t and
ssize_t. Those are different on x86_64 and equivalent on x86. We import them
with the types in Microsoft's documentation which means that c_read,
c_safe_read, c_write and c_safe_write have different Haskell types depending on
the OS.
-}