Create an endpoint for communication, returning a file descriptor that refers to that endpoint. The POSIX specification includes more details. No special preparation is required before calling this function. The author believes that it cannot block for a prolonged period of time.

Create an unbound pair of connected sockets in a specified domain, of a specified type, under the protocol optionally specified by the protocol argument. The POSIX specification includes more details. No special preparation is required before calling this function. The author believes that it cannot block for a prolonged period of time.

Assign a local socket address address to a socket identified by descriptor socket that has no local socket address assigned. The POSIX specification includes more details. The SocketAddress represents the sockaddr pointer argument, together with its socklen_t size, as a byte array. This allows bind to be used with sockaddr extensions on various platforms. No special preparation is required before calling this function. The author believes that it cannot block for a prolonged period of time.

Connect the socket to the specified socket address. The POSIX specification includes more details.

Connect the socket to the specified socket address. The POSIX specification includes more details. The only sensible way to use this is to give a nonblocking socket as the argument.

Mark the socket as a passive socket, that is, as a socket that will be used to accept incoming connection requests using accept. The POSIX specification includes more details. No special preparation is required before calling this function. The author believes that it cannot block for a prolonged period of time.

Extract the first connection on the queue of pending connections. The POSIX specification includes more details. This function's type differs slightly from the specification:

int accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len);

Instead of requiring the caller to prepare buffers through which information is returned, this haskell binding to accept prepares those buffers internally. This eschews C's characteristic buffer-passing in favor of the Haskell convention of allocating internally and returning.

More specifically, this binding lacks an argument corresponding to the sockaddr buffer from the specification. That mutable buffer is allocated internally, resized and frozen upon a success, and returned along with the file descriptor of the accepted socket. The size of this buffer is determined by the second argument (maximum socket address size). This size argument is also writen to the address_len buffer, which is also allocated internally. The size returned through this pointer is used to resize the sockaddr buffer, which is then frozen so that an immutable SocketAddress is returned to the end user.

For applications uninterested in the peer (described by sockaddr), POSIX accept allows the null pointer to be passed as both address and address_len. This behavior is provided by accept_.

See accept. This uses the unsafe FFI. Consequently, it does not not need to allocate pinned memory. It only makes sense to call this on a nonblocking socket.

A variant of accept that does not provide the user with a SocketAddress detailing the peer.

Retrieve the locally-bound name of the specified socket. The POSIX specification of getsockname includes more details.

Retrieve the value for the option specified by the Option argument for the socket specified by the Fd argument. The POSIX specification of getsockopt includes more details.

Close a socket. The POSIX specification includes more details. This uses the safe FFI.

Close a socket. This uses the unsafe FFI. According to the POSIX specification, "If fildes refers to a socket, close() shall cause the socket to be destroyed. If the socket is in connection-mode, and the SO_LINGER option is set for the socket with non-zero linger time, and the socket has untransmitted data, then close() shall block for up to the current linger interval until all data is transmitted."

Close a socket with the unsafe FFI. Do not check for errors. It is only appropriate to use this when a socket is being closed to handle an exceptional case. Since the user will want the propogate the original exception, the exception provided by uninterruptibleClose would just be discarded. This function allows us to potentially avoid an additional FFI call to getErrno.

Shutdown a socket. This uses the unsafe FFI.

Send data from an address over a network socket. This is not guaranteed to send the entire length. This uses the safe FFI since it may block indefinitely.

Send data from a byte array over a network socket. Users may specify an offset and a length to send fewer bytes than are actually present in the array. Since this uses the safe FFI, it allocates a pinned copy of the bytearry if it was not already pinned.

Send data from a mutable byte array over a network socket. Users may specify an offset and a length to send fewer bytes than are actually present in the array. Since this uses the safe FFI, it allocates a pinned copy of the bytearry if it was not already pinned.

Send data from an address over a network socket. This uses the unsafe FFI. Users of this function should be sure to set flags that prohibit this from blocking. On Linux this is accomplished with O_NONBLOCK. It is often desirable to call threadWaitWrite on a nonblocking socket before calling unsafeSend on it.

Send data from a byte array over a network socket. This uses the unsafe FFI; considerations pertaining to sendUnsafe apply to this function as well. Users may specify a length to send fewer bytes than are actually present in the array.

Send data from a mutable byte array over a network socket. This uses the unsafe FFI; considerations pertaining to sendUnsafe apply to this function as well. Users specify an offset and a length to send fewer bytes than are actually present in the array.

Send data from a byte array over an unconnected network socket. This uses the unsafe FFI; considerations pertaining to sendToUnsafe apply to this function as well. The offset and length arguments cause a slice of the byte array to be sent rather than the entire byte array.

Send data from a mutable byte array over an unconnected network socket. This uses the unsafe FFI; considerations pertaining to sendToUnsafe apply to this function as well. The offset and length arguments cause a slice of the mutable byte array to be sent rather than the entire byte array.

Receive data into an address from a network socket. This wraps recv using the safe FFI. When the returned size is zero, there are no additional bytes to receive and the peer has performed an orderly shutdown.

Receive data into a byte array from a network socket. This wraps recv using the safe FFI. When the returned size is zero, there are no additional bytes to receive and the peer has performed an orderly shutdown.

Receive data into an address from a network socket. This wraps recv using the unsafe FFI. Users of this function should be sure to set flags that prohibit this from blocking. On Linux this is accomplished by setting the MSG_DONTWAIT flag and handling the resulting EAGAIN or EWOULDBLOCK. When the returned size is zero, there are no additional bytes to receive and the peer has performed an orderly shutdown.

Receive data into an address from a network socket. This uses the unsafe FFI; considerations pertaining to receiveUnsafe apply to this function as well. Users may specify a length to receive fewer bytes than are actually present in the mutable byte array.

Receive data into an address from an unconnected network socket. This uses the unsafe FFI. Users may specify an offset into the destination byte array. This function does not resize the buffer.

Receive data into an address from a network socket. This uses the unsafe FFI. This does not return the socket address of the remote host that sent the packet received.

Convert a 32-bit word from host to network byte order (e.g. htonl).

Convert a 16-bit word from host to network byte order (e.g. htons).

Convert a 32-bit word from network to host byte order (e.g. ntohl).

Convert a 16-bit word from network to host byte order (e.g. ntohs).

A socket communications domain, sometimes referred to as a family. The spec mandates AF_UNIX, AF_UNSPEC, and AF_INET.

A socket type. The spec mandates SOCK_STREAM, SOCK_DGRAM, and SOCK_SEQPACKET. Other types may be available on a per-platform basis.

The option_value data.

Receive flags are given by MessageFlags Receive and send flags are given by MessageFlags Send. This is done because there are several flags that are applicable in either a receiving context or a sending context.

Which end of the socket to shutdown.

The sockaddr data. This is an extensible tagged union, so this library has chosen to represent it as byte array. It is up to platform-specific libraries to inhabit this type with values.

An address for an Internet socket over IPv4. The POSIX specification mandates three fields:

sa_family_t     sin_family   AF_INET
in_port_t       sin_port     Port number
struct in_addr  sin_addr     IP address

This type omits the first field since is a constant that is only relevant for serialization purposes. The spec also mandates that sin_port and sin_addr be in network byte order, so keep in mind that these values are not immidiately useable.

An address for a UNIX domain socket. The POSIX specification mandates two fields:

sa_family_t  sun_family  Address family. 
char         sun_path[]  Socket pathname. 

However, the first field is omitted since it is always AF_UNIX. It is adding during serialization. Although sun_path is a null-terminated string, SocketAddressUnix should not have a trailing null byte. The conversion function encodeSocketAddressUnix adds the null terminator. The size of path should not equal or exceed the platform-dependent size of sun_path.

Serialize a IPv4 socket address so that it may be passed to bind. This serialization is operating-system dependent.

Serialize a unix domain socket address so that it may be passed to bind. This serialization is operating-system dependent. If the path provided by the argument equals or exceeds the size of sun_path (typically in the range 92 to 108 but varies by platform), the socket address will instead be given the empty string as its path. This typically results in bind returning an error code.

The size of a serialized internet socket address.

The AF_UNIX communications domain.

The AF_UNSPEC communications domain.

The AF_INET communications domain.

The AF_INET6 communications domain. POSIX declares raw sockets optional. However, they are included here for convenience. Please open an issue if this prevents this library from compiling on a POSIX-compliant operating system that anyone uses for haskell development.

The SOCK_STREAM socket type.

The SOCK_DGRAM socket type.

The SOCK_RAW socket type. POSIX declares raw sockets optional. However, they are included here for convenience. Please open an issue if this prevents this library from compiling on a POSIX-compliant operating system that anyone uses for haskell development. Keep in mind that even though raw sockets may exist on all POSIX-compliant operating systems, they may differ in their behavior.

The SOCK_SEQPACKET socket type.

The default protocol for a socket type.

The IPPROTO_RAW protocol.

The IPPROTO_ICMP protocol.

The IPPROTO_TCP protocol.

The IPPROTO_UDP protocol.

The IPPROTO_IP protocol.

The IPPROTO_IPV6 protocol.

The MSG_PEEK receive flag.

The MSG_OOB receive flag or send flag.

The MSG_WAITALL receive flag.

Disable further receive operations (e.g. SHUT_RD)

Disable further send operations (e.g. SHUT_WR)

Disable further send operations (e.g. SHUT_RDWR)

Socket error status (e.g. SOL_SOCKET)

Socket error status (e.g. SO_ERROR)