CSS432: End-to-End Protocols 1

CSS432 End-to-End Protocols Textbook Ch5.1 – 5.2

Professor: Munehiro Fukuda

2

IP Protocols Underlying best-effort network

drop messages re-orders messages delivers duplicate copies of a given message limits messages to some finite size delivers messages after an arbitrarily long delay

M5, M4, M3, M2, M1 M5, M2, M1

M4, M3 M4

M3

M2, M1, M4M5

Request a retransmission of M3 and M5

M5, and M3M5, M5, M3

CSS432: End-to-End Protocols

3

Simple Demultiplexor (UDP) Unreliable and unordered datagram service Adds multiplexing No flow control Endpoints identified by ports

servers have well-known ports see /etc/services on Unix

Header format

Optional checksum psuedo header + UDP header + data

SrcPort DstPort

Checksum Length

Data

0 16 31

CSS432: End-to-End Protocols

4

UDP: Simple Demultiplexerint sd;sd = socket(AF_INET, SOCK_DGRAM, 0);

struct sockaddr_in server;server.sin_family =AF_INET;server.sin_addr.s_addr = htonl( INADDR_ANY)server.sin_port = htons( 12345 );bind( sd, (struct sockaddr *)&server, sizeof( server ) );

recv( sd, buf, sizeof( buf ), 0 );

struct sockaddr_in server;struct hostent *hp, *gethostbyname( );Server.sin_family = AF_INET;hp = gethostbyname( );bcopy( hp->h_addr, &( server.sin_addr.s_addr ), sizeof( hp->h_length) );server.sin_port = htons( 12345 );

sendto( sd, buf, sizeof( buf ), 0, (struct sockaddr *)&server, sizeof( server ) );

socket()

sendto()

socket()

bind()

recv()

Port:12345

socket()

bind()

recv()

Port: 13579

13579

13579

UDP

Packetsdemultiplexed

M5, M4, M3, M2, M1CSS432: End-to-End Protocols

5

End-to-End Protocols Common end-to-end services

guarantee message delivery deliver messages in FIFO order deliver at most one copy of each message support arbitrarily large messages support synchronization allow the receiver to flow control the sender support multiple application processes on each host

P1 P2 P3 P4

NetworkM5, M4, M3, M2, M1

m5, m4, m3, m2, m1

CSS432: End-to-End Protocols

6

TCP Overview Connection-oriented Byte-stream

app writes bytes TCP sends

segments app reads bytes

Application process

Writebytes

TCPSend buffer

Segment Segment Segment

Transmit segments

Application process

Readbytes

TCPReceive buffer

…

… …

Full duplex Flow control: keep sender from

overrunning receiver Congestion control: keep sender

from overrunning network

CSS432: End-to-End Protocols

7

Sockets (Code Example)int sd, newSd;sd = socket(AF_INET, SOCK_STREAM, 0);

sockaddr_in server;bzero( (char *)&server, sizeof( server ) );server.sin_family =AF_INET;server.sin_addr.s_addr = htonl( INADDR_ANY )server.sin_port = htons( 12345 );bind( sd, (sockaddr *)&server, sizeof( server ) );

struct hostent *host = gethostbyname( arg[0] );sockaddr_in server;bzero( (char *)&server, sizeof( server ) );server.sin_family = AF_INET;server.s_addr = inet_addr( inet_ntoa( *(struct in_addr*)*host->h_addr_list ) );server.sin_port = htons( 12345 );

connect( sd, (sockaddr *)&server, sizeof( server ) );

sockaddr_in client; socklen_t len=sizeof(client);while( true ) { newSd = accept(sd, (sockaddr *)&client, &len);

write( sd, buf1, sizeof( buf ) );write( sd, buf2, sizeof( buf ) ); if ( fork( ) == 0 ) {

close( sd ); read( newSd, buf1, sizeof( buf1 ) ); read( newSd, buf2, sizeof( buf2 ) );

} close( newSd );}

read() read()

socket()

connect()

write()

socket()

connect()

write()

listen( sd, 5 );

socket()

bind()

listen()

accept()

buf2, buf1

buf2, buf1close( newsd);exit( 0 );

int sd = socket(AF_INET, SOCK_STREAM, 0);

CSS432: End-to-End Protocols

8

Data Link Versus Transport Potentially connects many different hosts

need explicit connection establishment and termination Potentially different RTT (Round Trip Time)

need adaptive timeout mechanism Potentially long delay in network

need to be prepared for arrival of very old packets need to set MSL (Maximum Segment Lifetime)

Potentially different capacity at destination need to accommodate different node capacity

Potentially different network capacity need to be prepared for network congestion

CSS432: End-to-End Protocols

9

Segment Format

Options (variable)

Data

Checksum

SrcPort DstPort

HdrLen 0 Flags

UrgPtr

AdvertisedWindow

SequenceNum

Acknowledgment

0 4 10 16 31

Each connection identified with 4-tuple: (SrcPort, SrcIPAddr, DsrPort,

DstIPAddr) Sliding window + flow control

Acknowledgment, SequenceNum, AdvertisedWinow

Flags SYN, FIN, RESET, PUSH, URG,

ACK SYN: Establishing a conneciton FIN: terminating a connection RESET: Confused and Terminating PUSH: Section 5.2.7 URG: Sending urgent data ACK: Validating acknowledgment

field SequenceNum is incremented in all

cases other than ACK.

Sender

Data (SequenceNum)

Acknowledgment +AdvertisedWindow

Receiver

CSS432: End-to-End Protocols

10

Connection Establishment and Termination

Active participant(client)

Passive participant(server)

SYN, SequenceNum = x

SYN + ACK, SequenceNum = y,

ACK, Acknowledgment = y + 1

Acknowledgment = x + 1

Tree-Way Handshake Client

Initiate a connection to a server with seq=x

Set a timer and retransmit the request upon an expiration

Server Acknowledge the client

request with ack=++x Initiate a reverse

connection with seq=y Set a timer and retransmit

the request upon an expiration

Client Acknowledge the server

request with ack=++y X and y are chosen at

random Protect against two

incarnations of the same connection using the same sequence number.

CSS432: End-to-End Protocols

11

State Transition DiagramCLOSED

LISTEN

SYN_RCVD SYN_SENT

ESTABLISHED

CLOSE_WAIT

LAST_ACKCLOSING

TIME_WAIT

FIN_WAIT_2

FIN_WAIT_1

Passive open Close

Send/SYNSYN/SYN + ACK

SYN + ACK/ACK

SYN/SYN + ACK

ACK

Close/FIN

FIN/ACKClose/FIN

FIN/ACKACK + FIN/ACK Timeout after two segment lifetimes(2 * MSL)FIN/ACK

ACK

ACK

ACK

Close/FIN

Close

CLOSED

Active open/SYN Open

Active open A client connect( )

Passive open A server listen( ) Can change active

Close Active close

A client or a server First close( ) Both side can be

active Passive close

A client or server close( ) in response to

the first close( )CSS432: End-to-End Protocols

12

State Transition Diagram

In what condition can the state transit from FIN_WAIT_1 to TIME_WAIT?

What is the purpose of the TIME_WAIT state?

CSS432: End-to-End Protocols

13

Timing ChartClient Server

( connect( ) ) SYN_SENT SYN seq=x

ACK=y + 1

SYN_RCVD

ESTABLISHED

LISTEN ( listen( ) )

SYN seq=y, ACK=x + 1

ESTABLISHED

( write( ) )

( read( ) )

seq=x+1 ACK=y + 1

ACK x + 2

( close( ) ) FIN_WAIT_1 FIN seq=x+2 ACK=y + 1CLOSE_WAIT

LAST_ACK( close( ) )ACK x + 3

FIN seq = y + 1FIN_WAIT_2

TIME_WAITACK=y + 2

Est

ablis

hmen

tT

erm

inat

ion

Dat

aT

rans

fer

Peek such a flow with tcpdump in assignment 3.CSS432: End-to-End Protocols

14

Sliding Window Revisited

Sending side LastByteAcked ≤ LastByteSent LastByteSent ≤ LastByteWritten buffer bytes between

[LastByteAcked, LastByteWritten]

Sending application

LastByteWritten

TCP

LastByteSentLastByteAcked

Receiving application

LastByteRead

TCP

LastByteRcvdNextByteExpected

Receiving side LastByteRead < NextByteExpected NextByteExpected ≤ LastByteRcvd+1 buffer bytes between

[NextByteRead, LastByteRcvd]

CSS432: End-to-End Protocols

15

Flow ControlSending application

LastByteWritten

TCP

LastByteSentLastByteAcked

Receiving application

LastByteRead

TCP

LastByteRcvdNextByteExpected

LastByteRcvd – LastByteRead ≤ MaxRcvbuffer

AdvertisedWindow= MaxRcvBuffer – (NextByteExpected – NextByteRead)

LastByteSent – LastByteAcked ≤ AdvertisedWindow

EffectiveWindow= AdvertisedWindow – (LastByteSent – LastByteAcked)

LastByteWritten – LastByteAcked ≤ MaxsendBuffer

block sender if (LastByteWritten - LastByteAcked) + y > MaxSenderBuffer

y

Send ACK with an advertise windowin response to arriving data segments• as long as all the preceding bytes have also arrived and• until the advertised window reaches 0. (ACK returned at the first time when it reaches 0)

CSS432: End-to-End Protocols

16

Flow Control with A Slower ReceiverSending application

LastByteWritten

TCP

LastByteSentLastByteAcked

Receiving application

LastByteRead

TCP

LastByteRcvdNextByteExpected

LastByteRcvd – LastByteRead ≤ MaxRcvbuffer

AdvertisedWindow= MaxRcvBuffer – (NextByteExpected – LastByteRead)

LastByteSent – LastByteAcked ≤ AdvertisedWindow

EffectiveWindow= AdvertisedWindow – (LastByteSent – LastByteAcked)

LastByteWritten – LastByteAcked ≤ MaxsendBuffer

block sender since(LastByteWritten - LastByteAcked) + y > MaxSenderBuffer

0

0

0

< 0

y y

No more send, no more ack, thus it staysIn the same value

Read slow.

CSS432: End-to-End Protocols

17

The sender won’t send any more data. The receiver won’t initiate to send any

advertised window.

Then, how can the sender find out when the receiver can receive more data?

Flow Control

CSS432: End-to-End Protocols

18

32-bit SequenceNum MSL (Maximum Segment Lifetime) = 120sec.

SequenceNum should not be wrapped around within 120 seconds.

Bandwidth Time Until Wrap AroundT1 (1.5 Mbps) 6.4 hoursEthernet (10 Mbps) 57 minutesT3 (45 Mbps) 13 minutesFDDI (100 Mbps) 6 minutesSTS-3 (155 Mbps) 4 minutesSTS-12 (622 Mbps) 55 secondsSTS-24 (1.2 Gbps) 28 seconds

Protection Against Wrap Around

CSS432: End-to-End Protocols

19

Keeping the Pipe Full 16-bit AdvertisedWindow = 64KB Assuming that RTT = 100msec, the advertised window’s

capacity is at least RTT x Network bandwidthBandwidth RTT(100msec) x Bandwidth ProductT1 (1.5 Mbps) 18KBEthernet (10 Mbps) 122KBT3 (45 Mbps) 549KBFDDI (100 Mbps) 1.2MBSTS-3 (155 Mbps) 1.8MBSTS-12 (622 Mbps) 7.4MBSTS-24 (1.2 Gbps) 14.8MB

CSS432: End-to-End Protocols

20

Segment Transmission

A segment is transmitted out:1. When a segment to send reaches Maximum

segment size (MMS) = Maximum Transfer Unit (MTU)

2. When a TCP receives a push operation that flushes the unsent data (Peek with tcpdump in programming assignment 3)

3. When a timer expires A trigger by a timer may cause the silly

window syndrome.

CSS432: End-to-End Protocols

21

Silly Window Syndrome

If a sender aggressively takes advantage of any available window, The receiver empties every window regardless of its size and thus small

windows will never disappear.

The problem occurs only when either the sender transmits a small segment or the receiver opens the window a small amount

The receiver can delay ACKs to make a larger window How long does it wait?

The sender should make a decision Nagle’s Algorithm (Programming assignment 3)

MMS 1

MMS 2

Ad Window

Ad Window

small

Sender Receiver

CSS432: End-to-End Protocols

22

Nagle’s Algorithm

Ack works as a timer to fire a new segment transmission. The algorithm may not respond to interactive or real-time

applications TCP_NODELAY Option: Transmit data as soon as possible

setsockopt(sockfd, SOL_TCP, TCP_NODELAY, &intFlag, sizeof(intFlag))

When the application produces data to send { if both the available data and the window ≥ MSS send a full segment // no problem, send it right now else if there is unAcked data in transit // a full empty segment returns soon buffer the new data until an ACK arrives else // the receiver won’t reply. Can’t avoid the silly window syndrome send all the new data now}

CSS432: End-to-End Protocols

23

How to Estimate RTT

Timeout is necessaryTo retransmit a lost packetTo detect congestions and invoke AIMD.

RTT estimation algorithmsOriginal AlgorithmKarn/Partridge AlgorithmJacobson/Karels Algorithm

CSS432: End-to-End Protocols

24

Original Algorithm Measure SampleRTT for each segment/ ACK pair Compute weighted average of RTT

EstRTT = x EstRTT + x SampleRTT where + = 1- between 0.8 and 0.9- between 0.1 and 0.2

Set timeout based on EstRTT TimeOut = 2 x EstRTT Why double? EstRTT cannot respond to

deviated SampleRTT quickly.

CSS432: End-to-End Protocols

25

Karn/Partridge Algorithm

Do not sample RTT when retransmitting Can’t figure out which transmission the latest ACK corresponds to.

Double timeout after each retransmission Congestion causes this retransmission. Modestly retransmit segments.

Sender Receiver

Original transmission

ACK

Sam

pleR

TT

Retransmission

Sender Receiver

Original transmission

ACK

Sam

pleR

TT

Retransmission

CSS432: End-to-End Protocols

26

Jacobson/ Karels Algorithm Original Algorithm

EstRTT = x EstRTT + x SampleRTT 0.8 and 0.9 0.1 and 0.2

TimeOut = EstRTT * 2

New Algorithm that takes into a consideration if the variation among smapleRTTs are large. EstRTT = EstRTT + (SampleRTT – EstRTT)

0.125 Diff

Dev = Dev + (|SampleRTT – EstRTT| – Dev) Diff

TimeOut = x EstRTT + x Dev 1 4

CSS432: End-to-End Protocols

27

Jacobson/ Karels AlgorithmSampleRTT –= (EstimatedRTT >> 3)

EstimatedRTT += SampleRTT;

If (SampleRTT < 0)

SampleRTT = – SampelRTT;

SampleRTT –= (Deviation >> 3);

Deviation += SampleRTT;

TimeOut = (EstimatedRTT >> 3) + (Deviation >> 1)

EstimatedRTT = 8 EstRTTDeviation = 8 DevSampleRTT = (SampleRTT – 8 EstRTT) / 8

= SampleRTT – EstRTT)

diff

8 EstRTT = 8EstRTT + SampleRTT= 8EstRTT + (SampleRTT – EstRTT)

EstRTT = EstRTT + 1/8 (SampleRTT – EstRTT)

diff

8 Dev = 8 Dev + |SampleRTT – EsRTT| - DevDev = Dev + 1/8( |SampleRTT – EstRTT| - Dev )

TimeOut = 8 EstRTT / 8 + 8 Dev / 2TimeOut = EstRTT + 4 Dev

|SampleRTT – EstRTT| – 8Dev/8

|diff| Notes

Algorithm does not work accurately with a large granularity of clock (500ms on Unix)

Accurate timeout mechanism important to congestion control

CSS432: End-to-End Protocols

28

TCP Extensions RTT Measurement

Store a 32-bit timestamp in outgoing segments’ header option

Receive an ack with the original timestamp Sample RTT by subtracting the timestamp from the

current timer Resolving the quick wrap-around of sequence

number The 32-bit timestamp and the 32-bit sequence number

gives a 64-bit sequence space Extending an advertised window

Scale up the advertised window How many bytes to send → How many 16-byte units to send

CSS432: End-to-End Protocols

29

Reviews UDP TCP: three-way handshake and state transition Sliding window and flow control Segment transmission: silly window syndrome and

Nagle’s algorithm Adaptive retransmission: original, Karn/Partridge, and

Jacobson/Karels Exercises in Chapter 5

Ex. 5, 14, 22, and 39 (TCP state transition) Ex. 9(a) (Sliding window) Ex. 20 (Nagle’s algorithm)

CSS432: End-to-End Protocols