Transmission Control Protocol (TCP)

Sequence Numbers in TCP

• TCP treats payload as an unstructured, but ordered data stream
• Sequence numbers are used for numbering the bytes in the data stream
  • The sequence number of a segment is the position of the segments first byte in the data stream

Example for TCP Sequence Numbers

• Example
  • The sender splits the application layer data stream into segments
    • Length of data stream: 5,000 bytes
    • MSS: 1,460 bytes

Structure of TCP Segments

Functioning of TCP

TCP Connection Establishment (three-way Handshake)

TCP Data Transmission

TCP Connection Termination

TCP – Simplified Finite State Machine

Reliable Transmission through Flow Control

• Via flow control, the receiver controls the transmission speed of the sender dynamically, and this way ensures the completeness of the data transmission
  • Receivers with a low performance should not be flooded with data they can not process fast enough
    • As result, data would be lost
  • During transmission, lost data is transmitted again

Transmission Retries

• Procedure: Transmission retries, when they are required
• Basic mechanisms:
  • Acknowledgements (ACK) as feedback (receipt)
  • Timeouts
• Concepts for flow control:
  • Stop-and-Wait
  • Sliding Window

Stop-and-Wait

Sliding Window

Sliding Window – Method: Sender

Sliding Window – Method: Receiver

Example of Flow Control in TCP

Silly Window Syndrome

Reasons why Congestion occurs

Approach to avoid Congestion

Determine the Size of the Congestion Window

Determine the Congestion Window Size – Connection Establishment

Determine the Congestion Window Size – Slow Start

Determine the Congestion Window Size – Congestion Avoidance

Possible Continuation of the Example

Reasons why a Timeout expires and reasonable Proceeding

Additive Increase / Multiplicative Decrease (AIMD)

TCP Enhancements

Fast Retransmit

Fast Recovery

Selective Acknowledgement (SACK)

Summary of Flow Control and Congestion Control

Connection-oriented Communication via Sockets – TCP

Sockets via TCP – Example (Server)

#!/usr/bin/env python
# Echo Server via TCP
import socket              # Import module socket

HOST = ''                  # '' = all interfaces
PORT = 50007               # Port number of server

# Create socket and return socket descriptor
sd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Bind socket to port
sd.bind((HOST, PORT))      
# Make socket ready to receive
# Max. number of connections = 1
sd.listen(1)                           
# Socket accepts connections
conn, addr = sd.accept()   

print('Connected by', addr)

while 1:                   # Infinite loop
    data = conn.recv(1024) # Receive data
    if not data: break     # Break infinite loop
    conn.send(data)        # Send back received data

sd.close()                 # Close socket

$ python tcp_server.py 

Sockets via TCP – Example (Client)

#!/usr/bin/env python
# Echo Client via TCP
import socket              # Import module socket

HOST = 'localhost'         # Hostname of Server
PORT = 50007               # Port number of server

# Create socket and return socket descriptor
sd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect with server socket
sd.connect((HOST, PORT))   

sd.send('Hello, world')    # Send data
data = sd.recv(1024)       # Receive data
sd.close()                 # Close socket

# Print out received data
print('Received:', repr(data))

$ python tcp_client.py 
Received: 'Hello, world' 

$ python tcp_server.py 
Connected by ('127.0.0.1', 49898) 

User Datagram Protocol (UDP)

• Maximum size of an UDP datagram: 65,535 Bytes
  • Reason: The size of the length field inside the UDP header, which contains the datagram length, is 16 bits
    • The maximum representable number with 16 bits is 65,535
  • UDP datagrams of this size are transmitted fragmented by IP

Structure of UDP Segments

Connectionless Communication via Sockets – UDP

Sockets via UDP – Example (Server)

#!/usr/bin/env python
# Server: Receives a message via UDP

import socket              # Import module socket

# For all interfaces of the host
HOST = ''                  # '' = all interfaces
PORT = 50000               # Port number of server

# Create socket and return socket descriptor
sd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

try:
    sd.bind((HOST, PORT))      # Bind socket to port
    while True:
        # Receive data
        data = sd.recvfrom(1024)       
        # Print out received data
        print('Received:', repr(data))
finally:
    sd.close()               # Close socket 

$ python udp_server.py 

Sockets via UDP – Example (Client)

#!/usr/bin/env python
# Client: Sends a message via UDP

import socket              # Import module socket

HOST = 'localhost'         # Hostname of Server
PORT = 50000               # Port number of Server
MESSAGE = 'Hello World'    # Message

# Create socket and return socket descriptor
sd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# Send message to socket
sd.sendto(MESSAGE, (HOST, PORT))

sd.close()                 # Close socket 

$ python udp_client.py 

$ python udp_server.py
Received: ('Hello World', ('127.0.0.1', 39834)) 

Datagram Congestion Control Protocol (DCCP)

• Connection-oriented transport layer protocol
• Specified in RFC 4340
• Unreliable unicast transport with congestion control
• Reliable connection establishment
• Designed for real-time applications
• Detects packet lost without retransmissions