-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Low-level networking interface
--
-- This package provides a low-level networking interface.
--
-- High-Level Packages
--
-- Other packages provide higher level interfaces:
--
--
-- - connection
-- - hookup
-- - network-simple
--
--
-- Extended Packages
--
-- network seeks to provide a cross-platform core for
-- networking. As such some APIs live in extended libraries. Packages in
-- the network ecosystem are often prefixed with
-- network-.
--
-- network-bsd
--
-- In network-3.0.0.0 the Network.BSD module was split
-- off into its own package, network-bsd-3.0.0.0.
--
-- network-uri
--
-- In network-2.6 the Network.URI module was split off
-- into its own package, network-uri-2.6. If you're using the
-- Network.URI module you can automatically get it from the
-- right package by adding this to your .cabal file:
--
--
-- library
-- build-depends: network-uri-flag
--
@package network
@version 3.2.3.0
-- | A module containing semi-public Network.Socket internals.
-- Modules which extend the Network.Socket module will need to use
-- this module while ideally most users will be able to make do with the
-- public interface.
module Network.Socket.Internal
-- | Throw an IOError corresponding to the current socket error.
throwSocketError :: String -> IO a
-- | Like throwSocketError, but the error code is supplied as an
-- argument.
--
-- On Windows, do not use errno. Use a system error code instead.
throwSocketErrorCode :: String -> CInt -> IO a
-- | Throw an IOError corresponding to the current socket error if
-- the IO action returns a result of -1. Discards the result of
-- the IO action after error handling.
throwSocketErrorIfMinus1_ :: (Eq a, Num a) => String -> IO a -> IO ()
-- | Throw an IOError corresponding to the current socket error if
-- the IO action returns a result of -1, but retries in case of
-- an interrupted operation.
throwSocketErrorIfMinus1Retry :: (Eq a, Num a) => String -> IO a -> IO a
-- | Throw an IOError corresponding to the current socket error if
-- the IO action returns a result of -1, but retries in case of
-- an interrupted operation. Discards the result of the IO action after
-- error handling.
throwSocketErrorIfMinus1Retry_ :: (Eq a, Num a) => String -> IO a -> IO ()
-- | Throw an IOError corresponding to the current socket error if
-- the IO action returns a result of -1, but retries in case of
-- an interrupted operation. Checks for operations that would block and
-- executes an alternative action before retrying in that case.
throwSocketErrorIfMinus1RetryMayBlock :: (Eq a, Num a) => String -> IO b -> IO a -> IO a
-- | Like throwSocketErrorIfMinus1Retry, but if the action fails
-- with EWOULDBLOCK or similar, wait for the socket to be
-- read-ready, and try again.
throwSocketErrorWaitRead :: (Eq a, Num a) => Socket -> String -> IO a -> IO a
-- | Like throwSocketErrorIfMinus1Retry, but if the action fails
-- with EWOULDBLOCK or similar, wait for the socket to be
-- read-ready, and try again. If it fails with the error the user was
-- expecting then ignore the error
throwSocketErrorWaitReadBut :: (Eq a, Num a) => (CInt -> Bool) -> Socket -> String -> IO a -> IO a
-- | Like throwSocketErrorIfMinus1Retry, but if the action fails
-- with EWOULDBLOCK or similar, wait for the socket to be
-- write-ready, and try again.
throwSocketErrorWaitWrite :: (Eq a, Num a) => Socket -> String -> IO a -> IO a
-- | With older versions of the network library (version 2.6.0.2
-- or earlier) on Windows operating systems, the networking subsystem
-- must be initialised using withSocketsDo before any networking
-- operations can be used. eg.
--
--
-- main = withSocketsDo $ do {...}
--
--
-- It is fine to nest calls to withSocketsDo, and to perform
-- networking operations after withSocketsDo has returned.
--
-- withSocketsDo is not necessary for the current network library.
-- However, for compatibility with older versions on Windows, it is good
-- practice to always call withSocketsDo (it's very cheap).
withSocketsDo :: IO a -> IO a
-- | A null SocketAddress for situations where a socket address
-- parameter is optional.
data NullSockAddr
NullSockAddr :: NullSockAddr
-- | Zero a structure.
zeroMemory :: Ptr a -> CSize -> IO ()
-- | This module provides access to the BSD socket interface. For
-- detailed documentation, consult your favorite POSIX socket reference.
-- All functions communicate failures by converting the error number to
-- an IOError.
--
-- This module is made to be imported with Network.Socket like so:
--
--
-- import Network.Socket
-- import Network.Socket.ByteString
--
module Network.Socket.ByteString
-- | Send data to the socket. The socket must be connected to a remote
-- socket. Returns the number of bytes sent. Applications are responsible
-- for ensuring that all data has been sent.
send :: Socket -> ByteString -> IO Int
-- | Send data to the socket. The socket must be connected to a remote
-- socket. Unlike send, this function continues to send data until
-- either all data has been sent or an error occurs. On error, an
-- exception is raised, and there is no way to determine how much data,
-- if any, was successfully sent.
sendAll :: Socket -> ByteString -> IO ()
-- | Send data to the socket. The recipient can be specified explicitly, so
-- the socket need not be in a connected state. Returns the number of
-- bytes sent. Applications are responsible for ensuring that all data
-- has been sent.
sendTo :: Socket -> ByteString -> SockAddr -> IO Int
-- | Send data to the socket. The recipient can be specified explicitly, so
-- the socket need not be in a connected state. Unlike sendTo,
-- this function continues to send data until either all data has been
-- sent or an error occurs. On error, an exception is raised, and there
-- is no way to determine how much data, if any, was successfully sent.
sendAllTo :: Socket -> ByteString -> SockAddr -> IO ()
-- | Send data to the socket. The socket must be in a connected state. The
-- data is sent as if the parts have been concatenated. This function
-- continues to send data until either all data has been sent or an error
-- occurs. On error, an exception is raised, and there is no way to
-- determine how much data, if any, was successfully sent.
sendMany :: Socket -> [ByteString] -> IO ()
-- | Send data to the socket. The recipient can be specified explicitly, so
-- the socket need not be in a connected state. The data is sent as if
-- the parts have been concatenated. This function continues to send data
-- until either all data has been sent or an error occurs. On error, an
-- exception is raised, and there is no way to determine how much data,
-- if any, was successfully sent.
sendManyTo :: Socket -> [ByteString] -> SockAddr -> IO ()
-- | Send data and file descriptors over a UNIX-domain socket in a single
-- system call. This function does not work on Windows.
sendManyWithFds :: Socket -> [ByteString] -> [Fd] -> IO ()
-- | Receive data from the socket. The socket must be in a connected state.
-- This function may return fewer bytes than specified. If the message is
-- longer than the specified length, it may be discarded depending on the
-- type of socket. This function may block until a message arrives.
--
-- Considering hardware and network realities, the maximum number of
-- bytes to receive should be a small power of 2, e.g., 4096.
--
-- For TCP sockets, a zero length return value means the peer has closed
-- its half side of the connection.
--
-- Currently, the recv family is blocked on Windows because a
-- proper IO manager is not implemented. To use with timeout on
-- Windows, use setSocketOption with RecvTimeOut as well.
recv :: Socket -> Int -> IO ByteString
-- | Receive data from the socket. The socket need not be in a connected
-- state. Returns (bytes, address) where bytes is a
-- ByteString representing the data received and address
-- is a SockAddr representing the address of the sending socket.
recvFrom :: Socket -> Int -> IO (ByteString, SockAddr)
-- | Send data to the socket using sendmsg(2).
sendMsg :: Socket -> SockAddr -> [ByteString] -> [Cmsg] -> MsgFlag -> IO Int
-- | Receive data from the socket using recvmsg(2).
recvMsg :: Socket -> Int -> Int -> MsgFlag -> IO (SockAddr, ByteString, [Cmsg], MsgFlag)
-- | This module provides extensible APIs for socket addresses.
module Network.Socket.Address
-- | The core typeclass to unify socket addresses.
class SocketAddress sa
sizeOfSocketAddress :: SocketAddress sa => sa -> Int
peekSocketAddress :: SocketAddress sa => Ptr sa -> IO sa
pokeSocketAddress :: SocketAddress sa => Ptr a -> sa -> IO ()
-- | Getting peer's socket address.
getPeerName :: SocketAddress sa => Socket -> IO sa
-- | Getting my socket address.
getSocketName :: SocketAddress sa => Socket -> IO sa
-- | Connect to a remote socket at address.
connect :: SocketAddress sa => Socket -> sa -> IO ()
-- | Bind the socket to an address. The socket must not already be bound.
-- The Family passed to bind must be the same as that
-- passed to socket. If the special port number defaultPort
-- is passed then the system assigns the next available use port.
bind :: SocketAddress sa => Socket -> sa -> IO ()
-- | Accept a connection. The socket must be bound to an address and
-- listening for connections. The return value is a pair (conn,
-- address) where conn is a new socket object usable to
-- send and receive data on the connection, and address is the
-- address bound to the socket on the other end of the connection. On
-- Unix, FD_CLOEXEC is set to the new Socket.
accept :: SocketAddress sa => Socket -> IO (Socket, sa)
-- | Send data to the socket. The recipient can be specified explicitly, so
-- the socket need not be in a connected state. Returns the number of
-- bytes sent. Applications are responsible for ensuring that all data
-- has been sent.
sendTo :: SocketAddress sa => Socket -> ByteString -> sa -> IO Int
-- | Send data to the socket. The recipient can be specified explicitly, so
-- the socket need not be in a connected state. Unlike sendTo,
-- this function continues to send data until either all data has been
-- sent or an error occurs. On error, an exception is raised, and there
-- is no way to determine how much data, if any, was successfully sent.
sendAllTo :: SocketAddress sa => Socket -> ByteString -> sa -> IO ()
-- | Receive data from the socket. The socket need not be in a connected
-- state. Returns (bytes, address) where bytes is a
-- ByteString representing the data received and address
-- is a SockAddr representing the address of the sending socket.
--
-- If the first return value is zero, it means EOF.
recvFrom :: SocketAddress sa => Socket -> Int -> IO (ByteString, sa)
-- | Send data to the socket. The recipient can be specified explicitly, so
-- the socket need not be in a connected state. Returns the number of
-- bytes sent. Applications are responsible for ensuring that all data
-- has been sent.
sendBufTo :: SocketAddress sa => Socket -> Ptr a -> Int -> sa -> IO Int
-- | Receive data from the socket, writing it into buffer instead of
-- creating a new string. The socket need not be in a connected state.
-- Returns (nbytes, address) where nbytes is the number
-- of bytes received and address is a SockAddr
-- representing the address of the sending socket.
--
-- If the first return value is zero, it means EOF.
--
-- For Stream sockets, the second return value would be invalid.
--
-- NOTE: blocking on Windows unless you compile with -threaded (see GHC
-- ticket #1129)
recvBufFrom :: SocketAddress sa => Socket -> Ptr a -> Int -> IO (Int, sa)
-- | Send data to the socket using sendmsg(2).
sendBufMsg :: SocketAddress sa => Socket -> sa -> [(Ptr Word8, Int)] -> [Cmsg] -> MsgFlag -> IO Int
-- | Receive data from the socket using recvmsg(2). The supplied buffers
-- are filled in order, with subsequent buffers used only after all the
-- preceding buffers are full. If the message is short enough some of the
-- supplied buffers may remain unused.
recvBufMsg :: SocketAddress sa => Socket -> [(Ptr Word8, Int)] -> Int -> MsgFlag -> IO (sa, Int, [Cmsg], MsgFlag)
-- | This is the main module of the network package supposed to be used
-- with either Network.Socket.ByteString or
-- Network.Socket.ByteString.Lazy for sending/receiving.
--
-- Here are two minimal example programs using the TCP/IP protocol:
--
--
-- - a server that echoes all data that it receives back
-- - a client using it
--
--
--
-- -- Echo server program
-- module Main (main) where
--
-- import Control.Concurrent (forkFinally)
-- import qualified Control.Exception as E
-- import Control.Monad (unless, forever, void)
-- import qualified Data.ByteString as S
-- import qualified Data.List.NonEmpty as NE
-- import Network.Socket
-- import Network.Socket.ByteString (recv, sendAll)
--
-- main :: IO ()
-- main = runTCPServer Nothing "3000" talk
-- where
-- talk s = do
-- msg <- recv s 1024
-- unless (S.null msg) $ do
-- sendAll s msg
-- talk s
--
-- -- from the "network-run" package.
-- runTCPServer :: Maybe HostName -> ServiceName -> (Socket -> IO a) -> IO a
-- runTCPServer mhost port server = withSocketsDo $ do
-- addr <- resolve
-- E.bracket (open addr) close loop
-- where
-- resolve = do
-- let hints = defaultHints {
-- addrFlags = [AI_PASSIVE]
-- , addrSocketType = Stream
-- }
-- NE.head <$> getAddrInfo (Just hints) mhost (Just port)
-- open addr = E.bracketOnError (openSocket addr) close $ \sock -> do
-- setSocketOption sock ReuseAddr 1
-- withFdSocket sock setCloseOnExecIfNeeded
-- bind sock $ addrAddress addr
-- listen sock 1024
-- return sock
-- loop sock = forever $ E.bracketOnError (accept sock) (close . fst)
-- $ \(conn, _peer) -> void $
-- -- 'forkFinally' alone is unlikely to fail thus leaking @conn@,
-- -- but 'E.bracketOnError' above will be necessary if some
-- -- non-atomic setups (e.g. spawning a subprocess to handle
-- -- @conn@) before proper cleanup of @conn@ is your case
-- forkFinally (server conn) (const $ gracefulClose conn 5000)
--
--
--
-- {-# LANGUAGE OverloadedStrings #-}
-- -- Echo client program
-- module Main (main) where
--
-- import qualified Control.Exception as E
-- import qualified Data.ByteString.Char8 as C
-- import qualified Data.List.NonEmpty as NE
-- import Network.Socket
-- import Network.Socket.ByteString (recv, sendAll)
--
-- main :: IO ()
-- main = runTCPClient "127.0.0.1" "3000" $ \s -> do
-- sendAll s "Hello, world!"
-- msg <- recv s 1024
-- putStr "Received: "
-- C.putStrLn msg
--
-- -- from the "network-run" package.
-- runTCPClient :: HostName -> ServiceName -> (Socket -> IO a) -> IO a
-- runTCPClient host port client = withSocketsDo $ do
-- addr <- resolve
-- E.bracket (open addr) close client
-- where
-- resolve = do
-- let hints = defaultHints { addrSocketType = Stream }
-- NE.head <$> getAddrInfo (Just hints) (Just host) (Just port)
-- open addr = E.bracketOnError (openSocket addr) close $ \sock -> do
-- connect sock $ addrAddress addr
-- return sock
--
--
-- The proper programming model is that one Socket is handled by a
-- single thread. If multiple threads use one Socket concurrently,
-- unexpected things would happen. There is one exception for multiple
-- threads vs a single Socket: one thread reads data from a
-- Socket only and the other thread writes data to the
-- Socket only.
module Network.Socket
-- | With older versions of the network library (version 2.6.0.2
-- or earlier) on Windows operating systems, the networking subsystem
-- must be initialised using withSocketsDo before any networking
-- operations can be used. eg.
--
--
-- main = withSocketsDo $ do {...}
--
--
-- It is fine to nest calls to withSocketsDo, and to perform
-- networking operations after withSocketsDo has returned.
--
-- withSocketsDo is not necessary for the current network library.
-- However, for compatibility with older versions on Windows, it is good
-- practice to always call withSocketsDo (it's very cheap).
withSocketsDo :: IO a -> IO a
-- | Resolve a host or service name to one or more addresses. The
-- AddrInfo values that this function returns contain
-- SockAddr values that you can pass directly to connect or
-- bind.
--
-- This function calls getaddrinfo(3), which never successfully
-- returns with an empty list. If the query fails, getAddrInfo
-- throws an IO exception.
--
-- For backwards-compatibility reasons, a hidden GetAddrInfo class
-- is used to make the result polymorphic. It only has instances for
-- [] (lists) and NonEmpty. Use of NonEmpty is
-- recommended.
--
-- This function is protocol independent. It can return both IPv4 and
-- IPv6 address information.
--
-- The AddrInfo argument specifies the preferred query behaviour,
-- socket options, or protocol. You can override these conveniently using
-- Haskell's record update syntax on defaultHints, for example as
-- follows:
--
--
-- >>> let hints = defaultHints { addrFlags = [AI_NUMERICHOST], addrSocketType = Stream }
--
--
-- You must provide a Just value for at least one of the
-- HostName or ServiceName arguments. HostName can
-- be either a numeric network address (dotted quad for IPv4,
-- colon-separated hex for IPv6) or a hostname. In the latter case, its
-- addresses will be looked up unless AI_NUMERICHOST is specified
-- as a hint. If you do not provide a HostName value and do
-- not set AI_PASSIVE as a hint, network addresses in the result
-- will contain the address of the loopback interface.
--
-- There are several reasons why a query might result in several values.
-- For example, the queried-for host could be multihomed, or the service
-- might be available via several protocols.
--
-- Note: the order of arguments is slightly different to that defined for
-- getaddrinfo in RFC 2553. The AddrInfo parameter comes
-- first to make partial application easier.
--
--
-- >>> import qualified Data.List.NonEmpty as NE
--
-- >>> addr <- NE.head <$> getAddrInfo (Just hints) (Just "127.0.0.1") (Just "http")
--
-- >>> addrAddress addr
-- 127.0.0.1:80
--
--
-- Polymorphic version: @since 3.2.3.0
getAddrInfo :: GetAddrInfo t => Maybe AddrInfo -> Maybe HostName -> Maybe ServiceName -> IO (t AddrInfo)
-- | Either a host name e.g., "haskell.org" or a numeric host
-- address string consisting of a dotted decimal IPv4 address or an IPv6
-- address e.g., "192.168.0.1".
type HostName = String
-- | Either a service name e.g., "http" or a numeric port number.
type ServiceName = String
data AddrInfo
AddrInfo :: [AddrInfoFlag] -> Family -> SocketType -> ProtocolNumber -> SockAddr -> Maybe String -> AddrInfo
[addrFlags] :: AddrInfo -> [AddrInfoFlag]
[addrFamily] :: AddrInfo -> Family
[addrSocketType] :: AddrInfo -> SocketType
[addrProtocol] :: AddrInfo -> ProtocolNumber
[addrAddress] :: AddrInfo -> SockAddr
[addrCanonName] :: AddrInfo -> Maybe String
-- | Default hints for address lookup with getAddrInfo.
--
--
-- >>> addrFlags defaultHints
-- []
--
-- >>> addrFamily defaultHints
-- AF_UNSPEC
--
-- >>> addrSocketType defaultHints
-- NoSocketType
--
-- >>> addrProtocol defaultHints
-- 0
--
defaultHints :: AddrInfo
-- | Flags that control the querying behaviour of getAddrInfo. For
-- more information, see
-- https://tools.ietf.org/html/rfc3493#page-25
data AddrInfoFlag
-- | The list of returned AddrInfo values will only contain IPv4
-- addresses if the local system has at least one IPv4 interface
-- configured, and likewise for IPv6. (Only some platforms support this.)
AI_ADDRCONFIG :: AddrInfoFlag
-- | If AI_ALL is specified, return all matching IPv6 and IPv4
-- addresses. Otherwise, this flag has no effect. (Only some platforms
-- support this.)
AI_ALL :: AddrInfoFlag
-- | The addrCanonName field of the first returned AddrInfo
-- will contain the "canonical name" of the host.
AI_CANONNAME :: AddrInfoFlag
-- | The HostName argument must be a numeric address in
-- string form, and network name lookups will not be attempted.
AI_NUMERICHOST :: AddrInfoFlag
-- | The ServiceName argument must be a port number in string
-- form, and service name lookups will not be attempted. (Only some
-- platforms support this.)
AI_NUMERICSERV :: AddrInfoFlag
-- | If no HostName value is provided, the network address in each
-- SockAddr will be left as a "wild card". This is useful for
-- server applications that will accept connections from any client.
AI_PASSIVE :: AddrInfoFlag
-- | If an IPv6 lookup is performed, and no IPv6 addresses are found,
-- IPv6-mapped IPv4 addresses will be returned. (Only some platforms
-- support this.)
AI_V4MAPPED :: AddrInfoFlag
-- | Indicate whether the given AddrInfoFlag will have any effect on
-- this system.
addrInfoFlagImplemented :: AddrInfoFlag -> Bool
-- | Connect to a remote socket at address.
connect :: Socket -> SockAddr -> IO ()
-- | Bind the socket to an address. The socket must not already be bound.
-- The Family passed to bind must be the same as that
-- passed to socket. If the special port number
-- defaultPort is passed then the system assigns the next
-- available use port.
bind :: Socket -> SockAddr -> IO ()
-- | Listen for connections made to the socket. The second argument
-- specifies the maximum number of queued connections and should be at
-- least 1; the maximum value is system-dependent (usually 5).
listen :: Socket -> Int -> IO ()
-- | Accept a connection. The socket must be bound to an address and
-- listening for connections. The return value is a pair (conn,
-- address) where conn is a new socket object usable to
-- send and receive data on the connection, and address is the
-- address bound to the socket on the other end of the connection. On
-- Unix, FD_CLOEXEC is set to the new Socket.
accept :: Socket -> IO (Socket, SockAddr)
-- | Close the socket. This function does not throw exceptions even if the
-- underlying system call returns errors.
--
-- If multiple threads use the same socket and one uses
-- unsafeFdSocket and the other use close, unexpected
-- behavior may happen. For more information, please refer to the
-- documentation of unsafeFdSocket.
close :: Socket -> IO ()
-- | Close the socket. This function throws exceptions if the underlying
-- system call returns errors.
close' :: Socket -> IO ()
-- | Closing a socket gracefully. This sends TCP FIN and check if TCP FIN
-- is received from the peer. The second argument is time out to receive
-- TCP FIN in millisecond. In both normal cases and error cases, socket
-- is deallocated finally.
--
-- Since: 3.1.1.0
gracefulClose :: Socket -> Int -> IO ()
-- | Shut down one or both halves of the connection, depending on the
-- second argument to the function. If the second argument is
-- ShutdownReceive, further receives are disallowed. If it is
-- ShutdownSend, further sends are disallowed. If it is
-- ShutdownBoth, further sends and receives are disallowed.
shutdown :: Socket -> ShutdownCmd -> IO ()
data ShutdownCmd
ShutdownReceive :: ShutdownCmd
ShutdownSend :: ShutdownCmd
ShutdownBoth :: ShutdownCmd
-- | Socket options for use with setSocketOption and
-- getSocketOption.
--
-- The existence of a constructor does not imply that the relevant option
-- is supported on your system: see isSupportedSocketOption
data SocketOption
SockOpt :: CInt -> CInt -> SocketOption
pattern UnsupportedSocketOption :: SocketOption
-- | SO_DEBUG
pattern Debug :: SocketOption
-- | SO_REUSEADDR
pattern ReuseAddr :: SocketOption
-- | SO_DOMAIN, read-only
pattern SoDomain :: SocketOption
-- | SO_TYPE, read-only
pattern Type :: SocketOption
-- | SO_PROTOCOL, read-only
pattern SoProtocol :: SocketOption
-- | SO_ERROR
pattern SoError :: SocketOption
-- | SO_DONTROUTE
pattern DontRoute :: SocketOption
-- | SO_BROADCAST
pattern Broadcast :: SocketOption
-- | SO_SNDBUF
pattern SendBuffer :: SocketOption
-- | SO_RCVBUF
pattern RecvBuffer :: SocketOption
-- | SO_KEEPALIVE
pattern KeepAlive :: SocketOption
-- | SO_OOBINLINE
pattern OOBInline :: SocketOption
-- | IP_TTL
pattern TimeToLive :: SocketOption
-- | TCP_MAXSEG
pattern MaxSegment :: SocketOption
-- | TCP_NODELAY
pattern NoDelay :: SocketOption
-- | TCP_CORK
pattern Cork :: SocketOption
-- | SO_LINGER: timeout in seconds, 0 means disabling/disabled.
pattern Linger :: SocketOption
-- | SO_REUSEPORT
pattern ReusePort :: SocketOption
-- | SO_RCVLOWAT
pattern RecvLowWater :: SocketOption
-- | SO_SNDLOWAT
pattern SendLowWater :: SocketOption
-- | SO_RCVTIMEO: timeout in microseconds. This option is not useful in the
-- normal case where sockets are non-blocking.
pattern RecvTimeOut :: SocketOption
-- | SO_SNDTIMEO: timeout in microseconds. This option is not useful in the
-- normal case where sockets are non-blocking.
pattern SendTimeOut :: SocketOption
-- | SO_USELOOPBACK
pattern UseLoopBack :: SocketOption
-- | TCP_USER_TIMEOUT
pattern UserTimeout :: SocketOption
-- | IPV6_V6ONLY: don't use this on OpenBSD.
pattern IPv6Only :: SocketOption
-- | Receiving IPv4 TTL.
pattern RecvIPv4TTL :: SocketOption
-- | Receiving IPv4 TOS.
pattern RecvIPv4TOS :: SocketOption
-- | Receiving IP_PKTINFO (struct in_pktinfo).
pattern RecvIPv4PktInfo :: SocketOption
-- | Receiving IPv6 hop limit.
pattern RecvIPv6HopLimit :: SocketOption
-- | Receiving IPv6 traffic class.
pattern RecvIPv6TClass :: SocketOption
-- | Receiving IPV6_PKTINFO (struct in6_pktinfo).
pattern RecvIPv6PktInfo :: SocketOption
-- | Low level SO_LINBER option value, which can be used with
-- setSockOpt.
data StructLinger
StructLinger :: CInt -> CInt -> StructLinger
-- | Set the linger option on.
[sl_onoff] :: StructLinger -> CInt
-- | Linger timeout.
[sl_linger] :: StructLinger -> CInt
-- | Timeout in microseconds. This will be converted into struct timeval on
-- Unix and DWORD (as milliseconds) on Windows.
newtype SocketTimeout
SocketTimeout :: Word32 -> SocketTimeout
-- | Does the SocketOption exist on this system?
isSupportedSocketOption :: SocketOption -> Bool
-- | Execute the given action only when the specified socket option is
-- supported. Any return value is ignored.
whenSupported :: SocketOption -> IO a -> IO ()
-- | Get a socket option that gives an Int value.
getSocketOption :: Socket -> SocketOption -> IO Int
-- | Set a socket option that expects an Int value.
setSocketOption :: Socket -> SocketOption -> Int -> IO ()
-- | Get a socket option.
getSockOpt :: forall a. Storable a => Socket -> SocketOption -> IO a
-- | Set a socket option.
setSockOpt :: Storable a => Socket -> SocketOption -> a -> IO ()
-- | Basic type for a socket.
data Socket
-- | Create a new socket using the given address family, socket type and
-- protocol number. The address family is usually AF_INET,
-- AF_INET6, or AF_UNIX. The socket type is usually
-- Stream or Datagram. The protocol number is usually
-- defaultProtocol. If AF_INET6 is used and the socket type
-- is Stream or Datagram, the IPv6Only socket option
-- is set to 0 so that both IPv4 and IPv6 can be handled with one socket.
--
--
-- >>> import Network.Socket
--
-- >>> import qualified Data.List.NonEmpty as NE
--
-- >>> let hints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_NUMERICSERV], addrSocketType = Stream }
--
-- >>> addr <- NE.head <$> getAddrInfo (Just hints) (Just "127.0.0.1") (Just "5000")
--
-- >>> sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr)
--
-- >>> Network.Socket.bind sock (addrAddress addr)
--
-- >>> getSocketName sock
-- 127.0.0.1:5000
--
socket :: Family -> SocketType -> ProtocolNumber -> IO Socket
-- | A utility function to open a socket with AddrInfo. This is a
-- just wrapper for the following code:
--
--
-- \addr -> socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr)
--
openSocket :: AddrInfo -> IO Socket
-- | Get a file descriptor from a Socket. The socket will never be
-- closed automatically before withFdSocket completes, but it
-- may still be closed by an explicit call to close or
-- close', either before or during the call.
--
-- The file descriptor must not be used after withFdSocket
-- returns, because the Socket may have been garbage-collected,
-- invalidating the file descriptor.
--
-- Since: 3.1.0.0
withFdSocket :: Socket -> (CInt -> IO r) -> IO r
-- | Getting a file descriptor from a socket.
--
-- If a Socket is shared with multiple threads and one uses
-- unsafeFdSocket, unexpected issues may happen. Consider the
-- following scenario:
--
-- 1) Thread A acquires a Fd from Socket by
-- unsafeFdSocket.
--
-- 2) Thread B close the Socket.
--
-- 3) Thread C opens a new Socket. Unfortunately it gets the same
-- Fd number which thread A is holding.
--
-- In this case, it is safer for Thread A to clone Fd by
-- dup. But this would still suffer from a race condition between
-- unsafeFdSocket and close.
--
-- If you use this function, you need to guarantee that the Socket
-- does not get garbage-collected until after you finish using the file
-- descriptor. touchSocket can be used for this purpose.
--
-- A safer option is to use withFdSocket instead.
unsafeFdSocket :: Socket -> IO CInt
-- | Ensure that the given Socket stays alive (i.e. not
-- garbage-collected) at the given place in the sequence of IO actions.
-- This function can be used in conjunction with unsafeFdSocket to
-- guarantee that the file descriptor is not prematurely freed.
--
--
-- fd <- unsafeFdSocket sock
-- -- using fd with blocking operations such as accept(2)
-- touchSocket sock
--
touchSocket :: Socket -> IO ()
-- | Socket is closed and a duplicated file descriptor is returned. The
-- duplicated descriptor is no longer subject to the possibility of
-- unexpectedly being closed if the socket is finalized. It is now the
-- caller's responsibility to ultimately close the duplicated file
-- descriptor.
socketToFd :: Socket -> IO CInt
-- | Currently, this is an alias of unsafeFdSocket.
-- | Deprecated: Use withFdSocket or unsafeFdSocket instead
fdSocket :: Socket -> IO CInt
-- | Creating a socket from a file descriptor.
mkSocket :: CInt -> IO Socket
-- | Turns a Socket into an Handle. By default, the new handle is
-- unbuffered. Use hSetBuffering to change the buffering.
--
-- Note that since a Handle is automatically closed by a finalizer
-- when it is no longer referenced, you should avoid doing any more
-- operations on the Socket after calling socketToHandle.
-- To close the Socket after socketToHandle, call
-- hClose on the Handle.
--
-- Caveat Handle is not recommended for network programming in
-- Haskell, e.g. merely performing hClose on a TCP socket won't
-- cooperate with peer's gracefulClose, i.e. proper shutdown
-- sequence with appropriate handshakes specified by the protocol.
socketToHandle :: Socket -> IOMode -> IO Handle
-- | Socket Types.
--
-- Some of the defined patterns may be unsupported on some systems: see
-- isSupportedSocketType.
data SocketType
-- | Pattern for a general socket type.
pattern GeneralSocketType :: CInt -> SocketType
-- | Unsupported socket type, equal to any other types not supported on
-- this system.
pattern UnsupportedSocketType :: SocketType
-- | Used in getAddrInfo hints, for example.
pattern NoSocketType :: SocketType
pattern Stream :: SocketType
pattern Datagram :: SocketType
pattern Raw :: SocketType
pattern RDM :: SocketType
pattern SeqPacket :: SocketType
-- | Is the SOCK_xxxxx constant corresponding to the given
-- SocketType known on this system? GeneralSocketType values, not
-- equal to any of the named patterns or UnsupportedSocketType,
-- will return True even when not known on this system.
isSupportedSocketType :: SocketType -> Bool
-- | Get the SocketType of an active socket.
--
-- Since: 3.0.1.0
getSocketType :: Socket -> IO SocketType
-- | Address families. The AF_xxxxx constants are widely used as
-- synonyms for the corresponding PF_xxxxx protocol family
-- values, to which they are numerically equal in mainstream socket API
-- implementations.
--
-- Strictly correct usage would be to pass the PF_xxxxx
-- constants as the first argument when creating a Socket, while
-- the AF_xxxxx constants should be used as addrFamily
-- values with getAddrInfo. For now only the AF_xxxxx
-- constants are provided.
--
-- Some of the defined patterns may be unsupported on some systems: see
-- isSupportedFamily.
data Family
-- | Pattern for a general protocol family (a.k.a. address family).
pattern GeneralFamily :: CInt -> Family
-- | Unsupported address family, equal to any other families that are not
-- supported on the system.
pattern UnsupportedFamily :: Family
-- | unspecified
pattern AF_UNSPEC :: Family
-- | UNIX-domain
pattern AF_UNIX :: Family
-- | Internet Protocol version 4
pattern AF_INET :: Family
-- | Internet Protocol version 6
pattern AF_INET6 :: Family
-- | Arpanet imp addresses
pattern AF_IMPLINK :: Family
-- | pup protocols: e.g. BSP
pattern AF_PUP :: Family
-- | mit CHAOS protocols
pattern AF_CHAOS :: Family
-- | XEROX NS protocols
pattern AF_NS :: Family
-- | nbs protocols
pattern AF_NBS :: Family
-- | european computer manufacturers
pattern AF_ECMA :: Family
-- | datakit protocols
pattern AF_DATAKIT :: Family
-- | CCITT protocols, X.25 etc
pattern AF_CCITT :: Family
-- | IBM SNA
pattern AF_SNA :: Family
-- | DECnet
pattern AF_DECnet :: Family
-- | Direct data link interface
pattern AF_DLI :: Family
-- | LAT
pattern AF_LAT :: Family
-- | NSC Hyperchannel
pattern AF_HYLINK :: Family
-- | Apple Talk
pattern AF_APPLETALK :: Family
-- | Internal Routing Protocol (aka AF_NETLINK)
pattern AF_ROUTE :: Family
-- | NetBios-style addresses
pattern AF_NETBIOS :: Family
-- | Network Interface Tap
pattern AF_NIT :: Family
-- | IEEE 802.2, also ISO 8802
pattern AF_802 :: Family
-- | ISO protocols
pattern AF_ISO :: Family
-- | umbrella of all families used by OSI
pattern AF_OSI :: Family
-- | DNA Network Management
pattern AF_NETMAN :: Family
-- | CCITT X.25
pattern AF_X25 :: Family
-- | AX25
pattern AF_AX25 :: Family
-- | AFI
pattern AF_OSINET :: Family
-- | US Government OSI
pattern AF_GOSSIP :: Family
-- | Novell Internet Protocol
pattern AF_IPX :: Family
-- | eXpress Transfer Protocol (no AF)
pattern Pseudo_AF_XTP :: Family
-- | Common Trace Facility
pattern AF_CTF :: Family
-- | Wide Area Network protocols
pattern AF_WAN :: Family
-- | SGI Data Link for DLPI
pattern AF_SDL :: Family
-- | Netware
pattern AF_NETWARE :: Family
-- | NDD
pattern AF_NDD :: Family
-- | Debugging use only
pattern AF_INTF :: Family
-- | connection-oriented IP, aka ST II
pattern AF_COIP :: Family
-- | Computer Network Technology
pattern AF_CNT :: Family
-- | Help Identify RTIP packets
pattern Pseudo_AF_RTIP :: Family
-- | Help Identify PIP packets
pattern Pseudo_AF_PIP :: Family
-- | Simple Internet Protocol
pattern AF_SIP :: Family
-- | Integrated Services Digital Network
pattern AF_ISDN :: Family
-- | Internal key-management function
pattern Pseudo_AF_KEY :: Family
-- | native ATM access
pattern AF_NATM :: Family
-- | ARP (RFC 826)
pattern AF_ARP :: Family
-- | Used by BPF to not rewrite hdrs in iface output
pattern Pseudo_AF_HDRCMPLT :: Family
-- | ENCAP
pattern AF_ENCAP :: Family
-- | Link layer interface
pattern AF_LINK :: Family
-- | Link layer interface
pattern AF_RAW :: Family
-- | raw interface
pattern AF_RIF :: Family
-- | Amateur radio NetROM
pattern AF_NETROM :: Family
-- | multiprotocol bridge
pattern AF_BRIDGE :: Family
-- | ATM PVCs
pattern AF_ATMPVC :: Family
-- | Amateur Radio X.25 PLP
pattern AF_ROSE :: Family
-- | Netbeui 802.2LLC
pattern AF_NETBEUI :: Family
-- | Security callback pseudo AF
pattern AF_SECURITY :: Family
-- | Packet family
pattern AF_PACKET :: Family
-- | Ash
pattern AF_ASH :: Family
-- | Acorn Econet
pattern AF_ECONET :: Family
-- | ATM SVCs
pattern AF_ATMSVC :: Family
-- | IRDA sockets
pattern AF_IRDA :: Family
-- | PPPoX sockets
pattern AF_PPPOX :: Family
-- | Wanpipe API sockets
pattern AF_WANPIPE :: Family
-- | bluetooth sockets
pattern AF_BLUETOOTH :: Family
-- | Controller Area Network
pattern AF_CAN :: Family
-- | Does one of the AF_ constants correspond to a known address family on
-- this system. GeneralFamily values, not equal to any of the
-- named AF_xxxxx patterns or UnsupportedFamily, will
-- return True even when not known on this system.
isSupportedFamily :: Family -> Bool
packFamily :: Family -> CInt
-- | Convert CInt to Family.
unpackFamily :: CInt -> Family
-- | Protocol number.
type ProtocolNumber = CInt
-- | This is the default protocol for a given service.
--
--
-- >>> defaultProtocol
-- 0
--
defaultProtocol :: ProtocolNumber
-- | Socket addresses. The existence of a constructor does not necessarily
-- imply that that socket address type is supported on your system: see
-- isSupportedSockAddr.
data SockAddr
SockAddrInet :: PortNumber -> HostAddress -> SockAddr
SockAddrInet6 :: PortNumber -> FlowInfo -> HostAddress6 -> ScopeID -> SockAddr
-- | The path must have fewer than 104 characters. All of these characters
-- must have code points less than 256.
SockAddrUnix :: String -> SockAddr
-- | Is the socket address type supported on this system?
isSupportedSockAddr :: SockAddr -> Bool
-- | Getting peer's SockAddr.
getPeerName :: Socket -> IO SockAddr
-- | Getting my SockAddr.
getSocketName :: Socket -> IO SockAddr
-- | The raw network byte order number is read using host byte order.
-- Therefore on little-endian architectures the byte order is swapped.
-- For example 127.0.0.1 is represented as 0x0100007f
-- on little-endian hosts and as 0x7f000001 on big-endian hosts.
--
-- For direct manipulation prefer hostAddressToTuple and
-- tupleToHostAddress.
type HostAddress = Word32
-- | Converts HostAddress to representation-independent IPv4
-- quadruple. For example for 127.0.0.1 the function will return
-- (0x7f, 0, 0, 1) regardless of host endianness.
hostAddressToTuple :: HostAddress -> (Word8, Word8, Word8, Word8)
-- | Converts IPv4 quadruple to HostAddress.
tupleToHostAddress :: (Word8, Word8, Word8, Word8) -> HostAddress
-- | Independent of endianness. For example ::1 is stored as
-- (0, 0, 0, 1).
--
-- For direct manipulation prefer hostAddress6ToTuple and
-- tupleToHostAddress6.
type HostAddress6 = (Word32, Word32, Word32, Word32)
-- | Converts HostAddress6 to representation-independent IPv6
-- octuple.
hostAddress6ToTuple :: HostAddress6 -> (Word16, Word16, Word16, Word16, Word16, Word16, Word16, Word16)
-- | Converts IPv6 octuple to HostAddress6.
tupleToHostAddress6 :: (Word16, Word16, Word16, Word16, Word16, Word16, Word16, Word16) -> HostAddress6
-- | Flow information.
type FlowInfo = Word32
-- | Scope identifier.
type ScopeID = Word32
-- | Returns the index corresponding to the interface name.
--
-- Since 2.7.0.0.
ifNameToIndex :: String -> IO (Maybe Int)
-- | Returns the interface name corresponding to the index.
--
-- Since 2.7.0.0.
ifIndexToName :: Int -> IO (Maybe String)
-- | Port number. Use the Num instance (i.e. use a literal) to
-- create a PortNumber value.
--
--
-- >>> 1 :: PortNumber
-- 1
--
-- >>> read "1" :: PortNumber
-- 1
--
-- >>> show (12345 :: PortNumber)
-- "12345"
--
-- >>> 50000 < (51000 :: PortNumber)
-- True
--
-- >>> 50000 < (52000 :: PortNumber)
-- True
--
-- >>> 50000 + (10000 :: PortNumber)
-- 60000
--
data PortNumber
-- | Default port number.
--
--
-- >>> defaultPort
-- 0
--
defaultPort :: PortNumber
-- | Getting the port of socket.
socketPortSafe :: Socket -> IO (Maybe PortNumber)
-- | Getting the port of socket. IOError is thrown if a port is not
-- available.
socketPort :: Socket -> IO PortNumber
-- | Whether or not UNIX-domain sockets are available. AF_UNIX is
-- supported on Windows since 3.1.3.0. So, this variable is True
-- on all platforms.
--
-- Since 2.7.0.0.
isUnixDomainSocketAvailable :: Bool
-- | Build a pair of connected socket objects. On Windows, this function
-- emulates socketpair() using AF_UNIX and a temporary file will
-- remain.
socketPair :: Family -> SocketType -> ProtocolNumber -> IO (Socket, Socket)
-- | Send a file descriptor over a UNIX-domain socket. This function does
-- not work on Windows.
sendFd :: Socket -> CInt -> IO ()
-- | Receive a file descriptor over a UNIX-domain socket. Note that the
-- resulting file descriptor may have to be put into non-blocking mode in
-- order to be used safely. See setNonBlockIfNeeded. This function
-- does not work on Windows.
recvFd :: Socket -> IO CInt
-- | Getting process ID, user ID and group ID for UNIX-domain sockets.
--
-- This is implemented with SO_PEERCRED on Linux and getpeereid() on BSD
-- variants. Unfortunately, on some BSD variants getpeereid() returns
-- unexpected results, rather than an error, for AF_INET sockets. It is
-- the user's responsibility to make sure that the socket is a
-- UNIX-domain socket. Also, on some BSD variants, getpeereid() does not
-- return credentials for sockets created via socketPair, only
-- separately created and then explicitly connected UNIX-domain sockets
-- work on such systems.
--
-- Since 2.7.0.0.
getPeerCredential :: Socket -> IO (Maybe CUInt, Maybe CUInt, Maybe CUInt)
-- | Resolve an address to a host or service name. This function is
-- protocol independent. The list of NameInfoFlag values controls
-- query behaviour.
--
-- If a host or service's name cannot be looked up, then the numeric form
-- of the address or service will be returned.
--
-- If the query fails, this function throws an IO exception.
--
--
-- >>> addr:_ <- getAddrInfo (Just defaultHints) (Just "127.0.0.1") (Just "http")
--
-- >>> getNameInfo [NI_NUMERICHOST, NI_NUMERICSERV] True True $ addrAddress addr
-- (Just "127.0.0.1",Just "80")
--
getNameInfo :: [NameInfoFlag] -> Bool -> Bool -> SockAddr -> IO (Maybe HostName, Maybe ServiceName)
-- | Flags that control the querying behaviour of getNameInfo. For
-- more information, see
-- https://tools.ietf.org/html/rfc3493#page-30
data NameInfoFlag
-- | Resolve a datagram-based service name. This is required only for the
-- few protocols that have different port numbers for their
-- datagram-based versions than for their stream-based versions.
NI_DGRAM :: NameInfoFlag
-- | If the hostname cannot be looked up, an IO error is thrown.
NI_NAMEREQD :: NameInfoFlag
-- | If a host is local, return only the hostname part of the FQDN.
NI_NOFQDN :: NameInfoFlag
-- | The name of the host is not looked up. Instead, a numeric
-- representation of the host's address is returned. For an IPv4 address,
-- this will be a dotted-quad string. For IPv6, it will be
-- colon-separated hexadecimal.
NI_NUMERICHOST :: NameInfoFlag
-- | The name of the service is not looked up. Instead, a numeric
-- representation of the service is returned.
NI_NUMERICSERV :: NameInfoFlag
-- | Set the close_on_exec flag on Unix. On Windows, nothing is done.
--
-- Since 2.7.0.0.
setCloseOnExecIfNeeded :: CInt -> IO ()
-- | Get the close_on_exec flag. On Windows, this function always returns
-- False.
--
-- Since 2.7.0.0.
getCloseOnExec :: CInt -> IO Bool
-- | Set the nonblocking flag on Unix. On Windows, nothing is done.
setNonBlockIfNeeded :: CInt -> IO ()
-- | Get the nonblocking flag. On Windows, this function always returns
-- False.
--
-- Since 2.7.0.0.
getNonBlock :: CInt -> IO Bool
-- | Send data to the socket. The socket must be connected to a remote
-- socket. Returns the number of bytes sent. Applications are responsible
-- for ensuring that all data has been sent.
sendBuf :: Socket -> Ptr Word8 -> Int -> IO Int
-- | Receive data from the socket. The socket must be in a connected state.
-- This function may return fewer bytes than specified. If the message is
-- longer than the specified length, it may be discarded depending on the
-- type of socket. This function may block until a message arrives.
--
-- Considering hardware and network realities, the maximum number of
-- bytes to receive should be a small power of 2, e.g., 4096.
--
-- The return value is the length of received data. Zero means EOF.
-- Historical note: Version 2.8.x.y or earlier, an EOF error was thrown.
-- This was changed in version 3.0.
recvBuf :: Socket -> Ptr Word8 -> Int -> IO Int
-- | Send data to the socket. The recipient can be specified explicitly, so
-- the socket need not be in a connected state. Returns the number of
-- bytes sent. Applications are responsible for ensuring that all data
-- has been sent.
sendBufTo :: Socket -> Ptr a -> Int -> SockAddr -> IO Int
-- | Receive data from the socket, writing it into buffer instead of
-- creating a new string. The socket need not be in a connected state.
-- Returns (nbytes, address) where nbytes is the number
-- of bytes received and address is a SockAddr
-- representing the address of the sending socket.
--
-- If the first return value is zero, it means EOF.
--
-- For Stream sockets, the second return value would be invalid.
--
-- NOTE: blocking on Windows unless you compile with -threaded (see GHC
-- ticket #1129)
recvBufFrom :: Socket -> Ptr a -> Int -> IO (Int, SockAddr)
-- | Send data to the socket using sendmsg(2).
sendBufMsg :: Socket -> SockAddr -> [(Ptr Word8, Int)] -> [Cmsg] -> MsgFlag -> IO Int
-- | Receive data from the socket using recvmsg(2).
recvBufMsg :: Socket -> [(Ptr Word8, Int)] -> Int -> MsgFlag -> IO (SockAddr, Int, [Cmsg], MsgFlag)
-- | Message flags. To combine flags, use (<>).
data MsgFlag
-- | Send or receive OOB(out-of-bound) data.
pattern MSG_OOB :: MsgFlag
-- | Bypass routing table lookup.
pattern MSG_DONTROUTE :: MsgFlag
-- | Peek at incoming message without removing it from the queue.
pattern MSG_PEEK :: MsgFlag
-- | End of record.
pattern MSG_EOR :: MsgFlag
-- | Received data is truncated. More data exist.
pattern MSG_TRUNC :: MsgFlag
-- | Received control message is truncated. More control message exist.
pattern MSG_CTRUNC :: MsgFlag
-- | Wait until the requested number of bytes have been read.
pattern MSG_WAITALL :: MsgFlag
-- | Control message (ancillary data) including a pair of level and type.
data Cmsg
Cmsg :: CmsgId -> ByteString -> Cmsg
[cmsgId] :: Cmsg -> CmsgId
[cmsgData] :: Cmsg -> ByteString
-- | Identifier of control message (ancillary data).
data CmsgId
CmsgId :: CInt -> CInt -> CmsgId
-- | The identifier for IPv4TTL.
pattern CmsgIdIPv4TTL :: CmsgId
-- | The identifier for IPv6HopLimit.
pattern CmsgIdIPv6HopLimit :: CmsgId
-- | The identifier for IPv4TOS.
pattern CmsgIdIPv4TOS :: CmsgId
-- | The identifier for IPv6TClass.
pattern CmsgIdIPv6TClass :: CmsgId
-- | The identifier for IPv4PktInfo.
pattern CmsgIdIPv4PktInfo :: CmsgId
-- | The identifier for IPv6PktInfo.
pattern CmsgIdIPv6PktInfo :: CmsgId
-- | The identifier for Fds.
pattern CmsgIdFds :: CmsgId
-- | Unsupported identifier
pattern UnsupportedCmsgId :: CmsgId
-- | Locate a control message of the given type in a list of control
-- messages. The following shows an example usage:
--
--
-- (lookupCmsg CmsgIdIPv4TOS cmsgs >>= decodeCmsg) :: Maybe IPv4TOS
--
lookupCmsg :: CmsgId -> [Cmsg] -> Maybe Cmsg
-- | Filtering control message.
filterCmsg :: CmsgId -> [Cmsg] -> [Cmsg]
-- | Control message type class. Each control message type has a numeric
-- CmsgId and encode and decode functions.
class ControlMessage a
controlMessageId :: ControlMessage a => CmsgId
encodeCmsg :: ControlMessage a => a -> Cmsg
decodeCmsg :: ControlMessage a => Cmsg -> Maybe a
-- | Time to live of IPv4.
newtype IPv4TTL
IPv4TTL :: CInt -> IPv4TTL
-- | Hop limit of IPv6.
newtype IPv6HopLimit
IPv6HopLimit :: CInt -> IPv6HopLimit
-- | TOS of IPv4.
newtype IPv4TOS
IPv4TOS :: CChar -> IPv4TOS
-- | Traffic class of IPv6.
newtype IPv6TClass
IPv6TClass :: CInt -> IPv6TClass
-- | Network interface ID and local IPv4 address.
data IPv4PktInfo
IPv4PktInfo :: Int -> HostAddress -> HostAddress -> IPv4PktInfo
-- | Network interface ID and local IPv4 address.
data IPv6PktInfo
IPv6PktInfo :: Int -> HostAddress6 -> IPv6PktInfo
-- | This is the value of SOMAXCONN, typically 128. 128 is good enough for
-- normal network servers but is too small for high performance servers.
maxListenQueue :: Int
-- | STM action to wait until the socket is ready for reading.
waitReadSocketSTM :: Socket -> IO (STM ())
-- | STM action to wait until the socket is ready for reading and STM
-- action to cancel the waiting.
waitAndCancelReadSocketSTM :: Socket -> IO (STM (), IO ())
-- | STM action to wait until the socket is ready for writing.
waitWriteSocketSTM :: Socket -> IO (STM ())
-- | STM action to wait until the socket is ready for writing and STM
-- action to cancel the waiting.
waitAndCancelWriteSocketSTM :: Socket -> IO (STM (), IO ())
-- | This module provides access to the BSD socket interface. For
-- detailed documentation, consult your favorite POSIX socket reference.
-- All functions communicate failures by converting the error number to
-- an IOError.
--
-- This module is made to be imported with Network.Socket like so:
--
--
-- import Network.Socket
-- import Network.Socket.ByteString.Lazy
-- import Prelude hiding (getContents)
--
module Network.Socket.ByteString.Lazy
send :: Socket -> ByteString -> IO Int64
sendAll :: Socket -> ByteString -> IO ()
-- | Send data and file descriptors over a UNIX-domain socket in a single
-- system call. This function does not work on Windows.
sendWithFds :: Socket -> ByteString -> [Fd] -> IO ()
-- | Receive data from the socket. The socket must be in a connected state.
-- Data is received on demand, in chunks; each chunk will be sized to
-- reflect the amount of data received by individual recv calls.
--
-- All remaining data from the socket is consumed. When there is no more
-- data to be received, the receiving side of the socket is shut down. If
-- there is an error and an exception is thrown, the socket is not shut
-- down.
getContents :: Socket -> IO ByteString
-- | Receive data from the socket. The socket must be in a connected state.
-- This function may return fewer bytes than specified. If the received
-- data is longer than the specified length, it may be discarded
-- depending on the type of socket. This function may block until a
-- message arrives.
--
-- If there is no more data to be received, returns an empty
-- ByteString.
recv :: Socket -> Int64 -> IO ByteString