System.Socket

{-# LANGUAGE OverloadedStrings #-}
module Main where

import Control.Exception ( bracket, catch )
import Control.Monad ( forever )

import System.Socket
import System.Socket.Family.Inet6
import System.Socket.Type.Stream
import System.Socket.Protocol.TCP

main :: IO ()
main = bracket
  ( socket :: IO (Socket Inet6 Stream TCP) )
  ( \s-> do
    close s
    putStrLn "Listening socket closed."
  )
  ( \s-> do
    setSocketOption s (ReuseAddress True)
    setSocketOption s (V6Only False)
    bind s (SocketAddressInet6 inet6Any 8080 0 0)
    listen s 5
    putStrLn "Listening socket ready..."
    forever $ acceptAndHandle s `catch` \e-> print (e :: SocketException)
  )

acceptAndHandle :: Socket Inet6 Stream TCP -> IO ()
acceptAndHandle s = bracket
  ( accept s )
  ( \(p, addr)-> do
    close p
    putStrLn $ "Closed connection to " ++ show addr
  )
  ( \(p, addr)-> do
    putStrLn $ "Accepted connection from " ++ show addr
    sendAll p "Hello world!" msgNoSignal
  )

Socket

data Socket f t p

A generic socket type. Use socket to create a new socket.

The socket is just an MVar-wrapped file descriptor. The Socket constructor is exported trough the unsafe module in order to make this library easily extensible, but it is usually not necessary nor advised to work directly on the file descriptor. If you do, the following rules must be obeyed:

• Make sure not to deadlock. Use withMVar or similar.
• The lock must not be held during a blocking call. This would make it impossible to send and receive simultaneously or to close the socket.
• The lock must be held when calling operations that use the file descriptor. Otherwise the socket might get closed or even reused by another thread/capability which might result in reading from or writing totally different connection. This is a security nightmare!
• The socket is non-blocking and all the code relies on that assumption. You need to use GHC's eventing mechanism primitives to block until something happens. The former rules forbid to use threadWaitRead as it does not separate between registering the file descriptor (for which the lock must be held) and the actual waiting (for which you must not hold the lock). Also see this thread and read the library code to see how the problem is currently circumvented.

data family SocketAddress f

The SocketAddress type is a data family. This allows to provide different data constructors depending on the socket family wihtout knowing all of them in advance or the need to patch this core library.

SocketAddressInet  inetLoopback  8080     :: SocketAddress Inet
SocketAddressInet6 inet6Loopback 8080 0 0 :: SocketAddress Inet6

Instances

Eq (SocketAddress Inet6)

Methods

(==) :: SocketAddress Inet6 -> SocketAddress Inet6 -> Bool

(/=) :: SocketAddress Inet6 -> SocketAddress Inet6 -> Bool

Eq (SocketAddress Inet)

Methods

(==) :: SocketAddress Inet -> SocketAddress Inet -> Bool

(/=) :: SocketAddress Inet -> SocketAddress Inet -> Bool

Show (SocketAddress Inet6)

Methods

showsPrec :: Int -> SocketAddress Inet6 -> ShowS

show :: SocketAddress Inet6 -> String

showList :: [SocketAddress Inet6] -> ShowS

Show (SocketAddress Inet)

Methods

showsPrec :: Int -> SocketAddress Inet -> ShowS

show :: SocketAddress Inet -> String

showList :: [SocketAddress Inet] -> ShowS

Storable (SocketAddress Inet6)

Methods

sizeOf :: SocketAddress Inet6 -> Int

alignment :: SocketAddress Inet6 -> Int

peekElemOff :: Ptr (SocketAddress Inet6) -> Int -> IO (SocketAddress Inet6)

pokeElemOff :: Ptr (SocketAddress Inet6) -> Int -> SocketAddress Inet6 -> IO ()

peekByteOff :: Ptr b -> Int -> IO (SocketAddress Inet6)

pokeByteOff :: Ptr b -> Int -> SocketAddress Inet6 -> IO ()

peek :: Ptr (SocketAddress Inet6) -> IO (SocketAddress Inet6)

poke :: Ptr (SocketAddress Inet6) -> SocketAddress Inet6 -> IO ()

Storable (SocketAddress Inet)

Methods

sizeOf :: SocketAddress Inet -> Int

alignment :: SocketAddress Inet -> Int

peekElemOff :: Ptr (SocketAddress Inet) -> Int -> IO (SocketAddress Inet)

pokeElemOff :: Ptr (SocketAddress Inet) -> Int -> SocketAddress Inet -> IO ()

peekByteOff :: Ptr b -> Int -> IO (SocketAddress Inet)

pokeByteOff :: Ptr b -> Int -> SocketAddress Inet -> IO ()

peek :: Ptr (SocketAddress Inet) -> IO (SocketAddress Inet)

poke :: Ptr (SocketAddress Inet) -> SocketAddress Inet -> IO ()

data SocketAddress Inet6

An IPv6 socket address.

The socket address contains a port number that may be used by transport protocols like TCP.

SocketAddressInet6 inet6Loopback 8080 0 0

data SocketAddress Inet6 = SocketAddressInet6 {

• inet6Address :: Inet6Address
• inet6Port :: Inet6Port
• inet6FlowInfo :: Inet6FlowInfo
• inet6ScopeId :: Inet6ScopeId

}

data SocketAddress Inet

An IPv4 socket address.

The socket address contains a port number that may be used by transport protocols like TCP.

SocketAddressInet inetLoopback 8080

data SocketAddress Inet = SocketAddressInet {

• inetAddress :: InetAddress
• inetPort :: InetPort

}

Family

class Family f where

Minimal complete definition

familyNumber

Methods

familyNumber :: f -> CInt

Instances

Family Inet6

Methods

familyNumber :: Inet6 -> CInt

Family Inet

Methods

familyNumber :: Inet -> CInt

Type

class Type t where

Minimal complete definition

typeNumber

Methods

typeNumber :: t -> CInt

Instances

Type SequentialPacket

Methods

typeNumber :: SequentialPacket -> CInt

Type Datagram

Methods

typeNumber :: Datagram -> CInt

Type Raw

Methods

typeNumber :: Raw -> CInt

Type Stream

Methods

typeNumber :: Stream -> CInt

Protocol

class Protocol p where

Minimal complete definition

protocolNumber

Methods

protocolNumber :: p -> CInt

Instances

Protocol TCP

Methods

protocolNumber :: TCP -> CInt

Protocol UDP

Methods

protocolNumber :: UDP -> CInt

Operations

socket

socket :: (Family f, Type t, Protocol p) => IO (Socket f t p)

Creates a new socket.

Whereas the underlying POSIX socket operation takes 3 parameters, this library encodes this information in the type variables. This rules out several kinds of errors and escpecially simplifies the handling of addresses (by using associated type families). Examples:

-- create a IPv4-UDP-datagram socket
sock <- socket :: IO (Socket Inet Datagram UDP)
-- create a IPv6-TCP-streaming socket
sock6 <- socket :: IO (Socket Inet6 Stream TCP)

• This operation sets up a finalizer that automatically closes the socket when the garbage collection decides to collect it. This is just a fail-safe. You might still run out of file descriptors as there's no guarantee about when the finalizer is run. You're advised to manually close the socket when it's no longer needed. If possible, use bracket to reliably close the socket descriptor on exception or regular termination of your computation:

result <- bracket (socket :: IO (Socket Inet6 Stream TCP)) close $ \sock-> do
  somethingWith sock -- your computation here
  return somethingelse

• This operation configures the socket non-blocking to work seamlessly with the runtime system's event notification mechanism.
• This operation can safely deal with asynchronous exceptions without leaking file descriptors.
• This operation throws SocketExceptions. Consult your man page for details and specific errnos.

connect

connect :: (Family f, Storable (SocketAddress f)) => Socket f t p -> SocketAddress f -> IO ()

Connects to a remote address.

• This operation returns as soon as a connection has been established (as if the socket were blocking). The connection attempt has either failed or succeeded after this operation threw an exception or returned.
• The socket is locked throughout the whole operation.
• The operation throws SocketExceptions. Calling connect on a closed socket throws eBadFileDescriptor even if the former file descriptor has been reassigned.

bind

bind :: (Family f, Storable (SocketAddress f)) => Socket f t p -> SocketAddress f -> IO ()

Bind a socket to an address.

• Calling bind on a closed socket throws eBadFileDescriptor even if the former file descriptor has been reassigned.
• It is assumed that bind never blocks and therefore eInProgress, eAlready and eInterrupted don't occur. This assumption is supported by the fact that the Linux manpage doesn't mention any of these errors, the Posix manpage doesn't mention the last one and even MacOS' implementation will never fail with any of these when the socket is configured non-blocking as argued here.
• This operation throws SocketExceptions. Consult your man page for details and specific errnos.

listen

listen :: Socket f t p -> Int -> IO ()

Starts listening and queueing connection requests on a connection-mode socket.

• Calling listen on a closed socket throws eBadFileDescriptor even if the former file descriptor has been reassigned.
• The second parameter is called backlog and sets a limit on how many unaccepted connections the socket implementation shall queue. A value of 0 leaves the decision to the implementation.
• This operation throws SocketExceptions. Consult your man page for details and specific errnos.

accept

accept :: (Family f, Storable (SocketAddress f)) => Socket f t p -> IO (Socket f t p, SocketAddress f)

Accept a new connection.

• Calling accept on a closed socket throws eBadFileDescriptor even if the former file descriptor has been reassigned.
• This operation configures the new socket non-blocking (TODO: use accept4 if available).
• This operation sets up a finalizer for the new socket that automatically closes the new socket when the garbage collection decides to collect it. This is just a fail-safe. You might still run out of file descriptors as there's no guarantee about when the finalizer is run. You're advised to manually close the socket when it's no longer needed.
• This operation throws SocketExceptions. Consult your man page for details and specific errnos.
• This operation catches eAgain, eWouldBlock and eInterrupted internally and retries automatically.

send, sendTo

send :: Socket f t p -> ByteString -> MessageFlags -> IO Int

Send a message on a connected socket.

• Calling send on a closed socket throws eBadFileDescriptor even if the former file descriptor has been reassigned.
• The operation returns the number of bytes sent. On Datagram and SequentialPacket sockets certain assurances on atomicity exist and eAgain or eWouldBlock are returned until the whole message would fit into the send buffer.
• This operation throws SocketExceptions. Consult man 3p send for details and specific errnos.
• eAgain, eWouldBlock and eInterrupted and handled internally and won't be thrown. For performance reasons the operation first tries a write on the socket and then waits when it got eAgain or eWouldBlock.

sendTo :: (Family f, Storable (SocketAddress f)) => Socket f t p -> ByteString -> MessageFlags -> SocketAddress f -> IO Int

Like send, but allows to specify a destination address.

receive, receiveFrom

receive :: Socket f t p -> Int -> MessageFlags -> IO ByteString

Receive a message on a connected socket.

• Calling receive on a closed socket throws eBadFileDescriptor even if the former file descriptor has been reassigned.
• The operation takes a buffer size in bytes a first parameter which limits the maximum length of the returned ByteString.
• This operation throws SocketExceptions. Consult man 3p receive for details and specific errnos.
• eAgain, eWouldBlock and eInterrupted and handled internally and won't be thrown. For performance reasons the operation first tries a read on the socket and then waits when it got eAgain or eWouldBlock.

receiveFrom :: (Family f, Storable (SocketAddress f)) => Socket f t p -> Int -> MessageFlags -> IO (ByteString, SocketAddress f)

Like receive, but additionally yields the peer address.

close

close :: Socket f t p -> IO ()

Closes a socket.

• This operation is idempotent and thus can be performed more than once without throwing an exception. If it throws an exception it is presumably a not recoverable situation and the process should exit.
• This operation does not block.
• This operation wakes up all threads that are currently blocking on this socket. All other threads are guaranteed not to block on operations on this socket in the future. Threads that perform operations other than close on this socket will fail with eBadFileDescriptor after the socket has been closed (close replaces the Fd in the MVar with -1 to reliably avoid use-after-free situations).
• This operation potentially throws SocketExceptions (only EIO is documented). eInterrupted is catched internally and retried automatically, so won't be thrown.

Options

class SocketOption o where

Minimal complete definition

getSocketOption, setSocketOption

Methods

getSocketOption :: Socket f t p -> IO o

setSocketOption :: Socket f t p -> o -> IO ()

Instances

SocketOption ReuseAddress

Methods

getSocketOption :: Socket f t p -> IO ReuseAddress

setSocketOption :: Socket f t p -> ReuseAddress -> IO ()

SocketOption Error

Methods

getSocketOption :: Socket f t p -> IO Error

setSocketOption :: Socket f t p -> Error -> IO ()

SocketOption V6Only

Methods

getSocketOption :: Socket f t p -> IO V6Only

setSocketOption :: Socket f t p -> V6Only -> IO ()

data Error

SO_ERROR

Constructors

Error SocketException

Instances

Eq Error

Methods

(==) :: Error -> Error -> Bool

(/=) :: Error -> Error -> Bool

Ord Error

Methods

compare :: Error -> Error -> Ordering

(<) :: Error -> Error -> Bool

(<=) :: Error -> Error -> Bool

(>) :: Error -> Error -> Bool

(>=) :: Error -> Error -> Bool

max :: Error -> Error -> Error

min :: Error -> Error -> Error

Show Error

Methods

showsPrec :: Int -> Error -> ShowS

show :: Error -> String

showList :: [Error] -> ShowS

SocketOption Error

Methods

getSocketOption :: Socket f t p -> IO Error

setSocketOption :: Socket f t p -> Error -> IO ()

data ReuseAddress

SO_REUSEADDR

Constructors

ReuseAddress Bool

Instances

Eq ReuseAddress

Methods

(==) :: ReuseAddress -> ReuseAddress -> Bool

(/=) :: ReuseAddress -> ReuseAddress -> Bool

Ord ReuseAddress

Methods

compare :: ReuseAddress -> ReuseAddress -> Ordering

(<) :: ReuseAddress -> ReuseAddress -> Bool

(<=) :: ReuseAddress -> ReuseAddress -> Bool

(>) :: ReuseAddress -> ReuseAddress -> Bool

(>=) :: ReuseAddress -> ReuseAddress -> Bool

max :: ReuseAddress -> ReuseAddress -> ReuseAddress

min :: ReuseAddress -> ReuseAddress -> ReuseAddress

Show ReuseAddress

Methods

showsPrec :: Int -> ReuseAddress -> ShowS

show :: ReuseAddress -> String

showList :: [ReuseAddress] -> ShowS

SocketOption ReuseAddress

Methods

getSocketOption :: Socket f t p -> IO ReuseAddress

setSocketOption :: Socket f t p -> ReuseAddress -> IO ()

Name Resolution

getAddressInfo

data AddressInfo f t p

Constructors

AddressInfo

Fields

• addressInfoFlags :: AddressInfoFlags
• socketAddress :: SocketAddress f
• canonicalName :: Maybe ByteString

Instances

Eq (SocketAddress f) => Eq (AddressInfo f t p)

Methods

(==) :: AddressInfo f t p -> AddressInfo f t p -> Bool

(/=) :: AddressInfo f t p -> AddressInfo f t p -> Bool

Show (SocketAddress f) => Show (AddressInfo f t p)

Methods

showsPrec :: Int -> AddressInfo f t p -> ShowS

show :: AddressInfo f t p -> String

showList :: [AddressInfo f t p] -> ShowS

class Family f => HasAddressInfo f where

Minimal complete definition

getAddressInfo

Methods

getAddressInfo :: (Type t, Protocol p) => Maybe ByteString -> Maybe ByteString -> AddressInfoFlags -> IO [AddressInfo f t p]

Maps names to addresses (i.e. by DNS lookup).

The operation throws AddressInfoExceptions.

Contrary to the underlying getaddrinfo operation this wrapper is typesafe and thus only returns records that match the address, type and protocol encoded in the type. This is the price we have to pay for typesafe sockets and extensibility.

If you need different types of records, you need to start several queries. If you want to connect to both IPv4 and IPV6 addresses use aiV4Mapped and use IPv6-sockets.

getAddressInfo (Just "www.haskell.org") (Just "https") mempty :: IO [AddressInfo Inet Stream TCP]
> [AddressInfo {addressInfoFlags = AddressInfoFlags 0, socketAddress = SocketAddressInet {inetAddress = InetAddress 162.242.239.16, inetPort = InetPort 443}, canonicalName = Nothing}]

> getAddressInfo (Just "www.haskell.org") (Just "80") aiV4Mapped :: IO [AddressInfo Inet6 Stream TCP]
[AddressInfo {
   addressInfoFlags = AddressInfoFlags 8,
   socketAddress    = SocketAddressInet6 {inet6Address = Inet6Address 2400:cb00:2048:0001:0000:0000:6ca2:cc3c, inet6Port = Inet6Port 80, inet6FlowInfo = Inet6FlowInfo 0, inet6ScopeId = Inet6ScopeId 0},
   canonicalName    = Nothing }]

> getAddressInfo (Just "darcs.haskell.org") Nothing aiV4Mapped :: IO [AddressInfo Inet6 Stream TCP]
[AddressInfo {
   addressInfoFlags = AddressInfoFlags 8,
   socketAddress    = SocketAddressInet6 {inet6Address = Inet6Address 0000:0000:0000:0000:0000:ffff:17fd:e1ad, inet6Port = Inet6Port 0, inet6FlowInfo = Inet6FlowInfo 0, inet6ScopeId = Inet6ScopeId 0},
   canonicalName    = Nothing }]
> getAddressInfo (Just "darcs.haskell.org") Nothing mempty :: IO [AddressInfo Inet6 Stream TCP]
*** Exception: AddressInfoException "Name or service not known"

Instances

HasAddressInfo Inet6

Methods

getAddressInfo :: (Type t, Protocol p) => Maybe ByteString -> Maybe ByteString -> AddressInfoFlags -> IO [AddressInfo Inet6 t p]

HasAddressInfo Inet

Methods

getAddressInfo :: (Type t, Protocol p) => Maybe ByteString -> Maybe ByteString -> AddressInfoFlags -> IO [AddressInfo Inet t p]

getNameInfo

data NameInfo

A NameInfo consists of host and service name.

Constructors

NameInfo

Fields

• hostName :: ByteString
• serviceName :: ByteString

Instances

Eq NameInfo

Methods

(==) :: NameInfo -> NameInfo -> Bool

(/=) :: NameInfo -> NameInfo -> Bool

Show NameInfo

Methods

showsPrec :: Int -> NameInfo -> ShowS

show :: NameInfo -> String

showList :: [NameInfo] -> ShowS

class Family f => HasNameInfo f where

Maps addresses to readable host- and service names.

The operation throws AddressInfoExceptions.

> getNameInfo (SocketAddressInet inetLoopback 80) mempty
NameInfo {hostName = "localhost.localdomain", serviceName = "http"}

Minimal complete definition

getNameInfo

Methods

getNameInfo :: SocketAddress f -> NameInfoFlags -> IO NameInfo

Instances

HasNameInfo Inet6

Methods

getNameInfo :: SocketAddress Inet6 -> NameInfoFlags -> IO NameInfo

HasNameInfo Inet

Methods

getNameInfo :: SocketAddress Inet -> NameInfoFlags -> IO NameInfo

Flags

MessageFlags

newtype MessageFlags

Use the Monoid instance to combine several flags:

mconcat [msgNoSignal, msgWaitAll]

Use the Bits instance to check whether a flag is set:

if flags .&. msgEndOfRecord /= mempty then ...

Constructors

MessageFlags CInt

Instances

Eq MessageFlags

Methods

(==) :: MessageFlags -> MessageFlags -> Bool

(/=) :: MessageFlags -> MessageFlags -> Bool

Show MessageFlags

Methods

showsPrec :: Int -> MessageFlags -> ShowS

show :: MessageFlags -> String

showList :: [MessageFlags] -> ShowS

Monoid MessageFlags

Methods

mempty :: MessageFlags

mappend :: MessageFlags -> MessageFlags -> MessageFlags

mconcat :: [MessageFlags] -> MessageFlags

Storable MessageFlags

Methods

sizeOf :: MessageFlags -> Int

alignment :: MessageFlags -> Int

peekElemOff :: Ptr MessageFlags -> Int -> IO MessageFlags

pokeElemOff :: Ptr MessageFlags -> Int -> MessageFlags -> IO ()

peekByteOff :: Ptr b -> Int -> IO MessageFlags

pokeByteOff :: Ptr b -> Int -> MessageFlags -> IO ()

peek :: Ptr MessageFlags -> IO MessageFlags

poke :: Ptr MessageFlags -> MessageFlags -> IO ()

Bits MessageFlags

Methods

(.&.) :: MessageFlags -> MessageFlags -> MessageFlags

(.|.) :: MessageFlags -> MessageFlags -> MessageFlags

xor :: MessageFlags -> MessageFlags -> MessageFlags

complement :: MessageFlags -> MessageFlags

shift :: MessageFlags -> Int -> MessageFlags

rotate :: MessageFlags -> Int -> MessageFlags

zeroBits :: MessageFlags

bit :: Int -> MessageFlags

setBit :: MessageFlags -> Int -> MessageFlags

clearBit :: MessageFlags -> Int -> MessageFlags

complementBit :: MessageFlags -> Int -> MessageFlags

testBit :: MessageFlags -> Int -> Bool

bitSizeMaybe :: MessageFlags -> Maybe Int

bitSize :: MessageFlags -> Int

isSigned :: MessageFlags -> Bool

shiftL :: MessageFlags -> Int -> MessageFlags

unsafeShiftL :: MessageFlags -> Int -> MessageFlags

shiftR :: MessageFlags -> Int -> MessageFlags

unsafeShiftR :: MessageFlags -> Int -> MessageFlags

rotateL :: MessageFlags -> Int -> MessageFlags

rotateR :: MessageFlags -> Int -> MessageFlags

popCount :: MessageFlags -> Int

msgEndOfRecord :: MessageFlags

MSG_EOR

msgNoSignal :: MessageFlags

MSG_NOSIGNAL

Suppresses the generation of PIPE signals when writing to a socket that is no longer connected.

Although this flag is POSIX, it is not available on all platforms. Try

msgNoSignal /= mempty

in order to check whether this flag is defined on a certain platform. It is safe to just use this constant even if it might not have effect on a certain target platform. The platform independence of this flag is therefore fulfilled to some extent.

Some more explanation on the platform specific behaviour:

• Linux defines and supports MSG_NOSIGNAL and properly suppresses the generation of broken pipe-related signals.
• Windows does not define it, but does not generate signals either.
• OSX does not define it, but generates PIPE signals. The GHC runtime ignores them if you don't hook them explicitly. The non-portable socket option SO_NOSIGPIPE may be used disable signals on a per-socket basis.

msgOutOfBand :: MessageFlags

MSG_OOB

msgWaitAll :: MessageFlags

MSG_WAITALL

AddressInfoFlags

data AddressInfoFlags

Use the Monoid instance to combine several flags:

mconcat [aiAddressConfig, aiV4Mapped]

Instances

Eq AddressInfoFlags

Methods

(==) :: AddressInfoFlags -> AddressInfoFlags -> Bool

(/=) :: AddressInfoFlags -> AddressInfoFlags -> Bool

Show AddressInfoFlags

Methods

showsPrec :: Int -> AddressInfoFlags -> ShowS

show :: AddressInfoFlags -> String

showList :: [AddressInfoFlags] -> ShowS

Monoid AddressInfoFlags

Methods

mempty :: AddressInfoFlags

mappend :: AddressInfoFlags -> AddressInfoFlags -> AddressInfoFlags

mconcat :: [AddressInfoFlags] -> AddressInfoFlags

Bits AddressInfoFlags

Methods

(.&.) :: AddressInfoFlags -> AddressInfoFlags -> AddressInfoFlags

(.|.) :: AddressInfoFlags -> AddressInfoFlags -> AddressInfoFlags

xor :: AddressInfoFlags -> AddressInfoFlags -> AddressInfoFlags

complement :: AddressInfoFlags -> AddressInfoFlags

shift :: AddressInfoFlags -> Int -> AddressInfoFlags

rotate :: AddressInfoFlags -> Int -> AddressInfoFlags

zeroBits :: AddressInfoFlags

bit :: Int -> AddressInfoFlags

setBit :: AddressInfoFlags -> Int -> AddressInfoFlags

clearBit :: AddressInfoFlags -> Int -> AddressInfoFlags

complementBit :: AddressInfoFlags -> Int -> AddressInfoFlags

testBit :: AddressInfoFlags -> Int -> Bool

bitSizeMaybe :: AddressInfoFlags -> Maybe Int

bitSize :: AddressInfoFlags -> Int

isSigned :: AddressInfoFlags -> Bool

shiftL :: AddressInfoFlags -> Int -> AddressInfoFlags

unsafeShiftL :: AddressInfoFlags -> Int -> AddressInfoFlags

shiftR :: AddressInfoFlags -> Int -> AddressInfoFlags

unsafeShiftR :: AddressInfoFlags -> Int -> AddressInfoFlags

rotateL :: AddressInfoFlags -> Int -> AddressInfoFlags

rotateR :: AddressInfoFlags -> Int -> AddressInfoFlags

popCount :: AddressInfoFlags -> Int

aiAddressConfig :: AddressInfoFlags

AI_ADDRCONFIG:

aiAll :: AddressInfoFlags

AI_ALL: Return both IPv4 (as mapped SocketAddressInet6) and IPv6 addresses when aiV4Mapped is set independent of whether IPv6 addresses exist for this name.

aiCanonicalName :: AddressInfoFlags

AI_CANONNAME:

aiNumericHost :: AddressInfoFlags

AI_NUMERICHOST:

aiNumericService :: AddressInfoFlags

AI_NUMERICSERV:

aiPassive :: AddressInfoFlags

AI_PASSIVE:

aiV4Mapped :: AddressInfoFlags

AI_V4MAPPED: Return mapped IPv4 addresses if no IPv6 addresses could be found or if aiAll flag is set.

NameInfoFlags

data NameInfoFlags

Use the Monoid instance to combine several flags:

mconcat [niNameRequired, niNoFullyQualifiedDomainName]

Instances

Eq NameInfoFlags

Methods

(==) :: NameInfoFlags -> NameInfoFlags -> Bool

(/=) :: NameInfoFlags -> NameInfoFlags -> Bool

Show NameInfoFlags

Methods

showsPrec :: Int -> NameInfoFlags -> ShowS

show :: NameInfoFlags -> String

showList :: [NameInfoFlags] -> ShowS

Monoid NameInfoFlags

Methods

mempty :: NameInfoFlags

mappend :: NameInfoFlags -> NameInfoFlags -> NameInfoFlags

mconcat :: [NameInfoFlags] -> NameInfoFlags

Bits NameInfoFlags

Methods

(.&.) :: NameInfoFlags -> NameInfoFlags -> NameInfoFlags

(.|.) :: NameInfoFlags -> NameInfoFlags -> NameInfoFlags

xor :: NameInfoFlags -> NameInfoFlags -> NameInfoFlags

complement :: NameInfoFlags -> NameInfoFlags

shift :: NameInfoFlags -> Int -> NameInfoFlags

rotate :: NameInfoFlags -> Int -> NameInfoFlags

zeroBits :: NameInfoFlags

bit :: Int -> NameInfoFlags

setBit :: NameInfoFlags -> Int -> NameInfoFlags

clearBit :: NameInfoFlags -> Int -> NameInfoFlags

complementBit :: NameInfoFlags -> Int -> NameInfoFlags

testBit :: NameInfoFlags -> Int -> Bool

bitSizeMaybe :: NameInfoFlags -> Maybe Int

bitSize :: NameInfoFlags -> Int

isSigned :: NameInfoFlags -> Bool

shiftL :: NameInfoFlags -> Int -> NameInfoFlags

unsafeShiftL :: NameInfoFlags -> Int -> NameInfoFlags

shiftR :: NameInfoFlags -> Int -> NameInfoFlags

unsafeShiftR :: NameInfoFlags -> Int -> NameInfoFlags

rotateL :: NameInfoFlags -> Int -> NameInfoFlags

rotateR :: NameInfoFlags -> Int -> NameInfoFlags

popCount :: NameInfoFlags -> Int

niNameRequired :: NameInfoFlags

NI_NAMEREQD: Throw an exception if the hostname cannot be determined.

niDatagram :: NameInfoFlags

NI_DGRAM: Service is datagram based (i.e. UDP) rather than stream based (i.e. TCP).

niNoFullyQualifiedDomainName :: NameInfoFlags

NI_NOFQDN: Return only the hostname part of the fully qualified domain name for local hosts.

niNumericHost :: NameInfoFlags

NI_NUMERICHOST: Return the numeric form of the host address.

niNumericService :: NameInfoFlags

NI_NUMERICSERV: Return the numeric form of the service address.

Exceptions

SocketException

newtype SocketException

Constructors

SocketException CInt

Instances

Eq SocketException

Methods

(==) :: SocketException -> SocketException -> Bool

(/=) :: SocketException -> SocketException -> Bool

Ord SocketException

Methods

compare :: SocketException -> SocketException -> Ordering

(<) :: SocketException -> SocketException -> Bool

(<=) :: SocketException -> SocketException -> Bool

(>) :: SocketException -> SocketException -> Bool

(>=) :: SocketException -> SocketException -> Bool

max :: SocketException -> SocketException -> SocketException

min :: SocketException -> SocketException -> SocketException

Show SocketException

Methods

showsPrec :: Int -> SocketException -> ShowS

show :: SocketException -> String

showList :: [SocketException] -> ShowS

Exception SocketException

Methods

toException :: SocketException -> SomeException

fromException :: SomeException -> Maybe SocketException

displayException :: SocketException -> String

eOk :: SocketException

eInterrupted :: SocketException

eBadFileDescriptor :: SocketException

eInvalid :: SocketException

ePipe :: SocketException

eWouldBlock :: SocketException

eAgain :: SocketException

eNotSocket :: SocketException

eDestinationAddressRequired :: SocketException

eMessageSize :: SocketException

eProtocolType :: SocketException

eNoProtocolOption :: SocketException

eProtocolNotSupported :: SocketException

eSocketTypeNotSupported :: SocketException

eOperationNotSupported :: SocketException

eProtocolFamilyNotSupported :: SocketException

eAddressFamilyNotSupported :: SocketException

eAddressInUse :: SocketException

eAddressNotAvailable :: SocketException

eNetworkDown :: SocketException

eNetworkUnreachable :: SocketException

eNetworkReset :: SocketException

eConnectionAborted :: SocketException

eConnectionReset :: SocketException

eNoBufferSpace :: SocketException

eIsConnected :: SocketException

eNotConnected :: SocketException

eShutdown :: SocketException

eTooManyReferences :: SocketException

eTimedOut :: SocketException

eConnectionRefused :: SocketException

eHostDown :: SocketException

eHostUnreachable :: SocketException

eAlready :: SocketException

eInProgress :: SocketException

AddressInfoException

newtype AddressInfoException

Contains the error code that can be matched against. Use show to get a human readable explanation of the error.

Constructors

AddressInfoException CInt

Instances

Eq AddressInfoException

Methods

(==) :: AddressInfoException -> AddressInfoException -> Bool

(/=) :: AddressInfoException -> AddressInfoException -> Bool

Show AddressInfoException

Methods

showsPrec :: Int -> AddressInfoException -> ShowS

show :: AddressInfoException -> String

showList :: [AddressInfoException] -> ShowS

Exception AddressInfoException

Methods

toException :: AddressInfoException -> SomeException

fromException :: SomeException -> Maybe AddressInfoException

displayException :: AddressInfoException -> String

eaiAgain :: AddressInfoException

AddressInfoException "Temporary failure in name resolution"

eaiBadFlags :: AddressInfoException

AddressInfoException "Bad value for ai_flags"

eaiFail :: AddressInfoException

AddressInfoException "Non-recoverable failure in name resolution"

eaiFamily :: AddressInfoException

AddressInfoException "ai_family not supported"

eaiMemory :: AddressInfoException

AddressInfoException "Memory allocation failure"

eaiNoName :: AddressInfoException

AddressInfoException "No such host is known"

eaiSocketType :: AddressInfoException

AddressInfoException "ai_socktype not supported"

eaiService :: AddressInfoException

AddressInfoException "Servname not supported for ai_socktype"

eaiSystem :: AddressInfoException

AddressInfoException "System error"