{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE UnliftedFFITypes #-}
{-# LANGUAGE MagicHash #-}
module Netw.Internal.Socket 
( retryOrThrowErrnoIfMinus1
, throwErrnoIfNothing

, socket

, bind#
, bind

, listen

, getsockname#
, getsockname

, accept#
, accept

, connect#
, connect

, send#, send, sendto#
, sendto, sendmsg#, sendmsg

, recv#, recv
, recvfrom#, recvfrom
, recvmsg#, recvmsg

, shutdown
) where
import Netw.Internal.Enum
import Netw.Internal.Type

import Foreign
import Foreign.C

import System.Posix.Types

import GHC.Exts

retryOrThrowErrnoIfMinus1 :: (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 :: forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
msg IO a
action = do
  a
r <- IO a
action
  if a
r a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== -a
1
  then do
    Errno
errno <- IO Errno
getErrno
    if Errno
errno Errno -> Errno -> Bool
forall a. Eq a => a -> a -> Bool
== Errno
eAGAIN Bool -> Bool -> Bool
|| Errno
errno Errno -> Errno -> Bool
forall a. Eq a => a -> a -> Bool
== Errno
eWOULDBLOCK then
      String -> IO a -> IO a
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
msg IO a
action
    else
      String -> IO a
forall a. String -> IO a
throwErrno String
msg
  else
    a -> IO a
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return a
r
-- Remember to check a (the returned value) to determine if an error occure
-- since something else might have failed before that and errno is no longer EOK
throwErrnoIfNothing :: String -> (a -> Errno -> Maybe b) -> IO a -> IO b
throwErrnoIfNothing :: forall a b. String -> (a -> Errno -> Maybe b) -> IO a -> IO b
throwErrnoIfNothing String
msg a -> Errno -> Maybe b
func IO a
act = do
  a
ret <- IO a
act
  Errno
err <- IO Errno
getErrno
  let may :: Maybe b
may = a -> Errno -> Maybe b
func a
ret Errno
err
  case Maybe b
may of
    Maybe b
Nothing -> String -> IO b
forall a. String -> IO a
throwErrno String
msg
    Just b
b  -> b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
b

zeroIfMinus1AndEAGAINOrEWOULDBLOCK :: (Num a, Eq a) => a -> Errno -> Maybe a
zeroIfMinus1AndEAGAINOrEWOULDBLOCK :: forall a. (Num a, Eq a) => a -> Errno -> Maybe a
zeroIfMinus1AndEAGAINOrEWOULDBLOCK (-1) Errno
errno
  | Errno
errno Errno -> Errno -> Bool
forall a. Eq a => a -> a -> Bool
== Errno
eAGAIN Bool -> Bool -> Bool
|| Errno
errno Errno -> Errno -> Bool
forall a. Eq a => a -> a -> Bool
== Errno
eWOULDBLOCK = a -> Maybe a
forall a. a -> Maybe a
Just a
0
  | Bool
otherwise = Maybe a
forall a. Maybe a
Nothing
zeroIfMinus1AndEAGAINOrEWOULDBLOCK a
a Errno
_ = a -> Maybe a
forall a. a -> Maybe a
Just a
a

throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK :: (Num a, Eq a) => String -> IO a -> IO a
throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK :: forall a. (Num a, Eq a) => String -> IO a -> IO a
throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK String
msg IO a
act = do
  a
ret <- IO a
act
  if a
ret a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== -a
1 
  then do
    Errno
errno <- IO Errno
getErrno
    if Errno
errno Errno -> Errno -> Bool
forall a. Eq a => a -> a -> Bool
== Errno
eAGAIN Bool -> Bool -> Bool
|| Errno
errno Errno -> Errno -> Bool
forall a. Eq a => a -> a -> Bool
== Errno
eWOULDBLOCK
    then 
      a -> IO a
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return a
0
    else
      String -> IO a
forall a. String -> IO a
throwErrno String
msg
  else
    a -> IO a
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return a
ret

foreign import ccall unsafe "socket_wrapper"
  socket_  :: ProtocolFamily -> SocketType -> Protocol -> IO CInt
socket :: ProtocolFamily -> SocketType -> Protocol -> IO Fd
socket :: ProtocolFamily -> SocketType -> Protocol -> IO Fd
socket ProtocolFamily
domain SocketType
stype Protocol
protocol = CInt -> Fd
Fd (CInt -> Fd) -> IO CInt -> IO Fd
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  String -> IO CInt -> IO CInt
forall a. (Eq a, Num a) => String -> IO a -> IO a
throwErrnoIfMinus1 String
"socket failed to create socket"
    (ProtocolFamily -> SocketType -> Protocol -> IO CInt
socket_ ProtocolFamily
domain SocketType
stype Protocol
protocol)

foreign import ccall unsafe "bind"
  bind_#   :: Fd -> ByteArray# -> CSocklen -> IO CInt
bind# :: Fd -> ByteArray# -> CSocklen -> IO ()
bind# :: Fd -> ByteArray# -> CSocklen -> IO ()
bind# Fd
sockfd ByteArray#
address CSocklen
addressLen =
  String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"bind failed to bind sockfd"
    (Fd -> ByteArray# -> CSocklen -> IO CInt
bind_# Fd
sockfd ByteArray#
address CSocklen
addressLen)
foreign import ccall unsafe "bind"
  bind_    :: Fd -> Ptr () -> CSocklen -> IO CInt
bind :: Fd -> Ptr () -> CSocklen -> IO ()
bind :: Fd -> Ptr () -> CSocklen -> IO ()
bind Fd
sockfd Ptr ()
address CSocklen
addressLen =
  String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"bind failed to bind sockfd"
    (Fd -> Ptr () -> CSocklen -> IO CInt
bind_ Fd
sockfd Ptr ()
address CSocklen
addressLen)


foreign import ccall unsafe "listen"
  listen_   :: Fd -> CInt -> IO CInt
listen :: Fd -> CInt -> IO ()
listen :: Fd -> CInt -> IO ()
listen Fd
sockfd CInt
backlog =
  String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"listen fail"
    (Fd -> CInt -> IO CInt
listen_ Fd
sockfd CInt
backlog)

-- TODO: Add an extra argument to specify retry wait time
foreign import ccall unsafe "accept"
  accept_# :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO CInt
accept# :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO Fd
accept# :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO Fd
accept# Fd
sockfd MutableByteArray# RealWorld
address Ptr CSocklen
addressLen = CInt -> Fd
Fd (CInt -> Fd) -> IO CInt -> IO Fd
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  String -> IO CInt -> IO CInt
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
"accept failed" (Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO CInt
accept_# Fd
sockfd MutableByteArray# RealWorld
address Ptr CSocklen
addressLen)
foreign import ccall unsafe "accept"
  accept_  :: Fd -> Ptr () -> Ptr CSocklen -> IO CInt    
accept :: Fd -> Ptr () -> Ptr CSocklen -> IO Fd
accept :: Fd -> Ptr () -> Ptr CSocklen -> IO Fd
accept Fd
sockfd Ptr ()
address Ptr CSocklen
addressLen = CInt -> Fd
Fd (CInt -> Fd) -> IO CInt -> IO Fd
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  String -> IO CInt -> IO CInt
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
"accept failed" (Fd -> Ptr () -> Ptr CSocklen -> IO CInt
accept_ Fd
sockfd Ptr ()
address Ptr CSocklen
addressLen)

foreign import ccall unsafe "getsockname"
  getsockname_# :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO CInt
getsockname# :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO ()
getsockname# :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO ()
getsockname# Fd
sockfd MutableByteArray# RealWorld
address Ptr CSocklen
addressLen =
  String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"getsockname failed"
    (Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO CInt
getsockname_# Fd
sockfd MutableByteArray# RealWorld
address Ptr CSocklen
addressLen)

foreign import ccall unsafe "getsockname"
  getsockname_ :: Fd -> Ptr () -> Ptr CSocklen -> IO CInt
getsockname :: Fd -> Ptr () -> Ptr CSocklen -> IO ()
getsockname :: Fd -> Ptr () -> Ptr CSocklen -> IO ()
getsockname Fd
sockfd Ptr ()
address Ptr CSocklen
addressLen =
  String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"getsockname failed"
    (Fd -> Ptr () -> Ptr CSocklen -> IO CInt
getsockname_ Fd
sockfd Ptr ()
address Ptr CSocklen
addressLen)

foreign import ccall unsafe "connect"
  connect_# :: Fd -> ByteArray# -> CSocklen -> IO CInt
connect# :: Fd -> ByteArray# -> CSocklen -> IO ()
connect# :: Fd -> ByteArray# -> CSocklen -> IO ()
connect# Fd
sockfd ByteArray#
address CSocklen
addressLen =
  String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"connect failed"
    (Fd -> ByteArray# -> CSocklen -> IO CInt
connect_# Fd
sockfd ByteArray#
address CSocklen
addressLen)
foreign import ccall unsafe "connect"
  connect_  :: Fd -> Ptr () -> CSocklen -> IO CInt
connect :: Fd -> Ptr () -> CSocklen -> IO ()
connect :: Fd -> Ptr () -> CSocklen -> IO ()
connect Fd
sockfd Ptr ()
address CSocklen
addressLen =
  String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"connect failed"
    (Fd -> Ptr () -> CSocklen -> IO CInt
connect_ Fd
sockfd Ptr ()
address CSocklen
addressLen)

-- Actually sending and recving data
-- The send* function might return zero in case no byte is sent
-- failure is handled
foreign import ccall unsafe "send_wrapper"
  send_# :: Fd -> ByteArray# -> CPtrdiff -> CSize -> MsgFlags -> IO CSsize 
send# :: Fd -> ByteArray# -> CPtrdiff -> CSize -> MsgFlags -> IO CSsize
send# :: Fd -> ByteArray# -> CPtrdiff -> CSize -> MsgFlags -> IO CSsize
send# Fd
fd ByteArray#
buf# CPtrdiff
offs CSize
size MsgFlags
flags =
  String -> IO CSsize -> IO CSsize
forall a. (Num a, Eq a) => String -> IO a -> IO a
throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK String
"send failed"
    (Fd -> ByteArray# -> CPtrdiff -> CSize -> MsgFlags -> IO CSsize
send_# Fd
fd ByteArray#
buf# CPtrdiff
offs CSize
size MsgFlags
flags)

foreign import ccall unsafe "send"
  send_ :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> IO CSsize 
send :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> IO CSsize
send :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> IO CSsize
send Fd
fd Ptr Word8
buf CSize
size MsgFlags
flags = 
  String -> IO CSsize -> IO CSsize
forall a. (Num a, Eq a) => String -> IO a -> IO a
throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK String
"send failed"
    (Fd -> Ptr Word8 -> CSize -> MsgFlags -> IO CSsize
send_ Fd
fd Ptr Word8
buf CSize
size MsgFlags
flags)

foreign import ccall unsafe "sendto_wrapper"
  sendto_# :: Fd -> ByteArray# -> CPtrdiff -> CSize -> MsgFlags -> ByteArray# -> CSocklen -> IO CSsize
sendto# :: Fd -> ByteArray# -> CPtrdiff -> CSize -> MsgFlags -> ByteArray# -> CSocklen -> IO CSsize
sendto# :: Fd
-> ByteArray#
-> CPtrdiff
-> CSize
-> MsgFlags
-> ByteArray#
-> CSocklen
-> IO CSsize
sendto# Fd
fd ByteArray#
buf# CPtrdiff
offs CSize
size MsgFlags
flags ByteArray#
addr# CSocklen
addrlen =
  String -> IO CSsize -> IO CSsize
forall a. (Num a, Eq a) => String -> IO a -> IO a
throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK String
"sendto failed"
    (Fd
-> ByteArray#
-> CPtrdiff
-> CSize
-> MsgFlags
-> ByteArray#
-> CSocklen
-> IO CSsize
sendto_# Fd
fd ByteArray#
buf# CPtrdiff
offs CSize
size MsgFlags
flags ByteArray#
addr# CSocklen
addrlen)
foreign import ccall unsafe "sendto"
  sendto_  :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> ByteArray# -> CSocklen -> IO CSsize
sendto :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> ByteArray# -> CSocklen -> IO CSsize
sendto :: Fd
-> Ptr Word8
-> CSize
-> MsgFlags
-> ByteArray#
-> CSocklen
-> IO CSsize
sendto Fd
fd Ptr Word8
buf CSize
size MsgFlags
flags ByteArray#
addr# CSocklen
addrlen = 
  String -> IO CSsize -> IO CSsize
forall a. (Num a, Eq a) => String -> IO a -> IO a
throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK String
"sendto failed"
    (Fd
-> Ptr Word8
-> CSize
-> MsgFlags
-> ByteArray#
-> CSocklen
-> IO CSsize
sendto_ Fd
fd Ptr Word8
buf CSize
size MsgFlags
flags ByteArray#
addr# CSocklen
addrlen)

foreign import ccall unsafe "sendmsg_wrapper0" -- iovecs             offs         size          nvec
  sendmsg_# :: Fd -> ByteArray# -> CSocklen -> Array# ByteArray# -> ByteArray# -> ByteArray# -> CSize -> Ptr () -> CSize -> MsgFlags -> IO CSsize
sendmsg# :: Fd -> ByteArray# -> CSocklen -> Array# ByteArray# -> ByteArray# -> ByteArray# -> CSize -> Ptr () -> CSize -> MsgFlags -> IO CSsize
sendmsg# :: Fd
-> ByteArray#
-> CSocklen
-> Array# ByteArray#
-> ByteArray#
-> ByteArray#
-> CSize
-> Ptr ()
-> CSize
-> MsgFlags
-> IO CSsize
sendmsg# Fd
fd ByteArray#
addr# CSocklen
addrlen Array# ByteArray#
iovecs ByteArray#
offs ByteArray#
size CSize
nvec Ptr ()
cmsg CSize
cmsglen MsgFlags
flags =
  String -> IO CSsize -> IO CSsize
forall a. (Num a, Eq a) => String -> IO a -> IO a
throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK String
"sendmsg failed"
    (Fd
-> ByteArray#
-> CSocklen
-> Array# ByteArray#
-> ByteArray#
-> ByteArray#
-> CSize
-> Ptr ()
-> CSize
-> MsgFlags
-> IO CSsize
sendmsg_# Fd
fd ByteArray#
addr# CSocklen
addrlen Array# ByteArray#
iovecs ByteArray#
offs ByteArray#
size CSize
nvec Ptr ()
cmsg CSize
cmsglen MsgFlags
flags)

foreign import ccall unsafe "sendmsg_wrapper1"
  sendmsg_  :: Fd -> ByteArray# -> CSocklen -> Ptr Iovec -> CSize -> Ptr () -> CSize -> MsgFlags -> IO CSsize
sendmsg :: Fd -> ByteArray# -> CSocklen -> Ptr Iovec -> CSize -> Ptr () -> CSize -> MsgFlags -> IO CSsize
sendmsg :: Fd
-> ByteArray#
-> CSocklen
-> Ptr Iovec
-> CSize
-> Ptr ()
-> CSize
-> MsgFlags
-> IO CSsize
sendmsg Fd
fd ByteArray#
addr# CSocklen
addrlen Ptr Iovec
iovecs CSize
ioveclen Ptr ()
cmsg CSize
cmsglen MsgFlags
flags =
  String -> IO CSsize -> IO CSsize
forall a. (Num a, Eq a) => String -> IO a -> IO a
throwErrnoIfMinus1UnlessEAGAINorEWOULDBLOCK String
"sendmsg failed"
    (Fd
-> ByteArray#
-> CSocklen
-> Ptr Iovec
-> CSize
-> Ptr ()
-> CSize
-> MsgFlags
-> IO CSsize
sendmsg_ Fd
fd ByteArray#
addr# CSocklen
addrlen Ptr Iovec
iovecs CSize
ioveclen Ptr ()
cmsg CSize
cmsglen MsgFlags
flags)

foreign import ccall unsafe "recv_wrapper"
  recv_# :: Fd -> MutableByteArray# RealWorld -> CPtrdiff -> CSize -> MsgFlags -> IO CSsize
recv# :: Fd -> MutableByteArray# RealWorld -> CPtrdiff -> CSize -> MsgFlags -> IO CSsize
recv# :: Fd
-> MutableByteArray# RealWorld
-> CPtrdiff
-> CSize
-> MsgFlags
-> IO CSsize
recv# Fd
fd MutableByteArray# RealWorld
buf# CPtrdiff
offs CSize
size MsgFlags
flags =
  String -> IO CSsize -> IO CSsize
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
"recv failed"
    (Fd
-> MutableByteArray# RealWorld
-> CPtrdiff
-> CSize
-> MsgFlags
-> IO CSsize
recv_# Fd
fd MutableByteArray# RealWorld
buf# CPtrdiff
offs CSize
size MsgFlags
flags)

foreign import ccall unsafe "recv"
  recv_ :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> IO CSsize
recv :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> IO CSsize
recv :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> IO CSsize
recv Fd
fd Ptr Word8
buf CSize
size MsgFlags
flags =
  String -> IO CSsize -> IO CSsize
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
"recv failed"
    (Fd -> Ptr Word8 -> CSize -> MsgFlags -> IO CSsize
recv_ Fd
fd Ptr Word8
buf CSize
size MsgFlags
flags)

foreign import ccall unsafe "recvfrom_wrapper"
  recvfrom_# :: Fd -> MutableByteArray# RealWorld -> CPtrdiff -> CSize -> MsgFlags -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO CSsize
recvfrom# :: Fd -> MutableByteArray# RealWorld -> CPtrdiff -> CSize -> MsgFlags -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO CSsize
recvfrom# :: Fd
-> MutableByteArray# RealWorld
-> CPtrdiff
-> CSize
-> MsgFlags
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> IO CSsize
recvfrom# Fd
fd MutableByteArray# RealWorld
buf# CPtrdiff
offs CSize
size MsgFlags
flags MutableByteArray# RealWorld
addr# Ptr CSocklen
addrlen =
  String -> IO CSsize -> IO CSsize
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
"recvfrom failed"
    (Fd
-> MutableByteArray# RealWorld
-> CPtrdiff
-> CSize
-> MsgFlags
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> IO CSsize
recvfrom_# Fd
fd MutableByteArray# RealWorld
buf# CPtrdiff
offs CSize
size MsgFlags
flags MutableByteArray# RealWorld
addr# Ptr CSocklen
addrlen)

foreign import ccall unsafe "recvfrom"
  recvfrom_ :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO CSsize
recvfrom :: Fd -> Ptr Word8 -> CSize -> MsgFlags -> MutableByteArray# RealWorld -> Ptr CSocklen -> IO CSsize
recvfrom :: Fd
-> Ptr Word8
-> CSize
-> MsgFlags
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> IO CSsize
recvfrom Fd
fd Ptr Word8
buf CSize
size MsgFlags
flags MutableByteArray# RealWorld
addr# Ptr CSocklen
addrlen =
  String -> IO CSsize -> IO CSsize
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
"recvfrom failed"
    (Fd
-> Ptr Word8
-> CSize
-> MsgFlags
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> IO CSsize
recvfrom_ Fd
fd Ptr Word8
buf CSize
size MsgFlags
flags MutableByteArray# RealWorld
addr# Ptr CSocklen
addrlen)

foreign import ccall unsafe "recvmsg_wrapper0"
  recvmsg_# :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> Array# (MutableByteArray# RealWorld) -> ByteArray# -> ByteArray# -> CSize -> Ptr a -> Ptr CSize -> Ptr MsgFlags -> IO CSsize
recvmsg# :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> Array# (MutableByteArray# RealWorld) -> ByteArray# -> ByteArray# -> CSize -> Ptr a -> Ptr CSize -> Ptr MsgFlags -> IO CSsize
recvmsg# :: forall a.
Fd
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> Array# (MutableByteArray# RealWorld)
-> ByteArray#
-> ByteArray#
-> CSize
-> Ptr a
-> Ptr CSize
-> Ptr MsgFlags
-> IO CSsize
recvmsg# Fd
fd MutableByteArray# RealWorld
addr# Ptr CSocklen
addrlen Array# (MutableByteArray# RealWorld)
iovecs# ByteArray#
offs ByteArray#
size CSize
ioveclen Ptr a
cmsg Ptr CSize
cmsglen Ptr MsgFlags
flags =
  String -> IO CSsize -> IO CSsize
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
"recvmsg failed"
    (Fd
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> Array# (MutableByteArray# RealWorld)
-> ByteArray#
-> ByteArray#
-> CSize
-> Ptr a
-> Ptr CSize
-> Ptr MsgFlags
-> IO CSsize
forall a.
Fd
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> Array# (MutableByteArray# RealWorld)
-> ByteArray#
-> ByteArray#
-> CSize
-> Ptr a
-> Ptr CSize
-> Ptr MsgFlags
-> IO CSsize
recvmsg_# Fd
fd MutableByteArray# RealWorld
addr# Ptr CSocklen
addrlen Array# (MutableByteArray# RealWorld)
iovecs# ByteArray#
offs ByteArray#
size CSize
ioveclen Ptr a
cmsg Ptr CSize
cmsglen Ptr MsgFlags
flags)

foreign import ccall unsafe "recvmsg_wrapper1"
  recvmsg_  :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> Ptr Iovec -> CSize -> Ptr a -> Ptr CSize -> Ptr MsgFlags -> IO CSsize
recvmsg :: Fd -> MutableByteArray# RealWorld -> Ptr CSocklen -> Ptr Iovec -> CSize -> Ptr a -> Ptr CSize -> Ptr MsgFlags -> IO CSsize
recvmsg :: forall a.
Fd
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> Ptr Iovec
-> CSize
-> Ptr a
-> Ptr CSize
-> Ptr MsgFlags
-> IO CSsize
recvmsg Fd
fd MutableByteArray# RealWorld
addr# Ptr CSocklen
addrlen Ptr Iovec
iovecs CSize
ioveclen Ptr a
cmsg Ptr CSize
cmsglen Ptr MsgFlags
flags =
  String -> IO CSsize -> IO CSsize
forall a. (Eq a, Num a) => String -> IO a -> IO a
retryOrThrowErrnoIfMinus1 String
"recvmsg failed"
    (Fd
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> Ptr Iovec
-> CSize
-> Ptr a
-> Ptr CSize
-> Ptr MsgFlags
-> IO CSsize
forall a.
Fd
-> MutableByteArray# RealWorld
-> Ptr CSocklen
-> Ptr Iovec
-> CSize
-> Ptr a
-> Ptr CSize
-> Ptr MsgFlags
-> IO CSsize
recvmsg_ Fd
fd MutableByteArray# RealWorld
addr# Ptr CSocklen
addrlen Ptr Iovec
iovecs CSize
ioveclen Ptr a
cmsg Ptr CSize
cmsglen Ptr MsgFlags
flags)

foreign import ccall unsafe "shutdown"
  shutdown_ :: Fd -> ShutHow -> IO CInt
shutdown :: Fd -> ShutHow -> IO ()
shutdown :: Fd -> ShutHow -> IO ()
shutdown Fd
fd = String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"shutdown failed" (IO CInt -> IO ()) -> (ShutHow -> IO CInt) -> ShutHow -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fd -> ShutHow -> IO CInt
shutdown_ Fd
fd