Inside a TCP Connection: Handshake, Windows and Reliabilityناو پەیوەندییەکی TCP: سێ ڕێی تەوقەکردن، پەنجەرەکان و پشتپێبەستراوی

TCP and UDP showed what TCP promises: every byte, in order. This lesson shows how. When two hosts talk over TCP, they first set up a connection, then manage it while data flows, and finally close it. Opening uses the three-way handshake. While data flows, TCP numbers the bytes, acknowledges what arrived, resends what was lost and uses a window to control the flow. Closing uses FIN and ACK segments in both directions. Control bits in the TCP header show where the connection is.

TCP و UDP پیشانی دا TCP چی بەڵێن دەدات: هەموو بایتێک، بە ڕیز. ئەم وانەیە پیشان دەدات چۆن. کاتێک دوو میوانگر (Host) بە TCP قسە دەکەن، سەرەتا پەیوەندییەک دادەمەزرێنن، پاشان لە کاتی ڕۆیشتنی دراوەدا بەڕێوەی دەبەن و لە کۆتاییدا دایدەخەن. کردنەوە سێ ڕێی تەوقەکردن بەکار دەهێنێت. لە کاتی ڕۆیشتنی دراوەدا، TCP بایتەکان ژمارە دەکات، دان بەوەدا دەنێت کە گەیشتووە، ونبووەکان دووپاتە دەنێرێتەوە و قەبارەی پەنجەرە بۆ کۆنترۆڵی ڕەوت بەکار دەهێنێت. داخستن بڕەکانی FIN و ACK لە هەردوو ئاڕاستەدا بەکار دەهێنێت. بیتەکانی (Bit) کۆنترۆڵ لە سەردێڕی TCPـدا پیشان دەدەن پەیوەندییەکە لە کوێدایە.

The TCP header has eight one-bit flags, the control bits (CTL). A flag set to 1 tells the other side what this segment is for. SYN (synchronise) starts a connection and carries the starting sequence number. ACK says that the acknowledgement number is valid; after the handshake it is set in almost every segment. FIN says “I have finished sending”. RST (reset) ends a connection at once, for example when a segment arrives for a connection that does not exist. PSH asks the receiver to pass the data to the application now, URG marks urgent data, and ECE and CWR carry congestion signals.

سەردێڕی TCP هەشت ئاڵای یەک بیتی هەیە، واتە بیتەکانی کۆنترۆڵ ⁦(CTL)⁩. ئاڵایەک کە 1 بێت بە لایەکەی تر دەڵێت ئەم بڕە بۆ چییە. SYN ⁦(synchronise)⁩ پەیوەندییەک دەست پێ دەکات و ژمارەی زنجیرەی دەستپێک هەڵدەگرێت. ACK دەڵێت ژمارەی دانپێدانان دروستە؛ دوای سێ ڕێی تەوقەکردن لە نزیکەی هەموو بڕێکدا دانراوە. FIN دەڵێت «ناردنم تەواو کرد». RST ⁦(reset)⁩ یەکسەر پەیوەندییەک کۆتایی پێ دەهێنێت، بۆ نموونە کاتێک بڕێک بۆ پەیوەندییەک دەگات کە بوونی نییە. PSH داوا لە وەرگر دەکات ئێستا دراوەکە بداتە ئەپەکە (App)، URG دراوەی بەپەلە دیاری دەکات و ECE و CWR ئاماژەی قەرەباڵغی هەڵدەگرن.

Before any data moves, TCP must have a connection, and it builds one in three steps. The Kurdish name «three-way handshake» comes from people shaking hands: the first person holds out a hand, and if the other person agrees, he holds out his hand too, and the handshake — the connection — happens. When you open a website in your browser: (1) your computer sends SYN, as if asking “May I connect to you?”; (2) the server answers SYN-ACK: the ACK means “yes”, and its own SYN asks “May I connect to you too?”; (3) your computer answers with a plain ACK: “Yes, you may.” Now the connection exists in both directions.

پێش ئەوەی هیچ دراوەیەک بجووڵێت، TCP دەبێت پەیوەندیی هەبێت و بە سێ هەنگاو دروستی دەکات. ناوی کوردیی «سێ ڕێی تەوقەکردن» لە تەوقەکردنی خەڵکەوە هاتووە: کەسی یەکەم دەستی بۆ تەوقە درێژ دەکات و ئەگەر کەسی بەرانبەر ڕازی بێت، ئەویش دەستی درێژ دەکات و تەوقەکردنەکە — واتە پەیوەندییەکە — ڕوو دەدات. کاتێک ماڵپەڕێک لە تۆڕگەڕەکەتدا (Web browser) دەکەیتەوە: ⁦(1)⁩ کۆمپیوتەرەکەت SYN دەنێرێت، وەک ئەوەی بپرسێت «دەتوانم پەیوەندیت پێوە بکەم؟»؛ ⁦(2)⁩ ڕاژەکارەکە (Server) بە ⁦SYN-ACK⁩ وەڵام دەداتەوە: ACK واتە «بەڵێ» و SYNـەکەی خۆی دەپرسێت «ئەی من دەتوانم پەیوەندیت پێوە بکەم؟»؛ ⁦(3)⁩ کۆمپیوتەرەکەت بە ACKـێکی ئاسایی وەڵام دەداتەوە: «بەڵێ، دەتوانیت.» ئێستا پەیوەندییەکە لە هەردوو ئاڕاستەدا هەیە.

TCP numbers bytes, not segments. The sequence number of a segment is the number of its first data byte. The acknowledgement number that comes back is the next byte the receiver expects: it means “I have every byte before this one”. So one ACK can confirm several segments at once. If a segment carries bytes 101 to 1100, the next segment starts at 1101, and the ACK for both says 2101.

TCP بایتەکان ژمارە دەکات، نەک بڕەکان. ژمارەی زنجیرەی بڕێک ژمارەی یەکەم بایتی دراوەکەیەتی. ژمارەی دانپێدانان کە دەگەڕێتەوە بایتی داهاتووە کە وەرگر چاوەڕێی دەکات: واتە «هەموو بایتێک پێش ئەمەم هەیە». بۆیە یەک ACK دەتوانێت لە یەک کاتدا چەند بڕێک پشتڕاست بکاتەوە. ئەگەر بڕێک بایتەکانی ⁦101⁩ تا ⁦1100⁩ هەڵبگرێت، بڕی داهاتوو لە ⁦1101⁩ـەوە دەست پێ دەکات و ACKـی هەردووکیان دەڵێت ⁦2101⁩.

The pieces of one message may travel on different routes, so they can arrive out of order. TCP uses the sequence numbers to put the segments back in their original order before the application sees them: the data stream is rebuilt exactly. UDP is connectionless and does not do this: datagrams that arrive out of order are handed to the application as they come, and a lost datagram is not sent again. Applications that need order on top of UDP, such as voice calls (RTP), number their own packets.

پارچەکانی یەک نامە دەکرێت بە ڕێگای جیاوازدا بڕۆن، بۆیە دەکرێت بە ڕیزی هەڵە بگەن. TCP ژمارەکانی زنجیرە بەکار دەهێنێت بۆ ئەوەی بڕەکان پێش ئەوەی ئەپەکە بیانبینێت بگەڕێنێتەوە سەر ڕیزە ڕەسەنەکەیان: زنجیرەی دراوەکە ڕێک دووپاتە دروست دەکرێتەوە. UDP بێ‌گرێدانە (Connectionless) و ئەمە ناکات: ئەو داتاگرامانەی (Datagram) بە ڕیزی هەڵە دەگەن هەر وەک هاتوون دەدرێنە ئەپەکە و داتاگرامێکی ونبوو دووپاتە نانێردرێتەوە. ئەو ئەپانەی لە سەر UDP پێویستیان بە ڕیزە، وەک پەیوەندیی دەنگی ⁦(RTP)⁩، پاکێتەکانی (Packet) خۆیان ژمارە دەکەن.

A fast sender must not drown a slow receiver. TCP's answer is flow control between the two hosts: the receiving TCP reports a window size, the number of bytes, counted from the acknowledgement number, that it is ready to receive right now. The window size travels in every TCP segment, from the handshake on. TCP is full duplex, so the client and the server each announce their own window. In this example the client says it can take 5,000 bytes and the web server says 10,000.

نێرەرێکی خێرا نابێت وەرگرێکی خاو نوقم بکات. وەڵامی TCP کۆنترۆڵی ڕەوتـە لە نێوان دوو میوانگرەکەدا: TCPـی وەرگر قەبارەی پەنجەرە ڕادەگەیەنێت، واتە ئەو ژمارە بایتەی لە ژمارەی دانپێدانانەوە دەژمێردرێت و ئێستا ئامادەیە وەریبگرێت. قەبارەی پەنجەرە لە هەموو بڕێکی TCPـدا دەڕوات، لە سێ ڕێی تەوقەکردنەوە. TCP دوولایەنەی هاوکاتە (Full duplex)، بۆیە ڕاژەخواز و ڕاژەکار هەریەکەیان قەبارەی پەنجەرەی خۆی ڕادەگەیەنێت. لەم نموونەیەدا ڕاژەخوازەکە دەڵێت دەتوانێت ⁦5,000⁩ بایت وەربگرێت و ڕاژەکاری وێبەکە (Web server) دەڵێت ⁦10,000⁩.

The sender may have up to one window of unacknowledged data on the way; it does not wait for an ACK after every segment. Each ACK that comes back moves the window forward, so new segments may be sent: the window slides along the data. When the receiver's buffer fills up, it advertises a smaller window and the sender slows down; a window of 0 stops it until the receiver has room again.

نێرەر دەتوانێت تا یەک قەبارەی پەنجەرە دراوەی بێ ACK لە ڕێگادا هەبێت؛ دوای هەر بڕێک چاوەڕێی ACK ناکات. هەر ACKـێک کە دەگەڕێتەوە پەنجەرەکە بەرەو پێش دەبات، بۆیە دەکرێت بڕەکانی نوێ بنێردرێن: پەنجەرەکە بە درێژایی دراوەکە دەخزێت. کاتێک بافەری (Buffer) وەرگر پڕ دەبێت، قەبارەیەکی پەنجەرەی بچووکتر ڕادەگەیەنێت و نێرەر خاو دەبێتەوە؛ قەبارەی پەنجەرەی 0 دەیوەستێنێت تا وەرگر دووپاتە جێی دەبێتەوە.

TCP's reliability rests on three tools: acknowledgements say what has arrived, a retransmission timer notices when an ACK does not come in time, and retransmission sends the missing bytes again. Follow the example. The window is 3,000 bytes: the sender sends bytes 1–1500 and 1501–3000, and the receiver answers ACK 3001. The next segment, 3001–4500, is lost; 4501–6000 arrives. The receiver keeps 4501–6000 in its buffer but can only acknowledge up to the gap, so it answers ACK 3001 again, with a smaller window of 1,500 because its buffer is partly full. Only one repeated ACK comes back here, so the sender waits until the timer runs out and then resends 3001–4500; the receiver can now answer ACK 6001. When more segments follow a loss, three duplicate ACKs make the sender resend sooner, without waiting for the timer (fast retransmit, RFC 5681).

پشتپێبەستراویی (Reliability) TCP لە سەر سێ ئامراز وەستاوە: دانپێدانان دەڵێت چی گەیشتووە، تایمەری (Timer) دووپاتە ناردنەوە (Retransmission) دەزانێت کەی ACKـێک لە کاتی خۆیدا نەهاتووە و دووپاتە ناردنەوە بایتەکانە ونبووەکان دووپاتە دەنێرێتەوە. نموونەکە ببینە. قەبارەی پەنجەرە ⁦3,000⁩ بایتە: نێرەر بایتەکانی ⁦1–1500⁩ و ⁦1501–3000⁩ دەنێرێت و وەرگر ⁦ACK 3001⁩ وەڵام دەداتەوە. بڕی دواتر، ⁦3001–4500⁩، ون دەبێت؛ ⁦4501–6000⁩ دەگات. وەرگر ⁦4501–6000⁩ لە بافەرەکەیدا هەڵدەگرێت بەڵام تەنیا تا بۆشاییەکە دەتوانێت دانی پێدا بنێت، بۆیە دووپاتە ⁦ACK 3001⁩ وەڵام دەداتەوە، بە قەبارەیەکی پەنجەرەی بچووکتری ⁦1,500⁩، چونکە بافەرەکەی بەشێکی پڕ بووە. لێرەدا تەنیا یەک ACKـی دووپاتە دەگەڕێتەوە، بۆیە نێرەر چاوەڕێ دەکات تا تایمەرەکە تەواو دەبێت و پاشان ⁦3001–4500⁩ دووپاتە دەنێرێتەوە؛ ئێستا وەرگر دەتوانێت ⁦ACK 6001⁩ وەڵام بداتەوە. کاتێک بڕەکانی زیاتر بەدوای ونبوونێکدا دێن، سێ ACKـی دووپاتە وا لە نێرەر دەکەن زووتر و بێ چاوەڕوانیی تایمەرەکە دووپاتە بنێرێتەوە (fast retransmit، ⁦RFC 5681⁩).

Flow control protects the receiver; congestion control protects the network in between. When routers' queues overflow, segments are lost — and that loss is TCP's main signal of congestion. The receiver does not reduce its window because of this; the sender keeps a second limit for itself, the congestion window (cwnd), and never has more than the smaller of cwnd and the receiver's window on the way. A new connection starts with slow start: cwnd begins small and grows by one segment for every ACK, so it roughly doubles each round trip. Above a threshold (ssthresh) it switches to congestion avoidance and grows by about one segment per round trip. Three duplicate ACKs halve it; a timeout drops it back to one segment (RFC 5681). The result is the sawtooth below.

کۆنترۆڵی ڕەوت وەرگر دەپارێزێت؛ کۆنترۆڵی قەرەباڵغی ئەو ڕایەڵەیەی (Network) لە نێوانیاندایە دەپارێزێت. کاتێک ڕیزەکانی ڕێدۆزەکان (Router) پڕ دەبن، بڕەکان ون دەبن — و ئەو ونبوونە ئاماژەی سەرەکیی TCPـە بۆ قەرەباڵغیی ڕایەڵە (Congestion). وەرگر لەبەر ئەمە قەبارەی پەنجەرەکەی بچووک ناکاتەوە؛ نێرەر سنوورێکی دووەم بۆ خۆی هەڵدەگرێت، پەنجەرەی قەرەباڵغی (Congestion window) ⁦(cwnd)⁩. هەرگیز لە بچووکترینی cwnd و قەبارەی پەنجەرەی وەرگر زیاتری لە ڕێگادا نییە. پەیوەندییەکی نوێ بە دەستپێکی هێواش (Slow start) دەست پێ دەکات: cwnd بچووک دەست پێ دەکات و بۆ هەر ACKـێک یەک بڕ گەورە دەبێت، بۆیە لە هەر گەشتێکی چوون و گەڕانەوەدا نزیکەی دوو هێندە دەبێت. لە سەرووی سنوورێکەوە (ssthresh) دەچێتە سەر خۆلادان لە قەرەباڵغی و لە هەر گەشتێکدا نزیکەی یەک بڕ گەورە دەبێت. سێ ACKـی دووپاتە دەیکەنە نیوە؛ تەواوبوونی کات دەیگەڕێنێتەوە بۆ یەک بڕ ⁦(RFC 5681)⁩. ئەنجامەکە ئەم شێوە ددانەی خوارەوەیە.

A TCP connection has two directions, and each one is closed on its own with FIN and ACK — four segments in all, sometimes called the four-way handshake. (1) The client sends FIN: “I have nothing more to send.” (2) The server ACKs it; it may still send its own last data. (3) When it has finished, the server sends its FIN. (4) The client ACKs it and waits a while in TIME_WAIT (2 × MSL; RFC 9293 takes the MSL as 2 minutes, and systems often use less) so that a late segment cannot confuse a new connection. Often the server's ACK and FIN travel together in one segment. A RST instead ends the connection at once, without this exchange.

پەیوەندییەکی TCP دوو ئاڕاستەی هەیە و هەریەکەیان بە جیا بە FIN و ACK دادەخرێت — سەرجەم چوار بڕ، کە هەندێک جار پێی دەگوترێت تەوقەی چوار ڕێ. ⁦(1)⁩ ڕاژەخوازەکە FIN دەنێرێت: «هیچی ترم نییە بینێرم.» ⁦(2)⁩ ڕاژەکارەکە ACKـی بۆ دەنێرێت؛ هێشتا دەتوانێت دوایین دراوەی خۆی بنێرێت. ⁦(3)⁩ کە تەواو بوو، ڕاژەکارەکە FINـی خۆی دەنێرێت. ⁦(4)⁩ ڕاژەخوازەکە ACKـی بۆ دەنێرێت و ماوەیەک لە ⁦TIME_WAIT⁩ـدا چاوەڕێ دەکات (⁦2 × MSL⁩؛ ⁦RFC 9293 MSL⁩ بە 2 خولەک دادەنێت و سیستەمەکان زۆر جار کەمتر بەکار دەهێنن) بۆ ئەوەی بڕێکی دواکەوتوو پەیوەندییەکی نوێ تێک نەدات. زۆر جار ACK و FINـی ڕاژەکارەکە لە یەک بڕدا پێکەوە دەڕۆن. RST بەپێچەوانەوە یەکسەر پەیوەندییەکە کۆتایی پێ دەهێنێت، بێ ئەم ئاڵوگۆڕە.

Every TCP connection is always in one state, and netstat -an on Windows shows it in the State column. The names are RFC 9293's, written Windows' way (LISTEN appears as LISTENING). The four you will see most: LISTENING — a server program waiting for clients; ESTABLISHED — an open connection; TIME_WAIT — this side closed first and is waiting before the connection disappears (normal; the PID is shown as 0); CLOSE_WAIT — the other side has closed, but the program here has not closed its socket yet. Many CLOSE_WAIT lines that never go away usually mean a program that forgets to close its connections. You saw these states in the netstat example.

هەموو پەیوەندییەکی TCP هەمیشە لە یەک دۆخـدایە و netstat -an لەسەر Windows لە ستوونی Stateـدا پیشانی دەدات. ناوەکان هی ⁦RFC 9293⁩ن، بە شێوەی Windows نووسراون (LISTEN وەک LISTENING دەردەکەوێت). ئەو چوارەی زۆرتر دەیانبینیت: LISTENING — بەرنامەیەکی ڕاژەکار کە چاوەڕێی ڕاژەخوازەکان دەکات؛ ESTABLISHED — پەیوەندییەکی کراوە؛ ⁦TIME_WAIT⁩ — ئەم لایە یەکەم جار دایخست و پێش نەمانی پەیوەندییەکە چاوەڕێ دەکات (ئاساییە؛ PID وەک 0 پیشان دەدرێت)؛ ⁦CLOSE_WAIT⁩ — لایەکەی تر دایخستووە، بەڵام بەرنامەکەی ئێرە هێشتا سۆکێتەکەی (Socket) دانەخستووە. زۆر دێڕی ⁦CLOSE_WAIT⁩ کە هەرگیز ناڕۆن زۆربەی کات واتای بەرنامەیەکە کە لەبیری دەچێت پەیوەندییەکانی دابخات. ئەم دۆخانەت لە نموونەی netstat بینی.

After a server answers a SYN with SYN-ACK, it keeps a half-open connection (SYN_RECEIVED) and waits for the final ACK. In a SYN flood an attacker sends huge numbers of SYNs, often with fake source addresses, and never sends the ACK. The server's queue of half-open connections fills up and real clients cannot connect: a denial-of-service attack. Defences include SYN cookies — the server encodes the connection details in its own ISN and keeps no state until the ACK arrives — firewalls and DDoS protection services. Denial-of-service attacks and their defences are taught in network defences.

دوای ئەوەی ڕاژەکارێک وەڵامی SYN بە ⁦SYN-ACK⁩ دەداتەوە، پەیوەندییەکی نیوەکراوە ⁦(SYN_RECEIVED)⁩ هەڵدەگرێت و چاوەڕێی ACKـی کۆتایی دەکات. لە SYN floodـدا هێرشبەرێک ژمارەیەکی زۆر SYN دەنێرێت (زۆر جار بە ناونیشانی سەرچاوەی ساختە) و هەرگیز ACK نانێرێت. ڕیزی پەیوەندییە نیوەکراوەکانی ڕاژەکارەکە پڕ دەبێت و ڕاژەخوازەکانی ڕاستەقینە ناتوانن پەیوەندی بکەن: هێرشێکی ڕێگەگرتن لە خزمەتگوزاری (Denial of service). بەرگرییەکان SYN cookiesـن — ڕاژەکارەکە زانیاریی پەیوەندییەکە لە ISNـی خۆیدا دەشارێتەوە و تا ACK نەگات هیچ دۆخێک هەڵناگرێت — هەروەها ئاگرەدیوارەکان (Firewall) و خزمەتگوزارییەکانی پاراستن لە DDoS. هێرشەکانی ڕێگەگرتن لە خزمەتگوزاری و بەرگرییەکانیان لە بەرگرییەکانی ڕایەڵە دەخوێندرێن.