Last active
December 4, 2019 15:38
-
-
Save rickyzhang82/5af2a9ffa4588911edd1b1d24d6aa0a0 to your computer and use it in GitHub Desktop.
RFC 793 Segment Arrive
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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. | |
If the state is LISTEN then | |
========================== | |
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. | |
If the state is SYN-SENT then | |
============================= | |
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. | |
Otherwise, | |
========== | |
first check sequence number | |
SYN-RECEIVED STATE | |
ESTABLISHED STATE | |
FIN-WAIT-1 STATE | |
FIN-WAIT-2 STATE | |
CLOSE-WAIT STATE | |
CLOSING STATE | |
LAST-ACK STATE | |
TIME-WAIT STATE | |
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 Receive Test | |
Length Window | |
------- ------- ------------------------------------------- | |
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. | |
second check the RST bit, | |
SYN-RECEIVED STATE | |
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. | |
ESTABLISHED | |
FIN-WAIT-1 | |
FIN-WAIT-2 | |
CLOSE-WAIT | |
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. | |
CLOSING STATE | |
LAST-ACK STATE | |
TIME-WAIT | |
If the RST bit is set then, enter the CLOSED state, delete the | |
TCB, and return. | |
third check security and precedence | |
SYN-RECEIVED | |
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. | |
ESTABLISHED STATE | |
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. | |
fourth, check the SYN bit, | |
SYN-RECEIVED | |
ESTABLISHED STATE | |
FIN-WAIT STATE-1 | |
FIN-WAIT STATE-2 | |
CLOSE-WAIT STATE | |
CLOSING STATE | |
LAST-ACK STATE | |
TIME-WAIT STATE | |
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 reached | |
and an ack would have been sent in the first step (sequence | |
number check). | |
fifth check the ACK field, | |
if the ACK bit is off drop the segment and return | |
if the ACK bit is on | |
SYN-RECEIVED STATE | |
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. | |
ESTABLISHED STATE | |
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. | |
FIN-WAIT-1 STATE | |
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. | |
FIN-WAIT-2 STATE | |
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. | |
CLOSE-WAIT STATE | |
Do the same processing as for the ESTABLISHED state. | |
CLOSING STATE | |
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. | |
LAST-ACK STATE | |
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. | |
TIME-WAIT STATE | |
The only thing that can arrive in this state is a | |
retransmission of the remote FIN. Acknowledge it, and restart | |
the 2 MSL timeout. | |
sixth, check the URG bit, | |
ESTABLISHED STATE | |
FIN-WAIT-1 STATE | |
FIN-WAIT-2 STATE | |
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. | |
CLOSE-WAIT STATE | |
CLOSING STATE | |
LAST-ACK STATE | |
TIME-WAIT | |
This should not occur, since a FIN has been received from the | |
remote side. Ignore the URG. | |
seventh, process the segment text, | |
ESTABLISHED STATE | |
FIN-WAIT-1 STATE | |
FIN-WAIT-2 STATE | |
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. | |
CLOSE-WAIT STATE | |
CLOSING STATE | |
LAST-ACK STATE | |
TIME-WAIT STATE | |
This should not occur, since a FIN has been received from the | |
remote side. Ignore the segment text. | |
eighth, 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. | |
SYN-RECEIVED STATE | |
ESTABLISHED STATE | |
Enter the CLOSE-WAIT state. | |
FIN-WAIT-1 STATE | |
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. | |
FIN-WAIT-2 STATE | |
Enter the TIME-WAIT state. Start the time-wait timer, turn | |
off the other timers. | |
CLOSE-WAIT STATE | |
Remain in the CLOSE-WAIT state. | |
CLOSING STATE | |
Remain in the CLOSING state. | |
LAST-ACK STATE | |
Remain in the LAST-ACK state. | |
TIME-WAIT STATE | |
Remain in the TIME-WAIT state. Restart the 2 MSL time-wait | |
timeout. | |
and return. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment