Transmission Control Protocol (TCP)

TCP - Transmission Control Protocol

• TCP is based on Kurose & Ross' "Computer Networking: A Top-Down Approach".
• See RFCs 793, 1122, 1323, 2018, and 2581 for more information.
• TCP operates end-to-end between a sender and receiver.
• It provides a reliable, in-order byte stream.
• There is no message delimitation in TCP.
• TCP is connection-oriented, using handshaking to initiate sender and receiver states before data exchange.
• TCP is a full-duplex protocol supporting bidirectional data flow in the same connection.
• MSS is the maximum segment size.
• TCP incorporates congestion and flow control.
• Flow is controlled to prevent the sender from overwhelming the receiver.
• Send and receive buffers are used.

TCP Segment Structure

• CWR: Congestion Window Reduced
• ECE: ECN Echo
• NS: Nonce Sum
• HL is the header length in 32-bit words.
• Ports for source and destination are 16 bits each.
• The sequence number is 32 bits.
• The acknowledgment number is also 32 bits.
• Reserved bits, Control flags of 6 bits each, urgent pointer and options
• TCP includes options (0-40 bytes), data, and checksum for verification.
• URG indicates that the urgent pointer is valid.
• ACK signifies that the acknowledgment field is valid.
• PSH is a push flag to process immediately without queuing.
• RST resets the connection.
• SYN synchronizes sequence numbers
• FIN closes the connection.

TCP Header Fields

• Source Port: The port of the sender.
• Destination Port: The port of the receiver.
• Sequence Number: The initial sequence indicates initial sequence number if SYN==1, otherwise it indicates the sequence number of the first data byte in the segment.
• Acknowledgment Number: If ACK == 1, this is the next sequence number the ACK sender expects. This acknowledges receipt of all bytes up to #seq-1 (cumulative ACK).
• Initially, the first ACK confirms the initial sequence number of the counterpart but contains no data.
• Header Length: Length of the TCP header in 32-bit words. Minimum is 5, maximum is 15, allowing up to 40 bytes for options.
• Reserved Field: Reserved for future use.
• Flags:
  • NS (Nonce Sum): Protection against concealment of packets.
  • CWR (Congestion Window Reduced): Notification of segment reception with the ECE flag set
  • ECE (ECN-Echo): Indicates support for ECN (Explicit Congestion Notification).
  • URG: Validates the Urgent Pointer field.
  • ACK: Validates the Acknowledgment Number field.
  • PSH (Push): Indicates urgent data processing, bypass buffering.
  • RST (Reset): Used to reset the connection.
  • SYN (Synchronize): Used only during the initial handshake.
  • FIN (Finished): Used to close the connection.
• Window Size: Specifies the number of window-size units that the sender of this segment is willing to accept.
• Checksum: For error-checking, similar to UDP.
• Urgent Pointer: Points to the end of urgent data. Required when URG flag is enabled

TCP Options and Sequence Numbers

• Options include:

  • MSS (Maximum Segment Size): Used during SYN and SYN-ACK phases to define the maximum segment size for the connection, taking up 4 bytes
  • Window Scaling.
  • SACK (Selective Acknowledgements).
  • Timestamps
  • Nop

• Sequence Number(Sec) is the number of the first byte in the segment's data.

• Acknowledgment (ACKs)

  • is the sequence number of the next byte expected from the other side.
  • ACKs are cumulative.
  • TCP leaves out-of-order segment handling to the implementer.

Round Trip Time (RTT) and Retransmission Timeout (RTO)

• Retransmission Timeout (RTO) should be greater than RTT, but the RTT varies.
• If the timeout is too short, timeout will occur prematurely.
• This generates unnecessary retransmissions.
• If the timeout is too long, reaction to segment losses becomes slow.
• RTT must be estimated.
• SampleRTT is the time measured from segment transmission until ACK receipt.
• Retransmissions are ignored.
• SampleRTT varies, leading to the requirement for a smooth RTT estimate.
• You can average recent measures instead of just one sample.
• Use an Exponential Weighted Moving Average (EWMA) which is: EstimatedRTT = (1 − α) × EstimatedRTT + α × SampleRTT
• The influence of past samples decreases exponentially.
• A typical α value is 0.125
• A larger margin is applied when there is high variation in EstimatedRTT.
• First, determine how much SampleRTT deviates from EstimatedRTT.
  • DevRTT = (1 – β) × DevRTT + β × |SampleRTT – EstimatedRTT|
  • A typical value of β is 0.25
• Then, set the timeout interval using: RetransmissionTimeout = EstimatedRTT + 4 × DevRTT
• On initial values: RetransmissionTimeout (RTO) starts at 1 second.
• When the first ACK arrives, the RTT value gets stored in EstimatedRTT.
• DevRTT is set to RTT/2.
• RetransmissionTimeout is calculated with the prior formula.
• If RetransmissionTimeout is less than 1, round it up to 1.
• The ACK of a retransmitted segment is not considered for RTO calculation using Khan’s Algorithm.

Khan's Algorithm

• The ACK of a retransmitted segment is not considered for the calculation of the TimeoutInterval because it can lead to erroneous results.

Reliable Data Transfer

• TCP provides a reliable data transfer service over IP's unreliable service.
• Segments are encauzados.
• ACKs are cumulative.
• A single retransmission timer is used in TCP.
• Retransmissions occur when there is a timeout or when duplicate ACKs are received.
• A simplified TCP sender will ignore ACKs and flow/congestion control initially
• Events at the TCP Sender

TCP Sender Events

• Data Received from Application:
  • Create a segment with sequence number (seq#).
  • If the timer isn't running, start it. The timer is linked to the oldest unacknowledged segment
  • Expiration Interval: TimeOutInterval
• Timeout:
  • Retransmit the segment that caused the timeout.
  • Restart the timer.
• ACK Received:
  • If the ACK acknowledges previously unacknowledged segments.
    • Update as necessary.
    • Restart the timer if unacknowledged data exists.
• NextSeqNum equals InitialSeqNumber.
• SendBase equals InitialSeqNumber.
• In an infinite loop, the TCP emitter is constantly running.
• If an event occurs in which information is received from an application:
  • A TCP segment with consecutive sequence numbers is created.
  • IP gets the segment passed to it
  • Check to confirm the timer is not active, and start the timer.
  • The sequence is updated to the current number plus the length of the data.
• If the event is from a timeout:
  • A packet is retransmitted from the unconfirmed with the lowest sequence#
  • Timer restarts
• If there is an ACK received for the TCP stack with a higher value than SendBase
  • SendBase is set to equal "y"
  • Check for segments to be recognized, and restart the timer.
• SendBase-1: The last cumulatively confirmed byte.
• Example: If SenBase-1 = 71 and y=73 then the receiver expects sequence number 73+
• The statement If(y>SendBase) indicates confirmation of segments not previously confirmed

TCP Retransmission Scenarios

• A lost ACK results in re transmission.
• A premature timeout results in the segment not retransmitting.
• Cumulative acknowledgement avoids re transmissions of first segment

Generating Acknowledgements

• ACK sent when a segment arrives that matches the expected sequence number. All the data is confirmed up to expected sequence#.
• When a segment arrives with a seq# that is expected after some has already been received
  • One Acknowledgment is sent for two segments
• When a segment is out of order, it indicates seq# for the next expected byte.
• When a segment partially fills a hole in data received
  • Send segment comience in the limite inferior del hueco

Fast Retransmission

• Timeout periods are large which could result in long delays if retransmitting
• Implement lost segment detection with duplicate Acknowledgments
• Send many segments in a row, then duplicate ACKs may occur when a segment is lost
• When sender receives 3 duplicated ACKs for same data its assume the segment is lost
• Retransmit segment, before timer expires

Fast Retransmission Algorithm

• When an ACK is received for an ACK field that equals y when the value of "y" is greater than SendBase:
  • SendBase set to "y"
  • Unconfirmed segments are checked and the timer is restarted.
• An ACK duplicated for a confirmed event is added to a counter to monitor the duplicated count
• If count equals 3:
  • A retransmission is sent for the segment with numbering to equal the duplicate ACKs

TCP Flow Control

• Prevents the sender from overflowing the receiver's buffer.
• Flow control is a speed-matching service to match the transmission rate to the application's read rate.
• The receiver TCP has a receive buffer.
• The rate at which an Application can read data from the buffer is variable

TCP Flow Control details

• For TCP, to prevent the buffer from overfilling, last byte received - last byte read ≤ receive buffer

TCP Flow Control Details

• The receiver indicates available space is included when rwnd are sent
• The emitter limits rates of transfers to the receiver if necessary
  • This guarantees that the receptor will not overflow
• Formula: rwnd = RcvBuffer - [LastByteRcvd – LastByteRead] where, LastByteSent – LastByteAcked ≤ rwnd

TCP Connection Management

• TCP uses a connection before segments transfer between hosts
• During this handshake:
  • The #seq is initialized.
  • Communication buffer information is initialized
• The client initializes the connection.
  • socket clientSocket = new Socket(“hostname”, “port number");
• Server contacted by the Client:
  • Socket connectionSocket = welcomeSocket.accept();

Three-Way Handshake

1. The client sends a TCP SYN segment to the server:
   • Specifies the initial sequence number
   • Doesn't send data
2. The server receives the SYN and responds with a SYN-ACK segment:
   • The server assigns buffers.
   • Specifies the initial sequence number
3. The client receives the SYN-ACK and responds with an ACK segment, which may contain data.

• Connection from application

Connection Termination

• Client calls the socket close function.
• Client sends a TCP FIN control segment to notify that the connection must terminate
• Server receives segment and responds, then shuts down the connection while sending FIN
• Server shuts down and must respond with acknowledgements for the FINs
• Client responds when wait time complete
• The loop closes when the server receives the ACKs and the connection is terminated.

TCP Client Lifetime Cycle

• Closed: Starting state
• SYN Sent: After SYN initialization
• Established: Connection State
• End the Session to close the connection.
• FIN_WAIT_1: Begins to wait for FIN; Send data, Acknowledge.
• FIN_WAIT_2: Waiting from the other end to end the connection.
• TIME_WAIT: Wait after confirming to close the application after 30 seconds
• Closed

TCP Server Lifetime Cycle

• Listen; Ready to receive data
• SYN Received; Wait for SYN
• Established; Fully open
• Close_Wait; Wait for client termination;
• Last_ACK; Send last packet;
• Close connection

Principles of Congestion Control

• Congestion occurs when sources send data faster than the network can handle.
• Congestion becomes apparent with lost packets and queuing delays
• Congestion differs from Flow Control.

Congestion Causes and Costs

• Scenario 1: High traffic
  • Two emitters and receptors with infinite buffers and an unlimited connection
  • When used, delays will occur as data rate increases.
  • However, R/2 will still happen even with long delays.
  • Rate limit = R/2 at line capacity with little to no output
• Scenario 2: High traffic with fixed buffers
  • Since connections are reliable, there can be retransmissions.
  • If no packages are lost during the R/2, then the data is transferred to the output to the receptors
  • The emitter must compensate by sending more often to the overwhelmed buffer
• Scenario 3: High traffic with time out
  • The timeout allows traffic that potentially wasn't lost to transfer through fixed capacity
  • A discarded data packet wastes transmission capacity

Approaches to Congestion Control

• End-end Congestion Control:
  • Does not provide clear retries
  • Traffic and interferences inferred
  • Taken by TCP
• Network-assisted:
  • Routers perform traffic feedback
  • Includes a traffic indicator for TCP, ATM, etc...
  • Emitter transfer rates

Network-Assisted Congestion Control

• Congestion Feedback:
  • Feedback via emitter (choke packet)
  • Emitter shows congestion (marked packet) and receiver tells source to make a retransmission

TCP Congestion Control

• Employs an end-to-end congestion control approach.
• Transmitter limits the rate to transfer packages based on loss
• Limits are placed to send rates to a connection

TCP Congestion control details

• Limits rates for transfer for each receiver - Buffers and deliveries
• Each transfer encompasses a limit on the amount that the TCP can transfer
  • Limit values with a minimum size value called a congested window

Details of Congestion Control

• Emission is limited based on factors such as buffer, transfers and receive rate
  • These items monitor more detailed pieces such as delivery speeds, rate of buffer space, bytes etc...
• The window Congestion
  • Poses to a source of traffic

TCP Transmission Rate

• The TCP transmission rate will be dynamic based on the environment and congestion factors
  • Can adjust the transfer - Last Byte Sent - Last Byte Acked equal to a congestion/minimum size factors
  • The transmission is then a fraction for each transfer using congestion window/ RTT

TCP Congestion Detection

• TCP detects and reports back on lost data to the end user
  • There is detection and report for loss events- this stems from timeout / ACKs duplicated
  • The acknowledgement also monitors the overall transfer state and confirms all data has transferred over
• All is well when Acknowledge, it increments transfer speed.

TCP Algorithm Steps

• Algorithm is standardized using RFC 5681
  • Encompasses - Traffic avoidance, Slow start and fast recovery
    • First two are mandatory
    • Fast Recovery is optional
• Once a transfer starts the speed is cwnd=1MSS
• Rate increase = 1MSS/RTT

Slow Start and Congestion Algorithm

• Slow start occurs when one transfer starts with a speed to equal one MSS count
  • 1MSS is increased and the segment confirms the transfer
  • Traffic increases
  • TCP can increase MSS to one transfer
  • Slow start lowers initial traffic but increases capacity at steady rate

Slow Start Details

• Time out is the reason for most transfers to end- This ensures a congested window of just one transfer - It may start a second process however to ensure steady and complete movement
• There is an opportunity to start the variable
  • The steady stage
• The phase ends when 3 acknowledgements equal that of a congested traffic
  • This ensures that TCP is at evasive rates if needed
• The evasive action then ensures full speed is available at that current traffic location

Congestion Avoidance Algorithm

Congestion Avoidance follows this algorithm: - Is equal to traffic - TPC is increased with transmission rates

• The values increased with congestion

Congestion Avoidance details

• When the linear increase stops:
  • A time-out occurs (this forces TCP to divide in half with acknowledgement duplications along with setting to steady state mode)
  • The rate in steady-state ensures all data transfers

Fast Recover, Explained

• When Fast Recovery Begins, the transfers increase - When data from lost traffic duplicates, this ensures there is data to recover if there are issues - Then traffic can become steady and avoid future time outs - In a time out, traffic returns to slow state to start over - TPC Tahaoe decreases transfers by 1 after time out or 3ACK copies occur
• TCP Reno uses this fast recovery for more future transfers

Evolution of Packet Transfers

• TCP Tahoe:
  • Transferred over eight rounds
  • Identical data transferred (8rounds)
• Congestion will grow in rate
  • When data goes over more than 3 duplicate transfers then steady transfers will begin along with linear acknowledgments
• TPC will be less than 6MS
• TPC Tahoe = 1MSS where rates decrease during linear acknowledgement

Additive Increase, Multiplication Decrement

• Transfers of TPC
  • This is linear
  • 1MS transfer for ACK transfer for duplicated traffic
    • However, with many attempts , will then try to ensure bandwidth is available
• The congestive traffic allows one to determine how much available bandwidth there is
  • The ALMD data and information stems from the experiment and is open to investigation
    • There is no known to determine the amount on transfers but there will be congestive behavior

Control Resumes: Congestion Algorithm

• If a traffic Congestive state occurs, the data is below all traffic
  • When traffic grows over the stated limit it will expand - This expansion ensures all items transfer

States to Acknowledge Transfers (In Order)

• Slows State- Acknowledges and no duplicate acknowledgement
• Traffic Acknowledgement - No duplicate acknowledgment
• The stated timeout is CongWin/Transfer value with duplicate ACK, then a steady state can resume