Hans.Layer.Tcp.Monad

Documentation

type TcpHandle = Channel (Tcp ())

type Tcp = Layer TcpState

data TcpState

Constructors

TcpState

Fields

tcpSelf :: TcpHandle

tcpIP4 :: IP4Handle

tcpHost :: Host

emptyTcpState :: TcpHandle -> IP4Handle -> POSIXTime -> TcpState

self :: Tcp TcpHandle

The handle to this layer.

ip4Handle :: Tcp IP4Handle

Get the handle to the IP4 layer.

getHost :: Tcp Host

setHost :: Host -> Tcp ()

modifyHost :: (Host -> Host) -> Tcp ()

resetTimeWait2MSL :: SocketId -> Tcp ()

Reset the 2MSL timer on the socket in TimeWait.

getTimeWait :: IP4 -> TcpHeader -> Tcp (Maybe (SocketId, TimeWaitSock))

removeTimeWait :: SocketId -> Tcp ()

getConnections :: Tcp Connections

setConnections :: Connections -> Tcp ()

lookupConnection :: SocketId -> Tcp (Maybe TcpSocket)

Lookup a connection, returning Nothing if the connection doesn't exist.

getConnection :: SocketId -> Tcp TcpSocket

Retrieve a connection from the host. The computation fails if the connection doesn't exist.

setConnection :: SocketId -> TcpSocket -> Tcp ()

Assign a connection to a socket id. If the TcpSocket is in TimeWait, this will do two things:

1. Remove the corresponding key from the connections map
2. Add the socket to the TimeWait map, using the current value of its 2MSL timer (which should be set when the TimeWait state is entered)

The purpose of this is to clean up the memory associated with the connection as soon as possible, and once it's in TimeWait, no data will flow on the socket.

addConnection :: SocketId -> TcpSocket -> Tcp ()

Add a new connection to the host.

modifyConnection :: SocketId -> (TcpSocket -> TcpSocket) -> Tcp ()

Modify an existing connection in the host.

remConnection :: SocketId -> Tcp ()

Remove a connection from the host.

sendSegment :: IP4 -> TcpHeader -> ByteString -> Tcp ()

Send out a tcp segment via the IP layer.

initialSeqNum :: Tcp TcpSeqNum

Get the initial sequence number.

addInitialSeqNum :: TcpSeqNum -> Tcp ()

Increment the initial sequence number by a value.

allocatePort :: Tcp TcpPort

Allocate a new port for use.

closePort :: TcpPort -> Tcp ()

Release a used port.

newtype Sock a

Tcp operations in the context of a socket.

This implementation is a bit ridiculous, and when the eventual rewrite comes this should be one of the first things to be reconsidered. The basic problem is that if you rely on the finished implementation for the Layer monad, you exit from the socket context as well, losing any changes that have been made locally. This gives the ability to simulate finished, with the benefit of only yielding from the Sock context, not the whole Tcp context.

Constructors

Sock

Fields

unSock :: forall r. TcpSocket -> Escape r -> Next a r -> Tcp (TcpSocket, Maybe r)

Instances

Monad Sock

Functor Sock

Applicative Sock

type Escape r = TcpSocket -> Tcp (TcpSocket, Maybe r)

type Next a r = TcpSocket -> a -> Tcp (TcpSocket, Maybe r)

inTcp :: Tcp a -> Sock a

escape :: Sock a

Finish early, with no result.

runSock_ :: TcpSocket -> Sock a -> Tcp ()

runSock' :: TcpSocket -> Sock a -> Tcp TcpSocket

runSock :: TcpSocket -> Sock a -> Tcp (TcpSocket, Maybe a)

Run the socket action, and increment its internal timestamp value.

eachConnection :: Sock () -> Tcp ()

Iterate for each connection, rolling back to its previous state if the computation fails.

withConnection :: IP4 -> TcpHeader -> Sock a -> Tcp ()

withConnection' :: IP4 -> TcpHeader -> Sock a -> Tcp () -> Tcp ()

listeningConnection :: SocketId -> Sock a -> Tcp (Maybe a)

establishedConnection :: SocketId -> Sock a -> Tcp ()

Run a socket operation in the context of the socket identified by the socket id.

XXX this should really be renamed, as it's not guarding on the state of the socket

getParent :: Sock (Maybe SocketId)

Get the parent id of the current socket, and fail if it doesn't exist.

inParent :: Sock a -> Sock (Maybe a)

Run an action in the context of the socket's parent. Returns Nothing if the connection has no parent.

withChild :: TcpSocket -> Sock a -> Sock (Maybe a)

getTcpSocket :: Sock TcpSocket

setTcpSocket :: TcpSocket -> Sock ()

getTcpTimers :: Sock TcpTimers

modifyTcpSocket :: (TcpSocket -> (a, TcpSocket)) -> Sock a

modifyTcpSocket_ :: (TcpSocket -> TcpSocket) -> Sock ()

modifyTcpTimers :: (TcpTimers -> (a, TcpTimers)) -> Sock a

modifyTcpTimers_ :: (TcpTimers -> TcpTimers) -> Sock ()

setState :: ConnState -> Sock ()

Set the state of the current connection.

getState :: Sock ConnState

Get the state of the current connection.

whenState :: ConnState -> Sock () -> Sock ()

whenStates :: [ConnState] -> Sock () -> Sock ()

pushAcceptor :: Acceptor -> Sock ()

popAcceptor :: Sock (Maybe Acceptor)

Pop off an acceptor.

notify :: Bool -> Sock ()

Send a notification back to a waiting process that the socket has been established, or that it has failed. It's assumed that this will only be called from the context of a user socket, so when the parameter is False, the user close field will be set to true.

outputS :: IO () -> Sock ()

Output some IO to the Tcp layer.

advanceRcvNxt :: TcpSeqNum -> Sock ()

advanceSndNxt :: TcpSeqNum -> Sock ()

remoteHost :: Sock IP4

tcpOutput :: TcpHeader -> ByteString -> Sock ()

Send a TCP segment in the context of a socket.

shutdown :: Sock ()

Unblock any waiting processes, in preparation to close.

closeSocket :: Sock ()

Set the socket state to closed, and unblock any waiting processes.