network-2.2.1.10: Networking-related facilities

Portabilityportable
Stabilityprovisional
Maintainerlibraries@haskell.org

Network.Socket

Contents

Description

The Network.Socket module is for when you want full control over sockets. Essentially the entire C socket API is exposed through this module; in general the operations follow the behaviour of the C functions of the same name (consult your favourite Unix networking book).

A higher level interface to networking operations is provided through the module Network.

Synopsis

Types

data Family Source

This data type might have different constructors depending on what is supported by the operating system.

data SocketType Source

Socket Types.

This data type might have different constructors depending on what is supported by the operating system.

defaultProtocol :: ProtocolNumberSource

This is the default protocol for a given service.

Address operations

type HostName = StringSource

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

addrInfoFlagImplemented :: AddrInfoFlag -> BoolSource

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

defaultHints :: AddrInfoSource

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

getAddrInfoSource

Arguments

:: Maybe AddrInfo

preferred socket type or protocol

-> Maybe HostName

host name to look up

-> Maybe ServiceName

service name to look up

-> IO [AddrInfo]

resolved addresses, with best first

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

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:

   myHints = defaultHints { addrFlags = [AI_ADDRCONFIG, AI_CANONNAME] }

Values for addrFlags control query behaviour. The supported flags are as follows:

AI_PASSIVE
If no HostName value is provided, the network address in each SockAddr will be left as a wild card, i.e. as either iNADDR_ANY or iN6ADDR_ANY. This is useful for server applications that will accept connections from any client.
AI_CANONNAME
The addrCanonName field of the first returned AddrInfo will contain the canonical name of the host.
AI_NUMERICHOST
The HostName argument must be a numeric address in string form, and network name lookups will not be attempted.

Note: Although the following flags are required by RFC 3493, they may not have an effect on all platforms, because the underlying network stack may not support them. To see whether a flag from the list below will have any effect, call addrInfoFlagImplemented.

AI_NUMERICSERV
The ServiceName argument must be a port number in string form, and service name lookups will not be attempted.
AI_ADDRCONFIG
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.
AI_V4MAPPED
If an IPv6 lookup is performed, and no IPv6 addresses are found, IPv6-mapped IPv4 addresses will be returned.
AI_ALL
If AI_ALL is specified, return all matching IPv6 and IPv4 addresses. Otherwise, this flag has no effect.

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.

Example: let hints = defaultHints { addrFlags = [AI_ADDRCONFIG, AI_CANONNAME] } addrs <- getAddrInfo (Just hints) (Just www.haskell.org) (Just http) let addr = head addrs sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) connect sock (addrAddress addr)

getNameInfoSource

Arguments

:: [NameInfoFlag]

flags to control lookup behaviour

-> Bool

whether to look up a hostname

-> Bool

whether to look up a service name

-> SockAddr

the address to look up

-> IO (Maybe HostName, Maybe ServiceName) 

Resolve an address to a host or service name. This function is protocol independent.

The list of NameInfoFlag values controls query behaviour. The supported flags are as follows:

NI_NOFQDN
If a host is local, return only the hostname part of the FQDN.
NI_NUMERICHOST
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_NUMERICSERV
The name of the service is not looked up. Instead, a numeric representation of the service is returned.
NI_NAMEREQD
If the hostname cannot be looked up, an IO error is thrown.
NI_DGRAM
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.

Hostname and service name lookups can be expensive. You can specify which lookups to perform via the two Bool arguments. If one of these is False, the corresponding value in the returned tuple will be Nothing, and no lookup will be performed.

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

Socket operations

socket :: Family -> SocketType -> ProtocolNumber -> IO SocketSource

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.

socketPair :: Family -> SocketType -> ProtocolNumber -> IO (Socket, Socket)Source

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 :: Socket -> SockAddr -> IO ()Source

Connect to a remote socket at address.

bindSocket :: Socket -> SockAddr -> IO ()Source

Bind the socket to an address. The socket must not already be bound. The Family passed to bindSocket 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 :: Socket -> Int -> IO ()Source

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 :: Socket -> IO (Socket, SockAddr)Source

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.

getPeerCred :: Socket -> IO (CUInt, CUInt, CUInt)Source

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

Only available on platforms that support SO_PEERCRED on domain sockets.

socketToHandle :: Socket -> IOMode -> IO HandleSource

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.

sendTo :: Socket -> String -> SockAddr -> IO IntSource

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)

sendBufTo :: Socket -> Ptr a -> Int -> SockAddr -> IO IntSource

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.

recvFrom :: Socket -> Int -> IO (String, Int, SockAddr)Source

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)

recvBufFrom :: Socket -> Ptr a -> Int -> IO (Int, SockAddr)Source

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)

send :: Socket -> String -> IO IntSource

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.

recv :: Socket -> Int -> IO StringSource

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.

shutdown :: Socket -> ShutdownCmd -> IO ()Source

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.

sClose :: Socket -> IO ()Source

Close the socket. All future operations on the socket object will fail. The remote end will receive no more data (after queued data is flushed).

Predicates on sockets

Socket options

File descriptor transmission

sendAncillary :: Socket -> Int -> Int -> Int -> Ptr a -> Int -> IO ()Source

Special constants

iNADDR_ANY :: HostAddressSource

The IPv4 wild card address.

iN6ADDR_ANY :: HostAddress6Source

The IPv6 wild card address.

Initialisation

withSocketsDo :: IO a -> IO aSource

On Windows operating systems, the networking subsystem has to be initialised using withSocketsDo before any networking operations can be used. eg.

 main = withSocketsDo $ do {...}

Although this is only strictly necessary on Windows platforms, it is harmless on other platforms, so for portability it is good practice to use it all the time.

Very low level operations

Internal

The following are exported ONLY for use in the BSD module and should not be used anywhere else.

throwSocketErrorIfMinus1_Source

Arguments

:: Num a 
=> String

textual description of the location

-> IO a

the IO operation to be executed

-> IO () 

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.