connection-0.1.3: Simple and easy network connections API

MaintainerVincent Hanquez <>
Safe HaskellNone




Simple connection abstraction


Type for a connection

data Connection Source

This opaque type represent a connection to a destination.

connectionID :: Connection -> (HostName, PortNumber)Source

return a simple tuple of the port and hostname that we're connected to.

data ConnectionParams Source

Connection Parameters to establish a Connection.

The strict minimum is an hostname and the port.

If you need to establish a TLS connection, you should make sure connectionUseSecure is correctly set.

If you need to connect through a SOCKS, you should make sure connectionUseSocks is correctly set.




connectionHostname :: HostName

host name to connect to.

connectionPort :: PortNumber

port number to connect to.

connectionUseSecure :: Maybe TLSSettings

optional TLS parameters.

connectionUseSocks :: Maybe SockSettings

optional Socks configuration.

data TLSSettings Source

TLS Settings that can be either expressed as simple settings, or as full blown TLS.Params settings.

Unless you need access to parameters that are not accessible through the simple settings, you should use TLSSettingsSimple.



Simple TLS settings. recommended to use.


settingDisableCertificateValidation :: Bool

Disable certificate verification completely, this make TLS/SSL vulnerable to a MITM attack. not recommended to use, but for testing.

settingDisableSession :: Bool

Disable session management. TLS/SSL connections will always re-established their context. Not Implemented Yet.

settingUseServerName :: Bool

Use server name extension. Not Implemented Yet.

TLSSettings Params

full blown TLS Settings directly using TLS.Params. for power users.

data SockSettings Source

Socks settings for the connection.

The simple settings is just the hostname and portnumber of the proxy server.

That's for now the only settings in the SOCKS package, socks password, or any sort of other authentications is not yet implemented.


data LineTooLong Source

This is the exception raised if we reached the user specified limit for the line in ConnectionGetLine.



Library initialization

initConnectionContext :: IO ConnectionContextSource

Initialize the library with shared parameters between connection.

data ConnectionContext Source

Shared values (certificate store, sessions, ..) between connections

At the moment, this is only strictly needed to shared sessions and certificates when using a TLS enabled connection.

Connection operation

connectFromHandle :: ConnectionContext -> Handle -> ConnectionParams -> IO ConnectionSource

Use an already established handle to create a connection object.

if the TLS Settings is set, it will do the handshake with the server. The SOCKS settings have no impact here, as the handle is already established



:: ConnectionContext

The global context of this connection.

-> ConnectionParams

The parameters for this connection (where to connect, and such).

-> IO Connection

The new established connection on success.

connect to a destination using the parameter

connectionClose :: Connection -> IO ()Source

Close a connection.

Sending and receiving data

connectionGet :: Connection -> Int -> IO ByteStringSource

Get some bytes from a connection.

The size argument is just the maximum that could be returned to the user. The call will return as soon as there's data, even if there's less than requested. Hence, it behaves like hGetSome.

On end of input, connectionGet returns 0, but subsequent calls will throw an isEOFError exception.

connectionGetChunk :: Connection -> IO ByteStringSource

Get the next block of data from the connection.

connectionGetChunk' :: Connection -> (ByteString -> (a, ByteString)) -> IO aSource

Like connectionGetChunk, but return the unused portion to the buffer, where it will be the next chunk read.



:: Int

Maximum number of bytes before raising a LineTooLong exception

-> Connection


-> IO ByteString

The received line with the LF trimmed

Get the next line, using ASCII LF as the line terminator.

This throws an isEOFError exception on end of input, and LineTooLong when the number of bytes gathered is over the limit without a line terminator.

The actual line returned can be bigger than the limit specified, provided that the last chunk returned by the underlaying backend contains a LF. In another world only when we need more input and limit is reached that the LineTooLong exception will be raised.

An end of file will be considered as a line terminator too, if line is not empty.

connectionPut :: Connection -> ByteString -> IO ()Source

Put a block of data in the connection.

TLS related operation

connectionSetSecure :: ConnectionContext -> Connection -> TLSSettings -> IO ()Source

Activate secure layer using the parameters specified.

This is typically used to negociate a TLS channel on an already establish channel, e.g. supporting a STARTTLS command. it also flush the received buffer to prevent application confusing received data before and after the setSecure call.

If the connection is already using TLS, nothing else happens.

connectionIsSecure :: Connection -> IO BoolSource

Returns if the connection is establish securely or not.