Represents a socket. The fields are, respectively:

• File descriptor
• Socket family
• Socket type
• Protocol number
• Status flag

If you are calling the MkSocket constructor directly you should ensure you have called withSocketsDo and that the file descriptor is in non-blocking mode. See setNonBlockIfNeeded.

Address families.

A constructor being present here does not mean it is supported by the operating system: see isSupportedFamily.

Does the AF_ constant corresponding to the given family exist on this system?

Socket Types.

The existence of a constructor does not necessarily imply that that socket type is supported on your system: see isSupportedSocketType.

Does the SOCK_ constant corresponding to the given SocketType exist on this system?

The existence of a constructor does not necessarily imply that that socket address type is supported on your system: see isSupportedSockAddr.

Is the socket address type supported on this system?

The status of the socket as determined by this library, not necessarily reflecting the state of the connection itself.

For example, the Closed status is applied when the close function is called.

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.

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.

Converts IPv4 quadruple to HostAddress.

Independent of endianness. For example ::1 is stored as (0, 0, 0, 1).

For direct manipulation prefer hostAddress6ToTuple and tupleToHostAddress6.

Converts the from host byte order to network byte order.

Converts the from network byte order to host byte order.

This is the default protocol for a given service.

Use the Num instance (i.e. use a literal) to create a PortNumber value with the correct network-byte-ordering. You should not use the PortNum constructor. It will be removed in the next release.

>>> 1 :: PortNumber
1
>>> read "1" :: PortNumber
1

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".

Flags that control the querying behaviour of getAddrInfo. For more information, see https://tools.ietf.org/html/rfc3493#page-25

Indicate whether the given AddrInfoFlag will have any effect on this system.

Default hints for address lookup with getAddrInfo. The values of the addrAddress and addrCanonName fields are undefined, and are never inspected by getAddrInfo.

>>> addrFlags defaultHints
[]
>>> addrFamily defaultHints
AF_UNSPEC
>>> addrSocketType defaultHints
NoSocketType
>>> addrProtocol defaultHints
0

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 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.

If the query fails, this function throws an IO exception instead of returning an empty list. Otherwise, it returns a non-empty list of AddrInfo values.

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.

>>> addr:_ <- getAddrInfo (Just hints) (Just "127.0.0.1") (Just "http")
>>> addrAddress addr
127.0.0.1:80

Flags that control the querying behaviour of getNameInfo. For more information, see https://tools.ietf.org/html/rfc3493#page-30

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.

Example: (hostName, _) <- getNameInfo [] True False myAddress

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.

>>> let hints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_NUMERICSERV], addrSocketType = Stream }
>>> addr:_ <- getAddrInfo (Just hints) (Just "127.0.0.1") (Just "5000")
>>> sock@(MkSocket _ fam stype _ _) <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr)
>>> fam
AF_INET
>>> stype
Stream
>>> bind sock (addrAddress addr)
>>> getSocketName sock
127.0.0.1:5000

Build a pair of connected socket objects using the given address family, socket type, and protocol number. Address family, socket type, and protocol number are as for the socket function above. Availability: Unix.

Connect to a remote socket at address.

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 aNY_PORT is passed then the system assigns the next available use port.

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).

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.

Returns the processID, userID and groupID of the socket's peer.

Only available on platforms that support SO_PEERCRED or GETPEEREID(3) on domain sockets. GETPEEREID(3) returns userID and groupID. processID is always 0.

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.

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.

Sending data to closed socket may lead to undefined behaviour.

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.

NOTE: blocking on Windows unless you compile with -threaded (see GHC ticket #1129)

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.

Receiving data from closed socket may lead to undefined behaviour.

Receive data from the socket. The socket need not be in a connected state. Returns (bytes, nbytes, address) where bytes is a String of length nbytes representing the data received and address is a SockAddr representing the address of the sending socket.

NOTE: blocking on Windows unless you compile with -threaded (see GHC ticket #1129)

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.

Sending data to closed socket may lead to undefined behaviour.

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.

Receiving data from closed socket may lead to undefined behaviour.

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.

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.

NOTE: blocking on Windows unless you compile with -threaded (see GHC ticket #1129)

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.

Close the socket. Sending data to or receiving data from closed socket may lead to undefined behaviour.

Determines whether close has been used on the Socket. This does not indicate any status about the socket beyond this. If the socket has been closed remotely, this function can still return True.

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

Does the SocketOption exist on this system?

Get a socket option that gives an Int value. There is currently no API to get e.g. the timeval socket options

Set a socket option that expects an Int value. There is currently no API to set e.g. the timeval socket options

Receive a file descriptor over a 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.

The IPv4 wild card address.

The IPv6 wild card address.

This is the value of SOMAXCONN, typically 128. 128 is good enough for normal network servers but is too small for high performance servers.

With older versions of the network library 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.

In newer versions of the network library it is only necessary to call withSocketsDo if you are calling the MkSocket constructor directly. However, for compatibility with older versions on Windows, it is good practice to always call withSocketsDo (it's very cheap).

Smart constructor for constructing a Socket. It should only be called once for every new file descriptor. The caller must make sure that the socket is in non-blocking mode. See setNonBlockIfNeeded.

Set the socket to nonblocking, if applicable to this platform.

Depending on the platform this is required when using sockets from file descriptors that are passed in through recvFd or other means.

Deprecated alias for bind.

Deprecated alias for close.

Deprecated alias for isConnected.

Deprecated alias for isBound.

Deprecated alias for isListening.

Deprecated alias for isReadable.

Deprecated alias for isWritable.