Computer Networks • Transport Layer • Lesson 05

TCP (Transmission Control Protocol): Services, Byte-Stream Model, Segment Header, Flags, MSS, Options and Window Fields

A complete illustrated tutorial for APPSC Assistant Professor, RGUKT Lecturer, UGC NET and GATE. Based on Tanenbaum & Wetherall and Behrouz A. Forouzan, with compact diagrams, animations, formulas, step-by-step numericals and original practice MCQs.

TCP Header 20–60 bytesSequence & ACKMSS and MTUTCP OptionsMCQs + Numericals

TCP (Transmission Control Protocol) is a connection-oriented transport protocol that supplies a reliable, ordered byte stream between two application processes. TCP uses ports to identify processes, sequence and acknowledgement numbers to track data, a sliding window for flow control and congestion-control mechanisms to regulate traffic.

1. TCP Fundamentals and Services

Tanenbaum introduces TCP as a protocol built to deliver a dependable end-to-end byte stream even when IP datagrams are lost, delayed, duplicated or delivered out of order. Forouzan calls it a reliable, connection-oriented process-to-process transport protocol.

Reliable

Detects loss and recovers through acknowledgements and retransmissions.

Ordered

Returns application bytes in sequence, even when segments arrive out of order.

Full duplex

Two endpoints can send and receive at the same time.

Connection-oriented

Establishes a logical connection, transfers data, then releases it.

Flow controlled

Uses the receiver-advertised window to avoid overrunning the destination buffer.

Congestion controlled

Adapts its outstanding data to network conditions via the congestion window.

Very important: A TCP connection is a virtual connection between two endpoints. It does not reserve a dedicated physical path through routers. TCP uses IP underneath, and IP remains connectionless in the Internet model.

TCP socket address: IP address + port number. A TCP connection is distinguished by the combination of protocol, source IP/port and destination IP/port (the five-tuple). TCP is point-to-point: it does not itself provide IP multicast or broadcast connections.

2. TCP Byte-Stream Model and Animated Example

TCP is stream-oriented, not message-oriented. If an application makes four writes of 512 bytes, a receiver may obtain the same 2048 bytes in one read or in several reads. The original write boundaries do not survive automatically. This is illustrated in Tanenbaum Figure 6-35 and Forouzan Figure 23.13.

Concept animation — the same bytes, different segment and read boundaries

A · 512 BB · 512 BC · 512 BD · 512 B

Sender
Write bytes

ABCDTCP segments →

Receiver
Read bytes

ABCD · 2048 B

Pause / resume animation

Illustrative grouping: letters represent portions of an ordered byte stream, not fixed wire-level message boundaries. TCP can combine or divide writes into segments. This animation is an original educational drawing.

2.1 Sending and receiving buffers

Forouzan Figure 23.14 illustrates circular buffers: the sender retains bytes already sent but not yet acknowledged, alongside data waiting to be sent. The receiver stores accepted bytes until the application reads them. Buffers allow application and network rates to differ.

When designing applications with TCP, create message boundaries yourself when needed—for example, a fixed-length record, a delimiter, or a length-prefix protocol. A single send() does not guarantee a single matching recv().

3. TCP Segmentation and Encapsulation

The application supplies a continuous byte stream. TCP takes groups of bytes, adds a TCP header, and hands each segment to IP. IP encapsulates it in an IP packet; a data-link technology such as Ethernet wraps the packet in a frame.

Application
Byte stream

→

TCP
Segment

→

IP
Packet

→

Ethernet
Frame

The number of TCP data bytes in a segment is influenced by the Maximum Segment Size (MSS), the receiver's advertised capabilities, path MTU, buffering and other implementation considerations. The transport-layer unit is called a TCP segment.

4. TCP Segment Header Format — Complete Diagram

The fixed TCP header is 20 bytes (five rows of 32 bits). Options and padding may extend the header to 60 bytes. The diagram below follows Tanenbaum Figure 6-36 (eight control flags), rather than Forouzan's six-flag rendering.

TCP header: each row is 32 bits

Bit 0Bit 15Bit 16Bit 31

Source port 16 bits

Destination port 16 bits

Sequence number 32 bits

Acknowledgement number 32 bits

Offset 4

Res. 4

Flags 8 bits

Window size 16 bits

Checksum 16 bits

Urgent pointer 16 bits

Options and padding 0–40 bytes; header extends to a multiple of 4 bytes

TCP payload Variable; may be absent in control-only segments

Original clean redraw of Tanenbaum Figure 6-36. The 20-byte fixed header is the first five rows; options and payload do not count as part of that fixed portion. Textbook-era layout: 4 reserved bits + 8 control flags.

Minimum header

20 bytes = 160 bits

Maximum header

60 bytes = 480 bits

Data Offset

4 bits, measured in 32-bit words

TCP header bytes = Data Offset × 4

For Data Offset = 8, header length = 8 × 4 = 32 bytes, leaving 32 − 20 = 12 bytes for options and padding.

5. TCP Header Fields — Field-by-Field Explanation

Field	Size	Meaning / exam point
Source Port	16 bits	Sender's application endpoint; part of the connection five-tuple.
Destination Port	16 bits	Recipient application endpoint, for example HTTP typically uses TCP 80.
Sequence Number	32 bits	Number of the first application-data byte in the segment; SYN and FIN consume one sequence number.
Acknowledgement Number	32 bits	Next in-order byte expected from peer; valid when ACK flag = 1; cumulative.
Data Offset	4 bits	Length of TCP header in 32-bit words; usually 5–15.
Reserved + Flags	4 + 8 bits in Tanenbaum	Reserved bits and control bits for connection management, urgent data, and congestion feedback.
Window Size	16 bits	Receiver-advertised receive window, subject to negotiated scaling.
Checksum	16 bits	Mandatory error-detection checksum over TCP header, payload, and conceptual IP pseudoheader.
Urgent Pointer	16 bits	Meaningful when URG=1; seldom used.
Options + Padding	0–40 bytes	MSS, Window Scale, Timestamp, SACK, etc.; header aligned to a 32-bit boundary.

5.1 Sequence number and cumulative acknowledgement

TCP assigns sequence numbers to bytes, not packets. Forouzan Example 23.3 divides 5000 bytes into five segments of 1000 bytes, with the first data byte numbered 10,001. Segment sequence numbers are 10,001; 11,001; 12,001; 13,001; 14,001. The cumulative acknowledgement after all five segments is 15,001, provided the bytes arrive in order.

ACK number = first sequence number + contiguous data bytes received

If bytes 3000–3499 are missing, receiving bytes 3500–3999 does not advance the cumulative ACK beyond 3000. Optional SACK information can separately report out-of-order data.

5.2 TCP checksum

Both textbooks identify the TCP checksum as mandatory. It uses one's-complement arithmetic over the TCP segment and a conceptual IP pseudoheader containing information such as IP source/destination addresses and IP protocol number 6. The pseudoheader is used in the checksum calculation; it is not a separate wire-level TCP field.

6. TCP Control Flags — URG, ACK, PSH, RST, SYN, FIN, ECE and CWR

SYNStart / synchronize

ACKAcknowledgement valid

FINFinish sending

RSTReset / refuse

PSHPush delivery request

URGUrgent pointer valid

ECEECN echo

CWRCongestion window reduced

Flag	What it signals	Exam memory cue
SYN	Synchronization of sequence numbers for connection establishment.	Open a TCP connection
ACK	Acknowledgement-number field is valid.	Next expected byte
FIN	Sender has no more data to send in that direction.	Close one direction
RST	Abrupt reset or rejection of a connection attempt.	Reset/refuse
PSH	Requests prompt handoff of received data to the application.	Push
URG	Urgent pointer is relevant to urgent-data handling.	Urgent
ECE	Echoes an Explicit Congestion Notification in the ECN mechanism.	ECN Echo
CWR	Indicates congestion window was reduced in response to congestion feedback.	Congestion Window Reduced

Textbook diagram difference (important): Forouzan's 4th edition, Figure 23.16–23.17, presents six classic control flags and six reserved bits. Tanenbaum's 5th edition, Figure 6-36, presents eight flags including ECE/CWR and four reserved bits. The explanations above explicitly follow Tanenbaum for the eight-flag version. Do not assume all textbook-era figures show identical reserved/flag layouts.

6.1 Control flags and sequence numbers

A SYN or FIN consumes one sequence number even without ordinary application data. A pure ACK with no SYN/FIN and no payload consumes no data-sequence space. A FIN+ACK can both acknowledge previous bytes and consume one sequence number in its sender's direction.

7. Maximum Segment Size (MSS) versus MTU

MTU (Maximum Transmission Unit) limits an IP packet's size over a link. MSS (Maximum Segment Size) counts only the TCP data bytes per segment, not TCP or IP headers. The textbook uses an Ethernet MTU of 1500 bytes and a common TCP MSS of 1460 bytes for IPv4 when both headers have no options.

TCP MSS = Path MTU − IP header bytes − TCP header bytes

Example: 1500-byte IPv4 packet with no IP/TCP options

IPv4: 20 BTCP: 20 BData: 1460 B

Header regions are necessarily tiny at scale; label text states the exact byte counts.

IPv4 example

1500 − 20 − 20 = 1460 bytes

IPv6 example

1500 − 40 − 20 = 1440 bytes, assuming no extension headers and no TCP options.

MSS normally indicates the maximum TCP data payload a peer can accept, and can be advertised using a TCP option during connection setup. Unlike MTU, it does not include headers. Actual packetization can be constrained further by path MTU, TCP options and implementation behavior.

8. TCP Options — MSS, Window Scale, Timestamp and SACK

TCP options extend the fixed 20-byte header. The Data Offset field still counts the entire header, so options and padding are included in the header-length calculation. Both textbooks cover optional TCP header space, and Tanenbaum discusses several important examples.

Option	Purpose	Exam point
MSS	Advertises the maximum TCP data size the endpoint is willing to receive.	Concerned with payload, not total frame length.
Window Scale	Extends effective receive-window capability beyond the 16-bit unscaled field.	Scaled advertised window = field value × 2^shift.
Timestamp	Supports RTT measurements and protection against old wrapped sequence numbers (PAWS).	Timestamp value and echoed timestamp.
SACK	Reports selected out-of-order received byte ranges.	Complements cumulative ACK for more targeted recovery.

8.1 TCP Window Scale

Effective advertised rwnd = window field × 2^{scale factor}

Example: Window field = 20,000, negotiated scale factor = 3. The effective advertised receive window is 20,000 × 8 = 160,000 bytes.

Condition: Apply the scale only when it has been negotiated in connection setup. The scaling mechanism is distinct from the congestion window. Unscaled Window Size has a maximum field value of 65,535.

9. TCP Window Fields: rwnd versus cwnd

The TCP header contains the receiver's advertised Window Size field (rwnd). The sender also maintains a congestion window (cwnd), which is a local control variable rather than a field carried in every TCP header.

Effective sending window ≈ min(rwnd, cwnd)

New data send allowance ≈ max(0, min(rwnd, cwnd) − bytes in flight)

The following example assumes: rwnd = 8 KB, cwnd = 6 KB, and bytes already sent but unacknowledged = 2 KB. Then the effective cap is 6 KB and the sender may transmit 4 KB more, subject to other constraints.

Illustrative window of six 1-KB slots

12345678

Yellow: 2 KB in flightGreen: 4 KB availableGrey: beyond effective cap

New sending allowance = 6 KB − 2 KB = 4 KB. The diagram uses conceptual slots rather than actual TCP segments.

9.1 What if rwnd = 0?

TCP must stop sending ordinary new application data when the receive window is closed. As explained in Tanenbaum, TCP's persistence timer and window probes help handle cases where a later nonzero window advertisement is lost. A zero receive window is a flow-control condition, not proof that the network is congested.

10. Solved TCP Numerical Problems

Example 1 — Header length and option space

Question: TCP Data Offset = 11. Find header size, options/padding size and maximum TCP payload in a 1500-byte MTU IPv4 packet with a 20-byte IPv4 header.

Header = 11 × 4 = 44 bytes.

Options and padding = 44 − 20 = 24 bytes.

Payload = 1500 − 20 − 44 = 1436 bytes.

Example 2 — Forouzan-style byte sequencing

Question: 5000 bytes start with TCP data sequence 10,001 and are divided into five 1000-byte data segments. Find their sequence numbers and cumulative ACK when all bytes arrive correctly.

Sequence numbers = 10,001; 11,001; 12,001; 13,001; 14,001.

Final byte = 15,000. Next expected byte = ACK 15,001.

The sequence-number pattern follows Forouzan Example 23.3, p.719; the final ACK is an added derived exercise.

Example 3 — SYN sequence consumption

Question: Client sends SYN with seq = 7,000. Server sends SYN with seq = 24,000. Determine ACKs for the normal three-way handshake (no payload).

Server SYN+ACK has ACK = 7,001. Client's final ACK has seq = 7,001 and ACK = 24,001.

Example 4 — Effective window and new data

Question: rwnd = 10 KB, cwnd = 7 KB and bytes in flight = 3 KB. How much additional data can the sender transmit?

Effective cap = min(10,7) = 7 KB. New allowance = 7 − 3 = 4 KB.

Assume 1 KB means 1024 bytes consistently; no further restrictions or recovery adjustments.

Example 5 — TCP window scale

Question: Advertised Window field = 30,000, negotiated scale = 4. Find scaled rwnd.

rwnd = 30,000 × 2⁴ = 30,000 × 16 = 480,000 bytes.

Example 6 — Bandwidth-delay product

Question: A path offers 20 Mbps and has an RTT of 80 ms. How many bytes must be in flight to fill the path, ignoring overhead?

BDP = 20,000,000 bits/s × 0.080 s = 1,600,000 bits = 200,000 bytes.

A default unscaled maximum advertised window of 65,535 bytes would be smaller than that required amount; window scaling may be necessary.

Example 7 — Lost data and cumulative ACK

Question: Data segment A contains bytes 2000–2499, segment B contains 2500–2999 (lost), segment C contains 3000–3499 (received out of order). What cumulative ACK remains after C arrives?

The receiver is still waiting for byte 2500, so cumulative ACK = 2500. After B is recovered, it can advance to 3500 if all listed bytes are present.

10.1 Formula Revision Table

Formula	Use
TCP header = Data Offset × 4	Header-length and options questions
TCP payload = MTU − IP header − TCP header	Unfragmented-packet example under stated assumptions
ACK = first data sequence + contiguous bytes	In-order byte acknowledgement
rwnd (scaled) = window field × 2^shift	When window scaling negotiated
Effective cap = min(rwnd, cwnd)	Flow/congestion limits
BDP = bandwidth × RTT	Bits in flight to fill a path

11. APPSC / UGC NET / GATE-Style MCQs (20 Questions)

These are original practice MCQs inspired by the two textbook chapters. They are not represented as verbatim previous-year questions. Open the answer below each question to verify your reasoning.

Q1. TCP provides which type of application service?

Unreliable message delivery
Reliable ordered byte stream
Host-to-host routing only
Unordered broadcast