Ereignisse
// Zustände |
CLOSED |
LISTEN |
SYN-SENT |
SYN-RECEIVED |
ESTABLISHED |
FIN-WAIT-1 |
FIN-WAIT-2 |
CLOSE-WAIT |
CLOSING |
LAST-ACK |
TIME-WAIT |
OPEN |
(i.e., TCB does not exist) Create
a new transmission control block (TCB) to hold connection state information. Fill in local
socket identifier, foreign socket, precedence, security/compartment, and user timeout
information. Note that some parts of the foreign socket may be unspecified in a passive
OPEN and are to be filled in by the parameters of the incoming SYN segment. Verify the
security and precedence requested are allowed for this user, if not return "error:
precedence not allowed" or "error: security/compartment not allowed." If
passive enter the LISTEN state and return. If active and the foreign socket is
unspecified, return "error: foreign socket unspecified"; if active and the
foreign socket is specified, issue a SYN segment. An initial send sequence number (ISS) is
selected. A SYN segment of the form <SEQ=ISS><CTL=SYN> is sent. Set SND.UNA to
ISS, SND.NXT to ISS+1, enter SYN-SENT state, and return.
If the caller does not have access to the local socket specified, return
"error: connection illegal for this process". If there is no room to create a
new connection, return "error: insufficient resources". |
If active and the foreign socket is specified,
then change the connection from passive to active, select an ISS. Send a SYN segment, set
SND.UNA to ISS, SND.NXT to ISS+1. Enter SYN-SENT state. Data associated with SEND may be
sent with SYN segment or queued for transmission after entering ESTABLISHED state. The
urgent bit if requested in the command must be sent with the data segments sent as a
result of this command. If there is no room to queue the request, respond with
"error: insufficient resources". If Foreign socket was not specified, then
return "error: foreign socket unspecified". |
Return "error: connection already
exists". |
Return "error: connection already
exists". |
Return "error: connection already
exists". |
Return "error: connection already
exists". |
Return "error: connection already
exists". |
Return "error: connection already
exists". |
Return "error: connection already
exists". |
Return "error: connection already
exists". |
Return "error: connection already
exists". |
SEND |
(i.e., TCB does not exist) If
the user does not have access to such a connection, then return "error: connection
illegal for this process".
Otherwise, return "error: connection does not exist". |
If the foreign socket is specified, then change
the connection from passive to active, select an ISS. Send a SYN segment, set SND.UNA to
ISS, SND.NXT to ISS+1. Enter SYN-SENT state. Data associated with SEND may be sent with
SYN segment or queued for transmission after entering ESTABLISHED state. The urgent bit if
requested in the command must be sent with the data segments sent as a result of this
command. If there is no room to queue the request, respond with "error: insufficient
resources". If Foreign socket was not specified, then return "error: foreign
socket unspecified". |
Queue the data for transmission after entering
ESTABLISHED state. If no space to queue, respond with "error: insufficient
resources". |
Queue the data for transmission after entering
ESTABLISHED state. If no space to queue, respond with "error: insufficient
resources". |
Segmentize the buffer and send it with a
piggybacked acknowledgment (acknowledgment value = RCV.NXT). If there is insufficient
space to remember this buffer, simply return "error: insufficient resources". If
the urgent flag is set, then SND.UP <- SND.NXT-1 and set the urgent pointer in the
outgoing segments. |
Return "error: connection closing"
and do not service request. |
Return "error: connection closing"
and do not service request. |
Segmentize the buffer and send it with a
piggybacked acknowledgment (acknowledgment value = RCV.NXT). If there is insufficient
space to remember this buffer, simply return "error: insufficient resources". If
the urgent flag is set, then SND.UP <- SND.NXT-1 and set the urgent pointer in the
outgoing segments. |
Return "error: connection closing" and
do not service request. |
Return "error: connection closing" and
do not service request. |
Return "error: connection closing" and
do not service request. |
RECEIVE |
(i.e., TCB does not exist) If
the user does not have access to such a connection, return "error: connection illegal
for this process".
Otherwise return "error: connection does not exist". |
Queue for processing after entering ESTABLISHED
state. If there is no room to queue this request, respond with "error: insufficient
resources". |
Queue for processing after entering ESTABLISHED
state. If there is no room to queue this request, respond with "error: insufficient
resources". |
Queue for processing after entering ESTABLISHED
state. If there is no room to queue this request, respond with "error: insufficient
resources". |
If insufficient incoming segments are queued to
satisfy the request, queue the request. If there is no queue space to remember the
RECEIVE, respond with "error: insufficient resources". Reassemble
queued incoming segments into receive buffer and return to user. Mark "push
seen" (PUSH) if this is the case.
If RCV.UP is in advance of the data currently being passed to the user
notify the user of the presence of urgent data. When the TCP takes responsibility for
delivering data to the user that fact must be communicated to the sender via an
acknowledgment. The formation of such an acknowledgment is described
below in the discussion of processing an incoming segment. |
If insufficient incoming segments are queued to
satisfy the request, queue the request. If there is no queue space to remember the
RECEIVE, respond with "error: insufficient resources". Reassemble
queued incoming segments into receive buffer and return to user. Mark "push
seen" (PUSH) if this is the case.
If RCV.UP is in advance of the data currently being passed to the user
notify the user of the presence of urgent data. When the TCP takes responsibility for
delivering data to the user that fact must be communicated to the sender via an
acknowledgment. The formation of such an acknowledgment is described
below in the discussion of processing an incoming segment. |
If insufficient incoming segments are queued to
satisfy the request, queue the request. If there is no queue space to remember the
RECEIVE, respond with "error: insufficient resources". Reassemble
queued incoming segments into receive buffer and return to user. Mark "push
seen" (PUSH) if this is the case.
If RCV.UP is in advance of the data currently being passed to the user
notify the user of the presence of urgent data. When the TCP takes responsibility for
delivering data to the user that fact must be communicated to the sender via an
acknowledgment. The formation of such an acknowledgment is described
below in the discussion of processing an incoming segment. |
Since the remote side has already sent FIN,
RECEIVEs must be satisfied by text already on hand, but not yet delivered to the user. If
no text is awaiting delivery, the RECEIVE will get a "error: connection closing"
response. Otherwise, any remaining text can be used to satisfy the RECEIVE. |
Return "error: connection closing". |
Return "error: connection closing". |
Return "error: connection closing". |
CLOSE |
(i.e., TCB does not exist) If
the user does not have access to such a connection, return "error: connection illegal
for this process".
Otherwise, return "error: connection does not exist". |
Any outstanding RECEIVEs are returned with
"error: closing" responses. Delete TCB, enter CLOSED state, and return. |
Delete the TCB and return "error:
closing" responses to any queued SENDs, or RECEIVEs. |
If no SENDs have been issued and there is no
pending data to send, then form a FIN segment and send it, and enter FIN-WAIT-1 state;
otherwise queue for processing after entering ESTABLISHED state. |
Queue this until all preceding SENDs have been
segmentized, then form a FIN segment and send it. In any case, enter FIN-WAIT-1 state. |
Strictly speaking, this is an error and should
receive a "error: connection closing" response. An "ok" response would
be acceptable, too, as long as a second FIN is not emitted (the first FIN may be
retransmitted though). |
Strictly speaking, this is an error and should
receive a "error: connection closing" response. An "ok" response would
be acceptable, too, as long as a second FIN is not emitted (the first FIN may be
retransmitted though). |
Queue this request until all preceding SENDs
have been segmentized; then send a FIN segment, enter CLOSING state. |
Respond with "error: connection
closing". |
Respond with "error: connection
closing". |
Respond with "error: connection
closing". |
ABORT |
(i.e., TCB does not exist) If
the user should not have access to such a connection, return "error: connection
illegal for this process".
Otherwise return "error: connection does not exist". |
Any outstanding RECEIVEs should be returned
with "error: connection reset" responses. Delete TCB, enter CLOSED state, and
return. |
All queued SENDs and RECEIVEs should be given
"connection reset" notification, delete the TCB, enter CLOSED state, and return. |
Send a reset segment: <SEQ=SND.NXT><CTL=RST>
All queued SENDs and RECEIVEs should be given "connection
reset" notification; all segments queued for transmission (except for the RST formed
above) or retransmission should be flushed, delete the TCB, enter CLOSED state, and
return. |
Send a reset segment: <SEQ=SND.NXT><CTL=RST>
All queued SENDs and RECEIVEs should be given "connection
reset" notification; all segments queued for transmission (except for the RST formed
above) or retransmission should be flushed, delete the TCB, enter CLOSED state, and
return. |
Send a reset segment: <SEQ=SND.NXT><CTL=RST>
All queued SENDs and RECEIVEs should be given "connection
reset" notification; all segments queued for transmission (except for the RST formed
above) or retransmission should be flushed, delete the TCB, enter CLOSED state, and
return. |
Send a reset segment: <SEQ=SND.NXT><CTL=RST>
All queued SENDs and RECEIVEs should be given "connection
reset" notification; all segments queued for transmission (except for the RST formed
above) or retransmission should be flushed, delete the TCB, enter CLOSED state, and
return. |
Send a reset segment: <SEQ=SND.NXT><CTL=RST>
All queued SENDs and RECEIVEs should be given "connection
reset" notification; all segments queued for transmission (except for the RST formed
above) or retransmission should be flushed, delete the TCB, enter CLOSED state, and
return. |
Respond with "ok" and delete the TCB,
enter CLOSED state, and return. |
Respond with "ok" and delete the TCB,
enter CLOSED state, and return. |
Respond with "ok" and delete the TCB,
enter CLOSED state, and return. |
STATUS |
(i.e., TCB does not exist) If
the user should not have access to such a connection, return "error: connection
illegal for this process".
Otherwise return "error: connection does not exist". |
Return "state = LISTEN", and the TCB
pointer. |
Return "state = SYN-SENT", and the
TCB pointer. |
Return "state = SYN-RECEIVED", and
the TCB pointer. |
Return "state = ESTABLISHED", and the
TCB pointer. |
Return "state = FIN-WAIT-1", and the
TCB pointer. |
Return "state = FIN-WAIT-2", and the
TCB pointer. |
Return "state = CLOSE-WAIT", and the
TCB pointer. |
Return "state = CLOSING", and the TCB
pointer. |
Return "state = LAST-ACK", and the TCB
pointer. |
Return "state = TIME-WAIT", and the
TCB pointer. |
SEGMENT ARRIVES |
If the state is CLOSED (i.e., TCB
does not exist) then all data in the incoming segment is discarded. An incoming segment
containing a RST is discarded. An incoming segment not containing a RST causes a RST to be
sent in response. The acknowledgment and sequence field values are selected to make the
reset sequence acceptable to the TCP that sent the offending segment. If
the ACK bit is off, sequence number zero is used,
<SEQ=0><ACK=SEG.SEQ+SEG.LEN><CTL=RST,ACK>
If the ACK bit is on,
<SEQ=SEG.ACK><CTL=RST>
Return. |
first check for an RST
An incoming RST should be ignored. Return.
second check for an ACK
Any acknowledgment is bad if it arrives on a connection still in the
LISTEN state. An acceptable reset segment should be formed for any arriving ACK-bearing
segment. The RST should be formatted as follows:
<SEQ=SEG.ACK><CTL=RST>
Return.
third check for a SYN
If the SYN bit is set, check the security. If the security/compartment on
the incoming segment does not exactly match the security/compartment in the TCB then send
a reset and return.
<SEQ=SEG.ACK><CTL=RST>
If the SEG.PRC is greater than the TCB.PRC then if allowed by the user
and the system set TCB.PRC<-SEG.PRC, if not allowed send a reset and return.
<SEQ=SEG.ACK><CTL=RST>
If the SEG.PRC is less than the TCB.PRC then continue.
Set RCV.NXT to SEG.SEQ+1, IRS is set to SEG.SEQ and any other control or
text should be queued for processing later. ISS should be selected and a SYN segment sent
of the form:
<SEQ=ISS><ACK=RCV.NXT><CTL=SYN,ACK>
SND.NXT is set to ISS+1 and SND.UNA to ISS. The connection state should
be changed to SYN-RECEIVED. Note that any other incoming control or data (combined with
SYN) will be processed in the SYN-RECEIVED state, but processing of SYN and ACK should not
be repeated. If the listen was not fully specified (i.e., the foreign socket was not fully
specified), then the unspecified fields should be filled in now.
fourth other text or control
Any other control or text-bearing segment (not containing SYN) must have
an ACK and thus would be discarded by the ACK processing. An incoming RST segment could
not be valid, since it could not have been sent in response to anything sent by this
incarnation of the connection. So you are unlikely to get here, but if you do, drop the
segment, and return.
|
first check the ACK bit
If the ACK bit is set
If SEG.ACK =< ISS, or SEG.ACK > SND.NXT, send a reset (unless the
RST bit is set, if so drop the segment and return)
<SEQ=SEG.ACK><CTL=RST>
and discard the segment. Return.
If SND.UNA =< SEG.ACK =< SND.NXT then the ACK is acceptable.
second check the RST bit
If the RST bit is set
If the ACK was acceptable then signal the user "error: connection
reset", drop the segment, enter CLOSED state, delete TCB, and return. Otherwise (no
ACK) drop the segment and return.
third check the security and precedence
If the security/compartment in the segment does not exactly match the
security/compartment in the TCB, send a reset
If there is an ACK
<SEQ=SEG.ACK><CTL=RST>
Otherwise
<SEQ=0><ACK=SEG.SEQ+SEG.LEN><CTL=RST,ACK>
If there is an ACK
The precedence in the segment must match the precedence in the TCB, if
not, send a reset
<SEQ=SEG.ACK><CTL=RST>
If there is no ACK
If the precedence in the segment is higher than the precedence in the TCB
then if allowed by the user and the system raise the precedence in the TCB to that in the
segment, if not allowed to raise the prec then send a reset.
<SEQ=0><ACK=SEG.SEQ+SEG.LEN><CTL=RST,ACK>
If the precedence in the segment is lower than the precedence in the TCB
continue.
If a reset was sent, discard the segment and return.
fourth check the SYN bit
This step should be reached only if the ACK is ok, or there is no ACK,
and it the segment did not contain a RST.
If the SYN bit is on and the security/compartment and precedence are
acceptable then, RCV.NXT is set to SEG.SEQ+1, IRS is set to SEG.SEQ. SND.UNA should be
advanced to equal SEG.ACK (if there is an ACK), and any segments on the retransmission
queue which are thereby acknowledged should be removed.
If SND.UNA > ISS (our SYN has been ACKed), change the connection state
to ESTABLISHED, form an ACK segment
<SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK>
and send it. Data or controls which were queued for transmission may be
included. If there are other controls or text in the segment then continue processing at
the sixth step below where the URG bit is checked, otherwise return.
Otherwise enter SYN-RECEIVED, form a SYN,ACK segment
<SEQ=ISS><ACK=RCV.NXT><CTL=SYN,ACK>
and send it. If there are other controls or text in the segment, queue
them for processing after the ESTABLISHED state has been reached, return.
fifth, if neither of the SYN or RST bits is set then drop the segment and
return. |
First check sequence number Segments
are processed in sequence. Initial tests on arrival are used to discard old duplicates,
but further processing is done in SEG.SEQ order. If a segment's contents straddle the
boundary between old and new, only the new parts should be processed.
There are four cases for the acceptability test for an incoming segment:
Segment Length |
Receive Window |
Test |
0 |
0 |
SEG.SEQ = RCV.NXT |
0 |
>0 |
RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND |
>0 |
0 |
not acceptable |
>0 |
>0 |
RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND or
RCV.NXT =< SEG.SEQ+SEG.LEN-1 < RCV.NXT+RCV.WND |
If the RCV.WND is zero, no segments will be acceptable, but special
allowance should be made to accept valid ACKs, URGs and RSTs.
If an incoming segment is not acceptable, an acknowledgment should be
sent in reply (unless the RST bit is set, if so drop the segment and return):
<SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK>
After sending the acknowledgment, drop the unacceptable segment and
return.
In the following it is assumed that the segment is the idealized segment
that begins at RCV.NXT and does not exceed the window. One could tailor actual segments to
fit this assumption by trimming off any portions that lie outside the window (including
SYN and FIN), and only processing further if the segment then begins at RCV.NXT. Segments
with higher begining sequence numbers may be held for later processing. |
If the RST bit is set If
this connection was initiated with a passive OPEN (i.e., came from the LISTEN state), then
return this connection to LISTEN state and return. The user need not be informed. If this
connection was initiated with an active OPEN (i.e., came from SYN-SENT state) then the
connection was refused, signal the user "connection refused". In either case,
all segments on the retransmission queue should be removed. And in the active OPEN case,
enter the CLOSED state and delete the TCB, and return. |
If the RST bit is set
then, any outstanding RECEIVEs and SEND should receive "reset" responses. All
segment queues should be flushed. Users should also receive an unsolicited general
"connection reset" signal. Enter the CLOSED state, delete the TCB, and return. |
If the RST bit is set
then, enter the CLOSED state, delete the TCB, and return. |
If the security/compartment and
precedence in the segment do not exactly match the security/compartment and precedence in
the TCB then send a reset, and return. |
If the security/ compartment and
precedence in the segment do not exactly match the security/compartment and precedence in
the TCB then send a reset, any outstanding RECEIVEs and SEND should receive
"reset" responses. All segment queues should be flushed. Users should also
receive an unsolicited general "connection reset" signal. Enter the CLOSED
state, delete the TCB, and return. Note this check is
placed following the sequence check to prevent a segment from an old connection between
these ports with a different security or precedence from causing an abort of the current
connection. |
|
|
|
|
|
|
If the SYN is in the
window it is an error, send a reset, any outstanding RECEIVEs and SEND should receive
"reset" responses, all segment queues should be flushed, the user should also
receive an unsolicited general "connection reset" signal, enter the CLOSED
state, delete the TCB, and return. If the SYN is not in
the window this step would not be reachedand an ack would have been sent in the first step
(sequence number check). |
if the ACK bit is off drop the
segment and return if the ACK bit is on
If SND.UNA=<SEG.ACK=<SND.NXT then enter ESTABLISHED state and
continue processing.
If the segment acknowledgment is not acceptable, form a reset segment,
<SEQ=SEG.ACK><CTL=RST>
and send it.
|
if the ACK bit is off drop the
segment and return if the ACK bit is on
If SND.UNA < SEG.ACK =< SND.NXT then, set SND.UNA <- SEG.ACK.
Any segments on the retransmission queue which are thereby entirely acknowledged are
removed. Users should receive positive acknowledgments for buffers which have been SENT
and fully acknowledged (i.e., SEND buffer should be returned with "ok"
response). If the ACK is a duplicate (SEG.ACK < SND.UNA), it can be ignored. If the ACK
acks something not yet sent (SEG.ACK > SND.NXT) then send an ACK, drop the segment, and
return.
If SND.UNA < SEG.ACK =< SND.NXT, the send window should be updated.
If (SND.WL1 < SEG.SEQ or (SND.WL1 = SEG.SEQ and SND.WL2 =< SEG.ACK)), set SND.WND
<- SEG.WND, set SND.WL1 <- SEG.SEQ, and set SND.WL2 <- SEG.ACK.
Note that SND.WND is an offset from SND.UNA, that SND.WL1 records the
sequence number of the last segment used to update SND.WND, and that SND.WL2 records the
acknowledgment number of the last segment used to update SND.WND. The check here prevents
using old segments to update the window. |
if the ACK bit is off drop the
segment and return if the ACK bit is on
In addition to the processing for the ESTABLISHED state, if our FIN is
now acknowledged then enter FIN-WAIT-2 and continue processing in that state. |
if the ACK bit is off drop the
segment and return if the ACK bit is on
In addition to the processing for the ESTABLISHED state, if the
retransmission queue is empty, the user's CLOSE can be acknowledged ("ok") but
do not delete the TCB. |
if the ACK bit is off drop the
segment and return if the ACK bit is on
Do the same processing as for the ESTABLISHED state. |
if the ACK bit is off drop the
segment and return if the ACK bit is on
In addition to the processing for the ESTABLISHED state, if the ACK
acknowledges our FIN then enter the TIME-WAIT state, otherwise ignore the segment. |
if the ACK bit is off drop the
segment and return if the ACK bit is on
The only thing that can arrive in this state is an acknowledgment of our
FIN. If our FIN is now acknowledged, delete the TCB, enter the CLOSED state, and return. |
if the ACK bit is off drop the
segment and return if the ACK bit is on
The only thing that can arrive in this state is a retransmission of the
remote FIN. Acknowledge it, and restart the 2 MSL timeout. |
|
If the URG bit is set,
RCV.UP <- max(RCV.UP,SEG.UP), and signal the user that the remote side has urgent data
if the urgent pointer (RCV.UP) is in advance of the data consumed. If the user has already
been signaled (or is still in the "urgent mode") for this continuous sequence of
urgent data, do not signal the user again. |
This should not occur,
since a FIN has been received from the remote side. Ignore the URG. |
|
Once in the ESTABLISHED
state, it is possible to deliver segment text to user RECEIVE buffers. Text from segments
can be moved into buffers until either the buffer is full or the segment is empty. If the
segment empties and carries an PUSH flag, then the user is informed, when the buffer is
returned, that a PUSH has been received. When the TCP
takes responsibility for delivering the data to the user it must also acknowledge the
receipt of the data.
Once the TCP takes responsibility for the data it advances RCV.NXT over
the data accepted, and adjusts RCV.WND as apporopriate to the current buffer availability.
The total of RCV.NXT and RCV.WND should not be reduced.
Please note the window management suggestions in section 3.7.
Send an acknowledgment of the form:
<SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK>
This acknowledgment should be piggybacked on a segment being transmitted
if possible without incurring undue delay. |
This should not occur,
since a FIN has been received from the remote side. Ignore the segment text. |
|
check the FIN bit, Do
not process the FIN if the state is CLOSED, LISTEN or SYN-SENT since the SEG.SEQ cannot be
validated; drop the segment and return.
If the FIN bit is set, signal the user "connection closing" and
return any pending RECEIVEs with same message, advance RCV.NXT over the FIN, and send an
acknowledgment for the FIN. Note that FIN implies PUSH for any segment text not yet
delivered to the user.
Enter the CLOSE-WAIT state. |
check the FIN bit, Do
not process the FIN if the state is CLOSED, LISTEN or SYN-SENT since the SEG.SEQ cannot be
validated; drop the segment and return.
If the FIN bit is set, signal the user "connection closing" and
return any pending RECEIVEs with same message, advance RCV.NXT over the FIN, and send an
acknowledgment for the FIN. Note that FIN implies PUSH for any segment text not yet
delivered to the user.
If our FIN has been ACKed (perhaps in this segment), then enter
TIME-WAIT, start the time-wait timer, turn off the other timers; otherwise enter the
CLOSING state. |
check the FIN bit, Do
not process the FIN if the state is CLOSED, LISTEN or SYN-SENT since the SEG.SEQ cannot be
validated; drop the segment and return.
If the FIN bit is set, signal the user "connection closing" and
return any pending RECEIVEs with same message, advance RCV.NXT over the FIN, and send an
acknowledgment for the FIN. Note that FIN implies PUSH for any segment text not yet
delivered to the user.
Enter the TIME-WAIT state. Start the time-wait timer, turn off the other
timers.
Remain in the CLOSE-WAIT state. |
check the FIN bit, Do
not process the FIN if the state is CLOSED, LISTEN or SYN-SENT since the SEG.SEQ cannot be
validated; drop the segment and return.
If the FIN bit is set, signal the user "connection closing" and
return any pending RECEIVEs with same message, advance RCV.NXT over the FIN, and send an
acknowledgment for the FIN. Note that FIN implies PUSH for any segment text not yet
delivered to the user.
Remain in the CLOSING state. |
check the FIN bit,
Do not process the FIN if the state is CLOSED, LISTEN or SYN-SENT since
the SEG.SEQ cannot be validated; drop the segment and return.
If the FIN bit is set, signal the user "connection closing" and
return any pending RECEIVEs with same message, advance RCV.NXT over the FIN, and send an
acknowledgment for the FIN. Note that FIN implies PUSH for any segment text not yet
delivered to the user.
Remain in the LAST-ACK state. |
check the FIN bit,
Do not process the FIN if the state is CLOSED, LISTEN or SYN-SENT since
the SEG.SEQ cannot be validated; drop the segment and return.
If the FIN bit is set, signal the user "connection closing" and
return any pending RECEIVEs with same message, advance RCV.NXT over the FIN, and send an
acknowledgment for the FIN. Note that FIN implies PUSH for any segment text not yet
delivered to the user.
Remain in the TIME-WAIT state. Restart the 2 MSL time-wait timeout. |
USER TIMEOUT |
For any state if the user timeout
expires, flush all queues, signal the user "error: connection aborted due to user
timeout" in general and for any outstanding calls, delete the TCB, enter the CLOSED
state and return. |
RETRANSMISSION TIMEOUT |
For any state if the
retransmission timeout expires on a segment in the retransmission queue, send the segment
at the front of the retransmission queue again, reinitialize the retransmission timer, and
return. |
TIME-WAIT TIMEOUT |
If the time-wait timeout expires
on a connection delete the TCB, enter the CLOSED state and return. |