Chapter 3 Transport Layer Computer Networking: A Top Down Approach 4th edition. Jim Kurose, Keith Ross Addison-Wesley, July 2007.

Last Lecture Go-Back-N (GBN) Selective Repeat (SR)

Today’s Lecture Selective Repeat TCP Segment Structure TCP ACKs and Sequence numbers TCP Reliable Data transfer

Go-Back-N (GBN) Sender: Sender is allowed to transmit multiple packets without waiting for an acknowledgement Constrained to a certain maximum number N. Base or send_base Sequence number of oldest unacknowledged packet Nextseqnum Sequence number of next packet to be sent The range of sequence numbers for transmitted but not acknowledged packets can be viewed as a window of size N. This window slides forward as the protocol operates

Go-Back-N GBN sender must respond to three types of events Invocation from above (rdt_send() is called): If window is full, returns data to upper layer Maintain synchronization mechanism Receipt of an ACK: ACK for packet with seq # n is taken as“Cumulative ACK” More shortly in receiver Time out event: Sender has timer for oldest unacknowledged packet If timer expires, retransmit all unacknowledged packets

Go-Back-N Receiver: If a packet with seq # n is received correctly and is in order ACK is sent and data is delivered to upper layers For all other cases Receiver discards the packet and resends ACK for most recently received in order packet Packets are delivered one at a time to upper layers If a packet k has been received and delivered, then all packets with seq # lower than k have also been delivered. Receiver discards out of order packets No receiver buffering Need only remember expectedseqnum

GBN in action http://www.eecis.udel.edu/~amer/450/TransportApplets/GBN/GBNindex.html

Selective Repeat Sender: Data received from upper layers Timeout If window is full, returns data to upper layer Maintain synchronization mechanism Timeout Each packet has its own timer Single packet is retransmitted on timeout ACK received: Sender marked packet as received provided its in the window Packets sequence no is equal to send_base, The window base is moved forward to the unacknowledged packet

Selective Repeat Receiver: Packets with sequence no in the window Selective ACK is sent to the sender whether or not it is in order. Out-of-order: buffer but send ACK for that packet Deliver base plus buffered packets Packets with sequence number below the window base An ACK must be generated even though the packet has already been acknowledged by the receiver

Selective Repeat in Action http://www.eecis.udel.edu/~amer/450/TransportApplets/SR/SRindex.html

Selective Repeat: Dilemma Lack of synchronization between sender and receiver Finite range of sequence numbers Example: Seq #’s: 0, 1, 2, 3 Window size=3 Receiver sees no difference in two scenarios! Incorrectly passes duplicate data as new in (a) Window size of one less than the sequence number space does not work Window size must be less than or equal to half the size of sequence no. space

TCP: Overview RFCs: 793, 1122, 1323, 2018, 2581 Connection Oriented Handshake Send segments to each other to establish parameters of ensuing data transfer Runs on the end systems TCP connection is point to point (single sender and receiver) Does not support multicast (one sender many receivers) TCP send buffer TCP grab a chunk of data from this buffer MSS (Maximum Segment Size) The maximum amount of data that can be grabbed and placed in a segment MSS is set by determining the length of the largest link layer frame TCP receive buffer

TCP Segment Structure source port # dest port # sequence number URG: urgent data source port # dest port # application data (variable length) sequence number acknowledgement number Receive window Urg data pointer checksum F S R P A U head len not used Options (variable length) Used in implementing a reliable data transfer ACK? PSH? Used for flow control RST, SYN, FIN: connection estab (setup, teardown commands) Same as in UDP To negotiate maximum segment size etc. Find out about PSH?ACK? OPTONS?

TCP Segment Structure

TCP Sequence Numbers and ACKs Sequence nos. are over the stream of transmitted bytes and not over the series of transmitted segments Sequence no. is the byte stream “number” of first byte in segment’s data Example: Host A wants to send data to Host B File consisting of 500,000 bytes, MSS is 1,000 bytes First byte of stream is numbered zero TCP constructs 500 segments out of data stream First segment gets sequence number --- 0 Second segment gets sequence number----1000 Third segment gets sequence number------2000 and so on

TCP Sequence Numbers Imagine a TCP connection is transferring a file of 6000 bytes. The first byte is numbered 10010. What are the sequence numbers for each segment if data is sent in five segments with the first four segments carrying 1,000 bytes and the last segment carrying 2,000 bytes?

TCP Sequence Numbers The following shows the sequence number for each segment: Segment 1  10,010 (10,010 to 11,009) Segment 2  11,010 (11,010 to 12,009) Segment 3  12,010 (12,010 to 13,009) Segment 4  13,010 (13,010 to 14,009) Segment 5  14,010 (14,010 to 16,009)

TCP ACKs Acknowledgement Numbers: Example The acknowledgement no that hosts A puts in its segment is the sequence no of the next byte host A is expecting from host B. Example Host A receives all bytes numbered 0 through 535 from B Host A puts 536 in the acknowledgment number field of the segment it sends to B TCP acknowledges bytes up to first missing bytes in the stream Cumulative Acknowledgement How receiver handles out-of-order segments? TCP RFCs do not impose any rules Two choices The receiver discards out of order segments Keeps out of order bytes and waits for missing bytes to fill

TCP Sequence Numbers and ACKs Example: Host A sends a character to Host B, which echoes it back to Host A. Starting Sequence no for client and server are 42 and 79. Piggybacking: Acknowledgement of client to server data is carried by segment of server to client data Host A Host B User types ‘C’ Seq=42, ACK=79, data = ‘C’ host ACKs receipt of ‘C’, echoes back ‘C’ Seq=79, ACK=43, data = ‘C’ host ACKs receipt of echoed ‘C’ Piggybacked Seq=43, ACK=80 time

TCP Reliable Data Transfer TCP creates reliable data transfer service on top of IP’s unreliable service TCP uses single retransmission timer, even if there are multiple unacknowledged segments (RFC 2988) Uses cumulative acknowledgements Retransmissions are triggered by: Timeout Duplicate acks Initially consider simplified TCP sender: Ignore Duplicate Acks Ignore Flow control

TCP Sender Events: (1) Data Rcvd from Application Layer (2) Timeout: Create segment with sequence number. Sequence number is byte-stream number of first data byte in segment. Start timer if not already running. Expiration Interval: Will study in next lecture (2) Timeout: Retransmit segment Restart timer. (3)Ack Received: If acknowledges previously unACked segments Update what is known to be ACKed Start timer if there are outstanding segments

TCP Sender (Simplified) NextSeqNum = InitialSeqNum SendBase = InitialSeqNum loop (forever) { switch(event) event: data received from application above create TCP segment with sequence number NextSeqNum if (timer currently not running) start timer pass segment to IP NextSeqNum = NextSeqNum + length(data) event: timer timeout retransmit not-yet-acknowledged segment with smallest sequence number event: ACK received, with ACK field value of y if (y > SendBase) { SendBase = y if (there are currently not-yet-acknowledged segments) } } /* end of loop forever */ TCP Sender (Simplified)

TCP: Retransmission Scenarios Host A Host B Host A Seq=92, 8 bytes data ACK=100 loss timeout Lost ACK Scenario Host B X time Seq=92 timeout Seq=92, 8 bytes data Seq=100, 20 bytes data ACK=100 ACK=120 Sendbase = 100 Seq=92, 8 bytes data SendBase = 120 ACK=120 SendBase = 100 SendBase = 120 time Premature Timeout

TCP Retransmission Scenarios (more) Host A Seq=92, 8 bytes data ACK=100 loss timeout Cumulative ACK scenario Host B X Seq=100, 20 bytes data ACK=120 time SendBase = 120

TCP ACK Generation [RFC 1122, RFC 2581] Event at Receiver Arrival of in-order segment with expected seq #. All data up to expected seq # already ACKed expected seq #. One other Inorder segment has ACK pending Arrival of out-of-order segment higher-than-expect seq. # . Gap detected TCP Receiver action Delayed ACK. Wait up to 500ms for next in order segment. If no next segment, send ACK Immediately send single cumulative ACK, ACKing both in-order segments Immediately send duplicate ACK, indicating seq. # of next expected byte

Fast Retransmit Time-out period often relatively long: long delay before resending lost packet Detect lost segments via duplicate ACKs. Sender often sends many segments back-to-back If segment is lost, there will likely be many duplicate ACKs. If sender receives 3 ACKs for the same data, it supposes that segment after ACKed data was lost: Fast Retransmit: resend segment before timer expires Why Three Duplicate ACKs? Home Assignment

X Host A Host B timeout time resend 2nd segment Resending a Segment after Triple Duplicate ACK

Fast Retransmit Algorithm: event: ACK received, with ACK field value of y if (y > SendBase) { SendBase = y if (there are currently not-yet-acknowledged segments) start timer } else { increment count of duplicate ACKs received for y if (count of duplicate ACKs received for y ==3) { resend segment with sequence number y fast retransmit

Go-Back N or Selective Repeat GBN Protocol TCP acknowledgements are cumulative and out of order segments are not individually acked. Difference Buffering of correctly received packets GBN transmits all packets after the lost packet TCP only the missing packet Selective Repeat Buffering of out of order packets TCP SACK (RFC 2018) allows to ACK out of order packets selectively rather than cumulatively Timer with every packet Hybrid of Go-Back N and Selective Repeat Home Assignment:TCP SACK (RFC 2018)