Chapter 17 Transport Protocols

(1)

William Stallings

Data and Computer

Communications

Chapter 17

(2)

Connection Oriented Transport

Protocol Mechanisms

 _{Logical connection}  _{Establishment}

 _{Maintenance termination}  _Reliable

(3)

Reliable Sequencing Network

Service

 Assume arbitrary length message

 _{Assume virtually 100% reliable delivery by}

network service

 _{e.g. reliable packet switched network}

using X.25

 _{e.g. frame relay using LAPF control}

protocol

 _{e.g. IEEE 802.3 using connection oriented}

LLC service

 _{Transport service is end to end protocol}

(4)

Issues in a Simple Transprot

Protocol

 _Addressing  _Multiplexing  _{Flow Control}

(5)

Addressing

 _{Target user specified by:}  _{User identification}

 _{Usually host, port}

• Called a socket in TCP

 _{Port represents a particular transport service}

(TS) user

 _{Transport entity identification}  _{Generally only one per host}

 _{If more than one, then usually one of each type} • Specify transport protocol (TCP, UDP)

 _{Host address}

 _{An attached network device}

(6)

Finding Addresses

 _{Four methods}

 _{Know address ahead of time}

 _{e.g. collection of network device stats}  _{Well known addresses}

 _{Name server}

 _{Sending process request to well known}

(7)

Multiplexing

 _{Multiple users employ same transport protocol}  _{User identified by port number or service}

access point (SAP)

 _{May also multiplex with respect to network} services used

 _{e.g. multiplexing a single virtual X.25 circuit} to a number of transport service user

(8)

Flow Control

 _{Longer transmission delay between transport} entities compared with actual transmission time

 _{Delay in communication of flow control info}  _{Variable transmission delay}

 _{Difficult to use timeouts}

 _{Flow may be controlled because:}

 _{The receiving user can not keep up}

 _{The receiving transport entity can not keep} up

(9)

Coping with Flow Control

Requirements (1)

 _{Do nothing}

 _{Segments that overflow are discarded}  _{Sending transport entity will fail to get}

ACK and will retransmit

 _{Thus further adding to incoming data}  _{Refuse further segments}

 _Clumsy

 _{Multiplexed connections are controlled}

(10)

Coping with Flow Control

Requirements (2)

 Use fixed sliding window protocol

 _{See chapter 7 for operational details}  _{Works well on reliable network}

 _{Failure to receive ACK is taken as flow}

control indication

 _{Does not work well on unreliable network}  _{Can not distinguish between lost}

segment and flow control

(11)

Credit Scheme

 _{Greater control on reliable network}  _{More effective on unreliable network}  _{Decouples flow control from ACK}

 _{May ACK without granting credit and}

vice versa

 _{Each octet has sequence number}

 _{Each transport segment has seq number,}

(12)

Use of Header Fields

 _{When sending, seq number is that of first}

octet in segment

 _{ACK includes AN=i, W=j}

 _{All octets through SN=i-1 acknowledged}  _{Next expected octet is i}

 _{Permission to send additional window of}

W=j octets

(13)

(14)

(15)

Establishment and Termination

 _{Allow each end to now the other exists}  _{Negotiation of optional parameters}

 _{Triggers allocation of transport entity}

resources

(16)

(17)

(18)

Not Listening

 _{Reject with RST (Reset)}

 _{Queue request until matching open issued}  _{Signal TS user to notify of pending request}

(19)

Termination

 _{Either or both sides}  _{By mutual agreement}  _{Abrupt termination}

 _{Or graceful termination}

 _{Close wait state must accept incoming}

(20)

Side Initiating Termination

 _{TS user Close request}

 _{Transport entity sends FIN, requesting}

termination

 _{Connection placed in FIN WAIT state}

 _{Continue to accept data and deliver}

data to user

 _{Not send any more data}

 _{When FIN received, inform user and close}

(21)

Side Not Initiating Termination

 _{FIN received}

 _{Inform TS user Place connection in CLOSE WAIT} state

 _{Continue to accept data from TS user and} transmit it

 _{TS user issues CLOSE primitive}  _{Transport entity sends FIN}

 _{Connection closed}

 _{All outstanding data is transmitted from both} sides

(22)

Unreliable Network Service

 _E.g.

 _{internet using IP,}

 _{frame relay using LAPF}

 _{IEEE 802.3 using unacknowledged}

connectionless LLC

 _{Segments may get lost}

(23)

Problems

 _{Ordered Delivery}

 _{Retransmission strategy}  _{Duplication detection}

 _{Flow control}

 _{Connection establishment}  _{Connection termination}

(24)

Ordered Delivery

 _{Segments may arrive out of order}  _{Number segments sequentially}

 _{TCP numbers each octet sequentially}

 _{Segments are numbered by the first octet}

(25)

Retransmission Strategy

 _{Segment damaged in transit}  _{Segment fails to arrive}

 _{Transmitter does not know of failure}

 _{Receiver must acknowledge successful}

receipt

 _{Use cumulative acknowledgement}  _{Time out waiting for ACK triggers}

(26)

Timer Value

 _{Fixed timer}

 _{Based on understanding of network behavior}

 _{Can not adapt to changing network conditions}

 _{Too small leads to unnecessary re-transmissions}

 _{Too large and response to lost segments is slow}

 _{Should be a bit longer than round trip time}

 _{Adaptive scheme}

 _{May not ACK immediately}

 _{Can not distinguish between ACK of original}

segment and re-transmitted segment

(27)

Duplication Detection

 _{If ACK lost, segment is re-transmitted}  _{Receiver must recognize duplicates}

 _{Duplicate received prior to closing connection}  _{Receiver assumes ACK lost and ACKs}

duplicate

 _{Sender must not get confused with multiple} ACKs

(28)

(29)

Flow Control

 _{Credit allocation}

 _{Problem if AN=i, W=0 closing window}

 _{Send AN=i, W=j to reopen, but this is lost}  _{Sender thinks window is closed, receiver}

thinks it is open

 _{Use window timer}

 _{If timer expires, send something}

 _{Could be re-transmission of previous}

(30)

Connection Establishment

 _{Two way handshake}

 _{A send SYN, B replies with SYN}

 _{Lost SYN handled by re-transmission}

 _{Can lead to duplicate SYNs}

 _{Ignore duplicate SYNs once connected}

 _{Lost or delayed data segments can cause}

connection problems

 _{Segment from old connections}

 _{Start segment numbers fare removed from}

previous connection

 _{Use SYN i}

 _{Need ACK to include i}

(31)

Two Way

Handshake:

Obsolete

Data

(32)

Two Way Handshake:

(33)

Three Way

Handshake:

State

(34)

(35)

Connection Termination

 _{Entity in CLOSE WAIT state sends last data}

segment, followed by FIN

 _{FIN arrives before last data segment}  _{Receiver accepts FIN}

 _{Closes connection}

 _{Loses last data segment}

 _{Associate sequence number with FIN}

 _{Receiver waits for all segments before FIN}

sequence number

 _{Loss of segments and obsolete segments}

(36)

Graceful Close

 _{Send FIN i and receive AN i}  _{Receive FIN j and send AN j}

 _{Wait twice maximum expected segment}

(37)

Crash Recovery

 _{After restart all state info is lost}  _{Connection is half open}

 _{Side that did not crash still thinks it is} connected

 _{Close connection using persistence timer}  _{Wait for ACK for (time out) * (number of}

retries)

 _{When expired, close connection and inform} user

 _{Send RST i in response to any i segment} arriving

(38)

TCP & UDP

 _{Transmission Control Protocol}  _{Connection oriented}

 _{RFC 793}

 _{User Datagram Protocol (UDP)}  _{Connectionless}

(39)

TCP Services

 _{Reliable communication between pairs of}

processes

 _{Across variety of reliable and unreliable}

networks and internets

 _{Two labeling facilities}

 _{Data stream push}

 _{TCP user can require transmission of all data}

up to push flag

 _{Receiver will deliver in same manner}

 _{Avoids waiting for full buffers}

 _{Urgent data signal}

 _{Indicates urgent data is upcoming in stream}

(40)

(41)

Items Passed to IP

 _{TCP passes some parameters down to IP}  _Precedence

 _{Normal delay/low delay}

 _{Normal throughput/high throughput}  _{Normal reliability/high reliability}

(42)

TCP Mechanisms (1)

 _{Connection establishment}

 _{Three way handshake}  _{Between pairs of ports}

 _{One port can connect to multiple}

(43)

TCP Mechanisms (2)

 _{Data transfer}

 _{Logical stream of octets}

 _{Octets numbered modulo 2}23

 _{Flow control by credit allocation of}

number of octets

 _{Data buffered at transmitter and}

(44)

TCP Mechanisms (3)

 _{Connection termination}

 _{Graceful close}

 _{TCP users issues CLOSE primitive}

 _{Transport entity sets FIN flag on last}

segment sent

 _{Abrupt termination by ABORT primitive}  _{Entity abandons all attempts to send}

or receive data

(45)

Implementation Policy Options

 _Send

 _Deliver  _Accept

(46)

Send

 _{If no push or close TCP entity transmits at}

its own convenience

 _{Data buffered at transmit buffer}

(47)

Deliver

 _{In absence of push, deliver data at own}

convenience

 _{May deliver as each in order segment}

received

 _{May buffer data from more than one}

(48)

Accept

 _{Segments may arrive out of order}  _{In order}

 _{Only accept segments in order}  _{Discard out of order segments}  _{In windows}

 _{Accept all segments within receive}

(49)

Retransmit

 _{TCP maintains queue of segments}

transmitted but not acknowledged

 _{TCP will retransmit if not ACKed in given}

time

 _{First only}  _Batch

(50)

Acknowledgement

 _Immediate

(51)

Congestion Control

 _{RFC 1122, Requirements for Internet hosts}  _{Retransmission timer management}

 _{Estimate round trip delay by observing}

pattern of delay

 _{Set time to value somewhat greater}

than estimate

 _{Simple average}

 _{Exponential average}

 _{RTT Variance Estimation (Jacobson’s}

(52)

Use of

(53)

Jacobson’s

RTO

(54)

Exponential RTO Backoff

 _{Since timeout is probably due to}

congestion (dropped packet or long round trip), maintaining RTO is not good idea

 _{RTO increased each time a segment is}

re-transmitted

 _{RTO = q*RTO}  _{Commonly q=2}

(55)

Karn’s Algorithm

 _{If a segment is re-transmitted, the ACK} arriving may be:

 _{For the first copy of the segment}  _{RTT longer than expected}

 _{For second copy}  _{No way to tell}

 _{Do not measure RTT for re-transmitted} segments

 _{Calculate backoff when re-transmission occurs}  _{Use backoff RTO until ACK arrives for segment}

(56)

Window Management

 _{Slow start}

 _{awnd = MIN[credit, cwnd]}

 _{Start connection with cwnd=1}

 _{Increment cwnd at each ACK, to some max}

 _{Dynamic windows sizing on congestion}

 _{When a timeout occurs}

 _{Set slow start threshold to half current}

congestion window

 _{ssthresh=cwnd/2}

 _{Set cwnd = 1 and slow start until cwnd=ssthresh}

 _{Increasing cwnd by 1 for every ACK}

 _{For cwnd >=ssthresh, increase cwnd by 1 for}

(57)

UDP

 _{User datagram protocol}  _{RFC 768}

 _{Connectionless service for application}

level procedures

 _Unreliable

 _{Delivery and duplication control not}

guaranteed

 _{Reduced overhead}

(58)

UDP Uses

 _{Inward data collection}

 _{Outward data dissemination}  _{Request-Response}

(59)

(60)