Foreign/C/Error.hs

   1 {-# OPTIONS_GHC -XNoImplicitPrelude -#include "HsBase.h" #-}
   2 -----------------------------------------------------------------------------
   3 -- |
   4 -- Module      :  Foreign.C.Error
   5 -- Copyright   :  (c) The FFI task force 2001
   6 -- License     :  BSD-style (see the file libraries/base/LICENSE)
   7 --
   8 -- Maintainer  :  ffi@haskell.org
   9 -- Stability   :  provisional
  10 -- Portability :  portable
  11 --
  12 -- C-specific Marshalling support: Handling of C \"errno\" error codes.
  13 --
  14 -----------------------------------------------------------------------------
  15
  16 module Foreign.C.Error (
  17
  18   -- * Haskell representations of @errno@ values
  19
  20   Errno(..),            -- instance: Eq
  21
  22   -- ** Common @errno@ symbols
  23   -- | Different operating systems and\/or C libraries often support
  24   -- different values of @errno@.  This module defines the common values,
  25   -- but due to the open definition of 'Errno' users may add definitions
  26   -- which are not predefined.
  27   eOK, e2BIG, eACCES, eADDRINUSE, eADDRNOTAVAIL, eADV, eAFNOSUPPORT, eAGAIN,
  28   eALREADY, eBADF, eBADMSG, eBADRPC, eBUSY, eCHILD, eCOMM, eCONNABORTED,
  29   eCONNREFUSED, eCONNRESET, eDEADLK, eDESTADDRREQ, eDIRTY, eDOM, eDQUOT,
  30   eEXIST, eFAULT, eFBIG, eFTYPE, eHOSTDOWN, eHOSTUNREACH, eIDRM, eILSEQ,
  31   eINPROGRESS, eINTR, eINVAL, eIO, eISCONN, eISDIR, eLOOP, eMFILE, eMLINK,
  32   eMSGSIZE, eMULTIHOP, eNAMETOOLONG, eNETDOWN, eNETRESET, eNETUNREACH,
  33   eNFILE, eNOBUFS, eNODATA, eNODEV, eNOENT, eNOEXEC, eNOLCK, eNOLINK,
  34   eNOMEM, eNOMSG, eNONET, eNOPROTOOPT, eNOSPC, eNOSR, eNOSTR, eNOSYS,
  35   eNOTBLK, eNOTCONN, eNOTDIR, eNOTEMPTY, eNOTSOCK, eNOTTY, eNXIO,
  36   eOPNOTSUPP, ePERM, ePFNOSUPPORT, ePIPE, ePROCLIM, ePROCUNAVAIL,
  37   ePROGMISMATCH, ePROGUNAVAIL, ePROTO, ePROTONOSUPPORT, ePROTOTYPE,
  38   eRANGE, eREMCHG, eREMOTE, eROFS, eRPCMISMATCH, eRREMOTE, eSHUTDOWN,
  39   eSOCKTNOSUPPORT, eSPIPE, eSRCH, eSRMNT, eSTALE, eTIME, eTIMEDOUT,
  40   eTOOMANYREFS, eTXTBSY, eUSERS, eWOULDBLOCK, eXDEV,
  41
  42   -- ** 'Errno' functions
  43                         -- :: Errno
  44   isValidErrno,         -- :: Errno -> Bool
  45
  46   -- access to the current thread's "errno" value
  47   --
  48   getErrno,             -- :: IO Errno
  49   resetErrno,           -- :: IO ()
  50
  51   -- conversion of an "errno" value into IO error
  52   --
  53   errnoToIOError,       -- :: String       -- location
  54                         -- -> Errno        -- errno
  55                         -- -> Maybe Handle -- handle
  56                         -- -> Maybe String -- filename
  57                         -- -> IOError
  58
  59   -- throw current "errno" value
  60   --
  61   throwErrno,           -- ::                String               -> IO a
  62
  63   -- ** Guards for IO operations that may fail
  64
  65   throwErrnoIf,         -- :: (a -> Bool) -> String -> IO a       -> IO a
  66   throwErrnoIf_,        -- :: (a -> Bool) -> String -> IO a       -> IO ()
  67   throwErrnoIfRetry,    -- :: (a -> Bool) -> String -> IO a       -> IO a
  68   throwErrnoIfRetry_,   -- :: (a -> Bool) -> String -> IO a       -> IO ()
  69   throwErrnoIfMinus1,   -- :: Num a
  70                         -- =>                String -> IO a       -> IO a
  71   throwErrnoIfMinus1_,  -- :: Num a
  72                         -- =>                String -> IO a       -> IO ()
  73   throwErrnoIfMinus1Retry,
  74                         -- :: Num a
  75                         -- =>                String -> IO a       -> IO a
  76   throwErrnoIfMinus1Retry_,
  77                         -- :: Num a
  78                         -- =>                String -> IO a       -> IO ()
  79   throwErrnoIfNull,     -- ::                String -> IO (Ptr a) -> IO (Ptr a)
  80   throwErrnoIfNullRetry,-- ::                String -> IO (Ptr a) -> IO (Ptr a)
  81
  82   throwErrnoIfRetryMayBlock,
  83   throwErrnoIfRetryMayBlock_,
  84   throwErrnoIfMinus1RetryMayBlock,
  85   throwErrnoIfMinus1RetryMayBlock_,
  86   throwErrnoIfNullRetryMayBlock,
  87
  88   throwErrnoPath,
  89   throwErrnoPathIf,
  90   throwErrnoPathIf_,
  91   throwErrnoPathIfNull,
  92   throwErrnoPathIfMinus1,
  93   throwErrnoPathIfMinus1_,
  94 ) where
  95
  96
  97 -- this is were we get the CONST_XXX definitions from that configure
  98 -- calculated for us
  99 --
 100 #ifndef __NHC__
 101 #include "HsBaseConfig.h"
 102 #endif
 103
 104 -- system dependent imports
 105 -- ------------------------
 106
 107 -- GHC allows us to get at the guts inside IO errors/exceptions
 108 --
 109 #if __GLASGOW_HASKELL__
 110 import GHC.IOBase (IOException(..), IOErrorType(..))
 111 #endif /* __GLASGOW_HASKELL__ */
 112
 113
 114 -- regular imports
 115 -- ---------------
 116
 117 import Foreign.Storable
 118 import Foreign.Ptr
 119 import Foreign.C.Types
 120 import Foreign.C.String
 121 import Foreign.Marshal.Error    ( void )
 122 import Data.Maybe
 123
 124 #if __GLASGOW_HASKELL__
 125 import GHC.IOBase
 126 import GHC.Num
 127 import GHC.Base
 128 #elif __HUGS__
 129 import Hugs.Prelude             ( Handle, IOError, ioError )
 130 import System.IO.Unsafe         ( unsafePerformIO )
 131 #else
 132 import System.IO                ( Handle )
 133 import System.IO.Error          ( IOError, ioError )
 134 import System.IO.Unsafe         ( unsafePerformIO )
 135 #endif
 136
 137 #ifdef __HUGS__
 138 {-# CFILES cbits/PrelIOUtils.c #-}
 139 #endif
 140
 141
 142 -- "errno" type
 143 -- ------------
 144
 145 -- | Haskell representation for @errno@ values.
 146 -- The implementation is deliberately exposed, to allow users to add
 147 -- their own definitions of 'Errno' values.
 148
 149 newtype Errno = Errno CInt
 150
 151 instance Eq Errno where
 152   errno1@(Errno no1) == errno2@(Errno no2)
 153     | isValidErrno errno1 && isValidErrno errno2 = no1 == no2
 154     | otherwise                                  = False
 155
 156 -- common "errno" symbols
 157 --
 158 eOK, e2BIG, eACCES, eADDRINUSE, eADDRNOTAVAIL, eADV, eAFNOSUPPORT, eAGAIN,
 159   eALREADY, eBADF, eBADMSG, eBADRPC, eBUSY, eCHILD, eCOMM, eCONNABORTED,
 160   eCONNREFUSED, eCONNRESET, eDEADLK, eDESTADDRREQ, eDIRTY, eDOM, eDQUOT,
 161   eEXIST, eFAULT, eFBIG, eFTYPE, eHOSTDOWN, eHOSTUNREACH, eIDRM, eILSEQ,
 162   eINPROGRESS, eINTR, eINVAL, eIO, eISCONN, eISDIR, eLOOP, eMFILE, eMLINK,
 163   eMSGSIZE, eMULTIHOP, eNAMETOOLONG, eNETDOWN, eNETRESET, eNETUNREACH,
 164   eNFILE, eNOBUFS, eNODATA, eNODEV, eNOENT, eNOEXEC, eNOLCK, eNOLINK,
 165   eNOMEM, eNOMSG, eNONET, eNOPROTOOPT, eNOSPC, eNOSR, eNOSTR, eNOSYS,
 166   eNOTBLK, eNOTCONN, eNOTDIR, eNOTEMPTY, eNOTSOCK, eNOTTY, eNXIO,
 167   eOPNOTSUPP, ePERM, ePFNOSUPPORT, ePIPE, ePROCLIM, ePROCUNAVAIL,
 168   ePROGMISMATCH, ePROGUNAVAIL, ePROTO, ePROTONOSUPPORT, ePROTOTYPE,
 169   eRANGE, eREMCHG, eREMOTE, eROFS, eRPCMISMATCH, eRREMOTE, eSHUTDOWN,
 170   eSOCKTNOSUPPORT, eSPIPE, eSRCH, eSRMNT, eSTALE, eTIME, eTIMEDOUT,
 171   eTOOMANYREFS, eTXTBSY, eUSERS, eWOULDBLOCK, eXDEV                    :: Errno
 172 --
 173 -- the cCONST_XXX identifiers are cpp symbols whose value is computed by
 174 -- configure
 175 --
 176 eOK             = Errno 0
 177 #ifdef __NHC__
 178 #include "Errno.hs"
 179 #else
 180 e2BIG           = Errno (CONST_E2BIG)
 181 eACCES          = Errno (CONST_EACCES)
 182 eADDRINUSE      = Errno (CONST_EADDRINUSE)
 183 eADDRNOTAVAIL   = Errno (CONST_EADDRNOTAVAIL)
 184 eADV            = Errno (CONST_EADV)
 185 eAFNOSUPPORT    = Errno (CONST_EAFNOSUPPORT)
 186 eAGAIN          = Errno (CONST_EAGAIN)
 187 eALREADY        = Errno (CONST_EALREADY)
 188 eBADF           = Errno (CONST_EBADF)
 189 eBADMSG         = Errno (CONST_EBADMSG)
 190 eBADRPC         = Errno (CONST_EBADRPC)
 191 eBUSY           = Errno (CONST_EBUSY)
 192 eCHILD          = Errno (CONST_ECHILD)
 193 eCOMM           = Errno (CONST_ECOMM)
 194 eCONNABORTED    = Errno (CONST_ECONNABORTED)
 195 eCONNREFUSED    = Errno (CONST_ECONNREFUSED)
 196 eCONNRESET      = Errno (CONST_ECONNRESET)
 197 eDEADLK         = Errno (CONST_EDEADLK)
 198 eDESTADDRREQ    = Errno (CONST_EDESTADDRREQ)
 199 eDIRTY          = Errno (CONST_EDIRTY)
 200 eDOM            = Errno (CONST_EDOM)
 201 eDQUOT          = Errno (CONST_EDQUOT)
 202 eEXIST          = Errno (CONST_EEXIST)
 203 eFAULT          = Errno (CONST_EFAULT)
 204 eFBIG           = Errno (CONST_EFBIG)
 205 eFTYPE          = Errno (CONST_EFTYPE)
 206 eHOSTDOWN       = Errno (CONST_EHOSTDOWN)
 207 eHOSTUNREACH    = Errno (CONST_EHOSTUNREACH)
 208 eIDRM           = Errno (CONST_EIDRM)
 209 eILSEQ          = Errno (CONST_EILSEQ)
 210 eINPROGRESS     = Errno (CONST_EINPROGRESS)
 211 eINTR           = Errno (CONST_EINTR)
 212 eINVAL          = Errno (CONST_EINVAL)
 213 eIO             = Errno (CONST_EIO)
 214 eISCONN         = Errno (CONST_EISCONN)
 215 eISDIR          = Errno (CONST_EISDIR)
 216 eLOOP           = Errno (CONST_ELOOP)
 217 eMFILE          = Errno (CONST_EMFILE)
 218 eMLINK          = Errno (CONST_EMLINK)
 219 eMSGSIZE        = Errno (CONST_EMSGSIZE)
 220 eMULTIHOP       = Errno (CONST_EMULTIHOP)
 221 eNAMETOOLONG    = Errno (CONST_ENAMETOOLONG)
 222 eNETDOWN        = Errno (CONST_ENETDOWN)
 223 eNETRESET       = Errno (CONST_ENETRESET)
 224 eNETUNREACH     = Errno (CONST_ENETUNREACH)
 225 eNFILE          = Errno (CONST_ENFILE)
 226 eNOBUFS         = Errno (CONST_ENOBUFS)
 227 eNODATA         = Errno (CONST_ENODATA)
 228 eNODEV          = Errno (CONST_ENODEV)
 229 eNOENT          = Errno (CONST_ENOENT)
 230 eNOEXEC         = Errno (CONST_ENOEXEC)
 231 eNOLCK          = Errno (CONST_ENOLCK)
 232 eNOLINK         = Errno (CONST_ENOLINK)
 233 eNOMEM          = Errno (CONST_ENOMEM)
 234 eNOMSG          = Errno (CONST_ENOMSG)
 235 eNONET          = Errno (CONST_ENONET)
 236 eNOPROTOOPT     = Errno (CONST_ENOPROTOOPT)
 237 eNOSPC          = Errno (CONST_ENOSPC)
 238 eNOSR           = Errno (CONST_ENOSR)
 239 eNOSTR          = Errno (CONST_ENOSTR)
 240 eNOSYS          = Errno (CONST_ENOSYS)
 241 eNOTBLK         = Errno (CONST_ENOTBLK)
 242 eNOTCONN        = Errno (CONST_ENOTCONN)
 243 eNOTDIR         = Errno (CONST_ENOTDIR)
 244 eNOTEMPTY       = Errno (CONST_ENOTEMPTY)
 245 eNOTSOCK        = Errno (CONST_ENOTSOCK)
 246 eNOTTY          = Errno (CONST_ENOTTY)
 247 eNXIO           = Errno (CONST_ENXIO)
 248 eOPNOTSUPP      = Errno (CONST_EOPNOTSUPP)
 249 ePERM           = Errno (CONST_EPERM)
 250 ePFNOSUPPORT    = Errno (CONST_EPFNOSUPPORT)
 251 ePIPE           = Errno (CONST_EPIPE)
 252 ePROCLIM        = Errno (CONST_EPROCLIM)
 253 ePROCUNAVAIL    = Errno (CONST_EPROCUNAVAIL)
 254 ePROGMISMATCH   = Errno (CONST_EPROGMISMATCH)
 255 ePROGUNAVAIL    = Errno (CONST_EPROGUNAVAIL)
 256 ePROTO          = Errno (CONST_EPROTO)
 257 ePROTONOSUPPORT = Errno (CONST_EPROTONOSUPPORT)
 258 ePROTOTYPE      = Errno (CONST_EPROTOTYPE)
 259 eRANGE          = Errno (CONST_ERANGE)
 260 eREMCHG         = Errno (CONST_EREMCHG)
 261 eREMOTE         = Errno (CONST_EREMOTE)
 262 eROFS           = Errno (CONST_EROFS)
 263 eRPCMISMATCH    = Errno (CONST_ERPCMISMATCH)
 264 eRREMOTE        = Errno (CONST_ERREMOTE)
 265 eSHUTDOWN       = Errno (CONST_ESHUTDOWN)
 266 eSOCKTNOSUPPORT = Errno (CONST_ESOCKTNOSUPPORT)
 267 eSPIPE          = Errno (CONST_ESPIPE)
 268 eSRCH           = Errno (CONST_ESRCH)
 269 eSRMNT          = Errno (CONST_ESRMNT)
 270 eSTALE          = Errno (CONST_ESTALE)
 271 eTIME           = Errno (CONST_ETIME)
 272 eTIMEDOUT       = Errno (CONST_ETIMEDOUT)
 273 eTOOMANYREFS    = Errno (CONST_ETOOMANYREFS)
 274 eTXTBSY         = Errno (CONST_ETXTBSY)
 275 eUSERS          = Errno (CONST_EUSERS)
 276 eWOULDBLOCK     = Errno (CONST_EWOULDBLOCK)
 277 eXDEV           = Errno (CONST_EXDEV)
 278 #endif
 279
 280 -- | Yield 'True' if the given 'Errno' value is valid on the system.
 281 -- This implies that the 'Eq' instance of 'Errno' is also system dependent
 282 -- as it is only defined for valid values of 'Errno'.
 283 --
 284 isValidErrno               :: Errno -> Bool
 285 --
 286 -- the configure script sets all invalid "errno"s to -1
 287 --
 288 isValidErrno (Errno errno)  = errno /= -1
 289
 290
 291 -- access to the current thread's "errno" value
 292 -- --------------------------------------------
 293
 294 -- | Get the current value of @errno@ in the current thread.
 295 --
 296 getErrno :: IO Errno
 297
 298 -- We must call a C function to get the value of errno in general.  On
 299 -- threaded systems, errno is hidden behind a C macro so that each OS
 300 -- thread gets its own copy.
 301 #ifdef __NHC__
 302 getErrno = do e <- peek _errno; return (Errno e)
 303 foreign import ccall unsafe "errno.h &errno" _errno :: Ptr CInt
 304 #else
 305 getErrno = do e <- get_errno; return (Errno e)
 306 foreign import ccall unsafe "HsBase.h __hscore_get_errno" get_errno :: IO CInt
 307 #endif
 308
 309 -- | Reset the current thread\'s @errno@ value to 'eOK'.
 310 --
 311 resetErrno :: IO ()
 312
 313 -- Again, setting errno has to be done via a C function.
 314 #ifdef __NHC__
 315 resetErrno = poke _errno 0
 316 #else
 317 resetErrno = set_errno 0
 318 foreign import ccall unsafe "HsBase.h __hscore_set_errno" set_errno :: CInt -> IO ()
 319 #endif
 320
 321 -- throw current "errno" value
 322 -- ---------------------------
 323
 324 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'.
 325 --
 326 throwErrno     :: String        -- ^ textual description of the error location
 327                -> IO a
 328 throwErrno loc  =
 329   do
 330     errno <- getErrno
 331     ioError (errnoToIOError loc errno Nothing Nothing)
 332
 333
 334 -- guards for IO operations that may fail
 335 -- --------------------------------------
 336
 337 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
 338 -- if the result value of the 'IO' action meets the given predicate.
 339 --
 340 throwErrnoIf    :: (a -> Bool)  -- ^ predicate to apply to the result value
 341                                 -- of the 'IO' operation
 342                 -> String       -- ^ textual description of the location
 343                 -> IO a         -- ^ the 'IO' operation to be executed
 344                 -> IO a
 345 throwErrnoIf pred loc f  =
 346   do
 347     res <- f
 348     if pred res then throwErrno loc else return res
 349
 350 -- | as 'throwErrnoIf', but discards the result of the 'IO' action after
 351 -- error handling.
 352 --
 353 throwErrnoIf_   :: (a -> Bool) -> String -> IO a -> IO ()
 354 throwErrnoIf_ pred loc f  = void $ throwErrnoIf pred loc f
 355
 356 -- | as 'throwErrnoIf', but retry the 'IO' action when it yields the
 357 -- error code 'eINTR' - this amounts to the standard retry loop for
 358 -- interrupted POSIX system calls.
 359 --
 360 throwErrnoIfRetry            :: (a -> Bool) -> String -> IO a -> IO a
 361 throwErrnoIfRetry pred loc f  =
 362   do
 363     res <- f
 364     if pred res
 365       then do
 366         err <- getErrno
 367         if err == eINTR
 368           then throwErrnoIfRetry pred loc f
 369           else throwErrno loc
 370       else return res
 371
 372 -- | as 'throwErrnoIfRetry', but checks for operations that would block and
 373 -- executes an alternative action before retrying in that case.
 374 --
 375 throwErrnoIfRetryMayBlock
 376                 :: (a -> Bool)  -- ^ predicate to apply to the result value
 377                                 -- of the 'IO' operation
 378                 -> String       -- ^ textual description of the location
 379                 -> IO a         -- ^ the 'IO' operation to be executed
 380                 -> IO b         -- ^ action to execute before retrying if
 381                                 -- an immediate retry would block
 382                 -> IO a
 383 throwErrnoIfRetryMayBlock pred loc f on_block  =
 384   do
 385     res <- f
 386     if pred res
 387       then do
 388         err <- getErrno
 389         if err == eINTR
 390           then throwErrnoIfRetryMayBlock pred loc f on_block
 391           else if err == eWOULDBLOCK || err == eAGAIN
 392                  then do on_block; throwErrnoIfRetryMayBlock pred loc f on_block
 393                  else throwErrno loc
 394       else return res
 395
 396 -- | as 'throwErrnoIfRetry', but discards the result.
 397 --
 398 throwErrnoIfRetry_            :: (a -> Bool) -> String -> IO a -> IO ()
 399 throwErrnoIfRetry_ pred loc f  = void $ throwErrnoIfRetry pred loc f
 400
 401 -- | as 'throwErrnoIfRetryMayBlock', but discards the result.
 402 --
 403 throwErrnoIfRetryMayBlock_ :: (a -> Bool) -> String -> IO a -> IO b -> IO ()
 404 throwErrnoIfRetryMayBlock_ pred loc f on_block
 405   = void $ throwErrnoIfRetryMayBlock pred loc f on_block
 406
 407 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
 408 -- if the 'IO' action returns a result of @-1@.
 409 --
 410 throwErrnoIfMinus1 :: Num a => String -> IO a -> IO a
 411 throwErrnoIfMinus1  = throwErrnoIf (== -1)
 412
 413 -- | as 'throwErrnoIfMinus1', but discards the result.
 414 --
 415 throwErrnoIfMinus1_ :: Num a => String -> IO a -> IO ()
 416 throwErrnoIfMinus1_  = throwErrnoIf_ (== -1)
 417
 418 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
 419 -- if the 'IO' action returns a result of @-1@, but retries in case of
 420 -- an interrupted operation.
 421 --
 422 throwErrnoIfMinus1Retry :: Num a => String -> IO a -> IO a
 423 throwErrnoIfMinus1Retry  = throwErrnoIfRetry (== -1)
 424
 425 -- | as 'throwErrnoIfMinus1', but discards the result.
 426 --
 427 throwErrnoIfMinus1Retry_ :: Num a => String -> IO a -> IO ()
 428 throwErrnoIfMinus1Retry_  = throwErrnoIfRetry_ (== -1)
 429
 430 -- | as 'throwErrnoIfMinus1Retry', but checks for operations that would block.
 431 --
 432 throwErrnoIfMinus1RetryMayBlock :: Num a => String -> IO a -> IO b -> IO a
 433 throwErrnoIfMinus1RetryMayBlock  = throwErrnoIfRetryMayBlock (== -1)
 434
 435 -- | as 'throwErrnoIfMinus1RetryMayBlock', but discards the result.
 436 --
 437 throwErrnoIfMinus1RetryMayBlock_ :: Num a => String -> IO a -> IO b -> IO ()
 438 throwErrnoIfMinus1RetryMayBlock_  = throwErrnoIfRetryMayBlock_ (== -1)
 439
 440 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
 441 -- if the 'IO' action returns 'nullPtr'.
 442 --
 443 throwErrnoIfNull :: String -> IO (Ptr a) -> IO (Ptr a)
 444 throwErrnoIfNull  = throwErrnoIf (== nullPtr)
 445
 446 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
 447 -- if the 'IO' action returns 'nullPtr',
 448 -- but retry in case of an interrupted operation.
 449 --
 450 throwErrnoIfNullRetry :: String -> IO (Ptr a) -> IO (Ptr a)
 451 throwErrnoIfNullRetry  = throwErrnoIfRetry (== nullPtr)
 452
 453 -- | as 'throwErrnoIfNullRetry', but checks for operations that would block.
 454 --
 455 throwErrnoIfNullRetryMayBlock :: String -> IO (Ptr a) -> IO b -> IO (Ptr a)
 456 throwErrnoIfNullRetryMayBlock  = throwErrnoIfRetryMayBlock (== nullPtr)
 457
 458 -- | as 'throwErrno', but exceptions include the given path when appropriate.
 459 --
 460 throwErrnoPath :: String -> FilePath -> IO a
 461 throwErrnoPath loc path =
 462   do
 463     errno <- getErrno
 464     ioError (errnoToIOError loc errno Nothing (Just path))
 465
 466 -- | as 'throwErrnoIf', but exceptions include the given path when
 467 --   appropriate.
 468 --
 469 throwErrnoPathIf :: (a -> Bool) -> String -> FilePath -> IO a -> IO a
 470 throwErrnoPathIf pred loc path f =
 471   do
 472     res <- f
 473     if pred res then throwErrnoPath loc path else return res
 474
 475 -- | as 'throwErrnoIf_', but exceptions include the given path when
 476 --   appropriate.
 477 --
 478 throwErrnoPathIf_ :: (a -> Bool) -> String -> FilePath -> IO a -> IO ()
 479 throwErrnoPathIf_ pred loc path f  = void $ throwErrnoPathIf pred loc path f
 480
 481 -- | as 'throwErrnoIfNull', but exceptions include the given path when
 482 --   appropriate.
 483 --
 484 throwErrnoPathIfNull :: String -> FilePath -> IO (Ptr a) -> IO (Ptr a)
 485 throwErrnoPathIfNull  = throwErrnoPathIf (== nullPtr)
 486
 487 -- | as 'throwErrnoIfMinus1', but exceptions include the given path when
 488 --   appropriate.
 489 --
 490 throwErrnoPathIfMinus1 :: Num a => String -> FilePath -> IO a -> IO a
 491 throwErrnoPathIfMinus1 = throwErrnoPathIf (== -1)
 492
 493 -- | as 'throwErrnoIfMinus1_', but exceptions include the given path when
 494 --   appropriate.
 495 --
 496 throwErrnoPathIfMinus1_ :: Num a => String -> FilePath -> IO a -> IO ()
 497 throwErrnoPathIfMinus1_  = throwErrnoPathIf_ (== -1)
 498
 499 -- conversion of an "errno" value into IO error
 500 -- --------------------------------------------
 501
 502 -- | Construct a Haskell 98 I\/O error based on the given 'Errno' value.
 503 -- The optional information can be used to improve the accuracy of
 504 -- error messages.
 505 --
 506 errnoToIOError  :: String       -- ^ the location where the error occurred
 507                 -> Errno        -- ^ the error number
 508                 -> Maybe Handle -- ^ optional handle associated with the error
 509                 -> Maybe String -- ^ optional filename associated with the error
 510                 -> IOError
 511 errnoToIOError loc errno maybeHdl maybeName = unsafePerformIO $ do
 512     str <- strerror errno >>= peekCString
 513 #if __GLASGOW_HASKELL__
 514     return (IOError maybeHdl errType loc str maybeName)
 515     where
 516     errType
 517         | errno == eOK             = OtherError
 518         | errno == e2BIG           = ResourceExhausted
 519         | errno == eACCES          = PermissionDenied
 520         | errno == eADDRINUSE      = ResourceBusy
 521         | errno == eADDRNOTAVAIL   = UnsupportedOperation
 522         | errno == eADV            = OtherError
 523         | errno == eAFNOSUPPORT    = UnsupportedOperation
 524         | errno == eAGAIN          = ResourceExhausted
 525         | errno == eALREADY        = AlreadyExists
 526         | errno == eBADF           = InvalidArgument
 527         | errno == eBADMSG         = InappropriateType
 528         | errno == eBADRPC         = OtherError
 529         | errno == eBUSY           = ResourceBusy
 530         | errno == eCHILD          = NoSuchThing
 531         | errno == eCOMM           = ResourceVanished
 532         | errno == eCONNABORTED    = OtherError
 533         | errno == eCONNREFUSED    = NoSuchThing
 534         | errno == eCONNRESET      = ResourceVanished
 535         | errno == eDEADLK         = ResourceBusy
 536         | errno == eDESTADDRREQ    = InvalidArgument
 537         | errno == eDIRTY          = UnsatisfiedConstraints
 538         | errno == eDOM            = InvalidArgument
 539         | errno == eDQUOT          = PermissionDenied
 540         | errno == eEXIST          = AlreadyExists
 541         | errno == eFAULT          = OtherError
 542         | errno == eFBIG           = PermissionDenied
 543         | errno == eFTYPE          = InappropriateType
 544         | errno == eHOSTDOWN       = NoSuchThing
 545         | errno == eHOSTUNREACH    = NoSuchThing
 546         | errno == eIDRM           = ResourceVanished
 547         | errno == eILSEQ          = InvalidArgument
 548         | errno == eINPROGRESS     = AlreadyExists
 549         | errno == eINTR           = Interrupted
 550         | errno == eINVAL          = InvalidArgument
 551         | errno == eIO             = HardwareFault
 552         | errno == eISCONN         = AlreadyExists
 553         | errno == eISDIR          = InappropriateType
 554         | errno == eLOOP           = InvalidArgument
 555         | errno == eMFILE          = ResourceExhausted
 556         | errno == eMLINK          = ResourceExhausted
 557         | errno == eMSGSIZE        = ResourceExhausted
 558         | errno == eMULTIHOP       = UnsupportedOperation
 559         | errno == eNAMETOOLONG    = InvalidArgument
 560         | errno == eNETDOWN        = ResourceVanished
 561         | errno == eNETRESET       = ResourceVanished
 562         | errno == eNETUNREACH     = NoSuchThing
 563         | errno == eNFILE          = ResourceExhausted
 564         | errno == eNOBUFS         = ResourceExhausted
 565         | errno == eNODATA         = NoSuchThing
 566         | errno == eNODEV          = UnsupportedOperation
 567         | errno == eNOENT          = NoSuchThing
 568         | errno == eNOEXEC         = InvalidArgument
 569         | errno == eNOLCK          = ResourceExhausted
 570         | errno == eNOLINK         = ResourceVanished
 571         | errno == eNOMEM          = ResourceExhausted
 572         | errno == eNOMSG          = NoSuchThing
 573         | errno == eNONET          = NoSuchThing
 574         | errno == eNOPROTOOPT     = UnsupportedOperation
 575         | errno == eNOSPC          = ResourceExhausted
 576         | errno == eNOSR           = ResourceExhausted
 577         | errno == eNOSTR          = InvalidArgument
 578         | errno == eNOSYS          = UnsupportedOperation
 579         | errno == eNOTBLK         = InvalidArgument
 580         | errno == eNOTCONN        = InvalidArgument
 581         | errno == eNOTDIR         = InappropriateType
 582         | errno == eNOTEMPTY       = UnsatisfiedConstraints
 583         | errno == eNOTSOCK        = InvalidArgument
 584         | errno == eNOTTY          = IllegalOperation
 585         | errno == eNXIO           = NoSuchThing
 586         | errno == eOPNOTSUPP      = UnsupportedOperation
 587         | errno == ePERM           = PermissionDenied
 588         | errno == ePFNOSUPPORT    = UnsupportedOperation
 589         | errno == ePIPE           = ResourceVanished
 590         | errno == ePROCLIM        = PermissionDenied
 591         | errno == ePROCUNAVAIL    = UnsupportedOperation
 592         | errno == ePROGMISMATCH   = ProtocolError
 593         | errno == ePROGUNAVAIL    = UnsupportedOperation
 594         | errno == ePROTO          = ProtocolError
 595         | errno == ePROTONOSUPPORT = ProtocolError
 596         | errno == ePROTOTYPE      = ProtocolError
 597         | errno == eRANGE          = UnsupportedOperation
 598         | errno == eREMCHG         = ResourceVanished
 599         | errno == eREMOTE         = IllegalOperation
 600         | errno == eROFS           = PermissionDenied
 601         | errno == eRPCMISMATCH    = ProtocolError
 602         | errno == eRREMOTE        = IllegalOperation
 603         | errno == eSHUTDOWN       = IllegalOperation
 604         | errno == eSOCKTNOSUPPORT = UnsupportedOperation
 605         | errno == eSPIPE          = UnsupportedOperation
 606         | errno == eSRCH           = NoSuchThing
 607         | errno == eSRMNT          = UnsatisfiedConstraints
 608         | errno == eSTALE          = ResourceVanished
 609         | errno == eTIME           = TimeExpired
 610         | errno == eTIMEDOUT       = TimeExpired
 611         | errno == eTOOMANYREFS    = ResourceExhausted
 612         | errno == eTXTBSY         = ResourceBusy
 613         | errno == eUSERS          = ResourceExhausted
 614         | errno == eWOULDBLOCK     = OtherError
 615         | errno == eXDEV           = UnsupportedOperation
 616         | otherwise                = OtherError
 617 #else
 618     return (userError (loc ++ ": " ++ str ++ maybe "" (": "++) maybeName))
 619 #endif
 620
 621 foreign import ccall unsafe "string.h" strerror :: Errno -> IO (Ptr CChar)