TCP Tahoe: Advanced Network Communication

A robust network communication protocol implementation that enhances data transmission reliability and network efficiency.

Problem Solved

Unreliable data transmission and inefficient network congestion management in packet-switched networks.

🔍 Key Skills Demonstrated

• Python Programming
• Socket Programming
• Concurrent Programming
• UDP Implementation
• Object-Oriented Design
• Network Protocol Implementation

Technical Highlights

• Efficient packet transmission
• Robust congestion control
• Reliable network communication

🔄 TCP Tahoe Features

1. Two-Phase Operation

• Slow Start Phase
  • Initial window size: 1 MSS
  • Exponential growth
  • Continues until ssthresh or congestion
• Congestion Avoidance
  • Linear growth (cwnd += 1/cwnd)
  • Activated after reaching ssthresh
  • Conservative growth to prevent congestion

2. Fast Retransmission

• Detects packet loss via duplicate ACKs
• Retransmits after 3 duplicate ACKs
• Avoids waiting for timeout
• Reduces congestion window

3. Timeout Handling

• RTO (Retransmission Timeout) calculation
• Exponential backoff on consecutive timeouts
• State management during timeout recovery

🛠️ Implementation Details

TCP Header (model/tcp_header.py)

class TCPHeader:
    def __init__(self):
        self.source_port = 0
        self.dest_port = 0
        self.sequence_num = 0
        self.ack_num = 0
        self.flags = 0  # SYN, ACK, FIN
        self.window_size = 0

Congestion Window (model/congestion_wnd.py)

class CongestionWindow:
    def __init__(self):
        self.cwnd = 1        # Initial window size
        self.ssthresh = 65535  # Slow start threshold
        self.state = "slow_start"

TCP Packet (model/tcp_packet.py)

class TCPPacket:
    def __init__(self, header, data=None):
        self.header = header
        self.data = data
        self.checksum = self.calculate_checksum()

🚀 Usage

Starting the Server

python server.py --port 8080

Running the Client

python client.py --server-ip 127.0.0.1 --port 8080 --file data.txt

📊 State Management

Slow Start

def slow_start(self):
    """
    Implements slow start phase of TCP Tahoe
    - Doubles congestion window each RTT
    - Transitions to congestion avoidance at ssthresh
    """
    if self.cwnd < self.ssthresh:
        self.cwnd *= 2
    else:
        self.state = "congestion_avoidance"

Congestion Avoidance

def congestion_avoidance(self):
    """
    Implements congestion avoidance phase
    - Increases cwnd by 1/cwnd each ACK
    - More conservative growth
    """
    self.cwnd += 1.0/self.cwnd

Fast Retransmission

def fast_retransmit(self):
    """
    Handles triple duplicate ACK
    - Retransmits lost packet
    - Sets ssthresh to cwnd/2
    - Returns to slow start
    """
    self.ssthresh = max(self.cwnd/2, 2)
    self.cwnd = 1
    self.state = "slow_start"

🔧 Configuration

Default Settings

MSS = 1460  # Maximum Segment Size
INITIAL_SSTHRESH = 65535
INITIAL_CWND = 1
DUPLICATE_ACK_THRESHOLD = 3

🧪 Testing

Run the implementation with various network conditions:

# Normal network conditions
python test_tcp.py --mode normal

# High latency network
python test_tcp.py --mode high_latency

# Packet loss simulation
python test_tcp.py --mode packet_loss

📈 Performance Analysis

The implementation has been tested under various conditions:

• Normal network: 95% throughput efficiency
• High latency: Stable performance with RTT up to 200ms
• Packet loss: Graceful degradation up to 5% loss rate

📁 Project Structure

.
├── client.py           # Client-side TCP implementation
├── server.py          # Server-side TCP implementation
├── utilities.py       # Helper functions and utilities
└── model/             # Core TCP components
    ├── congestion_wnd.py  # Congestion window management
    ├── tcp_header.py      # TCP header structure
    └── tcp_packet.py      # TCP packet implementation