计算机网络原理英文版课件Chapter3

1、chapter 3: transport layerour goals: runderstand principles behind transport layer services:mmultiplexing/demultiplexingmreliable data transfermflow controlmcongestion controlrlearn about transport layer protocols in the internet:mudp: connectionless transportmtcp: connection-oriented transportmtcp

2、congestion control2/74chapter 3 -transport layerchapter 3 outliner3.1 transport-layer servicesr3.2 multiplexing and demultiplexingr3.3 connectionless transport: udpr3.4 principles of reliable data transfermrdt modelmgbn（go back n）msr（selective repeat ）r3.5 connection-oriented transport: tcpmsegment

3、structuremreliable data transfermflow controlmconnection managementr3.6 principles of congestion controlr3.7 tcp congestion control3/74chapter 3 -transport layertransport services and protocolsrprovide logical communication between app processes running on different hostsrtransport protocols run in

4、end systems msend side: breaks app messages into segments, passes to network layermrcv side: reassembles segments into messages, passes to app layerrmore than one transport protocol available to appsminternet: tcp and udpapplicationtransportnetworkdata linkphysicalapplicationtransportnetworkdata lin

5、kphysicalnetworkdata linkphysicalnetworkdata linkphysicalnetworkdata linkphysicalnetworkdata linkphysicalnetworkdata linkphysicallogical end-end transport4/74chapter 3 -transport layertransport vs. network layerrnetwork layer: logical communication between hostsrtransport layer: logical communicatio

6、n between processes mrelies on , enhances, network layer services5/74chapter 3 -transport layerinternet transport-layer protocolsrreliable, in-order delivery (tcp)mcongestion control mflow controlmconnection setuprunreliable, unordered delivery (udp) :mno-frills extension of “best-effort” ip (不对不对”尽

7、最大努力服务尽最大努力服务” 的的ip协议进行不必要的扩展）协议进行不必要的扩展）rservices not available (qos) : mdelay guaranteesmbandwidth guaranteesapplicationtransportnetworkdata linkphysicalapplicationtransportnetworkdata linkphysicalnetworkdata linkphysicalnetworkdata linkphysicalnetworkdata linkphysicalnetworkdata linkphysicalnetwo

8、rkdata linkphysicallogical end-end transportquality of services6/74chapter 3 -transport layerchapter 3 outliner3.1 transport-layer servicesr3.2 multiplexing and demultiplexingr3.3 connectionless transport: udpr3.4 principles of reliable data transfermrdt modelmgbn（go back n）msr（selective repeat ）r3.

9、5 connection-oriented transport: tcpmsegment structuremreliable data transfermflow controlmconnection managementr3.6 principles of congestion controlr3.7 tcp congestion control7/74chapter 3 -transport layermultiplexing/demultiplexingapplicationtransportnetworklinkphysicalp1applicationtransportnetwor

10、klinkphysicalapplicationtransportnetworklinkphysicalp2p3p4p1host 1host 2host 3= process= socketdelivering received segmentsto correct socketdemultiplexing at rcv host:gathering data from multiple sockets, enveloping data with header (later used for demultiplexing)multiplexing at send host:8/74chapte

11、r 3 -transport layerhow demultiplexing worksrhost receives ip datagramsmeach datagram has source ip address, destination ip addressmeach datagram carries 1 transport-layer segmentip datagram formatdata typically a tcp or udp segmentother header fields32 bit source ip address32 bit destination ip add

12、ress32 bits2b,4.139/74chapter 3 -transport layerhow demultiplexing worksrhost receives ip datagramsmeach segment has source, destination port number rhost uses ip addresses & port numbers to direct segment to appropriate sockettcp/udp segment formatsource port #dest port #32 bitsapplication data (me

13、ssage)other header fieldsdata typically a tcp or udp segmentother header fields32 bit source ip address32 bit destination ip address32 bitsip datagram format10/74chapter 3 -transport layerconnectionless demultiplexingrcreate sockets with port numbers:datagramsocket mysocket1 = new datagramsocket(991

14、11);datagramsocket mysocket2 = new datagramsocket(99222);rudp socket identified by two-tuple:(dest ip address, dest port number)rwhen host receives udp segment:mchecks destination port number in segmentmdirects udp segment to socket with that port numberrip datagrams with different source ip address

15、es and/or source port numbers directed to same socket11/74chapter 3 -transport layerconnectionless demux (cont)datagramsocket serversocket = new datagramsocket(6428);clientip:b9157p2client ip: ap15775p16428p3serverip: csp: 6428dp: 9157datasp: 9157dp: 6428datasp: 6428dp: 5775datasp: 5775dp: 6428datas

16、p provides “return address”12/74chapter 3 -transport layerconnection-oriented demuxrtcp socket identified by 4-tuple: msource ip addressmsource port numbermdest ip addressmdest port numberrrecv host uses all four values to direct segment to appropriate socketrserver host may support many simultaneou

17、s tcp sockets:meach socket identified by its own 4-tuplerweb servers have different sockets for each connecting client13/74chapter 3 -transport layerconnection-oriented demux (cont)clientip:b9157p1client ip: ap15775p280p4serverip: csp: 9157dp: 80sp: 9157dp: 8080p580p69157p3d-ip:cs-ip: ad-ip:cs-ip: b

18、sp: 5775dp: 80d-ip:cs-ip: bweb serverthread/subprocess14/74chapter 3 -transport layerchapter 3 outliner3.1 transport-layer servicesr3.2 multiplexing and demultiplexingr3.3 connectionless transport: udpr3.4 principles of reliable data transfermrdt modelmgbn（go back n）msr（selective repeat ）r3.5 connec

19、tion-oriented transport: tcpmsegment structuremreliable data transfermflow controlmconnection managementr3.6 principles of congestion controlr3.7 tcp congestion control15/74chapter 3 -transport layerudp: user datagram protocol rfc 768r“best effort” service, udp segments may be:mlostmdelivered out of

20、 order to apprconnectionless:mno handshaking between udp sender, receivermeach udp segment handled independently of otherswhy is there a udp?rno connection establishment (which can add delay)rsimple: no connection state at sender, receiverrsmall segment headerrno congestion control: udp can blast aw

21、ay (拼命）as fast as desired16/74chapter 3 -transport layerudp: moreroften used for streaming multimedia appsmloss tolerantmrate sensitiverother udp usesmdnsmsnmprreliable transfer over udp: add reliability at application layermapplication-specific error recovery!source port #dest port #32 bitsapplicat

22、iondata (message)udp segment formatlengthchecksumlength, inbytes of udpsegment,includingheader17/74chapter 3 -transport layerudp checksumsender:rtreat segment contents as sequence of 16-bit integersrchecksum: addition (1s complement sum) of segment contentsrsender puts checksum value into udp checks

23、um fieldreceiver:rcompute checksum of received segmentrif computed checksum equals checksum field value:mno error detectedmbut maybe errorsgoal: detect “errors” in transmitted segment18/74chapter 3 -transport layerinternet checksum examplernotemwhen adding numbers, a carry from the most significant

24、bit needs to be added to the resultrexample: add two 16-bit integers1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 11 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 11 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1wrap aroundsumchecksum119/74chapter 3 -transport layerinternet chec

25、ksum examplerexample: add three 16-bit integers, 0110011001100000,0101010101010101,1000111100001100 0 1 1 0 0 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 0 1 1 0 0 0 1 1 1 1 0 0 0 0 1 1 0 01 0 1 0 0 1 0 1 0 1 1 0 0 0 0 0 11 0 1 0 0 1 0 1 0 1 1 0 0 0 0 1 01 1 0 1

26、 1 0 1 0 1 0 0 1 1 1 1 0 1wrap aroundsumchecksum1+20/74chapter 3 -transport layerchapter 3 outliner3.1 transport-layer servicesr3.2 multiplexing and demultiplexingr3.3 connectionless transport: udpr3.4 principles of reliable data transfermrdt modelmgbn（go back n）msr（selective repeat ）r3.5 connection

27、-oriented transport: tcpmsegment structuremreliable data transfermflow controlmconnection managementr3.6 principles of congestion controlr3.7 tcp congestion control21/74chapter 3 -transport layerreliable data transfer: getting startedrdt：sendsiderdt: receiveside rdt_send(): called from above, (e.g.,

28、 by app.). passed data to deliver to receiver upper layerudt_send(): called by rdt,to transfer packet over unreliable channel to receiverrdt_rcv(): called when packet arrives on rcv-side of channeldeliver_data(): called by rdt to deliver data to upper22/74chapter 3 -transport layerchapter 3 outliner

29、3.1 transport-layer servicesr3.2 multiplexing and demultiplexingr3.3 connectionless transport: udpr3.4 principles of reliable data transfermrdt modelmgbn（go back n）msr（selective repeat ）r3.5 connection-oriented transport: tcpmsegment structuremreliable data transfermflow controlmconnection managemen

30、tr3.6 principles of congestion controlr3.7 tcp congestion control23/74chapter 3 -transport layergo-back-n (gbn)rslide windowsender:v k-bit seq # in pkt header：seq#=0-2k-1v “window” of up to n, consecutive unacked pkts allowedk-bit seq #other headerdata012345678 2k-1?n个包basenextseqnumbase+n0,base-10,

31、base-1已经被确认的包已经被确认的包base,nextseqnum-1base,nextseqnum-1还没有被确认的包还没有被确认的包nextseqnum,base+n-1nextseqnum,base+n-1还可以发送的包还可以发送的包base+n,base+n,不能发送的包不能发送的包连续的未被确认的包的最大数量连续的未被确认的包的最大数量（序号窗口、窗口、滑动窗口）（序号窗口、窗口、滑动窗口）24/74chapter 3 -transport layergo-back-n (gbn)nextseqnumbase+nbasebasenextseqnumbase+nbasenextse

32、qnumbase+n收到base包的ack后：收到base包的ack后：rslide window25/74chapter 3 -transport layergo-back-n(gbn)rack(n): acks all pkts up to, including seq # n - “cumulative ack (累计确认）”mmay receive duplicate acks (see receiver)rtimer: running at sender side so that time for base pktrtimeout: sender resend all pkts th

33、at have been previously sent but that have not yet been ackedacked26/74chapter 3 -transport layergbn: sender fsm(finite-state-machine)waitstart_timerudt_send(sndpktbase)udt_send(sndpktbase+1)udt_send(sndpktnextseqnum-1)timeoutrdt_send(data) if (nextseqnum no receiver buffering!mre-ack pkt with highe

34、st in-order seq #waitudt_send(sndpkt)defaultrdt_rcv(rcvpkt) & notcurrupt(rcvpkt) & hasseqnum(rcvpkt,expectedseqnum) extract(rcvpkt,data)deliver_data(data)sndpkt = make_pkt(expectedseqnum,ack,chksum)udt_send(sndpkt)expectedseqnum+expectedseqnum=1sndpkt = make_pkt(expectedseqnum,ack,chksum)lexpectedse

35、qnumexpectedseqnum发送窗口尺寸为n，接收窗口尺寸为1。q: n的最大值？28/74chapter 3 -transport layer28gbn in action 4 5 6 7 8 9pkt0 sent0 2 3 4 5 6 7 8 9pkt0 rcvd,delivered,ack0 sent, w1 4 5 6 7 8 9pkt1 sent0 1 3 4 5 6 7 8 9pkt1 rcvd,delivered,ack1 sent,w2 4 5 6 7 8 9pkt2 sent 4 5 6 7 8 9pkt3 sent, window full0 13 4 5 6 7

36、8 9pkt3 rcvd,discard, ack1 sent0 5 6 7 8 9ack0 rcvd,pkt4 sent0 13 4 5 6 7 8 9pkt4 rcvd,discard,ack1 sent0 1 6 7 8 9ack1 rcvd, pk5 sent0 13 4 5 6 7 8 9pkt5 rcvd,discard,ack1 sent0 1 6 7 8 9pkt2 timeout, sent pkt2/3/4/50 1 2 3 4 57 8 9pkt2/3/4/5 rcvd,delivered,ack2/3/4/5sentxw6w=expectedseqnum29/74cha

37、pter 3 -transport layerchapter 3 outliner3.1 transport-layer servicesr3.2 multiplexing and demultiplexingr3.3 connectionless transport: udpr3.4 principles of reliable data transfermrdt modelmgbn（go back n）msr（selective repeat ）r3.5 connection-oriented transport: tcpmsegment structuremreliable data t

38、ransfermflow controlmconnection managementr3.6 principles of congestion controlr3.7 tcp congestion control30/74chapter 3 -transport layerselective repeat (sr)rreceiver individually acknowledges all correctly received pktsmbuffers pkts, as needed, for eventual in-order delivery to upper layerrsender

39、only resends pkts for which ack not receivedmsender timer for each unacked pktrsender windowmn consecutive seq #srreceiver windowmn consecutive seq #s also31/74chapter 3 -transport layerselective repeat: sender, receiver windowsack延迟或丢失ack已经收到ack未发出，因pkt未到或丢失pkt未按序到达，而ack已收到32/74chapter 3 -transport

40、 layerselective repeat (sr)data from above :rif nextseqnum sendbase) sendbase = y if (there are currently not-yet-acknowledged segments) start timer /* end of loop forever */ 52/74chapter 3 -transport layertcp: retransmission scenarioshost aseq=92, 8 bytes dataack=100losstimeoutlost ack scenariohost

41、 bxseq=92, 8 bytes dataack=100timesendbase= 100host aseq=100, 20 bytes dataack=100timepremature timeouthost bseq=92, 8 bytes dataack=120seq=92, 8 bytes dataseq=92 timeoutack=120seq=92 timeoutsendbase= 120sendbase= 120sendbase= 10053/74chapter 3 -transport layertcp retransmission scenarios (more)host

42、 aseq=92, 8 bytes dataack=100losstimeoutcumulative ack scenariohost bxseq=100, 20 bytes dataack=120timesendbase= 12054/74chapter 3 -transport layertcp ack generation rfc 1122, rfc 2581event at receiverarrival of in-order segment with expected seq #. all data up to expected seq # already ackedarrival

43、 of in-order segment with expected seq #. one other segment has ack pendingarrival of out-of-order segment higher-than-expect seq. # . gap detectedarrival of segment that partially or completely fills gaptcp receiver actiondelayed ack. wait up to 500ms for next segment. if next in-order segment does

44、 not arrive in this interval, send an ackimmediately send single cumulative ack, acking both in-order segments immediately send duplicate ack, indicating seq. # of next expected byteimmediate send ack, provided that segment starts at lower end of gap推迟确认，以利用累计确认机制，推迟确认，以利用累计确认机制，减少减少ack包的数量包的数量对多个按序

45、到达的包进行累计确认对多个按序到达的包进行累计确认因延迟或丢失，有比该序号低的段未因延迟或丢失，有比该序号低的段未到达，重发到达，重发ack指示发送方重发某段指示发送方重发某段重发的包成功到达，用重发的包成功到达，用ack指示发指示发送方重发哪个序号的包送方重发哪个序号的包55/74chapter 3 -transport layerfast retransmitrtime-out period often relatively long:mlong delay before resending lost packetrdetect lost segments via duplicate ac

46、ks.msender often sends many segments back-to-backmif segment is lost, there will likely be many duplicate acks.rif sender receives 3 acks for the same segment, it supposes that segment after acked data was lost:mfast retransmit: resend segment before timer expires56/74chapter 3 -transport layer even

47、t: 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 dup acks received for y if (count of dup acks received for y = 3) resend segment with sequence number y fast retransmit algorithm:a dupli

48、cate ack for already acked segmentfast retransmit57/74chapter 3 -transport layerchapter 3 outliner3.5 connection-oriented transport: tcpmsegment structuremreliable data transfermflow controlmconnection managementr3.6 principles of congestion controlr3.7 tcp congestion controlr3.1 transport-layer ser

49、vicesr3.2 multiplexing and demultiplexingr3.3 connectionless transport: udpr3.4 principles of reliable data transfermrdt modelmgbn（go back n）msr（selective repeat ）58/74chapter 3 -transport layertcp flow controlrreceive side of tcp connection has a receive buffer:rspeed-matching service: matching the

50、 send rate to the receiving apps drain raterapp process may be slow at reading from buffersender wont overflowreceivers buffer bytransmitting too much, too fastflow control59/74chapter 3 -transport layertcp flow control: how it works(suppose tcp receiver discards out-of-order segments)rspare room si

51、ze in buffer is rcvwindowrcvwindow=rcvbuffer-lastbytercvd-lastbytereadrrcvr advertises spare room by including value of rcvwindow in segmentsrsender limits unacked data to rcvwindowmguarantees receive buffer doesnt overflow60/74chapter 3 -transport layerchapter 3 outliner3.5 connection-oriented tran

52、sport: tcpmsegment structuremreliable data transfermflow controlmconnection managementr3.6 principles of congestion controlr3.7 tcp congestion controlr3.1 transport-layer servicesr3.2 multiplexing and demultiplexingr3.3 connectionless transport: udpr3.4 principles of reliable data transfermrdt model

53、mgbn（go back n）msr（selective repeat ）61/74chapter 3 -transport layertcp connection managementrecall: tcp sender, receiver establish “connection” before exchanging data segmentsrinitialize tcp variables:mseq. #smbuffers, flow control info (e.g. rcvwindow)rclient: connection initiator socket clientsoc

54、ket = new socket(hostname,port number); rserver: contacted by client socket connectionsocket = welcomesocket.accept();create connectionthree way handshake:step 1: client host sends tcp syn segment to servermspecifies initial seq #mno datastep 2: server host receives syn, replies with synack segmentm

55、specifies server initial seq. #step 3: client receives synack, replies with ack segment, which may contain datamserver allocates bufferssyn synchronization62/74chapter 3 -transport layer62r create tcp connectionthree way handshakerequest(syn=1，seq=client_isn)syn=1,seq=server_isn,ack=cliect_isn+1syn=

56、0,seq=client_isn+1,ack=server_isn+1serverclientok,connectedok,connectedisn=initial sequence numbertcp connection management (cont.) conn granted仅仅是“准许”连接！synack segmentsyn segment63/74chapter 3 -transport layer63request(syn=1，seq=client_isn)syn=1,seq=server_isn,ack=cliect_isn+1serverclienti dont kno

57、wn!ok,accept it!isn=initial sequence numberok,connectedcommunicatingresent request(syn=1，seq=client_isn)ok,accept it!r create tcp connectionthree way handshaketcp connection management (cont.) timeout64/74chapter 3 -transport layertcp connection management (cont.)r closing a connection:client closes

58、 socket: clientsocket.close(); v step 1: client sends tcp fin control segment to server v step 2: server receives fin, replies with ack. closes connection, sends fin. clientfinserverackackfinclosecloseclosedtimed waitfinfinish65/74chapter 3 -transport layertcp connection management (cont.)v step 3:

59、client receives fin, replies with ack. menters “timed wait” - will respond with ack to received fins v step 4: server, receives ack. connection closed. clientfinserverackackfinclosingclosingclosedtimed waitclosed66/74chapter 3 -transport layertcp connection management (cont)tcp clientlifecycle67/74c

60、hapter 3 -transport layertcp connection management (cont)tcp serverlifecycle68/74chapter 3 -transport layerchapter 3 outliner3.5 connection-oriented transport: tcpmsegment structuremreliable data transfermflow controlmconnection managementr3.6 principles of congestion controlr3.7 tcp congestion cont