A comprehensive guide to Linux network fault diagnosis using tcpdump, netstat, and ss, covering TCP state analysis, packet capture filters, kernel parameter tuning, and real-world case studies for TIME_WAIT, SYN_RECV, CLOSE_WAIT, and latency issues.
This article provides a detailed, packet‑by‑packet walkthrough of TCP's three‑way handshake and four‑step connection termination, explains the TCP header fields, explores TIME_WAIT issues, compares BBR and Cubic congestion control, and offers practical Wireshark and tcpdump techniques for troubleshooting and interview preparation.
This article explains the OSI seven‑layer model, TCP header fields, the three‑way handshake and four‑way termination processes, TIME‑WAIT timing, connection capacity calculations, packet fragmentation and reassembly, flow control, HTTP version differences, HTTPS security flow, and common analysis tools like Wireshark.
This article explains TCP fundamentals, detailing the three‑way handshake and four‑step connection termination, the purpose of each flag and state transition, and why three handshakes and four teardowns are required, including the role of the TIME_WAIT state.
This article explains TCP as a connection‑oriented, reliable byte‑stream transport protocol, detailing its header fields, state machine, three‑way handshake, four‑way termination, TIME_WAIT handling, Linux inspection commands, optimization techniques, and a comparison with UDP, all illustrated with concrete examples and diagrams.
TIME_WAIT is a normal TCP state designed to prevent stray packets, but high volumes can indicate inefficient connection handling; this guide explains its mechanics, common causes, monitoring commands, and practical kernel and application-level tuning strategies to reduce TIME_WAIT buildup in high‑traffic services.
The article explains the TCP TIME_WAIT state, why it proliferates under high‑concurrency workloads, its impact on ports, memory and performance, and provides practical application‑level optimizations, cautious OS tuning, and monitoring techniques to mitigate the issue.
TIME_WAIT is a TCP state that appears on the side actively closing a connection; when many sockets linger in this state, ports are exhausted, causing connection failures, and the article explains typical scenarios, underlying causes, kernel limits, and practical client‑ and server‑side solutions.
This article explains the TCP state machine, details the four-way handshake, analyzes why the TIME_WAIT state lasts for two MSL intervals, and illustrates two critical problems caused by delayed packets and missing ACKs, providing examples and code snippets for deeper understanding.
The article walks through every step from typing a URL to final page rendering, detailing URL parsing, DNS lookup, TCP three‑way handshake and termination, HTTP request/response structure, congestion and flow control mechanisms, and the browser’s DOM, CSS, layout and painting processes.
This article explains how TCP connections are gracefully closed using the four‑way handshake, describes half‑close and half‑open states, compares the close and shutdown system calls, details the TIME_WAIT state and its impact, and offers practical techniques to reduce or avoid TIME_WAIT accumulation.
In high‑concurrency scenarios, massive TIME_WAIT TCP connections can exhaust local ports, causing new connections to fail, but by understanding the TCP four‑handshake, adjusting socket reuse settings, and using keep‑alive, you can mitigate the issue.
Under high‑concurrency loads, massive TIME_WAIT TCP connections can exhaust local ports, causing “address already in use” errors; this article explains the root causes, impact on services, and practical mitigation strategies such as keep‑alive headers, socket reuse, and reducing the TIME_WAIT timeout.
This article explains why TCP and UDP can share the same port number, how multiple TCP processes handle binding, client port reuse, TIME_WAIT implications, and practical solutions like SO_REUSEADDR and tcp_tw_reuse to avoid address‑in‑use errors.
The article investigates why a MySQL server shows a large number of TCP connections in TIME_WAIT state, examines OS and MySQL logs, tests sysctl adjustments, captures network packets to reveal short‑lived client connections, and concludes that using persistent connections can eliminate the issue.
The article explains why massive TIME_WAIT TCP connections appear during high‑concurrency scenarios, their impact on server ports and new connections, and provides practical analysis and solutions such as keep‑alive headers, socket reuse, and reducing the TIME_WAIT duration.
This article explains the purpose of the TCP TIME-WAIT state, the scenarios it protects against, common misconceptions, and practical Linux kernel tweaks—such as fast recycle, socket reuse, and tw_buckets settings—to manage TIME-WAIT efficiently on high‑concurrency servers.
This article explains the purpose of the TCP TIME_WAIT state, how it prevents packet loss and connection errors, examines its duration based on the Maximum Segment Lifetime, and analyzes why high‑QPS load testing tools like ab may appear to bypass TIME_WAIT, revealing the impact on server resources.
The article explains why large numbers of TIME_WAIT TCP connections appear under high concurrency, analyzes the underlying TCP four‑handshake mechanism and port exhaustion issues, and provides practical solutions such as socket reuse, reducing TIME_WAIT duration, and configuring keep‑alive connections.
This article explains the TCP three‑way handshake and four‑way termination processes, clarifies the TIME_WAIT state, shows how to inspect socket states with netstat, and provides practical Linux sysctl settings to reduce excessive TIME_WAIT sockets and improve network performance.
This article explains the purpose of TCP's three‑way handshake and four‑way termination, walks through the connection lifecycle, highlights the impact of excessive TIME_WAIT sockets, and shows how Linux sysctl parameters can be tuned to improve network performance.
The article explains why massive TIME_WAIT sockets appear during high‑concurrency traffic, how they can exhaust local ports and cause connection errors, and provides practical server‑side and client‑side configurations to mitigate the issue.
This article explains why massive TIME_WAIT TCP connections appear under high concurrency, the impact on services, and practical methods—such as adjusting socket reuse and reducing TIME_WAIT duration—to prevent new connection failures.
This article explains how an unstable response time caused by misconfigured public load balancers and the kernel parameters net.ipv4.tcp_tw_recycle and net.ipv4.tcp_tw_reuse led to frequent monitoring alerts, details the diagnostic steps taken, and provides concrete remediation recommendations.
The article investigates a Nacos 1.2.0 bug that caused excessive TIME_WAIT connections in Dubbo clients, explains the underlying HttpURLConnection misuse, and reviews TCP three‑way handshake and four‑way termination to illustrate why disconnect() leads to connection buildup.
This article examines a MySQL outage triggered by TCP wrappers, detailing how high thread counts, DNS latency, TIME_WAIT socket exhaustion, and frequent reads of /etc/hosts.allow and /etc/hosts.deny can block connections, and provides troubleshooting steps and mitigation recommendations.
This article explains why TIME_WAIT occurs, its resource impact, and demonstrates two optimization strategies—accelerating TIME_WAIT reclamation and using the SO_LINGER option to send an RST packet instead of the normal FIN handshake, with complete Go client and server examples and packet‑capture analysis.
This article walks through a real‑world incident where sudden traffic drops were traced to abnormal TCP states—TIME_WAIT, CLOSE_WAIT, and SYN_RECV—by examining monitoring data, explaining the TCP handshake, reviewing relevant kernel parameters, and debugging Java/ZooKeeper/HBase code to identify and fix the root cause.
This article examines why frequent short‑lived TCP connections on Linux trigger the [99] could not assign requested address and [110] connection timeout errors, explains the underlying TIME‑WAIT port exhaustion and listen‑queue overflow mechanisms, and offers verification experiments and practical mitigation strategies.
This article explains the TCP TIME_WAIT state, its role in connection termination, the performance impact of large numbers of TIME_WAIT sockets, and practical optimization methods such as using keep‑alive and tuning Linux kernel parameters to mitigate the issue.
The article explains why TCP’s TIME_WAIT state is essential for reliable data delivery, describes how excessive TIME_WAIT sockets can exhaust port resources in high‑concurrency short‑connection servers, and offers principled and practical mitigation techniques such as kernel sysctl tweaks and careful use of SO_LINGER.
This article breaks down the TCP three‑way handshake and four‑way termination processes, explaining each packet exchange, the role of sequence numbers, the TIME_WAIT state, and why these steps are essential for reliable full‑duplex communication.
This guide shows how to diagnose a flood of MySQL TIME_WAIT sockets, adjust Linux kernel parameters (or Windows registry) to shorten the wait period, verify the improvement, and understand why improper connection handling can cause the issue.
This article explains why a static‑file server can produce many TIME_WAIT connections, examines the role of the HTTP Connection and Keep‑Alive headers, and shows how different header settings affect when the server or client closes the TCP connection.
This article examines three common TCP issues—missing client‑side socket timeouts leading to monitor‑killed processes, excessive TIME_WAIT sockets after service failures and their kernel tunables, and 40 ms keep‑alive latency caused by Nagle and delayed ACK—explaining kernel behavior and offering practical configuration fixes.
This article explains Linux TIME_WAIT related kernel parameters, their effects on client and server performance, practical tuning recommendations, and how to monitor and resolve high TIME_WAIT counts on busy servers.
