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

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

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

Either a service name e.g., "http" or a numeric port number.

Default hints for address lookup with getAddrInfo.

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

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.

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 defaultPort 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. On Unix, FD_CLOEXEC is set to the new Socket.

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 the socket. This function throws exceptions if the underlying system call returns errors.

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

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.

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

Low level SO_LINBER option value, which can be used with setSockOpt.

Timeout in microseconds. This will be converted into struct timeval on Unix and DWORD (as milliseconds) on Windows.

Does the SocketOption exist on this system?

Execute the given action only when the specified socket option is supported. Any return value is ignored.

Get a socket option that gives an Int value.

Set a socket option that expects an Int value.

Get a socket option.

Set a socket option.

Basic type for a 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

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)

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

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.

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

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.

Currently, this is an alias of unsafeFdSocket.

Creating a socket from a file descriptor.

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.

Socket Types.

Some of the defined patterns may be unsupported on some systems: see isSupportedSocketType.

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.

Get the SocketType of an active socket.

Since: 3.0.1.0

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.

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.

Convert CInt to Family.

Protocol number.

This is the default protocol for a given service.

>>> defaultProtocol
0

Socket addresses. 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?

Getting peer's SockAddr.

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

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 HostAddress6 to representation-independent IPv6 octuple.

Converts IPv6 octuple to HostAddress6.

Flow information.

Scope identifier.

Returns the index corresponding to the interface name.

Since 2.7.0.0.

Returns the interface name corresponding to the index.

Since 2.7.0.0.

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

Default port number.

>>> defaultPort
0

Getting the port of socket.

Getting the port of socket. IOError is thrown if a port is not available.

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.

Build a pair of connected socket objects. On Windows, this function emulates socketpair() using AF_UNIX and a temporary file will remain.

Send a file descriptor over a UNIX-domain socket. This function does not work on Windows.

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.

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.

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

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

Set the close_on_exec flag on Unix. On Windows, nothing is done.

Since 2.7.0.0.

Get the close_on_exec flag. On Windows, this function always returns False.

Since 2.7.0.0.

Set the nonblocking flag on Unix. On Windows, nothing is done.

Get the nonblocking flag. On Windows, this function always returns False.

Since 2.7.0.0.

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.

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.

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.

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)

Send data to the socket using sendmsg(2).

Receive data from the socket using recvmsg(2).

Message flags. To combine flags, use (<>).

Control message (ancillary data) including a pair of level and type.

Identifier of control message (ancillary data).

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

Filtering control message.

Control message type class. Each control message type has a numeric CmsgId and encode and decode functions.

Time to live of IPv4.

Hop limit of IPv6.

TOS of IPv4.

Traffic class of IPv6.

Network interface ID and local IPv4 address.

Network interface ID and local IPv4 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.

STM action to wait until the socket is ready for reading.

STM action to wait until the socket is ready for reading and STM action to cancel the waiting.

STM action to wait until the socket is ready for writing.

STM action to wait until the socket is ready for writing and STM action to cancel the waiting.