Skip to content
Tutorials Center
My learning

Topics

Lesson 21 of 37 ยท Troubleshooting Networks

Slow Networks: Retransmissions, Duplicate ACKs and Latency

Diagnose slow connections in Wireshark: spot retransmissions, duplicate ACKs, out-of-order segments and high latency, and learn what each one means.

When a download crawls, the cause is very often packet loss. TCP hides loss from applications by resending data, but every resend costs time. Wireshark labels these events for you, and learning to read the labels is one of the most valuable troubleshooting skills.

This lesson follows A Packet-Level Troubleshooting Workflow. The outputs below are realistic examples shown as read-only text; the Python blocks are stand-ins that detect the same patterns in a handful of sample segments.

How TCP notices loss

TCP numbers every byte with a sequence number. The receiver answers with an acknowledgment number that says "I have everything up to here". If a segment is missing, the receiver keeps acknowledging the same number. The sender notices in two ways:

  • Fast retransmit: three duplicate ACKs in a row tell the sender that a later segment arrived but an earlier one did not, so it resends right away.
  • Timeout retransmit: if no ACK arrives within the retransmission timeout (RTO), the sender resends. Timeouts are slow (often 200 ms to seconds) and show up as visible gaps.
sequenceDiagram
    participant S as Sender
    participant R as Receiver
    S->>R: seq 1000 (1460 bytes)
    S-xR: seq 2460 (lost)
    S->>R: seq 3920
    R->>S: ACK 2460 (dup 1)
    S->>R: seq 5380
    R->>S: ACK 2460 (dup 2)
    S->>R: seq 6840
    R->>S: ACK 2460 (dup 3)
    S->>R: seq 2460 (fast retransmit)
    R->>S: ACK 8300

Three duplicate ACKs trigger a fast retransmit of the lost segment.

What Wireshark flags

In the Info column and the filter fields you will meet these labels:

Label Filter Meaning
TCP Retransmission tcp.analysis.retransmission A segment with an already-seen sequence number was sent again after a delay
TCP Fast Retransmission tcp.analysis.fast_retransmission Resend triggered by duplicate ACKs
TCP Dup ACK tcp.analysis.duplicate_ack The receiver repeats an ACK, hinting at a gap
TCP Out-Of-Order tcp.analysis.out_of_order A segment arrived after one with a higher sequence number
TCP Previous segment not captured tcp.analysis.lost_segment A gap exists; the capture point may simply have missed the packet
TEXT
 212  0.8211  10.0.0.5 -> 10.0.0.20  TCP 1514 [TCP Previous segment not captured] 443 > 51200 [ACK] Seq=2920
 213  0.8212  10.0.0.20 -> 10.0.0.5  TCP   66 [TCP Dup ACK 212#1] 51200 > 443 [ACK] Ack=1460
 214  0.8213  10.0.0.20 -> 10.0.0.5  TCP   66 [TCP Dup ACK 212#2] 51200 > 443 [ACK] Ack=1460
 215  0.8214  10.0.0.20 -> 10.0.0.5  TCP   66 [TCP Dup ACK 212#3] 51200 > 443 [ACK] Ack=1460
 216  0.8216  10.0.0.5 -> 10.0.0.20  TCP 1514 [TCP Fast Retransmission] 443 > 51200 [ACK] Seq=1460

Read it top to bottom: the segment at Seq=1460 never reached the capture point, the receiver complained three times, and the sender fixed it in about 2 ms. That loss cost almost nothing. A timeout retransmission with a one-second gap is much more painful.

Python Detect retransmissions in sample segments

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Out-of-order is not always loss

Packets can take different paths and arrive swapped. A single out-of-order segment followed by the missing one arriving a fraction of a millisecond later is harmless. Loss shows up as the missing segment arriving again from the sender, after a duplicate-ACK run or a timeout. Persistent reordering usually points at load balancing across links or link aggregation.

How much loss is too much?

  • Under 0.1% on a LAN is normally fine. On a wired LAN, any sustained loss is suspicious: look for bad cables, duplex mismatches, or overloaded switch ports.
  • 1% or more has a large effect on throughput, because TCP shrinks its sending rate each time it detects loss.
  • Wi-Fi loses packets at the radio layer and retries them below IP, so you often see delay and jitter instead of TCP retransmissions.

Use Statistics, then TCP Stream Graphs, then Time Sequence (Stevens). A healthy transfer is a smooth upward line. Steps and flat parts are stalls, and a sawtooth of small jumps points to repeated loss.

Check latency separately

Latency (RTT) limits speed even without loss: a sender can have only one window of data in flight per round trip. For a quick estimate, use the handshake delay. With a 100 KB window and a 100 ms RTT, the ceiling is about 1 MB/s no matter how fast the link is.

Python Throughput ceiling from window and RTT

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Common mistakes

  • Treating every flagged packet as a fault. Check that the flags are frequent or clustered.
  • Capturing only on the receiver and concluding "the sender never sent it" when a capture-side drop (busy machine) lost the packet. "Previous segment not captured" can mean your capture lost it.
  • Ignoring offload. On the sending host, checksum offload can make packets look corrupt. Look at the capture from another point before concluding.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. How many duplicate ACKs normally trigger a fast retransmit?

    Three duplicate ACKs make the sender conclude a segment was lost and resend it without waiting for the timeout.
  2. 2. Which is usually more harmful to performance?

    A timeout means the sender waited for the full RTO, stalling the transfer, while a fast retransmit recovers within a round trip.
  3. 3. What does 'TCP Previous segment not captured' mean?

    Wireshark saw a segment whose sequence number jumped ahead, so something in between did not appear in the file.
  4. 4. A link is fast but a 100 ms RTT limits a 64 KB window. Why?

    Throughput is capped at window size divided by RTT.

Summary

  • TCP repairs loss silently, but every repair costs time. Timeouts cost most.
  • Learn the labels: Retransmission, Fast Retransmission, Dup ACK, Out-Of-Order, Previous segment not captured.
  • Judge loss by frequency and clustering, and check whether your own capture caused a gap.
  • RTT and window size cap throughput even on a loss-free path.

Next: DNS and DHCP Problems