Chapter 3 Transport Layer A note on the

Chapter 3 Transport Layer A note on the use of these ppt slides: We’re making these slides freely available to all (faculty, students, readers). They’re in Power. Point form so you can add, modify, and delete slides (including this one) and slide content to suit your needs. They obviously represent a lot of work on our part. In return for use, we only ask the following: q If you use these slides (e. g. , in a class) in substantially unaltered form, that you mention their source (after all, we’d like people to use our book!) q If you post any slides in substantially unaltered form on a www site, that you note that they are adapted from (or perhaps identical to) our slides, and note our copyright of this material. Computer Networking: A Top Down Approach 4 th edition. Jim Kurose, Keith Ross Addison-Wesley, July 2007. Thanks and enjoy! JFK/KWR All material copyright 1996 -2007 J. F Kurose and K. W. Ross, All Rights Reserved Transport Layer 1

Chapter 3: Transport Layer Our goals: r understand principles behind transport layer services: m m multiplexing/demultipl exing reliable data transfer flow control congestion control r learn about transport layer protocols in the Internet: m m m UDP: connectionless transport TCP: connection-oriented transport TCP congestion control Transport Layer 2

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3

Transport services and protocols r provide logical communication al ic g lo d en d- en po s an tr rt between app processes running on different hosts r transport protocols run in end systems m send side: breaks app messages into segments, passes to network layer m rcv side: reassembles segments into messages, passes to app layer r more than one transport protocol available to apps m Internet: TCP and UDP application transport network data link physical Transport Layer 4

Transport vs. network layer r network layer: logical communication between hosts r transport layer: logical communication between processes m relies on, enhances, network layer services Transport Layer 5

Transport Layer Functions r Demux to upper layer m Delivering data to correct application process r Quality of service m Providing service guarantees in processing (buffers, process scheduling) r Security m Authenticity, Privacy, Integrity for connection r Connection setup m Providing a connection abstraction over a connectionless substrate r Delivery semantics m m m Reliable or unreliable Ordered or unordered Unicast, multicast, anycast r Flow control m Prevent overflow of receiver buffers r Congestion control m m Prevent overflow of network buffers Avoid packet loss and packet delay Transport Layer 6

UDP’s implementation r Demux to upper layer m UDP port field r Quality of service m none r Security m none r Connection setup m none r Delivery semantics m Unordered, mostly unicast (multicast no longer supported) m Unreliable, but data integrity provided by checksum r Flow control m none r Congestion control m none Transport Layer 7

TCP’s implementation r Demux to upper layer m TCP port field r Quality of service m none r Security m none, rely on TLS (SSL) r Connection setup m 3 -way handshake r Delivery semantics m In-order byte-stream, unicast m Data integrity provided via 32 -bit checksum r Flow control m Receiver advertised window r Congestion control m Window-based Transport Layer 8

SCTP’s implementation r Demux to upper layer m SCTP port field r Quality of service m none r Security m Limited Do. S protection via signed state cookie (SYN cookies) m Rely on TLS (SSL) r Connection setup m 4 -way handshake r Delivery semantics m Optional ordering, unicast m Optional reliability, but data integrity provided via 32 -bit CRC r Flow control m Receiver advertised window r Congestion control m Window-based Transport Layer 9

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 10

Multiplexing/demultiplexing Multiplexing at send host: gathering data from multiple sockets, enveloping data with header (later used for demultiplexing) Demultiplexing at rcv host: delivering received segments to correct socket = socket application transport network link = process P 3 P 1 application transport network P 2 P 4 application transport network link physical host 1 physical host 2 physical host 3 Transport Layer 11

How demultiplexing works r host receives IP datagrams each datagram has source IP address, destination IP address m each datagram carries 1 transport-layer segment that has source, destination port number r host uses IP addresses & port numbers to direct segment to appropriate socket m m m recall: well-known port numbers for specific applications Servers wait on well known ports (/etc/services) 32 bits source port # dest port # other header fields application data (message) TCP/UDP segment format Transport Layer 12

Connectionless demultiplexing r Create sockets with port numbers: Datagram. Socket my. Socket 1 = new Datagram. Socket(99111); Datagram. Socket my. Socket 2 = new Datagram. Socket(99222); r UDP socket identified by two-tuple: (dest IP address, dest port number) r When host receives UDP segment: m m checks destination port number in segment directs UDP segment to socket with that port number r IP datagrams with different source IP addresses and/or source port numbers directed to same socket Transport Layer 13

Connectionless demux (cont) Datagram. Socket server. Socket = new Datagram. Socket(6428); P 2 SP: 6428 DP: 9157 SP: 6428 DP: 5775 SP: 9157 client IP: A P 1 P 3 DP: 6428 server IP: C SP: 5775 DP: 6428 Client IP: B SP provides “return address” Transport Layer 14

Connection-oriented demux r TCP socket identified by 4 -tuple: m m source IP address source port number dest IP address dest port number r recv host uses all four values to direct segment to appropriate socket r Server host may support many simultaneous TCP sockets: m each socket identified by its own 4 -tuple r Web servers have different sockets for each connecting client m non-persistent HTTP will have different socket for each request Transport Layer 15

Connection-oriented demux: multi-threaded server P 1 P 4 P 5 P 2 P 6 P 1 P 3 SP: 5775 DP: 80 S-IP: B D-IP: C client IP: A SP: 9157 DP: 80 S-IP: A D-IP: C SP: 9157 server IP: C DP: 80 S-IP: B D-IP: C Client IP: B Transport Layer 16

Connection-oriented demux: single threaded server P 1 P 2 P 4 P 1 P 3 SP: 5775 DP: 80 S-IP: B D-IP: C client IP: A SP: 9157 DP: 80 S-IP: A D-IP: C SP: 9157 server IP: C DP: 80 S-IP: B D-IP: C Client IP: B Transport Layer 17

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 18

UDP: User Datagram Protocol r “no frills, ” “bare bones” Internet transport protocol r “best effort” service, UDP segments may be: m lost m delivered out of order to app r connectionless: m no handshaking between UDP sender, receiver m each UDP segment handled independently of others [RFC 768] Why is there a UDP? r no connection establishment (which can add delay) r simple: no connection state at sender, receiver r small segment header r no congestion control: UDP can blast away as fast as desired Transport Layer 19

UDP: more r often used for streaming multimedia apps m m loss tolerant rate sensitive Length, in bytes of UDP segment, including header r other UDP uses m DNS m SNMP r reliable transfer over UDP m add reliability at application layer m application-specific error recovery! m Many applications reimplement reliability over UDP to bypass TCP m New transport protocols? 32 bits source port # dest port # length checksum Application data (message) UDP segment format Transport Layer 20

UDP checksum Goal: detect “errors” (e. g. , flipped bits) in transmitted segment Sender: Receiver: r treat segment contents as r compute checksum of sequence of 16 -bit integers r checksum: addition (1’s complement sum) of segment contents r sender puts checksum value into UDP checksum field received segment r check if computed checksum equals checksum field value: m NO - error detected m YES - no error detected. But maybe errors nonetheless? More later …. Transport Layer 21

Internet Checksum Example r Note m m When adding numbers, a carryout from the most significant bit needs to be added to the result Do 1 s complement to get checksum • convert 0 to 1 and 1 to 0 r Example: checksum for two 16 -bit integers 1 1 0 0 1 1 1 0 1 0 1 wraparound 1 1 0 1 1 sum 1 1 0 1 1 0 0 checksum 1 0 0 0 0 1 1 Transport Layer 22

Internet Checksum Example r Verification at receiver m Add all 16 -bit words and checksum together m If no errors, sum will be all 1 s 1 1 0 0 1 1 1 0 1 0 1 wraparound 1 1 0 1 1 sum 1 1 0 1 1 0 0 checksum 1 0 0 0 0 1 1 Transport Layer 23

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 24

Principles of Reliable data transfer r important in app. , transport, link layers r characteristics of unreliable channel will determine complexity of reliable data transfer protocol (rdt) Transport Layer 25

Principles of Reliable data transfer r important in app. , transport, link layers r characteristics of unreliable channel will determine complexity of reliable data transfer protocol (rdt) Transport Layer 26

Principles of Reliable data transfer r important in app. , transport, link layers r characteristics of unreliable channel will determine complexity of reliable data transfer protocol (rdt) Transport Layer 27

Reliable data transfer basics r Error detection, correction r Retransmission m For lost or corrupted packets r Duplicate detection m Spurious retransmissions identified r Connection integrity m Bogus packets not included Transport Layer 28

rdt 3. 0 state machine r See textbook and extra slides for issues in developing protocols and state machines for reliable data transfer r Highlights m m Sequence numbers (duplicate detection) Acknowledgments (error and loss detection) • Positive or negative acks • Cumulative or selective acks • Rdt 3. 0: Cumulative positive acknowledgements m m m Checksum (error detection) Retransmission via timer (loss recovery) Problem: Stop-and-wait operation • Send one packet • Wait for ACK before sending next packet Transport Layer 29

Performance of Stop-and-Wait r example: 1 Gbps link, 15 ms e-e prop. delay, 1 KB packet: r Assume no errors or loss Ttransmit = m m m L (packet length in bits) 8 kb/pkt = = 8 microsec R (transmission rate, bps) 10**9 b/sec U sender: utilization – fraction of time sender busy sending 1 KB pkt every 30 msec -> 33 k. B/sec thruput over 1 Gbps link network protocol limits use of physical resources! Transport Layer 30

Pipelined protocols Pipelining: sender allows multiple, “in-flight”, yet-tobe-acknowledged pkts m m range of sequence numbers must be increased buffering at sender and/or receiver Transport Layer 31

Pipelining: increased utilization sender receiver first packet bit transmitted, t = 0 last bit transmitted, t = L / R RTT first packet bit arrives last packet bit arrives, send ACK last bit of 2 nd packet arrives, send ACK last bit of 3 rd packet arrives, send ACK arrives, send next packet, t = RTT + L / R Increase utilization by a factor of 3! Transport Layer 32

Pipelining Protocols Go-back-N: big picture: r Sender can have up to N unacked packets in pipeline r Rcvr only sends cumulative acks m Doesn’t ack packet if there’s a gap r Sender has timer for oldest unacked packet m If timer expires, retransmit all unacked packets Selective Repeat: big pic r Sender can have up to N unacked packets in pipeline r Rcvr acks individual packets r Sender maintains timer for each unacked packet m When timer expires, retransmit only unack packet Transport Layer 33

Go-Back-N Sender: r k-bit seq # in pkt header r “window” of up to N, consecutive unack’ed pkts allowed r Receiver sends cumulative ACK m i. e. Highest in-order sequence number received may receive duplicate ACKs on loss or out-of-order delivery(see receiver) r timer for each in-flight pkt m m timeout(n): if no ACK received for n within timeout, retransmit pkt n Transport Layer 34 and all higher seq # pkts in window

GBN: receiver r Receiver simple r ACK-only: always send ACK for correctly- received pkt with highest in-order seq # m may generate duplicate ACKs m need only remember expected seq # r Out-of-order pkt: m discard (don’t buffer) -> no receiver buffering! m Re-ACK pkt with highest in-order seq # Transport Layer 35

GBN in action Transport Layer 36

Selective Repeat r receiver individually acknowledges all correctly received pkts m buffers pkts, as needed, for eventual in-order delivery to upper layer r sender only resends pkts for which ACK not received m sender timer for each un. ACKed pkt r sender window m N consecutive seq #’s m again limits seq #s of sent, un. ACKed pkts Transport Layer 37

Selective repeat: sender, receiver windows Transport Layer 38

Selective repeat sender data from above : receiver pkt n in [rcvbase, rcvbase+N-1] r if next available seq # in r send ACK(n) timeout(n): r in-order: deliver (also window, send pkt r resend pkt n, restart timer ACK(n) in [sendbase, sendbase+N]: r mark pkt n as received r if n smallest un. ACKed pkt, advance window base to next un. ACKed seq # r out-of-order: buffer deliver buffered, in-order pkts), advance window to next not-yet-received pkt n in [rcvbase-N, rcvbase-1] r ACK(n) m ACK for pkt was lost, rexmit otherwise: ignore Transport Layer 39

Selective repeat in action Transport Layer 40

Selective repeat: dilemma Example: r seq #’s: 0, 1, 2, 3 r window size=3 r receiver sees no difference in two scenarios! r incorrectly passes duplicate data as new in (a) Q: what relationship between seq # size and window size? Transport Layer 41

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 42

TCP: Overview r point-to-point: m one sender, one receiver r reliable, in-order byte steam: m no “message boundaries” r pipelined: m TCP congestion and flow control set window size r send & receive buffers RFCs: 793, 1122, 1323, 2018, 2581 r full duplex data: m bi-directional data flow in same connection m MSS: maximum segment size r connection-oriented: m handshaking (exchange of control msgs) init’s sender, receiver state before data exchange r flow controlled: m sender will not overwhelm receiver Transport Layer 43

TCP segment structure 32 bits URG: urgent data (generally not used) ACK: ACK # valid PSH: push data now (generally not used) RST, SYN, FIN: connection estab (setup, teardown commands) Internet checksum (as in UDP) source port # dest port # sequence number acknowledgement number head not UA P R S F len used checksum Receive window Urg data pnter Options (variable length) counting by bytes of data (not segments!) # bytes rcvr willing to accept application data (variable length) Transport Layer 44

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 45

TCP reliable data transfer r TCP creates rdt service on top of IP’s unreliable service m Segment integrity via checksum m Cumulative acks m Triggered retransmissions Transport Layer 46

Segment integrity via checksum r Checksum included in header r Is it sufficient to just checksum the packet contents? r No, need to ensure correct source/destination m Pseudoheader – portion of IP hdr that are critical m Checksum covers Pseudoheader, transport hdr, and packet body m Layer violation, redundant with parts of IP checksum Transport Layer 47

Cumulative ACKs Seq. #’s: m byte stream “number” of first byte in segment’s data ACKs: m seq # of next byte expected from other side m cumulative ACK Q: how receiver handles out-of-order segments m A: TCP spec doesn’t say, - up to implementor Host B Host A User types ‘C’ Seq=4 2, ACK = 79, da ta ata = d , 3 4 K= C 79, A = q e S host ACKs receipt of echoed ‘C’ = ‘C’ host ACKs receipt of ‘C’, echoes back ‘C’ Seq=4 3, ACK =80 simple telnet scenario Transport Layer time 48

Delayed cumulative ACKs r Problem: m In request/response programs, you send separate ACK and Data packets for each transaction r Solution: m Delay ACK in order to send ACK back along with data • Don’t ACK data immediately • Wait 200 ms m m m Without delayed ACK: 40 byte ack + data packet With delayed ACK: data packet includes ACK Exceptions • Must ACK every other packet • Must not delay duplicate ACKs Transport Layer 49

TCP ACK generation [RFC 1122, RFC 2581] Event at Receiver TCP Receiver action Arrival of in-order segment with expected seq #. All data up to expected seq # already ACKed Delayed ACK. Wait up to 200 ms for next segment. If no next segment, send ACK Arrival of in-order segment with expected seq #. One other segment has ACK pending Immediately send single cumulative ACK, ACKing both in-order segments Arrival of out-of-order segment higher-than-expect seq. #. Gap detected Immediately send duplicate ACK, indicating seq. # of next expected byte Arrival of segment that partially or completely fills gap Immediately send ACK, provided that segment starts at lower end of gap Transport Layer 50

Triggered retransmissions r Via timeout events m TCP uses single retransmission timer m Sender sends segment and sets a timer • • Send 1 Wait for Ack 2 No Ack 2 and timer expires Send 1 again r Via duplicate acks (TCP’s “fast recovery”) m Covered later Transport Layer 51

TCP Round Trip Time and Timeout Q: how to set TCP timeout value? r longer than RTT m but RTT varies r too short: premature timeout m unnecessary retransmissions r too long: slow reaction to segment loss Q: how to estimate RTT? r Sample. RTT: measured time from segment transmission until ACK receipt r Sample. RTT will vary, want estimated RTT “smoother” m average several recent measurements, not just current Sample. RTT Transport Layer 52

TCP Round Trip Time Estimator and Timeout Estimated. RTT = (1 - )*Estimated. RTT + *Sample. RTT r Exponential weighted moving average r influence of past sample decreases exponentially fast r typical value: = 0. 125 r Initial retransmit timer set to b RTT, where b=2 m Not good at preventing spurious timeouts Transport Layer 53

Example RTT estimation: Transport Layer 54

TCP Round Trip Time and Timeout (Jacobson) Setting the timeout r first estimator produced spurious timeouts as RTT grew r New estimator (Van Jacobson) m Observation: at high-loads RTT variance is high m Need larger safety margin with larger variations in RTT • Estimted. RTT plus “safety margin” • large variation in Estimated. RTT -> larger safety margin m first estimate of how much Sample. RTT deviates from Estimated. RTT: Dev. RTT = (1 - )*Dev. RTT + *|Sample. RTT-Estimated. RTT| (typically, = 0. 25) Then set timeout interval: Timeout. Interval = Estimated. RTT + 4*Dev. RTT Transport Layer 55

TCP timeout scenarios Host A 2, 8 by tes da t Seq=92 timeout a =100 X ACK loss Seq=9 2, 8 by tes da ta 100 Sendbase = 100 Send. Base = 120 = ACK Send. Base = 100 time Host B Seq=9 Send. Base = 120 lost ACK scenario 2, 8 by Seq= 100, 2 tes da ta 0 byte s data 0 10 = K 120 = C K A AC Seq=92 timeout Seq=9 timeout Host A Host B time 2, 8 by tes da ta 20 K=1 AC premature timeout scenario Transport Layer 56

TCP timeout miscelleny r Backing off TCP’s retransmission timeout m What if successive TCP retransmissions timeout? • Every timer expires for same segment, RTO is doubled • Exponential back-off similar to Ethernet until successful retransmission Transport Layer 57

Triggered retransmissions r Via timeout events m TCP uses single retransmission timer m Sender sends segment and sets a timer • • Send 1 Wait for Ack 2 No Ack 2 and timer expires Send 1 again • • Receive 1, Ack 2 Receive 4, Ack 2 Receive 3, Ack 2 Receive 2, Ack 5 r Via duplicate acks m Segment loss results in duplicate cumulative ACKs m Note: Out of order packets generate duplicate acknowledgements also! Transport Layer 58

Fast retrasmit Recall TCP ACK generation…. Event at Receiver TCP Receiver action Arrival of in-order segment with expected seq #. All data up to expected seq # already ACKed Delayed ACK. Wait up to 500 ms for next segment. If no next segment, send ACK Arrival of in-order segment with expected seq #. One other segment has ACK pending Immediately send single cumulative ACK, ACKing both in-order segments Arrival of out-of-order segment higher-than-expect seq. #. Gap detected Immediately send duplicate ACK, indicating seq. # of next expected byte Arrival of segment that partially or completely fills gap Immediate send ACK, provided that segment startsat lower end of gap Transport Layer 59

Fast Retransmit r Time-out period often relatively long: m long delay before resending lost packet r Detect lost segments via duplicate ACKs. m m Sender often sends many segments back-toback If segment is lost, there will likely be many duplicate ACKs. r If sender receives 3 ACKs for the same data, it supposes that segment after ACKed data was lost: m fast retransmit: resend segment before timer expires Transport Layer 60

Host A Host B X timeout resend 2 nd se gment time Figure 3. 37 Resending a segment after triple duplicate ACK Layer Transport 61

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 62

TCP Flow Control r receive side of TCP connection has a receive buffer: flow control sender won’t overflow receiver’s buffer by transmitting too much, too fast r speed-matching r app process may be service: matching the send rate to the receiving app’s drain rate slow at reading from buffer Transport Layer 63

TCP Flow control: how it works r Rcvr advertises spare room in buffer by including value of Rcv. Window in each segment/ACK m Also known as the “advertised” window r Sender limits un. ACKed data to Rcv. Window m guarantees receive buffer doesn’t overflow r Before congestion control m Sender always sent entire window at once Transport Layer 64

TCP Flow control r What happens if window is 0? m Receiver updates window when application reads data m What if this update is lost? • Deadlock r TCP Persist timer m Sender periodically sends window probe packets m Receiver responds with ACK and up-to-date window advertisement Transport Layer 65

TCP flow control enhancements r Problem: (Clark, 1982) m If receiver advertises small increases in the receive window then the sender may waste time sending lots of small packets r What happens if window is small? m Small packet problem known as “Silly window syndrome” • Receiver advertises one byte window • Sender sends one byte packet (1 byte data, 40 byte header = 4000% overhead) Transport Layer 66

TCP flow control enhancements r Solutions to silly window syndrome m Clark (1982) • receiver avoidance • prevent receiver from advertising small windows • increase advertised receiver window by min(MSS, Recv. Buffer/2) Transport Layer 67

TCP flow control enhancements r Solutions to silly window syndrome m Nagle’s algorithm (1984) • sender avoidance • prevent sender from unnecessarily sending small packets • http: //www. rfc-editor. org/rfc 896. txt – Allow only one outstanding small (not full sized) segment that has not yet been acknowledged – Works for idle connections (no deadlock) – Works for telnet (send one-byte packets immediately) – Works for bulk data transfer (delay sending) Transport Layer 68

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 69

TCP Connection Management Recall: TCP sender, receiver establish “connection” before exchanging data segments r initialize TCP variables: m seq. #s m buffers, flow control info (e. g. Rcv. Window) m Window scaling r client: connection initiator Socket client. Socket = new Socket("hostname", "port number"); r server: contacted by client Socket connection. Socket = welcome. Socket. accept(); Three way handshake: Step 1: client host sends TCP SYN segment to server m specifies initial seq # m no data, should be random Step 2: server host receives SYN, replies with SYNACK segment server allocates buffers m specifies server initial seq. # and adv. window Step 3: client receives SYNACK, replies with ACK segment, which may contain data m Transport Layer 70

TCP Connection Establishment r 3 -way handshake with initial sequence number selection A B SYN + Seq A SYN+ACK-A + Seq B ACK-B Transport Layer 71

TCP Sequence Number Selection r Why not simply chose 0? r Must avoid overlap with earlier incarnation r Client machine seq #0, initiates connection to server with seq #0. m Client sends one byte and machine crashes m Client reboots and initiates connection again m Server thinks new incarnation is the same as old connection Transport Layer 72

TCP Sequence Number Selection r Why is selecting a random ISN Important? m Predictable ISNs allow adversary to blindly “spoof” connections from “trusted” hosts m Attack popularized by K. Mitnick • X trusts Y • Logins from Y are accepted without credential check • Predictable ISN of X allows Evil Ed to impersonate Y and access X without credential check Ed X Y . rhosts Y Transport Layer 73

Attack on predictable ISNs r Assume m Machine X selects a predictable ISN m Alice has. rhosts to allow login to X from Y r Evil Ed attacks m Guesses next ISN of X via probing m Disables host Y • Do. S attack on Y to prevents Y from detecting attack m Blindly masquerade as Y using guessed ISN of X • Ed never sees real ISN of X since it is sent to Y • Y never sees masquerade since it is disabled Ed X Y . rhosts Y Transport Layer 74

TCP ISN and spoofing attacks 7. Door now open, rlogin to X from Ed directly X . rhosts Y Ed 5. Send pre-canned rlogin/rsh messages rsh echo “Ed” >>. rhosts spoof acknowledgements 2. Spoof TCP SYN from Y Ed 4. Send ACK with guess of X’s ISN as if you received TCP SYNACK 3. TCP SYNACK Send X ISN PACKET DROPPED! 6. Real acks dropped so Y does not reset connection 1. Flood continuously Y Transport Layer 75

TCP connection termination Closing a connection: Client-initiated close (reverse for server-initiated close): client. Socket. close(); client closing sends TCP FIN control segment to server closing FIN timed wait FIN, replies with ACK. Closes connection, sends FIN ACK Step 1: client end system Step 2: server receives server ACK closed Transport Layer 76

TCP connection termination Step 3: client receives FIN, m m Enters “timed wait” will respond with ACK to received FINs Ensures ACK is out of network before allowing client to “reuse” connection ID (more later) Step 4: server, receives ACK. Connection closed. closing server FIN ACK closing FIN timed wait replies with ACK. client ACK closed Transport Layer 77

Time Wait Issues r Cannot close connection immediately after receiving FIN and sending ACK m What if a new connection restarts and uses same sequence number? r Web servers not clients close connection first m Established -> Fin-Wait -> Time-Wait -> Closed m Final ACK sent by web server r Time-Wait state lasts for 2 * MSL m MSL should be 120 seconds (is often 60 s) m Servers often have order of magnitude more connections in Time-Wait m Can be problematic on busy servers Transport Layer 78

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 79

Principles of Congestion Control Congestion: r informally: “too many sources sending too much data too fast for network to handle” r different from flow control! r manifestations: m lost packets (buffer overflow at routers) m long delays (queueing in router buffers) Transport Layer 80

Causes/costs of congestion: scenario 1 Host A r two senders, two receivers r one router, infinite buffers r no retransmission Host B lout lin : original data unlimited shared output link buffers “costs” of congestion: r large delays Transport Layer 81

Causes/costs of congestion: scenario 2 r one router, finite buffers r sender retransmission of lost packet Host A lin : original data lout l'in : original data, plus retransmitted data Host B finite shared output link buffers Transport Layer 82

Causes/costs of congestion: scenario 2 r always: l = in lout (goodput) a) “perfect” transmission when no loss: b) retransmission of lost packet makes l l = lout in in larger for same c) retransmission of delayed (not lost) packet makes R/2 l in lout even larger R/2 lin a. R/2 lout R/3 lin b. R/2 R/4 lin R/2 c. “costs” of congestion: r more work for sender (retransmissions) for a given “goodput” r unneeded retransmissions: link carries multiple copies of pkt Transport Layer 83

Causes/costs of congestion: scenario 3 Q: what happens as lin increases? r four senders r multihop paths r timeout/retransmit Host A lin : original data lout l'in : original data, plus retransmitted data finite shared output link buffers Host B Transport Layer 84

Causes/costs of congestion: scenario 3 H o st A l o u t H o st B Another “cost” of congestion: r when packet dropped, any “upstream transmission capacity used for that packet wasted! Transport Layer 85

Congestion Collapse r Increase in network load results in decrease of useful work done m Spurious retransmissions of packets still in flight • Solution: better timers and congestion control m Undelivered packets • Packets consume resources and are dropped elsewhere in network • Solution: congestion control for ALL traffic m Fragments • Mismatch of transmission and retransmission units • Solutions: – Make network drop all fragments of a packet (early packet discard in ATM) – Do path MTU discovery m Control traffic • Large percentage of traffic is for control (headers, routing messages, DNS) • Solution: engineer protocols to reduce overheads m Stale or unwanted packets • Packets that are delayed on long queues • Solution: better congestion control and active queue management Transport Layer 86

Goals for congestion control r Use network resources efficiently m 100% link utilization, 0% packet loss, Low delay m Maximize network power: (throughput /delay) r Preserve fair network resource allocation m Fairness: Max-min fair sharing • Small flows get all of the bandwidth they require • Large flows evenly share leftover m Example: 100 Mbs link • S 1 and S 2 are 1 Mbs streams, S 3 and S 4 are greedy streams • S 1 and S 2 each get 1 Mbs, S 3 and S 4 each get 49 Mbs r Convergence and stability r Distributed operation r Simple router and end-host behavior Transport Layer 87

Congestion Control vs. Avoidance r Avoidance keeps the system performing at the knee/cliff r Control kicks in once the system has reached a congested state Throughput Delay Load Transport Layer 88

Congestion control approaches r End-host vs. network controlled m Trust hosts to do the right thing • Hosts adjust rate based on detected congestion (TCP) m Don’t trust hosts and enforce within network • Network adjusts rates at congestion points – Scheduling – Queue management • Hard to prevent global collapse conditions locally r Implicit vs. explicit network feedback m Implicit: infer congestion from packet loss or delay • Increase rate in absence of loss, decrease on loss (TCP Tahoe/Reno) • Increase rate based on RTT behavior (TCP Vegas, Packet pair) m Explicit: signalled from network • Congestion notification (IBM SNA, DECbit, ECN) • Rate signaling (ATM ABR) Transport Layer 89

Case study: ATM ABR congestion control ABR: available bit rate: r “elastic service” RM (resource management) cells: r if sender’s path r sent by sender, interspersed “underloaded”: m sender should use available bandwidth r if sender’s path congested: m sender throttled to minimum guaranteed rate with data cells r bits in RM cell set by switches (“network-assisted”) m NI bit: no increase in rate (mild congestion) m CI bit: congestion indication r RM cells returned to sender by receiver, with bits intact Transport Layer 90

Case study: ATM ABR congestion control r two-byte ER (explicit rate) field in RM cell m congested switch may lower ER value in cell m sender’ send rate thus minimum supportable rate on path r EFCI bit in data cells: set to 1 in congested switch m if data cell preceding RM cell has EFCI set, sender sets CI bit in returned RM cell Transport Layer 91

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 92

TCP Congestion Control r Motivated by ARPANET congestion collapse m Flow control, but no congestion control m Sender sends as much as the receiver resources allows m Go-back-N on loss, burst out advertised window r Congestion control m Extending control to network resources m Underlying design principle: packet conservation • At equilibrium, inject packet into network only when one is removed • Basis for stability of physical systems (fluid model) r Why was this not working before? m No equilibrium • Solved by self-clocking m Spurious retransmissions • Solved by accurate RTO estimation (see earlier discussion) m Network resource limitations not considered • Solved by congestion window and congestion avoidance algorithms Transport Layer 93

TCP Congestion Control r Of all ways to do congestion, the Internet (TCP) chooses…. m Mainly end-host, window-based congestion control • Only place to really prevent collapse is at end-host • Reduce sender window when congestion is perceived • Increase sender window otherwise (probe for bandwidth) m Congestion signaling and detection • Mark/drop packets when queues fill, overflow Transport Layer 94

TCP congestion control basics r Keep a congestion window, (snd_cwnd) m Book calls this “Congwin”, also called just “cwnd” m Denotes how much network is able to absorb m Dynamic, function of perceived network congestion r Receiver’s advertised window (rcv_wnd) m Sent back in TCP header r Sender’s maximum window: m min (rcv_wnd, snd_cwnd) r In operation, sender’s actual window: m min(rcv_wnd, snd_cwnd) - unacknowledged segments Transport Layer 95

TCP Congestion Control r end-end control (no network assistance) m transmission rate limited by congestion window size, cwnd over segments: • Last. Byte. Sent-Last. Byte. Acked cwnd • For fixed window of w segments of MSS bytes length throughput = w * MSS Bytes/sec RTT Transport Layer 96

TCP congestion control r “probing” for usable bandwidth: m m m ideally: transmit as fast as possible (cwnd as large as possible) without loss increase cwnd until loss (congestion) loss: decrease cwnd, then begin probing (increasing) again • loss detected by timeout or 3 duplicate acks r two “phases” (TCP Tahoe) m m slow start congestion avoidance r important variables: – cwnd – ssthresh: defines threshold between two slow start phase, congestion avoidance phase (Book calls this threshold) r useful reference m http: //www. aciri. org/flo yd/papers/sacks. ps. Z Transport Layer 97

TCP slow start r When connection begins, cwnd = 1 MSS m m Example: MSS = 500 bytes & RTT = 200 msec initial rate = 20 kbps r When connection begins, increase rate exponentially fast until first loss event r available bandwidth may be much larger than MSS/RTT m desirable to quickly ramp up to respectable rate Transport Layer 98

TCP slow start Slowstart algorithm RTT initialize: cwnd = 1 for (each segment ACKed) cwnd++ until (loss event OR cwnd > ssthresh) Host A Host B one segm ent two segm ents four segm ents r exponential increase (per RTT) in window size m m Start with cwnd=1, increase cwnd by 1 with every ACK Window doubled every RTT Increases to W in RTT * log 2(W) Can overshoot window and cause packet loss time Transport Layer 99

TCP slow start example One RTT 0 R 1 One pkt time 1 R 1 2 3 2 R 2 3 4 5 3 R 4 6 7 5 8 9 6 10 11 7 12 13 14 15 Transport Layer 100

TCP slow start sequence plot. . . Sequence No pkt sent ack recv’d Time Transport Layer 101

TCP congestion avoidance Q: When should the exponential increase switch to linear? r If loss occurs when cwnd = W m m Network can handle 0. 5 W ~ W segments If loss detected by timeout • Retransmit lost packet • Set ssthresh to 0. 5 W and slow-start from cwnd=1 m If loss detected by 3 dupacks • Tahoe: (same as above) • Reno: Set ssthresh to 0. 5 W and cwnd=0. 5 W r Upon receiving ACK with cwnd > ssthresh m m Increase cwnd by 1/cwnd Results in additive increase r Loss implies congestion – why? m Not necessarily true on all link types Transport Layer 102

Refinement (TCP congestion avoidance) Congestion avoidance /* slowstart is over */ /* cwnd > ssthresh */ Until (loss event) { every w segments ACKed: cwnd++ } ssthresh = cwnd/2 If (Tahoe) cwnd=1; If (Reno) cwnd=ssthresh; TCP Reno halves cwnd and skips slowstart after three duplicate ACKs “Fast Recovery” mechanism => more later Transport Layer 103

TCP congestion avoidance plot Sequence No Time Transport Layer 104

TCP fast retransmit r Timeouts (see previous) r Duplicate acknowledgements (dupacks) m Repeated acks for the same sequence number m When can duplicate acks occur? • Loss • Packet re-ordering • Window update – advertisement of new flow control window r Fast retransmit m Assume re-ordering is infrequent and not of large magnitude m Use receipt of 3 or more duplicate acks as indication of loss m Don’t wait for timeout to retransmit packet Transport Layer 105

TCP fast retransmit X Sequence No Retransmission Duplicate Acks Time Transport Layer 106

TCP Reno’s fast recovery r Do not revert to slow-start on fast retransmit r After 3 dup ACKs: Trigger retransmission (fast retransmission) m cwnd is cut in half m Go directly into congestion avoidance (window grows linearly) r But after timeout event: m cwnd instead set to 1 MSS; m Threshold set to 0. 5 W m Window then grows exponentially to threshold, then grows linearly Philosophy: m q 3 dup ACKs indicates network capable of delivering some segments q timeout indicates a “more alarming” congestion scenario Transport Layer 107

Fast recovery implementation issues r Cumulative acknowledgments freeze window after fast retransmit m m On a single loss, get almost a window’s worth of duplicate acknowledgements Dividing cwnd abruptly in half further reduces sender’s ability to transmit r Need to transition smoothly into congestion avoidance m Each duplicate ack notifies sender that single packet has cleared network r Implementation m Inflate window temporarily while recovering lost segment m Allow new packets out with each subsequent duplicate acknowledgement to maintain self-clocking m Deflate window to cwnd/2 after lost packet is recovered m See extra slides for detail Transport Layer 108

TCP fast retransmit & recovery (Reno) r Combining congestion avoidance, fast retrasmit, and fast recovery gives…. increase: increase cwnd by 1 MSS every RTT until loss detected m multiplicative decrease: cut cwnd in half after loss Saw tooth behavior: probing for bandwidth congestion window size m additive Transport Layer 109

Interaction of flow and congestion control r Sender’s max window m min (advertised window, congestion window) m Question: • Can flow control mechanisms interact poorly with congestion control mechanisms? m Answer: • Yes…. . Delayed acknowledgements and congestion windows r Delayed Acknowledgements m TCP congestion control triggered by acks • If receive half as many acks -> window grows half as fast m Slow start with window = 1 • Will trigger delayed ack timer • First exchange will take at least 200 ms • Start with > 1 initial window – Bug in BSD, now a “feature”/standard Transport Layer 110

Summary: TCP Congestion Control r When cwnd is below ssthresh, sender in slow- start phase, window grows exponentially. r When cwnd is above ssthresh, sender is in congestion-avoidance phase, window grows linearly. r When a triple duplicate ACK occurs, retransmission occurs (fast retransmit) m ssthresh set to cwnd/2 and cwnd set to ssthresh. (fast recovery) r When timeout occurs, ssthresh set to cwnd/2 and cwnd is set to 1 MSS. Transport Layer 111

Summary: TCP congestion control State Event TCP Sender Action Commentary Slow Start (SS) ACK receipt Cong. Win = Cong. Win + MSS, for previously If (Cong. Win > Threshold) unacked data set state to “Congestion Avoidance” Resulting in a doubling of Cong. Win every RTT Congestion Avoidance (CA) ACK receipt Cong. Win = Cong. Win+MSS * for previously (MSS/Cong. Win) unacked data Additive increase, resulting in increase of Cong. Win by 1 MSS every RTT SS or CA Loss event detected by triple duplicate ACK Threshold = Cong. Win/2, Cong. Win = Threshold, Set state to “Congestion Avoidance” Fast recovery, implementing multiplicative decrease. Cong. Win will not drop below 1 MSS. SS or CA Timeout Threshold = Cong. Win/2, Cong. Win = 1 MSS, Set state to “Slow Start” Enter slow start SS or CA Duplicate ACK Increment duplicate ACK count for segment being acked Cong. Win and Threshold not changed Transport Layer 112

TCP throughput r What’s the average throughout of TCP as a function of window size and RTT? m Ignore slow start r Let 2 W be the window size when loss occurs. r When window is 2 W, throughput is 2 W/RTT r Just after loss, window drops to W, throughput to W/RTT. r Average throughout: 1. 5 W/RTT Transport Layer 113

TCP throughput Slow-start Congestion avoidance Fast Retransmit/Recovery 2 W 4 W+1 W 2 1 RTT RTT Transport Layer 114

Goals revisited: TCP Fairness goal: if K TCP sessions share same bottleneck link of bandwidth R, each should have average rate of R/K TCP connection 1 TCP connection 2 bottleneck router capacity R Transport Layer 115

Basic Control Model r Does TCP’s congestion control algorithm promote fairness between flows? Transport Layer 116

Linear Control r Many different possibilities for reaction to congestion and probing m Examine simple linear controls m Window(t + 1) = a + b Window(t) m Different ai/bi for increase and ad/bd for decrease r Supports various reaction to signals m Increase/decrease additively m Increase/decrease multiplicatively m Which of the four combinations is optimal? Transport Layer 117

Phase plots r Simple way to visualize behavior of competing connections over time Fairness Line User 2’s Allocation x 2 Efficiency Line User 1’s Allocation x 1 Transport Layer 118

Phase plots r What are desirable properties? r What if flows are not equal? Fairness Line Overload User 2’s Allocation x 2 Optimal point Underutilization Efficiency Line User 1’s Allocation x 1 Transport Layer 119

Additive Increase/Decrease r Both X 1 and X 2 increase/decrease by the same amount over time m Additive increase improves fairness and additive decrease reduces fairness Fairness Line T 1 User 2’s Allocation x 2 T 0 Efficiency Line User 1’s Allocation x 1 Transport Layer 120

Multiplicative Increase/Decrease r Both X 1 and X 2 increase by the same factor over time m Extension from origin – constant fairness Fairness Line T 1 User 2’s Allocation x 2 T 0 Efficiency Line User 1’s Allocation x 1 Transport Layer 121

Convergence to Efficiency & Fairness r From any point, want to converge quickly to intersection of fairness and efficiency lines Fairness Line x. H User 2’s Allocation x 2 Efficiency Line User 1’s Allocation x 1 Transport Layer 122

Why is TCP Reno fair? Recall phase plot discussion with two competing sessions: r Additive increase gives slope of 1, as throughout increases r multiplicative decreases throughput proportionally equal bandwidth share Connection 2 throughput R loss: decrease window by factor of 2 congestion avoidance: additive increase Connection 1 throughput R Transport Layer 123

What is the Right Choice? r Constraints limit us to AIMD moves towards optimal point Fairness Line x 1 User 2’s Allocation x 2 x 0 x 2 Efficiency Line User 1’s Allocation x 1 Transport Layer 124

Fairness (more) Fairness and UDP r Multimedia apps often do not use TCP m do not want rate throttled by congestion control r Instead use UDP: m pump audio/video at constant rate, tolerate packet loss r Research area: TCP friendly Fairness and parallel TCP connections r nothing prevents app from opening parallel connections between 2 hosts. r Web browsers do this r Example: link of rate R supporting 9 cnctions; m m new app asks for 1 TCP, gets rate R/10 new app asks for 11 TCPs, gets R/2 ! Transport Layer 125

Advanced transport topics r Long fat pipes m Example: 1500 byte segments, 100 ms RTT, want 10 Gbps throughput m BW*Delay = 10 Gbs * 0. 1 s = 1 Gbit • In packets, W=83, 333 • In bytes, 1 Gbit/8 = 125 MB m Problem #1: 16 -bit advertised window field (in bytes) • Maximum of 64 KB !! • Solution: TCP window scaling option – Scaling factor on advertised window specifies # of bits to shift to the left – Scaling factor exchanged during connection setup Transport Layer 126

Advanced transport topics r Long fat pipes m Problem #2: 32 -bit sequence/ack number wraparound • • Recall maximum window must be less than ½ seq. no. space 10 Mbs: 57 min. , 100 Mbs: 6 min. , 622 Mbs: 55 sec. < MSL! Use timestamp option to disambiguate TCP sequence number wraparound (TCP PAWS) Transport Layer 127

Advanced transport topics r Long fat pipes m Problem #3: TCP Sawtooth for large W • For sawtooth W to 2 W • Packets xferred in sawtooth – W + (W+1) + (W+2) …. + 2 W = (3 W/2) * (W+1) = 1. 5 W(W+1) – For W=83, 333 » Packets xferred in sawtooth between losses = 10. 4 billion » Loss rate = 1 packet loss per sawtooth ➜ L = 10 -10 Wow • Sawtooth length = W*RTT – For W=83, 333 and RTT=100 ms, sawtooth length over 2 hours – Average connection throughput ¾ of capacity • Solution: new versions of TCP for high-speed – HS-TCP, FAST TCP, etc. Transport Layer 128

Advanced transport topics r Better congestion control algorithms m TCP increases rate until loss m TCP Vegas: avoid losses by backing off sending rate when delays increase r Short transfers slow m Flows timeout on loss if cwnd < 3 • Change dupack threshold for small cwnd m 3 -4 packet flows (most HTTP transfers) need 2 -3 roundtrips to complete • Use larger initial cwnd (IETF approved initial cwnd = 3 or 4) r Non-TCP traffic m Multimedia applications do not work well over TCP’s sawtooth m TCP-friendly rate control (TFRC) m Derive smooth, stable equilibrium rate via equations based on loss rate Transport Layer 129

Advanced transport topics r Explicit network congestion signalling m TCP uses implicit information to fix sender’s rate • Packet loss reduces rate • Successful packet transmissions increase rate m ATM • Explicitly signal rate from network elements m TCP with ECN • Add bit in IP header to signal congestion (hybrid between TCP approach and ATM approach) r Active queue management m Congestion signal the result of congestion not a signal of imminent congestion m Actively detect and signal congestion beforehand Transport Layer 130

Advanced transport topics r Congestion information sharing m Individual connections each probe for bandwidth (to set ssthresh) m Share information between connections on same machine or nearby machines (SPAND, Congestion Manager) r Non-responsive, aggressive applications m Applications written to take advantage of network resources (multiple TCP connections) m Network-level enforcement, end-host enforcement of fairness r Ambiguous acknowledgements m TCP SACK (Selective acknowledgements) Transport Layer 131

Advanced transport topics r Redundant header fields m Many header fields fixed or change slightly • TCP header compression • Compress header to save bandwidth r RTT ambiguity for retransmitted packets m TCP timestamp option m Sender puts timestamp in packet that receiver echoes r Asymmetric pipes m TCP over highly asymmetric links is limited by ACK throughput (40 byte ack for every MTU-sized segment) m Coalesce multiple acknowledgements into single one r Wireless networks m TCP infers loss on wireless links as congestion and backs off m Add link-layer retransmission and explicit loss Transport Layer notification (to squelch RTO) 132

Advanced transport topics r Security m Layer underneath application layer and above transport layer (See Chapter 8) m SSL, TLS m Provides TCP/IP connection the following…. • • m Data encryption Server authentication Message integrity Optional client authentication Original implementation: Secure Sockets Layer (SSL) • Netscape (circa 1994) • http: //www. openssl. org/ for more information • Submitted to W 3 and IETF m New version: Transport Layer Security (TLS) • http: //www. ietf. org/html. charters/tls-charter. html Transport Layer 133

Chapter 3: Summary r principles behind transport layer services: m multiplexing, demultiplexing m reliable data transfer m flow control m congestion control r instantiation and implementation in the Internet m UDP m TCP Next: r leaving the network “edge” (application, transport layers) r into the network “core” Transport Layer 134

Extra slides Transport Layer 135

Internet transport-layer protocols r reliable, in-order delivery (TCP) network data link physical po s an rt no-frills extension of “best-effort” IP network data link physical tr m d en d- delivery: UDP en r unreliable, unordered al m network data link physical ic m congestion control flow control connection setup g lo m application transport network data link physical Transport Layer 136

Reliable data transfer: getting started rdt_send(): called from above, (e. g. , by app. ). Passed data to deliver to receiver upper layer send side udt_send(): called by rdt, to transfer packet over unreliable channel to receiver deliver_data(): called by rdt to deliver data to upper receive side rdt_rcv(): called when packet arrives on rcv-side of channel Transport Layer 137

Reliable data transfer: getting started We’ll: r incrementally develop sender, receiver sides of reliable data transfer protocol (rdt) r consider only unidirectional data transfer m but control info will flow on both directions! r use finite state machines (FSM) to specify sender, receiver state: when in this “state” next state uniquely determined by next event state 1 event causing state transition actions taken on state transition event actions state 2 Transport Layer 138

Rdt 1. 0: reliable transfer over a reliable channel r underlying channel perfectly reliable m no bit errors m no loss of packets r separate FSMs for sender, receiver: m sender sends data into underlying channel m receiver read data from underlying channel Wait for call from above rdt_send(data) packet = make_pkt(data) udt_send(packet) sender Wait for call from below rdt_rcv(packet) extract (packet, data) deliver_data(data) receiver Transport Layer 139

Rdt 2. 0: channel with bit errors r underlying channel may flip bits in packet m checksum to detect bit errors r the question: how to recover from errors: m acknowledgements (ACKs): receiver explicitly tells sender that pkt received OK m negative acknowledgements (NAKs): receiver explicitly tells sender that pkt had errors m sender retransmits pkt on receipt of NAK r new mechanisms in rdt 2. 0 (beyond rdt 1. 0): m m error detection receiver feedback: control msgs (ACK, NAK) rcvr->sender Transport Layer 140

rdt 2. 0: FSM specification rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && is. NAK(rcvpkt) Wait for call from ACK or udt_send(sndpkt) above NAK rdt_rcv(rcvpkt) && is. ACK(rcvpkt) L sender receiver rdt_rcv(rcvpkt) && corrupt(rcvpkt) udt_send(NAK) Wait for call from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) extract(rcvpkt, data) deliver_data(data) udt_send(ACK) Transport Layer 141

rdt 2. 0: operation with no errors rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && is. NAK(rcvpkt) Wait for call from ACK or udt_send(sndpkt) above NAK rdt_rcv(rcvpkt) && is. ACK(rcvpkt) L rdt_rcv(rcvpkt) && corrupt(rcvpkt) udt_send(NAK) Wait for call from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) extract(rcvpkt, data) deliver_data(data) udt_send(ACK) Transport Layer 142

rdt 2. 0: error scenario rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && is. NAK(rcvpkt) Wait for call from ACK or udt_send(sndpkt) above NAK rdt_rcv(rcvpkt) && is. ACK(rcvpkt) L rdt_rcv(rcvpkt) && corrupt(rcvpkt) udt_send(NAK) Wait for call from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) extract(rcvpkt, data) deliver_data(data) udt_send(ACK) Transport Layer 143

rdt 2. 0 has a fatal flaw! What happens if ACK/NAK corrupted? r sender doesn’t know what happened at receiver! r can’t just retransmit: possible duplicate Handling duplicates: r sender retransmits current pkt if ACK/NAK garbled r sender adds sequence number to each pkt r receiver discards (doesn’t deliver up) duplicate pkt stop and wait Sender sends one packet, then waits for receiver response Transport Layer 144

rdt 2. 1: sender, handles garbled ACK/NAKs rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt) Wait for call 0 from above rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt) L rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || is. NAK(rcvpkt) ) udt_send(sndpkt) Wait for ACK or NAK 0 L Wait for ACK or NAK 1 Wait for call 1 from above rdt_send(data) sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) Transport Layer 145

rdt 2. 1: receiver, handles garbled ACK/NAKs rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 0(rcvpkt) rdt_rcv(rcvpkt) && (corrupt(rcvpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && (corrupt(rcvpkt) sndpkt = make_pkt(NAK, chksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq 1(rcvpkt) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) sndpkt = make_pkt(NAK, chksum) udt_send(sndpkt) Wait for 0 from below Wait for 1 from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 1(rcvpkt) rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq 0(rcvpkt) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) Transport Layer 146

rdt 2. 1: discussion Sender: r seq # added to pkt r two seq. #’s (0, 1) will suffice. Why? r must check if received ACK/NAK corrupted r twice as many states m state must “remember” whether “current” pkt has 0 or 1 seq. # Receiver: r must check if received packet is duplicate m state indicates whether 0 or 1 is expected pkt seq # r note: receiver can not know if its last ACK/NAK received OK at sender Transport Layer 147

rdt 2. 2: a NAK-free protocol r same functionality as rdt 2. 1, using ACKs only r instead of NAK, receiver sends ACK for last pkt received OK m receiver must explicitly include seq # of pkt being ACKed r duplicate ACK at sender results in same action as NAK: retransmit current pkt Transport Layer 148

rdt 2. 2: sender, receiver fragments rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && Wait for call 0 from above rdt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq 1(rcvpkt)) udt_send(sndpkt) Wait for 0 from below ( corrupt(rcvpkt) || is. ACK(rcvpkt, 1) ) udt_send(sndpkt) Wait for ACK 0 sender FSM fragment rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt, 0) receiver FSM fragment L rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 1(rcvpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK 1, chksum) udt_send(sndpkt) Transport Layer 149

rdt 3. 0: channels with errors and loss New assumption: underlying channel can also lose packets (data or ACKs) m checksum, seq. #, ACKs, retransmissions will be of help, but not enough Approach: sender waits “reasonable” amount of time for ACK r retransmits if no ACK received in this time r if pkt (or ACK) just delayed (not lost): m retransmission will be duplicate, but use of seq. #’s already handles this m receiver must specify seq # of pkt being ACKed r requires countdown timer Transport Layer 150

rdt 3. 0 sender rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) start_timer rdt_rcv(rcvpkt) L rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt, 1) rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || is. ACK(rcvpkt, 0) ) timeout udt_send(sndpkt) start_timer rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt, 0) stop_timer timeout udt_send(sndpkt) start_timer L Wait for ACK 0 Wait for call 0 from above L rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || is. ACK(rcvpkt, 1) ) Wait for ACK 1 Wait for call 1 from above rdt_send(data) rdt_rcv(rcvpkt) L sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) start_timer Transport Layer 151

rdt 3. 0 in action Transport Layer 152

rdt 3. 0 in action Transport Layer 153

Performance of rdt 3. 0 r rdt 3. 0 works, but performance stinks r ex: 1 Gbps link, 15 ms prop. delay, 8000 bit packet: m m m U sender: utilization – fraction of time sender busy sending 1 KB pkt every 30 msec -> 33 k. B/sec thruput over 1 Gbps link network protocol limits use of physical resources! Transport Layer 154

rdt 3. 0: stop-and-wait operation sender receiver first packet bit transmitted, t = 0 last packet bit transmitted, t = L / R RTT first packet bit arrives last packet bit arrives, send ACK arrives, send next packet, t = RTT + L / R Transport Layer 155

GBN: sender extended FSM rdt_send(data) L base=1 nextseqnum=1 if (nextseqnum < base+N) { sndpkt[nextseqnum] = make_pkt(nextseqnum, data, chksum) udt_send(sndpkt[nextseqnum]) if (base == nextseqnum) start_timer nextseqnum++ } else refuse_data(data) Wait rdt_rcv(rcvpkt) && corrupt(rcvpkt) timeout start_timer udt_send(sndpkt[base]) udt_send(sndpkt[base+1]) … udt_send(sndpkt[nextseqnum-1]) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) base = getacknum(rcvpkt)+1 If (base == nextseqnum) stop_timer else start_timer Transport Layer 156

GBN: receiver extended FSM default udt_send(sndpkt) L Wait expectedseqnum=1 sndpkt = make_pkt(expectedseqnum, ACK, chksum) rdt_rcv(rcvpkt) && notcurrupt(rcvpkt) && hasseqnum(rcvpkt, expectedseqnum) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(expectedseqnum, ACK, chksum) udt_send(sndpkt) expectedseqnum++ ACK-only: always send ACK for correctly-received pkt with highest in-order seq # m m may generate duplicate ACKs need only remember expectedseqnum r out-of-order pkt: m discard (don’t buffer) -> no receiver buffering! m Re-ACK pkt with highest in-order seq # Transport Layer 157

TCP sender events: data rcvd from app: r Create segment with seq # r seq # is byte-stream number of first data byte in segment r start timer if not already running (think of timer as for oldest unacked segment) r expiration interval: Time. Out. Interval timeout: r retransmit segment that caused timeout r restart timer Ack rcvd: r If acknowledges previously unacked segments m m update what is known to be acked start timer if there are outstanding segments Transport Layer 158

Next. Seq. Num = Initial. Seq. Num Send. Base = Initial. Seq. Num loop (forever) { switch(event) event: data received from application above create TCP segment with sequence number Next. Seq. Num if (timer currently not running) start timer pass segment to IP Next. Seq. Num = Next. Seq. Num + length(data) event: timer timeout retransmit not-yet-acknowledged segment with smallest sequence number start timer event: ACK received, with ACK field value of y if (y > Send. Base) { Send. Base = y if (there are currently not-yet-acknowledged segments) start timer } } /* end of loop forever */ TCP timeout events Comment: • Send. Base-1: last cumulatively ack’ed byte Example: • Send. Base-1 = 71; y= 73, so the rcvr wants 73+ ; y > Send. Base, so that new data is acked Transport Layer 159

Fast retransmit algorithm: event: ACK received, with ACK field value of y if (y > Send. Base) { Send. Base = y if (there are currently not-yet-acknowledged segments) start timer } else { increment count of dup ACKs received for y if (count of dup ACKs received for y = 3) { resend segment with sequence number y } a duplicate ACK for already ACKed segment fast retransmit Transport Layer 160

TCP timeout scenarios (more) Host A Host B Seq=9 timeout 2, 8 by Send. Base = 120 Seq=1 tes da ta =100 K C A 00, 20 bytes data X loss 120 = ACK time Cumulative ACK scenario Transport Layer 161

TCP timeout ambiguity A B Original trans A Original trans mission RTO Sample RTT retran X smiss ACK ion B RTO Sample RTT ACK retran smiss ion X Transport Layer 162

Karn’s algorithm r Accounts for retransmission ambiguity r If a segment has been retransmitted: m Don’t count RTT sample on ACKs for this segment m Keep backed off time-out for next packet m Reuse RTT estimate only after one successful transmission Transport Layer 163

TCP timeout miscellany r TCP timer granularity m Many TCP implementations set RTO in multiples of 200, 500, 1000 ms m Why? • Avoid spurious timeouts – RTTs can vary quickly due to cross traffic • Make timers interrupts efficient Transport Layer 164

TCP connection setup CLOSED passive OPEN CLOSE delete TCB create TCB CLOSE delete TCB LISTEN SYN RCVD rcv SYN snd SYN ACK rcv SYN snd ACK APP SEND snd SYN SENT Rcv SYN, ACK rcv ACK of SYN CLOSE Send FIN active OPEN create TCB Snd SYN Snd ACK ESTAB Transport Layer 165

TCP Connection Tear-down CLOSE send FIN ESTAB rcv FIN send ACK CLOSE WAIT FIN WAIT-1 rcv FIN snd ACK rcv ACK FIN WAIT-2 rcv FIN+ACK snd ACK CLOSE snd FIN CLOSING LAST-ACK rcv ACK of FIN rcv FIN snd ACK TIME WAIT rcv ACK of FIN Timeout=2 msl delete TCB CLOSED Transport Layer 166

TCP Half-Close Sender Receiver FIN-ACK Data write Data ack FIN-ACK Transport Layer 167

TCP Connection Management (cont) TCP server lifecycle TCP client lifecycle Transport Layer 168

TCP slow start (Tahoe) r Start the self-clocking behavior of TCP m Use acks to clock sending new data m Do not send entire advertised window in one shot Pb Pr Sender Receiver As Ab Ar Transport Layer 169

Reno fast recovery example 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 15 16 17 18 19 20 21 22 23 24 cwnd=8 23 base S 22 21 20 19 18 17 16 D Ack 16 (15) Transport Layer 170

Reno fast recovery example 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 base cwnd=8 23 S 22 21 15 16 17 18 19 20 21 22 23 24 20 19 18 17 16 X D Transport Layer 171

Reno fast recovery example 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 base 23 cwnd=8 15 16 17 18 19 20 21 22 23 24 22 21 20 19 18 D S Ack 16 (17) D S Ack 16 Ack 16 (18) (19) (20) (17) (21) (22) (23) 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 15 16 17 18 19 20 21 22 23 24 base cwnd=8 Transport Layer 172

Reno fast recovery example 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 base cwnd=8 15 16 17 18 19 20 21 22 23 24 3 rd Dup. Ack 13 D S Ack 16 Ack 16 (18) (19) (20) (17) (21) (22) (23) 16 D S Ack 16 Ack 16 (19) (20) (21) (22) (23) 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 cwnd_to_use_after_recovery=4 inflated_cwnd=4+3=7 base 15 16 17 18 19 20 21 22 23 24 Transport Layer 173

Reno fast recovery example 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 16 cwnd_to_use_after_recovery=4 inflated_cwnd=8 base 15 16 17 18 19 20 21 22 23 24 D S Ack 16 (20) (21) (22) (23) 24 16 D S Ack 16 (21) (22) (23) 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 cwnd_to_use_after_recovery=4 inflated_cwnd=9 base Transport Layer 174

Reno fast recovery example 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 15 16 17 18 19 20 21 22 23 24 cwnd_to_use_after_recovery=4 inflated_cwnd=12 base 27 26 25 24 D S Ack 24 (16) 27 S 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 cwnd=4 26 25 24 D 15 16 17 18 19 20 21 22 23 24 Transport Layer base 175

TCP Reno fast recovery behavior r Behavior m Sender idle after halving window m Sender continues to get dupacks • Waiting for ½ cwnd worth of dupacks • Window inflation puts “inflated cwnd” at original cwnd after ½ cwnd worth of dupacks • Additional dupacks push “inflated cwnd” beyond original cwnd allowing for additional data to be pushed out during recovery m After pausing for ½ cwnd worth of dupacks • Transmits at original rate after wait • Ack clocking rate is same as before loss m m Results in ½ RTT time idle, ½ RTT time at old rate Upon recovery of lost segment, cwnd deflated to cwnd/2 Transport Layer 176

Reno fast recovery example r What if the retransmission is lost? m Window inflation to support sending at halved rate until eventual RTO r Reference m http: //www. rfc-editor. org/rfc 2001 Transport Layer 177

TCP Reno fast recovery plot Sent for each dupack after W/2 dupacks arrive Sequence No Time Transport Layer 178

TCP Reno and multiple losses r Multiple losses cause timeout in TCP Reno m Sender pulls out of fast recovery after first retransmission X X Sequence No Time Now what? Retransmission timeout Duplicate Acks Transport Layer 179