Skip to content
Tutorials Center
My learning

Topics

Lesson 20 of 37 ยท Troubleshooting Networks

A Packet-Level Troubleshooting Workflow

Learn a repeatable method for network troubleshooting with Wireshark: define the symptom, capture at the right place, narrow the data, and prove the cause.

A capture file can hold millions of packets. Without a method you will scroll, guess, and blame the wrong thing. This lesson gives you a short, repeatable workflow that turns "the network is slow" into a specific, provable statement such as "the server answers the SYN after 800 ms, so the delay is on the server side".

Everything in this chapter builds on the filters from Filters and Display and the protocol knowledge from Protocol Analysis. Wireshark itself cannot run in your browser, so the examples show realistic output as read-only text, and the Python blocks are small stand-ins that do on a few sample records what Wireshark does on a whole capture.

Only capture on networks you own or have written permission to analyze. Captures contain other people's data. Treat them like sensitive documents.

The five steps

The troubleshooting loop

Define One clear symptom.
Place Capture where it hurts.
Narrow Filter to one conversation.
Prove Find the packet evidence.

Then fix, and capture again to confirm.

1 / 2
  1. Define the symptom. Write it down in measurable terms: "login page takes 12 seconds", not "slow". Note who is affected, which application, and since when.
  2. Choose the capture point. Capture on the client, on the server, or on a mirror port between them. Two captures at both ends, taken at the same time, let you see whether a packet was lost on the path.
  3. Capture only what you need. Use a capture filter such as host 10.0.0.5 and port 443 (capture filters) to keep the file small.
  4. Narrow with display filters. Isolate one TCP stream (tcp.stream eq 7) or one request and read it from top to bottom.
  5. Prove the cause. Point at specific packets: a gap in timestamps, a retransmission, a reset, an error response. Fix, then capture again.

Read the timing before the content

Most performance problems are visible in time, not in payload. Set the Time column to "Seconds Since Previous Displayed Packet" and look for large gaps. A big gap just before a packet means the sender of that packet was slow to produce it (or the request needed time to arrive).

TEXT
No.  Time     Source        Destination   Info
 1   0.000    10.0.0.20     10.0.0.5      SYN
 2   0.001    10.0.0.5      10.0.0.20     SYN, ACK
 3   0.001    10.0.0.20     10.0.0.5      ACK
 4   0.002    10.0.0.20     10.0.0.5      GET /login HTTP/1.1
 5   2.410    10.0.0.5      10.0.0.20     HTTP/1.1 200 OK

Packet 5 comes 2.4 seconds after the request. The network handled the handshake in about one millisecond, so the path is fine: the server took 2.4 seconds to build the page. That is a conclusion you could not reach by staring at the page body.

Python Find the slow side of a request

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.

Separate network time from application time

Wireshark can show the round-trip time of the handshake: the delay between the SYN and the ACK that completes it is roughly one RTT. Compare that with the delay between a request and its response.

  • RTT small, response slow: the server or application is slow.
  • RTT large: distance, congestion, or a slow link. Every request pays it.
  • Gaps with retransmissions: packet loss. See Retransmissions.
Python Handshake RTT versus server time

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.

The subtraction is an approximation: a response needs about one RTT to travel back, so what remains is the time the server spent working.

Useful starting filters

TEXT
tcp.analysis.flags              # anything Wireshark flags as odd
tcp.analysis.retransmission     # retransmitted segments
tcp.flags.reset == 1            # connections that were reset
dns.flags.rcode != 0            # DNS errors
frame.time_delta_displayed > 1  # gaps longer than one second

Start with tcp.analysis.flags and the Expert Information window (Analyze, then Expert Information). It sorts problems into Errors, Warnings, Notes and Chats, giving you a ready-made list of places to look. Treat it as a pointer, not a verdict: some flags, such as a few duplicate ACKs, are normal.

Common mistakes

  • Capturing on the wrong interface, then wondering why nothing appears.
  • Blaming the network when the Time column shows the server is slow.
  • Capturing on a busy server and drowning in unrelated traffic. Use capture filters.
  • Changing three things at once. Change one, capture again.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. A request is sent at 0.002 s and the response arrives at 2.410 s, but the handshake took 1 ms. What does this suggest?

    A fast handshake shows the path is quick, so the long gap between request and response points to the server or application.
  2. 2. Why capture on both client and server at the same time?

    Comparing both ends shows which packets left one side but never arrived at the other.
  3. 3. Which display filter lists packets Wireshark has marked as retransmissions?

    The tcp.analysis.* fields come from Wireshark's TCP analysis, and retransmission is one of them.
  4. 4. What is a good first symptom statement?

    A measurable symptom with who, what and when tells you where to capture and what to filter.

Summary

  • Work in a loop: define, place the capture, narrow, prove, fix, re-capture.
  • Read timing first: gaps and round-trip times separate network problems from server problems.
  • Use tcp.analysis.flags and Expert Information as pointers, not final answers.
  • Capture only what you are authorized to capture, and keep captures private.

Next: Slow Networks and TCP Retransmissions