Download
slide1 n.
Skip this Video
Loading SlideShow in 5 Seconds..
Chapter 3: Transport Layer PowerPoint Presentation
Download Presentation
Chapter 3: Transport Layer

Chapter 3: Transport Layer

320 Views Download Presentation
Download Presentation

Chapter 3: Transport Layer

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Chapter 3: Transport Layer TransportLayer

  2. our goals: understand principles behind transport layer services: multiplexing, demultiplexing reliable data transfer flow control congestion control learn about Internet transport layer protocols: UDP: connectionless transport TCP: connection-oriented reliable transport TCP congestion control Chapter 3: Transport Layer TransportLayer

  3. 3.1 transport-layer services 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Chapter 3 outline TransportLayer

  4. providelogical (instead of physical!)communication between app processes running on different hosts transport protocols run in end systems send side: breaks app messages into segments, passes to network layer rcv side: reassembles segments into messages, passes to app layer more than one transport protocol available to apps Internet: TCP and UDP application transport network data link physical application transport network data link physical logical end-end transport Transport services and protocols TransportLayer

  5. network layer: logical communication between hosts transport layer: logical communication between processes relies on & enhances network layer services 12 kids in Ann’s house sending letters to 12 kids in Bill’s house: hosts = houses processes = kids app messages = letters in envelopes transport protocol = Ann and Bill collect from/distribute to in-house siblings each week => give to/get from postal service mail carrier network-layer protocol = postal service Transport vs. network layer household analogy: TransportLayer

  6. 3.1 transport-layer services 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Chapter 3 outline TransportLayer

  7. demultiplexing at receiver: use header info to deliver received segments to correct socket (Bill receives batch of mails from carrier and delivers to his brothers and sister) handle data from multiple sockets, add transport header (later used for demultiplexing) multiplexing at sender: Multiplexing/demultiplexing application P1 P2 application application socket P4 P3 transport process network transport transport link network network physical link link physical physical TransportLayer

  8. host receives IP datagrams each datagram has source IP address, destination IP address each datagram carries one transport-layer segment each segment has source, destination port number host uses IP addresses & port numbers to direct segment to appropriate socket How demultiplexing works Remark: wecallpacketsofthenetworklayer DATAGRAMS and packetsofthetransportlayerarecalled SEGMENTS 32 bits source port # dest port # other header fields application data (payload) TCP/UDP segment format TransportLayer

  9. when host receives UDP segment: checks destination port # in segment directs UDP segment to socket with that port # Connectionless demultiplexing • recall: when creating datagram to send into UDP socket, one must specify • destination IP address • destination port # • port number is typically assigned autom. in client app IP datagrams with same dest. port # and same destination IP address,but different source IP addresses and/or source port numbers will be directed to same socket at destination TransportLayer

  10. UDP segm UDP segm UDP segm UDP segm source port: 6428 dest port: 5775 source port: 9157 dest port: 6428 source port: 5775 dest port: 6428 source port: 6428 dest port: 9157 Connectionless demux: example P1: port number 6428 P3: port number 9157 P4: port number 5775 application application application P1 P3 P4 transport transport transport network network network link link link physical physical physical TransportLayer

  11. TCP socket identified by 4-tuple: source IP address source port number dest IP address dest port number demux: receiver uses all four values to direct segment to appropriate socket server host may support many simultaneous TCP sockets: each socket identified by its own 4-tuple web servers have different sockets for each connecting client non-persistent HTTP will have different socket for each request Connection-oriented demux TransportLayer

  12. TCP segm TCP segm TCP segm TCP segm source IP,port: A,9157 dest IP, port: B,80 source IP,port: C,5775 dest IP,port: B,80 source IP,port: B,80 dest IP,port: A,9157 source IP,port: C,9157 destIP,port: B,80 Connection-oriented demux: example application application application P4 P5 P6 P3 P1 P2 transport transport transport network network network link link link physical physical physical server: IP address B host: IP address C host: IP address A three segments, all destined to IP address: B, dest port: 80 are demultiplexed to different sockets (different source IP/source port number!); one process per connection socket TransportLayer

  13. TCP segm TCP segm TCP segm TCP segm source IP,port: A,9157 dest IP, port: B,80 source IP,port: C,9157 destIP,port: B,80 source IP,port: C,5775 dest IP,port: B,80 source IP,port: B,80 dest IP,port: A,9157 Connection-oriented demux: example threaded server application application application P4 P3 P1 P2 transport transport transport network network network link link link physical physical physical server: IP address B host: IP address C host: IP address A three segments, all destined to IP address: B, dest port: 80 are demultiplexed to different sockets (different source IP/source port number!); one THREAD per connection socket TransportLayer

  14. TCP segm TCP segm TCP segm TCP segm source IP,port: A,9157 dest IP, port: B,80 source IP,port: C,9157 destIP,port: B,80 source IP,port: C,5775 dest IP,port: B,80 source IP,port: B,80 dest IP,port: A,9157 Connection-oriented demux: example threaded server application application application P4 P3 P1 P2 transport transport transport network network network link link link physical physical physical server: IP address B host: IP address C host: IP address A Note: during persisent HTTP, same server socket it used during non-persistent HTTP, new TCP connection (=> new socket) for every request/response TransportLayer

  15. 3.1 transport-layer services 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Chapter 3 outline TransportLayer

  16. “no frills,”“bare bones” Internet transport protocol “best effort” service, UDP segments may be: lost delivered out-of-order to app connectionless: no handshaking between UDP sender, receiver each UDP segment handled independently of others UDP: User Datagram Protocol [RFC 768] • UDP use: • streaming multimedia (loss tolerant, rate sensitive) • DNS • Internet phone • real-time video conferencing • reliable transfer over UDP: • add reliability at application layer • application-specific error recovery! TransportLayer

  17. no connection establishment which can add delay (e.g. important for DNS) simple: no connection state at sender, receiver (server can support more active clients) small header size (UDP: 8 bytes, TCP: 20 bytes) no congestion control: UDP can blast away as fast as desired UDP: segment header length: in bytes of UDP segment, including header; max. 16 bits => length of data field <2^16=65536 bytes (minus 8 bytes (UDP header), 20 bytes (IP header – not yet prepended!) 4 x 16 bits = 4 x 2 bytes source port # dest port # checksum length why is there a UDP? application data (payload) UDP segment format TransportLayer

  18. sender: add IP pseudo header (transport layer must inform network layer about destination => certain information known); later ‘real’ IP header is generated treat segment contents, including header fields, as sequence of 16-bit integers checksum: addition of segment contents and one’s complement sender puts checksum value into UDP checksum field receiver: compute checksum of received segment check if computed checksum equals checksum field value: NO - error detected => pass damaged segment to app with warning or discard it YES - no error detected. But maybe errors nonetheless? More later …. UDP checksum Goal: detect “errors” (e.g., flipped bits) in transmitted segment TransportLayer

  19. Internet checksum: example example: add two 16-bit integers 1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 0 1 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1 wraparound sum checksum Note: when adding numbers, a carryout from the most significant bit needs to be added to the result RFC 768 TransportLayer

  20. Internet checksum Why do we have to add the carry from the most significant bit? 4-Bit example: we want to add -5 and -3 in 1’s complement arithmetic +5 is 0101 => -5 is 1010 +3 is 0011 => -3 is 1100 1010 +’ 1100 = (ignoring the carry) 0110 (which is -9) = (with carry) 0111 (which is -8) TransportLayer

  21. Internet checksum (efficient implementation: see RFC 1071) Why is the checksum calculated like this? • Use notation [a,b] for 16-bit integer a⋅28+b, where a and b are bytes • checksum computation corresponds to • [A,B] +' [C,D] +' ... +' [Y,Z] • where +' is1's complement addition • 1’s complement addition has nice properties: - associative property: ( [A,B] +' [C,D] +' ... +' [J,0] ) +' ( [0,K] +' ... +' [Y,Z] ) - commutative property: ( [0,K] +' ... +' [Y,Z] ) +’ ( [A,B] +' [C,D] +' ... +' [J,0] ) - byte orderindependence: [B,A] +' [D,C] +' ... +' [Z,Y] - allowsparallelsummation TransportLayer

  22. 3.1 transport-layer services 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Chapter 3 outline TransportLayer

  23. rdt_send():called from above, (e.g., by app.). Passes data to deliver to receiver at upper layer deliver_data():called by rdt to deliver data to upper udt_send():called by rdt, to transfer packet over unreliable channel to receiver rdt_rcv():called when packet arrives on rcv-side of channel (receive function of the abstract rdt protocol) Reliable data transfer protocols imaginethefollowing (abstract) datatransferprotocol: someabstractupperlayer send side receive side TransportLayer

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

  25. underlying channel perfectly reliable no bit errors no loss of packets separate FSMs for sender and receiver: sender sends data into underlying channel receiver reads data from underlying channel rdt1.0: reliable transfer over a reliable channel rdt_send(data) rdt_rcv(packet) Wait for call from below Wait for call from above extract (packet,data) deliver_data(data) packet = make_pkt(data) udt_send(packet) receiver sender TransportLayer

  26. underlying channel may flip bits in packet checksum to detect bit errors the question: how to recover from errors: acknowledgements (ACKs): receiver explicitly tells sender that pkt received OK negative acknowledgements (NAKs): receiver explicitly tells sender that pkt had errors sender retransmits pkt on receipt of NAK new mechanisms in rdt2.0 (beyond rdt1.0): error detection receiver feedback: control msgs (ACK,NAK) rcvr->sender rdt2.0: channel with bit errors How do humans recover from “errors” during conversation? TransportLayer

  27. underlying channel may flip bits in packet checksum to detect bit errors the question: how to recover from errors: acknowledgements (ACKs): receiver explicitly tells sender that pkt received OK negative acknowledgements (NAKs): receiver explicitly tells sender that pkt had errors sender retransmits pkt on receipt of NAK new mechanisms in rdt2.0 (beyond rdt1.0): error detection feedback: control msgs (ACK,NAK) from receiver to sender rdt2.0: channel with bit errors TransportLayer

  28. Wait for ACK or NAK rdt_rcv(rcvpkt) && corrupt(rcvpkt) stop and wait udt_send(NAK) sender sends one packet, then waits for receiver response Wait for call from below rdt2.0: FSM specification rdt_send(data) receiver sndpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && isNAK(rcvpkt) Wait for call from above udt_send(sndpkt) rdt_rcv(rcvpkt) && isACK(rcvpkt) L sender rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) extract(rcvpkt,data) deliver_data(data) udt_send(ACK) TransportLayer

  29. what happens if ACK/NAK corrupted? sender doesn’t know what happened at receiver! can’t just retransmit: possible duplicate handling duplicates: sender retransmits current pkt if ACK/NAK corrupted sender adds sequence number to each pkt receiver discards (doesn’t deliver up) duplicate pkt rdt2.0 has a fatal flaw! TransportLayer

  30. Wait for ACK or NAK 0 Wait for call 1 from above Wait for ACK or NAK 1 rdt2.1: sender handles corrupted ACK/NAKs sequence numbers 0 and 1 rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || isNAK(rcvpkt) ) Wait for call 0 from above udt_send(sndpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt) L L rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || isNAK(rcvpkt) ) rdt_send(data) sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) udt_send(sndpkt) TransportLayer

  31. Wait for 0 from below Wait for 1 from below rdt2.1: receiver, handles garbled ACK/NAKs rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq0(rcvpkt) extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && (corrupt(rcvpkt) rdt_rcv(rcvpkt) && (corrupt(rcvpkt) sndpkt = make_pkt(NAK, chksum) udt_send(sndpkt) sndpkt = make_pkt(NAK, chksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq1(rcvpkt) rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq0(rcvpkt) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq1(rcvpkt) extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) TransportLayer

  32. sender: seq # added to pkt two seq. #’s (0,1) will sufficesince receiver can distinguish detect retransmission must check if received ACK/NAK corrupted twice as many states state must “remember” whether “expected”ACK is for seq # of 0 or 1 receiver: must check if received packet is duplicate state indicates whether 0 or 1 is expected pktseq # note: receiver can not know if its last ACK/NAK received OK at sender rdt2.1: discussion TransportLayer

  33. same functionality as rdt2.1, using ACKs only instead of NAK, receiver sends ACK for last packet received OK (=> may ACK same paket several times) receiver must explicitly include seq # of packet being ACKed duplicate ACK at sender results in same action as NAK: retransmit current packet rdt2.2: a NAK-free protocol TransportLayer

  34. rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || isACK(rcvpkt,1) ) udt_send(sndpkt) sender FSM fragment rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt,0) Wait for ACK 0 Wait for call 0 from above rdt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq1(rcvpkt)) L receiver FSM fragment udt_send(sndpkt) Wait for 0 from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq1(rcvpkt) extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(ACK1, chksum) udt_send(sndpkt) rdt2.2: sender, receiver fragments TransportLayer

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

  36. Wait for ACK0 Wait for ACK1 Wait for call 1 from above Wait for call 0from above rdt3.0 sender rdt_send(data) rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || isACK(rcvpkt,1) ) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) start_timer L rdt_rcv(rcvpkt) L timeout udt_send(sndpkt) start_timer rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt,1) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt,0) stop_timer stop_timer timeout udt_send(sndpkt) start_timer rdt_rcv(rcvpkt) L rdt_send(data) rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || isACK(rcvpkt,0) ) sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) start_timer L receiver FSM ishomework (do it at home and compare your solution to our solution during the tutorial) TransportLayer

  37. pkt0 pkt0 ack0 ack0 pkt1 pkt1 pkt1 X loss ack1 ack1 pkt0 pkt0 timeout resend pkt1 ack0 ack0 rdt3.0 in action receiver receiver sender sender send pkt0 send pkt0 rcv pkt0 rcv pkt0 send ack0 send ack0 rcv ack0 rcv ack0 send pkt1 send pkt1 rcv pkt1 send ack1 rcv ack1 send pkt0 rcv pkt0 send ack0 rcv pkt1 send ack1 rcv ack1 send pkt0 rcv pkt0 (a) no loss send ack0 (b) packet loss TransportLayer

  38. pkt0 pkt0 pkt0 ack0 ack0 pkt1 pkt1 pkt1 pkt1 ack1 ack1 ack1 X loss pkt0 timeout resend pkt1 timeout resend pkt1 send ack1 ack0 ack1 ack0 rcv ack0 rcv pkt1 rcv pkt0 pkt1 send pkt1 send ack0 send ack1 rcv ack1 ack1 send pkt0 rdt3.0 in action (slide is repaired) receiver sender receiver sender send pkt0 rcv pkt0 send pkt0 send ack0 rcv pkt0 rcv ack0 send ack0 send pkt1 rcv ack0 rcv pkt1 send pkt1 send ack1 rcv pkt1 send ack1 rcv pkt1 (detect duplicate) rcv pkt1 (detect duplicate) send ack1 rcv ack1 send pkt0 rcv pkt0 send ack0 (d) premature timeout/ delayed ACK (c) ACK loss TransportLayer

  39. rdt3.0 is correct, but performance is slow e.g.: 1 Gbpslink (109 bits/sec), from US west to east coast 15 ms prop. delay (RRT=30 ms=30/1000 sec), 8000 bit packet: 8000 bits .008 ms = = Dtrans = 109 bits/sec L R Performance of rdt3.0 • Calculate • U sender: utilization – fraction of time sender busy sending TransportLayer

  40. rdt3.0: stop-and-wait operation sender receiver first packet bit transmitted, t = 0 last packet bit transmitted, t = L / R first packet bit arrives RTT last packet bit arrives, send ACK assumeno transmissiondelay for ACK ACK arrives, send next packet, t = RTT + L / R percentageof time theserverisbusy (withtransmitting) TransportLayer

  41. rdt3.0 is correct, but performance is slow e.g.: 1 Gbpslink (109 bits/sec), from US west to east coast 15 ms prop. delay (RRT=30 ms=30/1000 sec), 8000 bit packet: 8000 bits .008 ms = = Dtrans = 109 bits/sec L R Performance of rdt3.0 • U sender: utilization – fraction of time sender busy sending • throughput = utilization x net bitrate = 270 000 bits/sec • ≈ 34kB/sec throughput over 1 Gbps link • receiver has very slow download rate from that server! TransportLayer

  42. pipelining: sender allows multiple, yet-to-be-acknowledged packets range of sequence numbers must be increased buffering at sender and/or receiver two generic forms of pipelined protocols: go-Back-N, selective repeat Pipelined protocols TransportLayer

  43. Pipelining: increased utilization maximal 3 unacknowledgedpackets in pipeline sender receiver first packet bit transmitted, t = 0 last bit transmitted, t = L / R first packet bit arrives RTT last packet bit arrives, send ACK last bit of 2nd packet arrives, send ACK last bit of 3rd packet arrives, send ACK ACK arrives, send next packet, t = RTT + L / R 3-packet pipelining increases utilization by a factor of 3! TransportLayer

  44. Go-back-N: sender can have up to N unack’ edpackets in pipeline receiver only sends ‘cumulative’ ack doesn’t ack packet if there’s a gap sender has timer for oldest unack’edpacket when timer expires, retransmit allunacked packets Selective Repeat: sender can have up to N unack’edpackets in pipeline rcvr sends individual ack for each packet sender maintains timer for each unacked packet when timer expires, retransmit only that unacked packet Pipelined protocols: overview TransportLayer

  45. k-bit seq # in packet header “window” of up to N, consecutive unack’edpackets allowed Go-Back-N protocol: sender • ACK(n): ACKs all pkts up to, including seq # n - “cumulative ACK” • may receive duplicate ACKs (see receiver) • monitor timer for oldest in-flight pkt • timeout(n): retransmit packet n and all higher seq # pkts in window TransportLayer

  46. Wait GBN: sender extended FSM (slide is repaired) rdt_send(data) if (nextseqnum < base+N) { sndpkt[nextseqnum] = make_pkt(nextseqnum,data,chksum) udt_send(sndpkt[nextseqnum]) start_timer(nextseqnum) nextseqnum++ } else refuse_data(data) L Timeout(base) base=1 nextseqnum=1 restart_timer(base) udt_send(sndpkt[base]) restart_timer(base+1) udt_send(sndpkt[base+1]) … restart_timer(nextseqnum-1) udt_send(sndpkt[nextseqnum-1]) rdt_rcv(rcvpkt) && corrupt(rcvpkt) L rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) base = getacknum(rcvpkt)+1 (drop all timers with # < base) TransportLayer

  47. GBN: receiver extended FSM default udt_send(sndpkt) rdt_rcv(rcvpkt) && notcurrupt(rcvpkt) && hasseqnum(rcvpkt,expectedseqnum) L Wait extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(expectedseqnum,ACK,chksum) udt_send(sndpkt) expectedseqnum++ expectedseqnum=1 sndpkt = make_pkt(0,ACK,chksum) TransportLayer

  48. GBN: receiver extended FSM default udt_send(sndpkt) rdt_rcv(rcvpkt) && notcurrupt(rcvpkt) && hasseqnum(rcvpkt,expectedseqnum) L Wait extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(expectedseqnum,ACK,chksum) udt_send(sndpkt) expectedseqnum++ expectedseqnum=1 sndpkt = make_pkt(0,ACK,chksum) initialize: counter for expected sequence number make initial packet ready for sending but use seqnum 0 in case that 1st packet is corrupt or has wrong number TransportLayer

  49. GBN: receiver extended FSM default udt_send(sndpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && hasseqnum(rcvpkt,expectedseqnum) L Wait extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(expectedseqnum,ACK,chksum) udt_send(sndpkt) expectedseqnum++ expectedseqnum=1 sndpkt= make_pkt(0,ACK,chksum) • if packet arrives that is not corrupt and has the expected seq number: • - extract and deliver data to layer above • send ack • increase seq number TransportLayer

  50. GBN: receiver extended FSM default udt_send(sndpkt) rdt_rcv(rcvpkt) && notcurrupt(rcvpkt) && hasseqnum(rcvpkt,expectedseqnum) L Wait extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(expectedseqnum,ACK,chksum) udt_send(sndpkt) expectedseqnum++ expectedseqnum=1 sndpkt= make_pkt(0,ACK,chksum) if packet arrives that is corrupt or has the wrong seq number: resend ack for last correctly received packet TransportLayer