12 TCP: Finite State Machine Implementation

12
TCP: Finite State Machine Implementation
12.2 CLOSED state processing
• 表 示 TCB 己 經 allocated, 但 尚 未 使 用 ( 尚 未 active open or
passive open)
– 若 收 到 一 個 packet (unexpectedly),=> 送 出 一 reset packet
/* tcpclosed.c - tcpclosed */
/*------------------------------------------------------------------------
* tcpclosed - do CLOSED state processing
*------------------------------------------------------------------------
*/
int
tcpclosed(struct tcb *ptcb, struct ep *pep)
{
tcpreset(pep);
return SYSERR;
}
12.3 Graceful Shutdown
• use modified 3-way handshake to shut down connections
– shutdown connection is the most complexity for TCP
SYN_RCVD
AP Close
snd FIN
recv SYN
snd ACK, SYN
FIN_WAIT_1
recv ACK
FIN_WAIT_2
AP Close
snd FIN
passive OPEN
recv ACK
recv FIN
snd ACK
recv FIN,ACK
snd ACK
recv FIN
snd ACK
CLOSED
LISTEN
recv SYN
snd SYN+ACK
ESTABLISHED
CLOSING
TIME_WAIT
recv SYN, ACK
snd ACK
recv ACK
recv FIN
snd ACK
Timeout=2MSL
active OPEN
snd SYN
SYN_SENT
CLOSE_WAIT
AP Close
snd FIN
LAST_ACK
AP Close
or timeout
recv ACK
12.4 Timed Delay After Closing
• packet over internet may duplication or delay
– duplication and delay pose a potential problem for TCP
• to prevent duplicated segments from interfering
with later connections, TCP does not delete a TCB
after a connection closes (after 2 * Maximum
Segment Lift Time)
tcpwait()
• Schedules the delayed deletion of a TCB
– Schedule a DELETE event for 2MSL from
– tcpkilltimes(): delete any pending events associated with the
TCB (ex: retransmission evnets)
– tmset(): create a delection event that will occur
TCP_TWOMSL time units in the future
• If time out, it causes the timer process to delete the TCB

* tcpwait.c - tcpwait */
#include
#include
#include
/*------------------------------------------------------------------------
* tcpwait - (re)schedule a DELETE event for 2MSL from now
*------------------------------------------------------------------------
*/
int
tcpwait(struct tcb *ptcb)
{
int tcbnum = ptcb - &tcbtab[0];
}
tcpkilltimers(ptcb);
tmset(tcps_oport, TCPQLEN, MKEVENT(DELETE, tcbnum), TCP_TWOMSL);
return OK;
12.5 Time-Wait State Processing
• 當 TCP graceful shutdown 後 , 會 在 Time-wait state 等 待 2*MSL 時
間 , 以 確 定 屬 於 這 個 connection 的 packet 皆 可 處 理 完 畢 , 不 會 因 太
早 disconnect, 而 使 有 些 後 到 的 packet 無 人 可 回 應 ( 此 無 回 應 的
packet 可 能 造 成 connection 的 另 一 端 機 器 , timeout, 而 造 成 reset or
retransmission.
• 在 此 狀 態 若 收 到 reset packet
– 對 方 想 將 connect reset, 再 重 新 傳 送 , 因 我 已 經 disconnect, => 將 TCB delete,
等 待 對 方 再 送 syn packet, 重 新 建 立 連 線
• 若 收 到 syn packet
– 送 出 reset packet ( 將 對 方 reset). 將 自 己 的 TCB delete 等 待 重 新 建 立 連 線
• 若 其 它 packet, 則 仍 正 常 將 此 packet 做 處 理
– tcpacked(): 處 理 收 到 的 packet 的 ack seq# 與 自 己 的 send window 比 對
– tcpdata(): 處 理 收 到 的 packet 的 data 部 份 : 是 否 在 receive window 內 , 將 其 搬
到 rx buffer 內 , 判 斷 是 否 out of order, 是 否 有 urgent or push flag, 是 否 要 回
送 ack packet, 是 否 要 將 rx buffer 內 的 data 送 給 上 層
– 呼 叫 tcpwait(), 重 新 啟 動 2*MSL timer ( 只 要 對 方 仍 繼 續 send packet, 我 的
2*MSL timer 就 不 會 timeout
/*------------------------------------------------------------------------
* tcptimewait - do TIME_WAIT state input processing
*------------------------------------------------------------------------ */
int tcptimewait(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
}
if (ptcp->tcp_code & TCPF_RST)
return tcbdealloc(ptcb);
if (ptcp->tcp_code & TCPF_SYN) {
tcpreset(pep);
return tcbdealloc(ptcb);
}
tcpacked(ptcb, pep);
tcpdata(ptcb, pep); /* just ACK any packets */
tcpwait(ptcb);
return OK;
12.6 CLOSING state processing
• 若 在 closing state, 表 示 雙 方 都 已 收 到 FIN packet, 即 皆
己 同 意 disconnect
• 在 此 state, 若 收 到 fin 的 ack packet, 則 跳 到 time-wait state
• 在 此 狀 態 若 收 到 reset packet
– 對 方 想 將 connect reset, 再 重 新 傳 送 , 因 我 己 完 全 disconnect, => 將 TCB
delete, 等 待 對 方 再 送 syn packet, 重 新 建 立 連 線
• 若 收 到 syn packet
– 送 出 reset packet ( 將 對 方 reset). 將 自 己 的 TCB delete 等 待 重 新 建 立 連 線
• 其 它 部 份 只 需 呼 叫 tcpacked, 處 理 收 到 packet 的 ack seq 欄 位
• 最 後 判 斷 是 否 收 到 送 出 的 fin packet 的 ack packet, 若 是 , 則 將 狀
態 跳 到 time wait state

*------------------------------------------------------------------------
* tcpclosing - do CLOSING state input processing
*------------------------------------------------------------------------ */
int tcpclosing(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
}
if (ptcp->tcp_code & TCPF_RST)
return tcbdealloc(ptcb);
if (ptcp->tcp_code & TCPF_SYN) {
tcpreset(pep);
return tcbdealloc(ptcb);
}
tcpacked(ptcb, pep);
if ((ptcb->tcb_code & TCPF_FIN) == 0) {
ptcb->tcb_state = TCPS_TIMEWAIT;
signal(ptcb->tcb_ocsem); /* wake closer */
tcpwait(ptcb);
}
return OK;
12.7 FIN-WAIT 2 State Processing
• 當 送 出 的 fin packet 己 被 ack, 則 TCP 在 fin-wait 2 state, 等 待 收
到 對 方 的 fin packet
• 在 此 狀 態 , 若 收 到 reset packet, 則 abort 此 connection
– tcpabort(): 將 此 連 線 的 pending events delete, 停 止 收 取 與 送 出 仍 何
data packet, tcb_error 設 成 error, 呼 叫 所 有 等 待 接 收 此 連 線 packet 的
process
• 若 收 到 syn packet, 則 送 出 reset packet, 並 呼 叫 tcpabort()
• 其 它 , 則 呼 叫 tcpacked() 與 tcpdata() 來 處 理 收 到 packet 的 data
與 ack 部 份 , 並 判 斷 是 否 收 到 fin-packet, 且 fin packet 之 前 的 所
有 packet 皆 己 收 到 , 若 是 , 則 連 線 狀 態 變 為 time wait state
/*------------------------------------------------------------------------
* tcpfin2 - do FIN_WAIT_2 state input processing
*------------------------------------------------------------------------ */
int tcpfin2(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
if (ptcp->tcp_code & TCPF_RST)
return tcpabort(ptcb, TCPE_RESET);
if (ptcp->tcp_code & TCPF_SYN) {
tcpreset(pep);
return tcpabort(ptcb, TCPE_RESET);
}
if (tcpacked(ptcb, pep) == SYSERR)
return OK;
tcpdata(ptcb, pep); /* for data + FIN ACKing */
}
if (ptcb->tcb_flags & TCBF_RDONE) {
ptcb->tcb_state = TCPS_TIMEWAIT;
tcpwait(ptcb);
}
return OK;
12.8 FIN-WAIT-1 State Processing
( 傳 送 部 分 己 關 閉 , 但 接 收 部 分 尚 未 關 閉 )
• 當 AP 產 生 一 個 close 要 求 時 , TCP 送 出 fin
packet, 其 跳 到 fin-wait-1 state, 等 待 對 方 對 此 finpacket
回 ack packet
• 在 此 狀 態 , 若 收 到 fin packet, 表 對 方 亦 已 確 定 要
finish connection, => 回 此 fin packet 一 個 ack
packet, 並 跳 到 closing state
• 若 收 到 之 前 送 出 fin packet 的 ack packet => 跳 到
fin-wait-2 state
• 若 收 到 fin + fin’s ack packet, 表 對 方 己 收 到 我 的
fin packet, 且 對 方 亦 同 意 要 finish connection =>
直 接 跳 到 time-wait state

*------------------------------------------------------------------------
* tcpfin1 - do FIN_WAIT_1 state input processing
*------------------------------------------------------------------------ */
int tcpfin1(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
if (ptcp->tcp_code & TCPF_RST)
return tcpabort(ptcb, TCPE_RESET);
if (ptcp->tcp_code & TCPF_SYN) {
tcpreset(pep);
return tcpabort(ptcb, TCPE_RESET);
}
if (tcpacked(ptcb, pep) == SYSERR)
return OK;
tcpdata(ptcb, pep);
Receiving down: 表 示 收 到 fin 與 fin 之 前 的 data,
tcpswindow(ptcb, pep);
對 方 已 經 結 束 傳 送 資 料
if (ptcb->tcb_flags & TCBF_RDONE) {
if (ptcb->tcb_code & TCPF_FIN)
/* 我 送 出 的 FIN 尚 未 ACKed*/
ptcb->tcb_state = TCPS_CLOSING; // 收 到 fin, 但 我 送 出 的 fin 尚 未 ack
else {
ptcb->tcb_state = TCPS_TIMEWAIT;// 收 到 fin, 且 收 到 fin ack
signal(ptcb->tcb_ocsem); /* wake closer (AP) */
tcpwait(ptcb);
}
} else if ((ptcb->tcb_code & TCPF_FIN) == 0) {
signal(ptcb->tcb_ocsem); /* wake closer */
ptcb->tcb_state = TCPS_FINWAIT2; // 收 到 fin ack, 尚 未 收 到 fin
}
return OK;
}
12.9 Close-Wait State Processing
• 當 被 動 收 到 對 方 的 fin-packet, 則 回 其 ack packet 後 , 將 此 資 訊 ( 利 用 end-of-file)
通 知 AP 後 , 跳 到 close-wait state
• 當 AP 亦 同 意 close 時 , TCP 將 送 一 fin packet 給 對 方 , 並 進 入 last-ack state
int tcpclosewait(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
if (ptcp->tcp_code & TCPF_RST) {
TcpEstabResets++;
TcpCurrEstab--;
return tcpabort(ptcb, TCPE_RESET);
}
if (ptcp->tcp_code & TCPF_SYN) {
TcpEstabResets++;
TcpCurrEstab--;
tcpreset(pep);
return tcpabort(ptcb, TCPE_RESET);
}
tcpacked(ptcb, pep);
tcpswindow(ptcb, pep);
return OK;
}
12.10 Last-ACK State Processing
• 等 待 fin-packet’s ack packet
• 若 收 到 一 般 data or fin packet, 則 仍 要 呼 叫 tcpacket() 來 處 理 , 否 則 若
timeout, 會 做 retransmission
int tcplastack(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
}
if (ptcp->tcp_code & TCPF_RST)
return tcpabort(ptcb, TCPE_RESET);
if (ptcp->tcp_code & TCPF_SYN) {
tcpreset(pep);
return tcpabort(ptcb, TCPE_RESET);
}
tcpacked(ptcb, pep);
if ((ptcb->tcb_code & TCPF_FIN) == 0) // 表 FIN’s packet 已 ack
signal(ptcb->tcb_ocsem); /* close() deallocs */
return OK;
12.11 Established State Processing
• 當 tcp 連 線 建 立 起 來 時 , 連 線 的 兩 端 皆 在 established
狀 態 ( 正 常 的 data/ack packet)
• 若 收 到 reset packet, 表 示 對 方 要 restarted, abort 連 線
• 若 收 到 syn packet, 則 送 出 reset packet, 並 abort 連 線
• 其 它 , 則 呼 叫 tcpacked() 與 tcpdata() 處 理 收 到 packet
的 data field 與 ack field, 呼 叫 tcpswindow() 來 調 整
send window size
• 若 收 到 fin-packet 且 其 之 前 的 data packet 皆 己 收 到 ,
則 跳 到 close-wait state

*------------------------------------------------------------------------
* tcpestablished - do ESTABLISHED state input processing
*------------------------------------------------------------------------ */
int tcpestablished(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
if (ptcp->tcp_code & TCPF_RST) {
TcpEstabResets++;
TcpCurrEstab--;
return tcpabort(ptcb, TCPE_RESET); }
if (ptcp->tcp_code & TCPF_SYN) {
TcpEstabResets++;
TcpCurrEstab--;
tcpreset(pep);
return tcpabort(ptcb, TCPE_RESET);}
if (tcpacked(ptcb, pep) == SYSERR)
return OK;
tcpdata(ptcb, pep);
tcpswindow(ptcb, pep);
if (ptcb->tcb_flags & TCBF_RDONE)
ptcb->tcb_state = TCPS_CLOSEWAIT;
return OK;
}
12.12 Processing Urgent Data in a Segment
• tcpdata.c:
– 處 理 收 進 來 packet 的 data 部 份
– 首 先 判 斷 收 進 來 的 packet 是 否 有 urgent flag, 若 有 , 則 根 據 urgent
point, 記 錄 urgent data 的 範 圍 (rup, receive urgent poing), 判 斷 之 前
是 否 仍 有 urgent data 尚 未 收 進 來 , 適 當 調 整 tcb_rupseq, 與 tcb_flags
– 若 收 進 來 的 packet 有 syn flag, 則 需 調 整 tcb_rnext 與 tcp_seq
– 算 出 rwindow 的 wlast, rnext 與 收 到 packet 的 datalen, first, last 等 參 數
值 ( 以 sequence # 為 單 位 ), 將 已 收 進 來 的 與 超 過 rwindow 的 data
discard, 其 餘 的 利 用 pb(rwindow 指 標 ) 與 pp(packet buffer 指 標 )( 以
offset 為 單 位 ), 將 packet 放 在 rwindow 內
– 呼 叫 tcpdodat() 將 收 到 rwindow 的 packet 做 進 一 步 處 理 ( 是 否 要 送 給
AP, 是 否 要 ACK,…)
– 若 因 收 到 的 packet 必 需 要 回 送 一 個 packet 出 去 , 則 需 將 tcb_flags 設
成 TCBF_NEEDOUT, 並 呼 叫 tcpkick() 送 出 適 當 的 packet
/*------------------------------------------------------------------------
* tcpdata - process an input segment's data section
*------------------------------------------------------------------------ */
int tcpdata(struct tcb *ptcb, struct ep *pep)
{
struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
tcpseq first, last, wlast;
unsigned pb;
int
datalen, rwindow, i, pp;
if (ptcp->tcp_code & TCPF_URG) {
int rup = ptcp->tcp_seq + ptcp->tcp_urgptr;
#ifdef BSDURG
rup--;
#endif
if (!(ptcb->tcb_flags & TCBF_RUPOK) ||
SEQCMP(rup, ptcb->tcb_rupseq) > 0) {
ptcb->tcb_rupseq = rup;
ptcb->tcb_flags |= TCBF_RUPOK;
}
}
if (ptcp->tcp_code & TCPF_SYN) {
ptcb->tcb_rnext++;
ptcb->tcb_flags |= TCBF_NEEDOUT;
++ptcp->tcp_seq; /* so we start with data */
}
datalen = pip->ip_len - IP_HLEN(pip) - TCP_HLEN(ptcp);
rwindow = ptcb->tcb_rbsize - ptcb->tcb_rbcount;
wlast = ptcb->tcb_rnext + rwindow-1;
first = ptcp->tcp_seq;
last = first + datalen - 1;
if (SEQCMP(ptcb->tcb_rnext, first) > 0) {
datalen -= ptcb->tcb_rnext - first;
first = ptcb->tcb_rnext;
}
if (SEQCMP(last, wlast) > 0) {
datalen -= last - wlast;
ptcp->tcp_code &= ~TCPF_FIN; /* cutting it off */
}
pb = ptcb->tcb_rbstart + ptcb->tcb_rbcount; /* == rnext, in buf */
pb += first - ptcb->tcb_rnext; /* distance in buf */
pb %= ptcb->tcb_rbsize; /* may wrap */
pp = first - ptcp->tcp_seq; /* distance in packet */
for (i=0; itcb_rcvbuf[pb] = ptcp->tcp_data[pp++];
if (++pb >= ptcb->tcb_rbsize)
pb = 0;
}
tcpdodat(ptcb, ptcp, first, datalen); /* deal with it */
if (ptcb->tcb_flags & TCBF_NEEDOUT)
tcpkick(ptcb);
return OK;
}

12.13 Processing other Data in a Segment
• tcpdodata()
– 若 收 到 的 packet 是 in sequence
• 若 data length > 0, 則 呼 叫 flcoalesce() 判 斷 所 收 到 的 packet 是 否 有
將 之 前 的 out of order packet 的 洞 補 起 來 , 是 否 己 到 達 finseq 或
pushseq 等 , wakeup tx 回 傳 ack
• 若 收 到 FIN packet, 則 tcb flags 設 成 TCBF_RDONE( 已 收 到 finish,
即 對 方 不 可 能 再 送 data, 即 將 receive 設 成 done), wakeup tx 回 傳
ack
• 若 收 到 的 packet 有 push 或 urgent flag, 則 將 tcb-flags 設 成
TCBF_PUSH, wakeup tx 回 傳 ack
– 若 收 到 的 packet 是 out of order
• TCP 收 到 out of order packet 做 法 和 IP 收 到 segment packet 一 樣 ,
是 利 用 link-list 將 其 串 起 來 , 每 個 node 內 容 為 (seq, datalen)
• 若 收 到 的 packet 具 有 finish 或 push 或 urgent flag, 則 需 記 錄
finish, push, urgent data 的 sequence number
• 呼 叫 tfinsert() 將 收 到 的 packet 放 到 link list
12.14 tfinsert(), 將 out of order packet 的 seq 與
data length 以 linked-list 方 式 串 起 來
/*------------------------------------------------------------------------
* tfinsert - add a new TCP segment fragment to a TCB sequence queue
*------------------------------------------------------------------------ */
int
tfinsert(struct tcb *ptcb, tcpseq seq, unsigned datalen)
{
struct tcpfrag *tf;
}
if (datalen == 0)
return OK;
tf = (struct tcpfrag *)getmem(sizeof(struct tcpfrag));
tf->tf_seq = seq;
tf->tf_len = datalen;
if (ptcb->tcb_rsegq < 0)
ptcb->tcb_rsegq = newq(NTCPFRAG, QF_WAIT);
if (enq(ptcb->tcb_rsegq, tf, -tf->tf_seq) < 0)
freemem(tf, sizeof(struct tcpfrag));
return OK;
int tcpdodat(struct tcb *ptcb,struct tcp *ptcp,tcpseq first,unsigned datalen)
{ int wakeup = 0;
if (ptcb->tcb_rnext == first) {
if (datalen > 0) {
tfcoalesce(ptcb, datalen, ptcp);
ptcb->tcb_flags |= TCBF_NEEDOUT;
wakeup++;
}
if (ptcp->tcp_code & TCPF_FIN) {
ptcb->tcb_flags |= TCBF_RDONE|TCBF_NEEDOUT;
ptcb->tcb_rnext++;
wakeup++;
}
if (ptcp->tcp_code & (TCPF_PSH | TCPF_URG)) {
ptcb->tcb_flags |= TCBF_PUSH;
wakeup++;
}
if (wakeup)
tcpwakeup(READERS, ptcb);
}
} else {
/* process delayed controls */
if (ptcp->tcp_code & TCPF_FIN)
ptcb->tcb_finseq = ptcp->tcp_seq + datalen;
if (ptcp->tcp_code & (TCPF_PSH | TCPF_URG))
ptcb->tcb_pushseq = ptcp->tcp_seq + datalen;
ptcp->tcp_code &= ~(TCPF_FIN|TCPF_PSH);
tfinsert(ptcb, first, datalen);
}
return OK;
tfcoalesce(): 將 放 到 rwindow 的 in sequence
packet 做 進 一 步 處 理
• 調 整 tcb_rnext 與 tcb_rbcount
• 若 收 進 來 的 packet 為 finish, 則 將 out of order packet queue
清 掉
• 若 收 進 來 的 packet 已 到 達 urgent/push point 位 置 , 則 準 備
將 rwindow 的 data 上 傳 給 AP
• 若 之 前 已 有 out of packet 被 收 進 來 , 則 再 去 判 斷 是 否 已 將
out of order 的 hole 補 起 來 了 , 否 則 return ok
• 利 用 tf-len, tf_seq, 與 tcb-rnext 判 斷 是 否 有 將 洞 補 起 來

*------------------------------------------------------------------------
* tfcoalesce - join TCP fragments
*------------------------------------------------------------------------ */
int tfcoalesce(struct tcb *ptcb, unsigned datalen, struct tcp *ptcp)
{
struct tcpfrag *tf = 0;
int
newcount;
ptcb->tcb_rnext += datalen;
ptcb->tcb_rbcount += datalen;
if (ptcb->tcb_rnext == ptcb->tcb_finseq)
goto alldone;
if ((ptcb->tcb_rnext - ptcb->tcb_pushseq) >= 0) {
ptcp->tcp_code |= TCPF_PSH;
ptcb->tcb_pushseq = 0;
}
if (ptcb->tcb_rsegq < 0) /* see if this closed a hole */
return OK;
tf = (struct tcpfrag *)deq(ptcb->tcb_rsegq);
if (tf == 0)
return OK;
while ((tf->tf_seq - ptcb->tcb_rnext) tf_len - (ptcb->tcb_rnext - tf->tf_seq);
if (newcount > 0) {
ptcb->tcb_rnext += newcount;
ptcb->tcb_rbcount += newcount;}
if (ptcb->tcb_rnext == ptcb->tcb_finseq)
goto alldone;
if ((ptcb->tcb_rnext - ptcb->tcb_pushseq) >= 0) {
ptcp->tcp_code |= TCPF_PSH;
ptcb->tcb_pushseq = 0; }
freemem(tf, sizeof(struct tcpfrag));
tf = (struct tcpfrag *)deq(ptcb->tcb_rsegq);
if (tf == 0) {
freeq(ptcb->tcb_rsegq);
ptcb->tcb_rsegq = EMPTY;
return OK;}
}
enq(ptcb->tcb_rsegq, tf, -tf->tf_seq); /* got one too many */
return OK;
alldone:
if (tf)
freemem(tf, sizeof(struct tcpfrag));
while (tf = (struct tcpfrag *)deq(ptcb->tcb_rsegq))
freemem(tf, sizeof(struct tcpfrag));
freeq(ptcb->tcb_rsegq);
ptcb->tcb_rsegq = EMPTY;
ptcp->tcp_code |= TCPF_FIN;
return OK;
}
12.15 Aborting a TCP connection
/*------------------------------------------------------------------------
* tcpabort - abort an active TCP connection
*------------------------------------------------------------------------ */
int
tcpabort(struct tcb *ptcb, int error)
{
tcpkilltimers(ptcb);
ptcb->tcb_flags |= TCBF_RDONE|TCBF_SDONE;
ptcb->tcb_error = error;
tcpwakeup(READERS|WRITERS, ptcb);
return OK;
}
• tcpkilltimers(): delete all pending events for the connection
• 將 send 與 receive status 設 成 done
• 利 用 tcpwakeup(): 將 所 有 等 待 此 connection 的 packet 的 process 叫 起
來
12.16 Establish a TCP Connection
SYN_RCVD
passive OPEN
recv SYN
snd ACK, SYN
recv ACK
CLOSED
LISTEN
ESTABLISHED
recv SYN, ACK
snd ACK
active OPEN
snd SYN
SYN_SENT
AP Close
or timeout
• 3-way handshake to establish a connection
• Server issues a passive open => listen state
• client issues an active open => send syn packet => syn-sent
• server receives syn packet => send syn+ack packet => syn_revd
• client receives syn+ack packet => send ack packet => established
• server receives ack packet => established

12.17 Initializing a TCB
• 當 AP 要 求 active 或 passive open 時 , 則 TCP 呼 叫 tcpsync()
去 設 定 一 新 的 連 線 的 TCB 值
• 主 要 設 定 :
– connection state: CLOSED state
– allocate send and receive buffers
– create send and receive semaphores, etc .
int tcpsync(struct tcb *ptcb)
{ ptcb->tcb_state = TCPS_CLOSED;
ptcb->tcb_type = TCPT_CONNECTION;
ptcb->tcb_iss = ptcb->tcb_suna = ptcb->tcb_snext = tcpiss();
ptcb->tcb_lwack = ptcb->tcb_iss;
ptcb->tcb_sndbuf = (u_char *)getmem(TCPSBS);
ptcb->tcb_sbsize = TCPSBS;
ptcb->tcb_sbstart = ptcb->tcb_sbcount = 0;
ptcb->tcb_ssema = screate(1);
12.18 SYN-SENT State Processing
• 如 果 收 到 ack-flag packet 時 , 判 斷 其 sequence # 是 否 為 ack 之
前 送 出 的 syn packet, 若 不 是 , 則 送 一 reset packet
• 如 果 收 到 的 是 reset packet, 則 回 到 closed state, 且 呼 叫
tcpkilltimers(), delete 所 有 此 connection 的 pending events
• 若 收 到 的 是 syn packet ( 可 能 carry data or syn’s ack), 則 設 定
一 些 基 本 參 數 ( 根 據 收 的 的 packet), 如 : swindow, lwseq,
rnext, cwin 等
• 呼 叫 tcpacked(): 處 理 此 packet 的 ack seq#
• 呼 叫 tcpdata(): 處 理 此 packet 的 data 部 份
• 收 到 的 packet 若 有 ack 之 前 的 syn packet, 則 跳 到 established
state, 否 則 , 跳 到 synrcvd state
ptcb->tcb_rcvbuf = (u_char *)getmem(TCPRBS);
ptcb->tcb_rbsize = TCPRBS;
ptcb->tcb_rbstart = ptcb->tcb_rbcount = 0;
ptcb->tcb_rsegq = EMPTY;
ptcb->tcb_rsema = screate(0);
ptcb->tcb_ocsem = screate(0);
}
/* timer stuff */
ptcb->tcb_srt = 0; /* in sec/100 */
ptcb->tcb_rtde = 0; /* in sec/100 */
ptcb->tcb_rexmt = 50; /* in sec/100 */
ptcb->tcb_rexmtcount = 0;
ptcb->tcb_keep = 12000; /* in sec/100 */
ptcb->tcb_code = TCPF_SYN;
ptcb->tcb_flags = 0;
return OK;
int tcpsynsent(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
if ((ptcp->tcp_code & TCPF_ACK) &&
((ptcp->tcp_ack - ptcb->tcb_iss tcp_ack - ptcb->tcb_snext) > 0))
return tcpreset(pep);
if (ptcp->tcp_code & TCPF_RST) {
ptcb->tcb_state = TCPS_CLOSED;
ptcb->tcb_error = TCPE_RESET;
TcpAttemptFails++;
tcpkilltimers(ptcb);
signal(ptcb->tcb_ocsem);
return OK;}
if ((ptcp->tcp_code & TCPF_SYN) == 0)
return OK;
ptcb->tcb_swindow = ptcp->tcp_window;
ptcb->tcb_lwseq = ptcp->tcp_seq;
ptcb->tcb_rnext = ptcp->tcp_seq;
ptcb->tcb_cwin = ptcb->tcb_rnext + ptcb->tcb_rbsize;
tcpacked(ptcb, pep);
tcpdata(ptcb, pep);
ptcp->tcp_code &= ~TCPF_FIN;
if (ptcb->tcb_code & TCPF_SYN) /* our SYN not ACKed */
ptcb->tcb_state = TCPS_SYNRCVD;
else {
TcpCurrEstab++;
ptcb->tcb_state = TCPS_ESTABLISHED;
signal(ptcb->tcb_ocsem);/* return in open */
}
return OK;
}

12.19 SYN-RECEIVED State Processing
• listen state receives syn packet => syn-received state
• syn-sent state only received syn packet without an ACK => synreceived
state
• 當 收 到 reset packet 時 , 若 為 server side, 則 將 之 前 為 這 新 連 線 所
allocate 的 TCB delete, 若 為 client side, 則 about 此 connection
• 若 收 到 syn packet=> 送 出 reset packet, 且 abort 此 連 線
• 以 three-way handshake 方 式 , 若 我 在 syn-received state, 則 對 方 可
能 已 在 established state, 所 以 必 須 呼 叫 tcpacked() 與 tcpdata() 來 處
理 收 到 packet 的 ack 與 data 部 份
• 若 為 server side, 則 利 用 tcb_listenq 將 此 connection 的 pseudo
device number 送 給 AP program
int tcpsynrcvd(struct tcb *ptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
struct tcb *pptcb;
if (ptcp->tcp_code & TCPF_RST) {
TcpAttemptFails++;
if (ptcb->tcb_pptcb != 0)
return tcbdealloc(ptcb);
else
return tcpabort(ptcb, TCPE_REFUSED); }
if (ptcp->tcp_code & TCPF_SYN) {
TcpAttemptFails++;
tcpreset(pep);
return tcpabort(ptcb, TCPE_RESET); }
if (tcpacked(ptcb, pep) == SYSERR)
return OK;
if (ptcb->tcb_pptcb != 0) { /* from a passive open */
pptcb = ptcb->tcb_pptcb;
if (wait(pptcb->tcb_mutex) != OK) {
TcpAttemptFails++;
tcpreset(pep);
return tcbdealloc(ptcb); }
if (pptcb->tcb_state != TCPS_LISTEN) {
TcpAttemptFails++;
tcpreset(pep);
signal(pptcb->tcb_mutex);
return tcbdealloc(ptcb);
}
if (pcount(pptcb->tcb_listenq) >= pptcb->tcb_lqsize) {
TcpAttemptFails++;
tcpreset(pep);
signal(pptcb->tcb_mutex);
return tcbdealloc(ptcb); }
psend(pptcb->tcb_listenq, ptcb->tcb_dvnum);
signal(pptcb->tcb_mutex);
} else /* from an active open */
signal(ptcb->tcb_ocsem);
TcpCurrEstab++;
ptcb->tcb_state = TCPS_ESTABLISHED;
tcpdata(ptcb, pep);
if (ptcb->tcb_flags & TCBF_RDONE)
ptcb->tcb_state = TCPS_CLOSEWAIT;
return OK;
}
12.20 Listen State Processing
• server side wait for new connection request
• It ignores RESET packet because no connection
exists
• send a RESET packet for any incoming segment
other than a SYN packet
• when SYN packet received, it call tcballoc() to
create new TCB for new connection
• the new TCB is children and the original TCB is
parent

int tcplisten(struct tcb *ptcb, struct ep *pep)
{ struct tcb *newptcb, *tcballoc();
struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
if (ptcp->tcp_code & TCPF_RST)
return OK; /* "parent" TCB still in LISTEN */
if ((ptcp->tcp_code & TCPF_ACK) ||
(ptcp->tcp_code & TCPF_SYN) == 0)
return tcpreset(pep);
newptcb = tcballoc();
if ((int)newptcb == SYSERR || tcpsync(newptcb) == SYSERR)
return SYSERR;
newptcb->tcb_state = TCPS_SYNRCVD;
newptcb->tcb_ostate = TCPO_IDLE;
newptcb->tcb_error = 0;
newptcb->tcb_pptcb = ptcb; /* for ACCEPT */
newptcb->tcb_rip = pip->ip_src;
newptcb->tcb_rport = ptcp->tcp_sport;
newptcb->tcb_lip = pip->ip_dst;
newptcb->tcb_lport = ptcp->tcp_dport;
tcpwinit(ptcb, newptcb, pep); /* initialize window data */
newptcb->tcb_finseq = newptcb->tcb_pushseq = 0;
newptcb->tcb_flags = TCBF_NEEDOUT;
TcpPassiveOpens++;
tcpdata(newptcb, pep);
signal(newptcb->tcb_mutex);
return OK;
}
12.21 Initializing Window Variables for a New TCB
int tcpwinit(struct tcb *ptcb, struct tcb *newptcb, struct ep *pep)
{ struct ip *pip = (struct ip *)pep->ep_data;
struct tcp *ptcp = (struct tcp *)pip->ip_data;
struct route *prt;
unsigned mss;
Bool
local;
newptcb->tcb_swindow = ptcp->tcp_window;
newptcb->tcb_lwseq = ptcp->tcp_seq;
newptcb->tcb_lwack = newptcb->tcb_iss; /* set in tcpsync() */
prt = (struct route *)rtget(pip->ip_src, RTF_REMOTE);
local = prt && prt->rt_metric == 0;
newptcb->tcb_pni = &nif[prt->rt_ifnum];
rtfree(prt);
if (local)
mss = newptcb->tcb_pni->ni_mtu-IPMHLEN-TCPMHLEN;
else
mss = 536;/* RFC 1122 */
if (ptcb->tcb_smss) {
newptcb->tcb_smss = min(ptcb->tcb_smss, mss);
ptcb->tcb_smss = 0; /* reset server smss */
} else
newptcb->tcb_smss = mss;
newptcb->tcb_rmss = mss; /* receive mss */
newptcb->tcb_cwnd = newptcb->tcb_smss; /* 1 segment */
newptcb->tcb_ssthresh = 65535; /* IP max window */
newptcb->tcb_rnext = ptcp->tcp_seq;
newptcb->tcb_cwin = newptcb->tcb_rnext + newptcb->tcb_rbsize;
}